OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0027617: Visualization, TKOpenGl - apply highlighting color without disabling lighting

Browse Source 
Update colors in test cases
This commit is contained in:
kgv 2016-06-20 09:51:56 +03:00 committed by bugmaster
parent 2831708b17
commit f9ba5c4ddd
19 changed files with 297 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/OpenGl/OpenGl_BackgroundArray.cxx
View File

@ -337,7 +337,7 @@ Standard_Boolean OpenGl_BackgroundArray::createTextureArray (const Handle(OpenGl
// Get texture parameters
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
const OpenGl_AspectFace* anAspectFace = theWorkspace->AspectFace (Standard_False);
const OpenGl_AspectFace* anAspectFace = theWorkspace->AspectFace();
GLfloat aTextureWidth = (GLfloat )anAspectFace->TextureRes (aCtx)->SizeX();
GLfloat aTextureHeight = (GLfloat )anAspectFace->TextureRes (aCtx)->SizeY();

8
src/OpenGl/OpenGl_CappingAlgo.cxx
View File

@ -65,7 +65,7 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks
}
// remember current aspect face defined in workspace
const OpenGl_AspectFace* aFaceAsp = theWorkspace->AspectFace (Standard_False);
const OpenGl_AspectFace* aFaceAsp = theWorkspace->AspectFace();
// replace primitive groups rendering filter
Handle(OpenGl_RenderFilter) aRenderFilter = theWorkspace->GetRenderFilter();
@ -104,7 +104,7 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks
// override aspects, disable culling
theWorkspace->SetAspectFace (&theWorkspace->NoneCulling());
theWorkspace->AspectFace (Standard_True);
theWorkspace->ApplyAspectFace();
// evaluate number of pair faces
glDisable (GL_DEPTH_TEST);
@ -117,7 +117,7 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks
// override material, cull back faces
theWorkspace->SetAspectFace (&theWorkspace->FrontCulling());
theWorkspace->AspectFace (Standard_True);
theWorkspace->ApplyAspectFace();
// enable all clip plane except the rendered one
for (aPlaneIt.Init (aContextPlanes); aPlaneIt.More(); aPlaneIt.Next())
@ -176,7 +176,7 @@ void OpenGl_CappingAlgo::RenderPlane (const Handle(OpenGl_Workspace)& theWorkspa
aPlaneRes->Update (aContext);
const OpenGl_AspectFace* aFaceAspect = theWorkspace->AspectFace (Standard_False);
const OpenGl_AspectFace* aFaceAspect = theWorkspace->AspectFace();
const OpenGl_AspectFace* aPlaneAspect = aPlaneRes->AspectFace();
if (aPlaneAspect != NULL)
{

9
src/OpenGl/OpenGl_Context.cxx
View File

@ -2514,7 +2514,8 @@ Handle(OpenGl_FrameBuffer) OpenGl_Context::SetDefaultFrameBuffer (const Handle(O
// function : SetShadingMaterial
// purpose :
// =======================================================================
void OpenGl_Context::SetShadingMaterial (const OpenGl_AspectFace* theAspect)
void OpenGl_Context::SetShadingMaterial (const OpenGl_AspectFace* theAspect,
const OpenGl_Vec4* theHighlightColor)
{
if (!myActiveProgram.IsNull())
{
@ -2541,6 +2542,12 @@ void OpenGl_Context::SetShadingMaterial (const OpenGl_AspectFace* theAspect)
: theAspect->IntBack();
aParams.Init (aProp);
aParams.Diffuse.a() = aProp.trans;
if (theHighlightColor != NULL)
{
aParams.SetColor (*theHighlightColor);
}
myActiveProgram->SetUniform (this, aLoc, OpenGl_Material::NbOfVec4(),
aParams.Packed());
}

3
src/OpenGl/OpenGl_Context.hxx
View File

@ -551,7 +551,8 @@ public: //! @name methods to alter or retrieve current state
Standard_EXPORT Standard_Boolean BindProgram (const Handle(OpenGl_ShaderProgram)& theProgram);
//! Setup current shading material.
Standard_EXPORT void SetShadingMaterial (const OpenGl_AspectFace* theAspect);
Standard_EXPORT void SetShadingMaterial (const OpenGl_AspectFace* theAspect,
const OpenGl_Vec4* theHighlightColor = NULL);
//! Setup current color.
Standard_EXPORT void SetColor4fv (const OpenGl_Vec4& theColor);

4
src/OpenGl/OpenGl_GraduatedTrihedron.cxx
View File

@ -615,8 +615,8 @@ void OpenGl_GraduatedTrihedron::Render (const Handle(OpenGl_Workspace)& theWorks
Standard_ExtCharacter anAxesState = getGridAxes (aCorners, aGridAxes);
// Remember current aspects
const OpenGl_AspectLine* anOldAspectLine = theWorkspace->AspectLine (Standard_False);
const OpenGl_AspectText* anOldAspectText = theWorkspace->AspectText (Standard_False);
const OpenGl_AspectLine* anOldAspectLine = theWorkspace->AspectLine();
const OpenGl_AspectText* anOldAspectText = theWorkspace->AspectText();
OpenGl_Mat4 aModelMatrix;
aModelMatrix.Convert (aContext->WorldViewState.Current());

8
src/OpenGl/OpenGl_Group.cxx
View File

@ -332,10 +332,10 @@ void OpenGl_Group::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
const Handle(OpenGl_RenderFilter)& aFilter = theWorkspace->GetRenderFilter();
// Setup aspects
const OpenGl_AspectLine* aBackAspectLine = theWorkspace->AspectLine (Standard_False);
const OpenGl_AspectFace* aBackAspectFace = theWorkspace->AspectFace (Standard_False);
const OpenGl_AspectMarker* aBackAspectMarker = theWorkspace->AspectMarker (Standard_False);
const OpenGl_AspectText* aBackAspectText = theWorkspace->AspectText (Standard_False);
const OpenGl_AspectLine* aBackAspectLine = theWorkspace->AspectLine();
const OpenGl_AspectFace* aBackAspectFace = theWorkspace->AspectFace();
const OpenGl_AspectMarker* aBackAspectMarker = theWorkspace->AspectMarker();
const OpenGl_AspectText* aBackAspectText = theWorkspace->AspectText();
Standard_Boolean isLineSet = myAspectLine && myAspectLine->RenderFiltered (theWorkspace, aFilter);
Standard_Boolean isFaceSet = myAspectFace && myAspectFace->RenderFiltered (theWorkspace, aFilter);
Standard_Boolean isMarkerSet = myAspectMarker && myAspectMarker->RenderFiltered (theWorkspace, aFilter);

1
src/OpenGl/OpenGl_NamedStatus.hxx
View File

@ -17,7 +17,6 @@
#define _OpenGl_NamedStatus_Header
// Dynamic fields
#define OPENGL_NS_HIGHLIGHT (1<<1)
#define OPENGL_NS_RESMAT (1<<2)
#define OPENGL_NS_TEXTURE (1<<4)
#define OPENGL_NS_ANTIALIASING (1<<5)

51
src/OpenGl/OpenGl_PrimitiveArray.cxx
View File

@ -361,7 +361,7 @@ void OpenGl_PrimitiveArray::drawArray (const Handle(OpenGl_Workspace)& theWorksp
const Standard_Boolean theHasVertColor) const
{
const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
const bool toHilight = (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT) != 0;
const bool toHilight = theWorkspace->ToHighlight();
bool hasVColors = theHasVertColor && !toHilight;
if (myVboAttribs.IsNull())
{
@ -456,10 +456,8 @@ void OpenGl_PrimitiveArray::drawEdges (const TEL_COLOUR* theEdgeCo
}
#endif
const OpenGl_AspectLine* anAspectLineOld = NULL;
anAspectLineOld = theWorkspace->SetAspectLine (theWorkspace->AspectFace (Standard_True)->AspectEdge());
const OpenGl_AspectLine* anAspect = theWorkspace->AspectLine (Standard_True);
const OpenGl_AspectLine* anAspectLineOld = theWorkspace->SetAspectLine (theWorkspace->AspectFace()->AspectEdge());
const OpenGl_AspectLine* anAspect = theWorkspace->ApplyAspectLine();
#if !defined(GL_ES_VERSION_2_0)
glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
@ -531,7 +529,7 @@ void OpenGl_PrimitiveArray::drawEdges (const TEL_COLOUR* theEdgeCo
// =======================================================================
void OpenGl_PrimitiveArray::drawMarkers (const Handle(OpenGl_Workspace)& theWorkspace) const
{
const OpenGl_AspectMarker* anAspectMarker = theWorkspace->AspectMarker (Standard_True);
const OpenGl_AspectMarker* anAspectMarker = theWorkspace->ApplyAspectMarker();
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
const Handle(OpenGl_PointSprite)& aSpriteNorm = anAspectMarker->SpriteRes (aCtx);
if (!aSpriteNorm.IsNull()
@ -692,9 +690,11 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
return;
}
const OpenGl_AspectFace* anAspectFace = theWorkspace->AspectFace (Standard_True);
const OpenGl_AspectLine* anAspectLine = theWorkspace->AspectLine (Standard_True);
const OpenGl_AspectMarker* anAspectMarker = theWorkspace->AspectMarker (myDrawMode == GL_POINTS);
const OpenGl_AspectFace* anAspectFace = theWorkspace->ApplyAspectFace();
const OpenGl_AspectLine* anAspectLine = theWorkspace->ApplyAspectLine();
const OpenGl_AspectMarker* anAspectMarker = myDrawMode == GL_POINTS
? theWorkspace->ApplyAspectMarker()
: theWorkspace->AspectMarker();
// create VBOs on first render call
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
@ -712,17 +712,6 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
}
Tint aFrontLightingModel = anAspectFace->IntFront().color_mask;
const TEL_COLOUR* anInteriorColor = &anAspectFace->IntFront().matcol;
const TEL_COLOUR* anEdgeColor = &anAspectFace->AspectEdge()->Color();
const TEL_COLOUR* aLineColor = myDrawMode == GL_POINTS ? &anAspectMarker->Color() : &anAspectLine->Color();
// Use highlight colors
if (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)
{
anEdgeColor = anInteriorColor = aLineColor = theWorkspace->HighlightColor;
aFrontLightingModel = 0;
}
const Standard_Boolean hasColorAttrib = !myVboAttribs.IsNull()
&& myVboAttribs->HasColorAttribute();
const Standard_Boolean isLightOn = aFrontLightingModel != 0
@ -752,10 +741,7 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
if ((myDrawMode > GL_LINE_STRIP && anAspectFace->InteriorStyle() != Aspect_IS_EMPTY) ||
(myDrawMode <= GL_LINE_STRIP))
{
const bool toHilight = (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT) != 0;
const Graphic3d_Vec4* aFaceColors = !myBounds.IsNull() && !toHilight && anAspectFace->InteriorStyle() != Aspect_IS_HIDDENLINE
? myBounds->Colors
: NULL;
const bool toHilight = theWorkspace->ToHighlight();
const Standard_Boolean hasVertColor = hasColorAttrib && !toHilight;
if (aCtx->core20fwd != NULL)
{
@ -805,7 +791,7 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
// All primitives should gather material properties from the AspectFace in shading mode
if (isLightOn)
{
aCtx->SetShadingMaterial (anAspectFace);
aCtx->SetShadingMaterial (anAspectFace, theWorkspace->ToHighlight() ? (const OpenGl_Vec4* )theWorkspace->HighlightColor : NULL);
}
if (!theWorkspace->ActiveTexture().IsNull()
@ -814,7 +800,16 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
aCtx->SetTextureMatrix (theWorkspace->ActiveTexture()->GetParams());
}
aCtx->SetColor4fv (*(const OpenGl_Vec4* )(myDrawMode <= GL_LINE_STRIP ? aLineColor->rgb : anInteriorColor->rgb));
if (myDrawMode <= GL_LINE_STRIP)
{
const TEL_COLOUR& aLineColor = myDrawMode == GL_POINTS ? theWorkspace->MarkerColor() : theWorkspace->LineColor();
aCtx->SetColor4fv (*(const OpenGl_Vec4* )aLineColor.rgb);
}
else
{
const TEL_COLOUR& anInteriorColor = theWorkspace->InteriorColor();
aCtx->SetColor4fv (*(const OpenGl_Vec4* )anInteriorColor.rgb);
}
if (myDrawMode == GL_LINES
|| myDrawMode == GL_LINE_STRIP)
{
@ -822,6 +817,9 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
aCtx->SetLineWidth (anAspectLine->Width());
}
const Graphic3d_Vec4* aFaceColors = !myBounds.IsNull() && !toHilight && anAspectFace->InteriorStyle() != Aspect_IS_HIDDENLINE
? myBounds->Colors
: NULL;
drawArray (theWorkspace, aFaceColors, hasColorAttrib);
}
@ -834,6 +832,7 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
if (anAspectFace->Edge()
|| anAspectFace->InteriorStyle() == Aspect_IS_HIDDENLINE)
{
const TEL_COLOUR* anEdgeColor = &theWorkspace->EdgeColor();
drawEdges (anEdgeColor, theWorkspace);
// restore OpenGL polygon mode if needed

26
src/OpenGl/OpenGl_Structure.cxx
View File

@ -68,13 +68,12 @@ public:
{
#if !defined(GL_ES_VERSION_2_0)
// Apply line aspect
const OpenGl_AspectLine* anAspectLine = theWorkspace->AspectLine (Standard_True);
const Handle(OpenGl_Texture) aPrevTexture = theWorkspace->DisableTexture();
glDisable (GL_LIGHTING);
// Use highlight colors
theWorkspace->GetGlContext()->core11->glColor3fv ((theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT) ? theWorkspace->HighlightColor->rgb : anAspectLine->Color().rgb);
theWorkspace->GetGlContext()->core11->glColor3fv (theWorkspace->LineColor().rgb);
glEnableClientState (GL_VERTEX_ARRAY);
glVertexPointer (3, GL_FLOAT, 0, (GLfloat* )&myVerts);
@ -466,10 +465,9 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
// Render named status
const Standard_Integer aNamedStatus = theWorkspace->NamedStatus;
if (highlight)
{
theWorkspace->NamedStatus |= OPENGL_NS_HIGHLIGHT;
theWorkspace->SetHighlight (true);
}
// Apply local transformation
@ -500,11 +498,11 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
// Take into account transform persistence
aCtx->ApplyModelViewMatrix();
// Apply aspects
const OpenGl_AspectLine *anAspectLine = theWorkspace->AspectLine (Standard_False);
const OpenGl_AspectFace *anAspectFace = theWorkspace->AspectFace (Standard_False);
const OpenGl_AspectMarker *anAspectMarker = theWorkspace->AspectMarker (Standard_False);
const OpenGl_AspectText *anAspectText = theWorkspace->AspectText (Standard_False);
// remember aspects
const OpenGl_AspectLine* aPrevAspectLine = theWorkspace->AspectLine();
const OpenGl_AspectFace* aPrevAspectFace = theWorkspace->AspectFace();
const OpenGl_AspectMarker* aPrevAspectMarker = theWorkspace->AspectMarker();
const OpenGl_AspectText* aPrevAspectText = theWorkspace->AspectText();
// Apply correction for mirror transform
if (myIsMirrored)
@ -597,10 +595,10 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
theWorkspace->HighlightColor = aHighlightColor;
// Restore aspects
theWorkspace->SetAspectLine (anAspectLine);
theWorkspace->SetAspectFace (anAspectFace);
theWorkspace->SetAspectMarker (anAspectMarker);
theWorkspace->SetAspectText (anAspectText);
theWorkspace->SetAspectLine (aPrevAspectLine);
theWorkspace->SetAspectFace (aPrevAspectFace);
theWorkspace->SetAspectMarker (aPrevAspectMarker);
theWorkspace->SetAspectText (aPrevAspectText);
// Apply highlight box
if (!myHighlightBox.IsNull())
@ -609,7 +607,7 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
}
// Restore named status
theWorkspace->NamedStatus = aNamedStatus;
theWorkspace->SetHighlight (false);
}
// =======================================================================

26
src/OpenGl/OpenGl_Text.cxx
View File

@ -411,7 +411,7 @@ void OpenGl_Text::StringSize (const Handle(OpenGl_Context)& theCtx,
// =======================================================================
void OpenGl_Text::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
{
const OpenGl_AspectText* aTextAspect = theWorkspace->AspectText (Standard_True);
const OpenGl_AspectText* aTextAspect = theWorkspace->ApplyAspectText();
const Handle(OpenGl_Texture) aPrevTexture = theWorkspace->DisableTexture();
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
@ -425,24 +425,12 @@ void OpenGl_Text::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
myProjMatrix.Convert (aCtx->ProjectionState.Current());
// use highlight color or colors from aspect
if (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)
{
render (theWorkspace->PrinterContext(),
aCtx,
*aTextAspect,
*theWorkspace->HighlightColor,
*theWorkspace->HighlightColor,
theWorkspace->View()->RenderingParams().Resolution);
}
else
{
render (theWorkspace->PrinterContext(),
aCtx,
*aTextAspect,
aTextAspect->Color(),
aTextAspect->SubtitleColor(),
theWorkspace->View()->RenderingParams().Resolution);
}
render (theWorkspace->PrinterContext(),
aCtx,
*aTextAspect,
theWorkspace->TextColor(),
theWorkspace->TextSubtitleColor(),
theWorkspace->View()->RenderingParams().Resolution);
aCtx->BindProgram (NULL);

4
src/OpenGl/OpenGl_Trihedron.cxx
View File

@ -196,7 +196,7 @@ void OpenGl_Trihedron::redraw (const Handle(OpenGl_Workspace)& theWorkspace) con
OpenGl_Mat4d aModelViewZ (aModelMatrix);
// Set line aspect
const OpenGl_AspectLine* aCurrentAspectLine = theWorkspace->AspectLine (Standard_True);
const OpenGl_AspectLine* aCurrentAspectLine = theWorkspace->ApplyAspectLine();
CALL_DEF_CONTEXTLINE aLineAspect = {1, 1, { 1.F, 1.F, 1.F }, aCurrentAspectLine->Type(), aCurrentAspectLine->Width(), 0};
aLineAspect.Color.r = myZColor.r();
aLineAspect.Color.g = myZColor.g();
@ -325,7 +325,7 @@ void OpenGl_Trihedron::redrawZBuffer (const Handle(OpenGl_Workspace)& theWorkspa
const GLdouble aScale = myScale * myRatio;
const OpenGl_AspectLine* anAspectLine = theWorkspace->AspectLine (Standard_True);
const OpenGl_AspectLine* anAspectLine = theWorkspace->ApplyAspectLine();
const TEL_COLOUR& aLineColor = anAspectLine->Color();
// Create the trihedron

192
src/OpenGl/OpenGl_Workspace.cxx
View File

@ -148,17 +148,18 @@ OpenGl_Workspace::OpenGl_Workspace (OpenGl_View* theView, const Handle(OpenGl_Wi
myUseDepthWrite (Standard_True),
myUseGLLight (Standard_True),
//
AspectLine_set (&myDefaultAspectLine),
AspectLine_applied (NULL),
AspectFace_set (&myDefaultAspectFace),
AspectFace_applied (NULL),
AspectMarker_set (&myDefaultAspectMarker),
AspectMarker_applied (NULL),
AspectText_set (&myDefaultAspectText),
AspectText_applied (NULL),
myAspectLineSet (&myDefaultAspectLine),
myAspectFaceSet (&myDefaultAspectFace),
myAspectFaceApplied (NULL),
myAspectMarkerSet (&myDefaultAspectMarker),
myAspectMarkerApplied (NULL),
myAspectTextSet (&myDefaultAspectText),
myAspectFaceAppliedWithHL (false),
//
ViewMatrix_applied (&myDefaultMatrix),
StructureMatrix_applied (&myDefaultMatrix),
myCullingMode (TelCullUndefined),
myToHighlight (false),
myModelViewMatrix (myDefaultMatrix),
PolygonOffset_applied (THE_DEFAULT_POFFSET)
{
@ -242,22 +243,19 @@ void OpenGl_Workspace::ResetAppliedAspect()
NamedStatus = !myTextureBound.IsNull() ? OPENGL_NS_TEXTURE : 0;
HighlightColor = &THE_WHITE_COLOR;
AspectLine_set = &myDefaultAspectLine;
AspectLine_applied = NULL;
AspectFace_set = &myDefaultAspectFace;
AspectFace_applied = NULL;
AspectMarker_set = &myDefaultAspectMarker;
AspectMarker_applied = NULL;
AspectText_set = &myDefaultAspectText;
AspectText_applied = NULL;
myAspectLineSet = &myDefaultAspectLine;
myAspectFaceSet = &myDefaultAspectFace;
myAspectFaceApplied = NULL;
myAspectMarkerSet = &myDefaultAspectMarker;
myAspectMarkerApplied = NULL;
myAspectTextSet = &myDefaultAspectText;
PolygonOffset_applied = THE_DEFAULT_POFFSET;
myCullingMode = TelCullUndefined;
AspectLine(Standard_True);
AspectFace(Standard_True);
AspectMarker(Standard_True);
AspectText(Standard_True);
ApplyAspectLine();
ApplyAspectFace();
ApplyAspectMarker();
ApplyAspectText();
myGlContext->SetTypeOfLine (myDefaultAspectLine.Type());
myGlContext->SetLineWidth (myDefaultAspectLine.Width());
@ -648,31 +646,35 @@ static void TelUpdatePolygonOffsets (const TEL_POFFSET_PARAM& theOffsetData)
void OpenGl_Workspace::updateMaterial (const int theFlag)
{
// Case of hidden line
if (AspectFace_set->InteriorStyle() == Aspect_IS_HIDDENLINE)
if (myAspectFaceSet->InteriorStyle() == Aspect_IS_HIDDENLINE)
{
myAspectFaceHl = *AspectFace_set; // copy all values including line edge aspect
myAspectFaceHl = *myAspectFaceSet; // copy all values including line edge aspect
myAspectFaceHl.ChangeIntFront().matcol = myView->BackgroundColor();
myAspectFaceHl.ChangeIntFront().color_mask = 0;
myAspectFaceHl.ChangeIntFront().color_mask = 0;
AspectFace_set = &myAspectFaceHl;
myAspectFaceSet = &myAspectFaceHl;
return;
}
const OPENGL_SURF_PROP* aProps = &AspectFace_set->IntFront();
const OPENGL_SURF_PROP* aProps = &myAspectFaceSet->IntFront();
GLenum aFace = GL_FRONT_AND_BACK;
if (theFlag == TEL_BACK_MATERIAL)
{
aFace = GL_BACK;
aProps = &AspectFace_set->IntBack();
aProps = &myAspectFaceSet->IntBack();
}
else if (AspectFace_set->DistinguishingMode() == TOn
else if (myAspectFaceSet->DistinguishingMode() == TOn
&& !(NamedStatus & OPENGL_NS_RESMAT))
{
aFace = GL_FRONT;
}
myMatTmp.Init (*aProps);
if (myToHighlight)
{
myMatTmp.SetColor (*(const OpenGl_Vec4* )HighlightColor);
}
// handling transparency
if (NamedStatus & OPENGL_NS_2NDPASSDO)
@ -798,83 +800,64 @@ void OpenGl_Workspace::updateMaterial (const int theFlag)
// function : SetAspectLine
// purpose :
// =======================================================================
const OpenGl_AspectLine * OpenGl_Workspace::SetAspectLine(const OpenGl_AspectLine *AnAspect)
const OpenGl_AspectLine* OpenGl_Workspace::SetAspectLine (const OpenGl_AspectLine* theAspect)
{
const OpenGl_AspectLine *AspectLine_old = AspectLine_set;
AspectLine_set = AnAspect;
return AspectLine_old;
const OpenGl_AspectLine* aPrevAspectLine = myAspectLineSet;
myAspectLineSet = theAspect;
return aPrevAspectLine;
}
// =======================================================================
// function : SetAspectFace
// purpose :
// =======================================================================
const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace(const OpenGl_AspectFace *AnAspect)
const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace (const OpenGl_AspectFace* theAspect)
{
const OpenGl_AspectFace *AspectFace_old = AspectFace_set;
AspectFace_set = AnAspect;
return AspectFace_old;
const OpenGl_AspectFace* aPrevAspectFace = myAspectFaceSet;
myAspectFaceSet = theAspect;
return aPrevAspectFace;
}
// =======================================================================
// function : SetAspectMarker
// purpose :
// =======================================================================
const OpenGl_AspectMarker * OpenGl_Workspace::SetAspectMarker(const OpenGl_AspectMarker *AnAspect)
const OpenGl_AspectMarker* OpenGl_Workspace::SetAspectMarker (const OpenGl_AspectMarker* theAspect)
{
const OpenGl_AspectMarker *AspectMarker_old = AspectMarker_set;
AspectMarker_set = AnAspect;
return AspectMarker_old;
const OpenGl_AspectMarker* aPrevAspectMarker = myAspectMarkerSet;
myAspectMarkerSet = theAspect;
return aPrevAspectMarker;
}
// =======================================================================
// function : SetAspectText
// purpose :
// =======================================================================
const OpenGl_AspectText * OpenGl_Workspace::SetAspectText(const OpenGl_AspectText *AnAspect)
const OpenGl_AspectText * OpenGl_Workspace::SetAspectText (const OpenGl_AspectText* theAspect)
{
const OpenGl_AspectText *AspectText_old = AspectText_set;
AspectText_set = AnAspect;
return AspectText_old;
const OpenGl_AspectText* aPrevAspectText = myAspectTextSet;
myAspectTextSet = theAspect;
return aPrevAspectText;
}
// =======================================================================
// function : AspectLine
// function : ApplyAspectFace
// purpose :
// =======================================================================
const OpenGl_AspectLine * OpenGl_Workspace::AspectLine(const Standard_Boolean theWithApply)
const OpenGl_AspectFace* OpenGl_Workspace::ApplyAspectFace()
{
if (theWithApply)
{
AspectLine_applied = AspectLine_set;
}
return AspectLine_set;
}
// =======================================================================
// function : AspectFace
// purpose :
// =======================================================================
const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean theToApply)
{
if (!theToApply)
{
return AspectFace_set;
}
if (myView->BackfacingModel() == Graphic3d_TOBM_AUTOMATIC)
{
// manage back face culling mode, disable culling when clipping is enabled
TelCullMode aCullingMode = (myGlContext->Clipping().IsClippingOrCappingOn()
|| AspectFace_set->InteriorStyle() == Aspect_IS_HATCH)
|| myAspectFaceSet->InteriorStyle() == Aspect_IS_HATCH)
? TelCullNone
: (TelCullMode )AspectFace_set->CullingMode();
: (TelCullMode )myAspectFaceSet->CullingMode();
if (aCullingMode != TelCullNone
&& !(NamedStatus & OPENGL_NS_2NDPASSDO))
{
// disable culling in case of translucent shading aspect
if (AspectFace_set->IntFront().trans != 1.0f)
if (myAspectFaceSet->IntFront().trans != 1.0f)
{
aCullingMode = TelCullNone;
}
@ -906,14 +889,17 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
}
}
if (AspectFace_set == AspectFace_applied)
if (myAspectFaceSet == myAspectFaceApplied
&& myToHighlight == myAspectFaceAppliedWithHL)
{
return AspectFace_set;
return myAspectFaceSet;
}
myAspectFaceAppliedWithHL = myToHighlight;
#if !defined(GL_ES_VERSION_2_0)
const Aspect_InteriorStyle anIntstyle = AspectFace_set->InteriorStyle();
if (AspectFace_applied == NULL || AspectFace_applied->InteriorStyle() != anIntstyle)
const Aspect_InteriorStyle anIntstyle = myAspectFaceSet->InteriorStyle();
if (myAspectFaceApplied == NULL
|| myAspectFaceApplied->InteriorStyle() != anIntstyle)
{
switch (anIntstyle)
{
@ -926,7 +912,7 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
case Aspect_IS_HATCH:
{
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
myLineAttribs->SetTypeOfHatch (AspectFace_applied != NULL ? AspectFace_applied->Hatch() : TEL_HS_SOLID);
myLineAttribs->SetTypeOfHatch (myAspectFaceApplied != NULL ? myAspectFaceApplied->Hatch() : TEL_HS_SOLID);
break;
}
case Aspect_IS_SOLID:
@ -949,8 +935,9 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
if (anIntstyle == Aspect_IS_HATCH)
{
const Tint hatchstyle = AspectFace_set->Hatch();
if (AspectFace_applied == NULL || AspectFace_applied->Hatch() != hatchstyle)
const Tint hatchstyle = myAspectFaceSet->Hatch();
if (myAspectFaceApplied == NULL
|| myAspectFaceApplied->Hatch() != hatchstyle)
{
myLineAttribs->SetTypeOfHatch (hatchstyle);
}
@ -958,28 +945,28 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
#endif
// Aspect_POM_None means: do not change current settings
if ((AspectFace_set->PolygonOffset().mode & Aspect_POM_None) != Aspect_POM_None)
if ((myAspectFaceSet->PolygonOffset().mode & Aspect_POM_None) != Aspect_POM_None)
{
if (PolygonOffset_applied.mode != AspectFace_set->PolygonOffset().mode
|| PolygonOffset_applied.factor != AspectFace_set->PolygonOffset().factor
|| PolygonOffset_applied.units != AspectFace_set->PolygonOffset().units)
if (PolygonOffset_applied.mode != myAspectFaceSet->PolygonOffset().mode
|| PolygonOffset_applied.factor != myAspectFaceSet->PolygonOffset().factor
|| PolygonOffset_applied.units != myAspectFaceSet->PolygonOffset().units)
{
SetPolygonOffset (AspectFace_set->PolygonOffset().mode,
AspectFace_set->PolygonOffset().factor,
AspectFace_set->PolygonOffset().units);
SetPolygonOffset (myAspectFaceSet->PolygonOffset().mode,
myAspectFaceSet->PolygonOffset().factor,
myAspectFaceSet->PolygonOffset().units);
}
}
updateMaterial (TEL_FRONT_MATERIAL);
if (AspectFace_set->DistinguishingMode() == TOn)
if (myAspectFaceSet->DistinguishingMode() == TOn)
{
updateMaterial (TEL_BACK_MATERIAL);
}
if (AspectFace_set->DoTextureMap())
if (myAspectFaceSet->DoTextureMap())
{
EnableTexture (AspectFace_set->TextureRes (myGlContext),
AspectFace_set->TextureParams());
EnableTexture (myAspectFaceSet->TextureRes (myGlContext),
myAspectFaceSet->TextureParams());
}
else
{
@ -994,8 +981,8 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
}
}
AspectFace_applied = AspectFace_set;
return AspectFace_set;
myAspectFaceApplied = myAspectFaceSet;
return myAspectFaceSet;
}
//=======================================================================
@ -1014,39 +1001,26 @@ void OpenGl_Workspace::SetPolygonOffset (int theMode,
}
// =======================================================================
// function : AspectMarker
// function : ApplyAspectMarker
// purpose :
// =======================================================================
const OpenGl_AspectMarker* OpenGl_Workspace::AspectMarker (const Standard_Boolean theToApply)
const OpenGl_AspectMarker* OpenGl_Workspace::ApplyAspectMarker()
{
if (theToApply && (AspectMarker_set != AspectMarker_applied))
if (myAspectMarkerSet != myAspectMarkerApplied)
{
if (!AspectMarker_applied || (AspectMarker_set->Scale() != AspectMarker_applied->Scale()))
if (myAspectMarkerApplied == NULL
|| (myAspectMarkerSet->Scale() != myAspectMarkerApplied->Scale()))
{
#if !defined(GL_ES_VERSION_2_0)
glPointSize (AspectMarker_set->Scale());
glPointSize (myAspectMarkerSet->Scale());
#ifdef HAVE_GL2PS
gl2psPointSize (AspectMarker_set->Scale());
gl2psPointSize (myAspectMarkerSet->Scale());
#endif
#endif
}
AspectMarker_applied = AspectMarker_set;
myAspectMarkerApplied = myAspectMarkerSet;
}
return AspectMarker_set;
}
// =======================================================================
// function : AspectText
// purpose :
// =======================================================================
const OpenGl_AspectText* OpenGl_Workspace::AspectText (const Standard_Boolean theWithApply)
{
if (theWithApply)
{
AspectText_applied = AspectText_set;
}
return AspectText_set;
return myAspectMarkerSet;
}
// =======================================================================

119
src/OpenGl/OpenGl_Workspace.hxx
View File

@ -35,10 +35,6 @@
#include <OpenGl_Vec.hxx>
#include <OpenGl_Window.hxx>
class OpenGl_AspectLine;
class OpenGl_AspectMarker;
class OpenGl_AspectText;
class OpenGl_Element;
class OpenGl_View;
class Image_PixMap;
@ -58,6 +54,14 @@ struct OpenGl_Material
Standard_ShortReal Transparency() const { return Params.y(); }
Standard_ShortReal& ChangeTransparency() { return Params.y(); }
//! Set material color.
void SetColor (const OpenGl_Vec4& theColor)
{
// apply the same formula as in Graphic3d_MaterialAspect::SetColor()
Ambient.xyz() = theColor.rgb() * 0.25f;
Diffuse.xyz() = theColor.rgb();
}
//! Initialize material
void Init (const OPENGL_SURF_PROP& theProps);
@ -171,18 +175,101 @@ public:
const TEL_COLOUR* HighlightColor;
//! Return true if following structures should apply highlight color.
bool ToHighlight() const { return myToHighlight; }
//! Set highlight.
void SetHighlight (bool theToHighlight) { myToHighlight = theToHighlight; }
//! Return line color taking into account highlight flag.
const TEL_COLOUR& LineColor() const
{
return myToHighlight
? *HighlightColor
: myAspectLineSet->Color();
}
//! Return edge color taking into account highlight flag.
const TEL_COLOUR& EdgeColor() const
{
return myToHighlight
? *HighlightColor
: myAspectFaceSet->AspectEdge()->Color();
}
//! Return marker color taking into account highlight flag.
const TEL_COLOUR& MarkerColor() const
{
return myToHighlight
? *HighlightColor
: myAspectMarkerSet->Color();
}
//! Return Interior color taking into account highlight flag.
const TEL_COLOUR& InteriorColor() const
{
return myToHighlight
? *HighlightColor
: myAspectFaceSet->IntFront().matcol;
}
//! Return text color taking into account highlight flag.
const TEL_COLOUR& TextColor() const
{
return myToHighlight
? *HighlightColor
: myAspectTextSet->Color();
}
//! Return text Subtitle color taking into account highlight flag.
const TEL_COLOUR& TextSubtitleColor() const
{
return myToHighlight
? *HighlightColor
: myAspectTextSet->SubtitleColor();
}
//! Currently set line aspect (can differ from applied).
const OpenGl_AspectLine* AspectLine() const { return myAspectLineSet; }
//! Currently set face aspect (can differ from applied).
const OpenGl_AspectFace* AspectFace() const { return myAspectFaceSet; }
//! Currently set marker aspect (can differ from applied).
const OpenGl_AspectMarker* AspectMarker() const { return myAspectMarkerSet; }
//! Currently set text aspect (can differ from applied).
const OpenGl_AspectText* AspectText() const { return myAspectTextSet; }
//! Assign new line aspect (will be applied within ApplyAspectLine()).
Standard_EXPORT const OpenGl_AspectLine* SetAspectLine (const OpenGl_AspectLine* theAspect);
//! Assign new face aspect (will be applied within ApplyAspectFace()).
Standard_EXPORT const OpenGl_AspectFace* SetAspectFace (const OpenGl_AspectFace* theAspect);
//! Assign new marker aspect (will be applied within ApplyAspectMarker()).
Standard_EXPORT const OpenGl_AspectMarker* SetAspectMarker (const OpenGl_AspectMarker* theAspect);
//! Assign new text aspect (will be applied within ApplyAspectText()).
Standard_EXPORT const OpenGl_AspectText* SetAspectText (const OpenGl_AspectText* theAspect);
//// THESE METHODS ARE EXPORTED AS THEY PROVIDE STATE INFO TO USERDRAW
Standard_EXPORT const OpenGl_AspectLine* AspectLine (const Standard_Boolean theWithApply);
Standard_EXPORT const OpenGl_AspectFace* AspectFace (const Standard_Boolean theWithApply);
Standard_EXPORT const OpenGl_AspectMarker* AspectMarker (const Standard_Boolean theWithApply);
Standard_EXPORT const OpenGl_AspectText* AspectText (const Standard_Boolean theWithApply);
//! Apply line aspect.
//! @return aspect set by SetAspectLine()
const OpenGl_AspectLine* ApplyAspectLine() { return myAspectLineSet; }
//! Clear the applied aspect state.
//! Apply face aspect.
//! @return aspect set by SetAspectFace()
Standard_EXPORT const OpenGl_AspectFace* ApplyAspectFace();
//! Apply marker aspect.
//! @return aspect set by SetAspectMarker()
Standard_EXPORT const OpenGl_AspectMarker* ApplyAspectMarker();
//! Apply text aspect.
//! @return aspect set by SetAspectText()
const OpenGl_AspectText* ApplyAspectText() { return myAspectTextSet; }
//! Clear the applied aspect state to default values.
void ResetAppliedAspect();
Standard_EXPORT Handle(OpenGl_Texture) DisableTexture();
@ -274,10 +361,13 @@ protected: //! @name fields related to status
Handle(OpenGl_RenderFilter) myRenderFilter;
Handle(OpenGl_Texture) myTextureBound; //!< currently bound texture (managed by OpenGl_AspectFace and OpenGl_View environment texture)
const OpenGl_AspectLine *AspectLine_set, *AspectLine_applied;
const OpenGl_AspectFace *AspectFace_set, *AspectFace_applied;
const OpenGl_AspectMarker *AspectMarker_set, *AspectMarker_applied;
const OpenGl_AspectText *AspectText_set, *AspectText_applied;
const OpenGl_AspectLine* myAspectLineSet;
const OpenGl_AspectFace* myAspectFaceSet;
const OpenGl_AspectFace* myAspectFaceApplied;
const OpenGl_AspectMarker* myAspectMarkerSet;
const OpenGl_AspectMarker* myAspectMarkerApplied;
const OpenGl_AspectText* myAspectTextSet;
bool myAspectFaceAppliedWithHL;
const OpenGl_Matrix* ViewMatrix_applied;
const OpenGl_Matrix* StructureMatrix_applied;
@ -286,6 +376,7 @@ protected: //! @name fields related to status
OpenGl_Material myMatBack; //!< current back material state
OpenGl_Material myMatTmp; //!< temporary variable
TelCullMode myCullingMode; //!< back face culling mode, applied from face aspect
bool myToHighlight; //!< flag indicating highlighting mode
OpenGl_Matrix myModelViewMatrix; //!< Model matrix with applied structure transformations

8
src/ViewerTest/ViewerTest_OpenGlCommands.cxx
View File

@ -159,13 +159,11 @@ void VUserDrawObj::Render(const Handle(OpenGl_Workspace)& theWorkspace) const
aCtx->BindProgram (NULL);
// To test linking against OpenGl_Workspace and all aspect classes
const OpenGl_AspectLine* aLA = theWorkspace->AspectLine(0);
const OpenGl_AspectMarker* aMA = theWorkspace->AspectMarker(0);
const OpenGl_AspectMarker* aMA = theWorkspace->AspectMarker();
aMA->Type();
const OpenGl_AspectText* aTA = theWorkspace->AspectText(0);
const OpenGl_AspectText* aTA = theWorkspace->AspectText();
aTA->FontName();
TEL_COLOUR aColor = theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT ?
*(theWorkspace->HighlightColor) : aLA->Color();
TEL_COLOUR aColor = theWorkspace->LineColor();
// Finally draw something to make sure UserDraw really works
glPushAttrib(GL_ENABLE_BIT);

22
tests/bugs/vis/bug22018
View File

@ -42,20 +42,28 @@ set y 200
vmoveto 0 0
vmoveto 0 0
checkcolor ${x1} ${y} ${White_R} ${White_G} ${White_B}
checkcolor ${x2} ${y} ${White_R} ${White_G} ${White_B}
if { [vreadpixel $x1 $y rgb name] != "IVORY" || [vreadpixel $x2 $y rgb name] != "IVORY" } {
Error: unexpected color of not selected object
}
vmoveto ${x1} ${y}
vmoveto ${x1} ${y}
checkcolor ${x1} ${y} ${Select_R} ${Select_G} ${Select_B}
checkcolor ${x2} ${y} ${White_R} ${White_G} ${White_B}
if { [vreadpixel $x1 $y rgb name] != "WHITE" } {
Error: unexpected color of selected object
}
if { [vreadpixel $x2 $y rgb name] != "IVORY" } {
Error: unexpected color of not selected object
}
vmoveto ${x2} ${y}
vmoveto ${x2} ${y}
checkcolor ${x1} ${y} ${White_R} ${White_G} ${White_B}
checkcolor ${x2} ${y} ${Select_R} ${Select_G} ${Select_B}
if { [vreadpixel $x1 $y rgb name] != "IVORY" } {
Error: unexpected color of not selected object
}
if { [vreadpixel $x2 $y rgb name] != "WHITE" } {
Error: unexpected color of selected object
}
checkview -screenshot -3d -path ${imagedir}/${test_image}.png

2
tests/bugs/vis/bug26217
View File

@ -26,7 +26,7 @@ vselect 0 0
vselect 40 120 185 320 -allowoverlap 1
set aColor [vreadpixel 120 200 rgb name]
if {$aColor != "GRAY80"} {
if {$aColor != "GRAY66"} {
puts "ERROR: the circle is not selected with overlap mode activated"
}

8
tests/bugs/vis/bug26680
View File

@ -16,20 +16,20 @@ meshcolors m elem2 1
vselmode 0 1
vmoveto 200 200
if {[vreadpixel 197 257 name] != "CYAN1 1"} {
if {[vreadpixel 197 257 rgb name] != "CYAN1"} {
puts "ERROR: presentation for dynamic highlight of the object is wrong!"
}
vmoveto 0 0
if {[vreadpixel 197 257 name] != "BLUE2 1"} {
if {[vreadpixel 197 257 rgb name] != "BLUE2"} {
puts "ERROR: the object is not unhighlighted after dynamic highlight!"
}
vselect 200 200
if {[vreadpixel 197 257 name] != "GRAY80 1"} {
if {[vreadpixel 197 257 rgb name] != "GRAY93"} {
puts "ERROR: presentation for selection highlight is wrong!"
}
vselect 0 0
if {[vreadpixel 197 257 name] != "BLUE2 1"} {
if {[vreadpixel 197 257 rgb name] != "BLUE2"} {
puts "ERROR: the object is not unhighlighted after selection highlight!"
}

2
tests/bugs/vis/bug26960
View File

@ -21,7 +21,7 @@ if {[vreadpixel 350 140 rgb name] != "BLACK"} {
puts "ERROR: wrong inital location"
}
vsetlocation b 0.5 0 0
if {[vreadpixel 350 140 rgb name] != "CYAN1"} {
if {[vreadpixel 350 140 rgb name] != "DARKTURQUOISE"} {
puts "ERROR: the transformation was not applied to highlight structure"
}

18
tests/v3d/materials/bug27617 Normal file
View File

@ -0,0 +1,18 @@
puts "========"
puts "OCC27617: Visualization, TKOpenGl - apply highlighting color without disabling lighting"
puts "========"
pload MODELING VISUALIZATION
box b 1 2 3
vclear
vinit View1
vdisplay -highMode 1 -dispMode 1 b
vaxo
vfit
vrotate 1 0 0
vfit
vmoveto 250 150
set aColor [vreadpixel 200 150 name rgb]
if { "$aColor" != "TURQUOISE4" } {
puts "Error: Wrong dynamic highlight color"
}