Added new flag Graphic3d_AspectFillArea3d::ToDrawSilhouette() activating silhouette (outline) rendering.
The new feature can simulate fake HLR look-n-feel,
when combined with Aspect_IS_HIDDENLINE interior style (filling object with background color),
face boundary edges (with most continuity flag set to c2 or lower).
Silhouette GLSL program is very simple - it displaces model alongside vertex normal,
so that it is applicable only to smooth surfaces and closed volumes,
and produces visual artifacts at sharp corners, especially when face boundary is disabled.
OpenGl_SetOfShaderPrograms has been modified so that to reduce
dimensions of the grid of static size based on amount of program combinations.
OpenGl_PrimitiveArray no more allocates VBO resources if primitive array
is marked to be not drawn via interior style / line type / marker type.
myToSkipFirstEdge (false),
myToDistinguishMaterials (false),
myToDrawEdges (false),
+ myToDrawSilhouette (false),
myToSuppressBackFaces (true),
myToMapTexture (false)
{
myToSkipFirstEdge (false),
myToDistinguishMaterials (false),
myToDrawEdges (false),
+ myToDrawSilhouette (false),
myToSuppressBackFaces (true),
myToMapTexture (false)
{
//! Set skip first triangle edge flag for drawing wireframe presentation of quads array split into triangles.
void SetSkipFirstEdge (bool theToSkipFirstEdge) { myToSkipFirstEdge = theToSkipFirstEdge; }
+ //! Returns TRUE if silhouette (outline) should be drawn (with edge color and width); FALSE by default.
+ bool ToDrawSilhouette() const { return myToDrawSilhouette; }
+
+ //! Enables/disables drawing silhouette (outline).
+ void SetDrawSilhouette (bool theToDraw) { myToDrawSilhouette = theToDraw; }
+
public:
//! Returns the hatch type used when InteriorStyle is IS_HATCH
bool myToSkipFirstEdge;
bool myToDistinguishMaterials;
bool myToDrawEdges;
+ bool myToDrawSilhouette;
bool myToSuppressBackFaces;
bool myToMapTexture;
myAttribs = new Graphic3d_Buffer (anAlloc);
myDrawMode = GL_TRIANGLE_STRIP;
+ myIsFillType = true;
myGradientParams.color1 = OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 1.0f);
myGradientParams.color2 = OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 1.0f);
#include <OpenGl_ShaderProgram.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_VertexBufferCompat.hxx>
+#include <OpenGl_View.hxx>
#include <OpenGl_Workspace.hxx>
#include <Graphic3d_TextureParams.hxx>
#include <NCollection_AlignedAllocator.hxx>
? theWorkspace->ApplyAspectMarker()
: theWorkspace->AspectMarker();
- // create VBOs on first render call
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
- if (!myIsVboInit)
- {
- // compatibility - keep data to draw markers using display lists
- Standard_Boolean toKeepData = Standard_False;
- if (myDrawMode == GL_POINTS)
- {
- const Handle(OpenGl_TextureSet)& aSpriteNormRes = anAspectMarker->SpriteRes (aCtx);
- const OpenGl_PointSprite* aSpriteNorm = !aSpriteNormRes.IsNull() ? dynamic_cast<const OpenGl_PointSprite*> (aSpriteNormRes->First().get()) : NULL;
- toKeepData = aSpriteNorm != NULL
- && aSpriteNorm->IsDisplayList();
- }
- #if defined (GL_ES_VERSION_2_0)
- processIndices (aCtx);
- #endif
- buildVBO (aCtx, toKeepData);
- myIsVboInit = Standard_True;
- }
- else if ((!myAttribs.IsNull()
- && myAttribs->IsMutable())
- || (!myIndices.IsNull()
- && myIndices->IsMutable()))
- {
- updateVBO (aCtx);
- }
- // Temporarily disable environment mapping
Handle(OpenGl_TextureSet) aTextureBack;
bool toDrawArray = true;
int toDrawInteriorEdges = 0; // 0 - no edges, 1 - glsl edges, 2 - polygonMode
- if (myDrawMode > GL_LINE_STRIP)
+ if (myIsFillType)
{
toDrawArray = anAspectFace->Aspect()->InteriorStyle() != Aspect_IS_EMPTY;
if (anAspectFace->Aspect()->ToDrawEdges())
#endif
}
}
- else if (myDrawMode <= GL_LINE_STRIP)
+ else
{
- aTextureBack = aCtx->BindTextures (Handle(OpenGl_TextureSet)());
if (myDrawMode == GL_POINTS)
{
- toDrawArray = anAspectMarker->Aspect()->Type() != Aspect_TOM_EMPTY;
+ if (anAspectMarker->Aspect()->Type() == Aspect_TOM_EMPTY)
+ {
+ return;
+ }
}
else
{
- toDrawArray = anAspectLine->Aspect()->Type() != Aspect_TOL_EMPTY;
+ if (anAspectLine->Aspect()->Type() == Aspect_TOL_EMPTY)
+ {
+ return;
+ }
+ }
+
+ // Temporarily disable environment mapping
+ aTextureBack = aCtx->BindTextures (Handle(OpenGl_TextureSet)());
+ }
+
+ // create VBOs on first render call
+ if (!myIsVboInit)
+ {
+ // compatibility - keep data to draw markers using display lists
+ Standard_Boolean toKeepData = Standard_False;
+ if (myDrawMode == GL_POINTS)
+ {
+ const Handle(OpenGl_TextureSet)& aSpriteNormRes = anAspectMarker->SpriteRes (aCtx);
+ const OpenGl_PointSprite* aSpriteNorm = !aSpriteNormRes.IsNull() ? dynamic_cast<const OpenGl_PointSprite*> (aSpriteNormRes->First().get()) : NULL;
+ toKeepData = aSpriteNorm != NULL
+ && aSpriteNorm->IsDisplayList();
}
+ #if defined (GL_ES_VERSION_2_0)
+ processIndices (aCtx);
+ #endif
+ buildVBO (aCtx, toKeepData);
+ myIsVboInit = Standard_True;
+ }
+ else if ((!myAttribs.IsNull()
+ && myAttribs->IsMutable())
+ || (!myIndices.IsNull()
+ && myIndices->IsMutable()))
+ {
+ updateVBO (aCtx);
}
Graphic3d_TypeOfShadingModel aShadingModel = Graphic3d_TOSM_UNLIT;
aCtx->SetTextureMatrix (aCtx->ActiveTextures()->First()->Sampler()->Parameters());
}
- if (myDrawMode <= GL_LINE_STRIP)
+ const Graphic3d_Vec4* aFaceColors = !myBounds.IsNull() && !toHilight && anAspectFace->Aspect()->InteriorStyle() != Aspect_IS_HIDDENLINE
+ ? myBounds->Colors
+ : NULL;
+ if (!myIsFillType)
{
const OpenGl_Vec4& aLineColor = myDrawMode == GL_POINTS ? theWorkspace->MarkerColor() : theWorkspace->LineColor();
aCtx->SetColor4fv (aLineColor);
- }
- else
- {
- const OpenGl_Vec4& anInteriorColor = theWorkspace->InteriorColor();
- aCtx->SetColor4fv (anInteriorColor);
- }
- if (myDrawMode == GL_LINES
- || myDrawMode == GL_LINE_STRIP)
- {
- aCtx->SetTypeOfLine (anAspectLine->Aspect()->Type());
- aCtx->SetLineWidth (anAspectLine->Aspect()->Width());
+ if (myDrawMode == GL_LINES
+ || myDrawMode == GL_LINE_STRIP)
+ {
+ aCtx->SetTypeOfLine (anAspectLine->Aspect()->Type());
+ aCtx->SetLineWidth (anAspectLine->Aspect()->Width());
+ }
+
+ drawArray (theWorkspace, aFaceColors, hasColorAttrib);
+ aCtx->BindTextures (aTextureBack);
+ return;
}
- const Graphic3d_Vec4* aFaceColors = !myBounds.IsNull() && !toHilight && anAspectFace->Aspect()->InteriorStyle() != Aspect_IS_HIDDENLINE
- ? myBounds->Colors
- : NULL;
+ const OpenGl_Vec4& anInteriorColor = theWorkspace->InteriorColor();
+ aCtx->SetColor4fv (anInteriorColor);
drawArray (theWorkspace, aFaceColors, hasColorAttrib);
- }
- if (myDrawMode <= GL_LINE_STRIP)
- {
- aCtx->BindTextures (aTextureBack);
+ // draw outline - only closed triangulation with defined vertex normals can be drawn in this way
+ if (anAspectFace->Aspect()->ToDrawSilhouette()
+ && aCtx->ToCullBackFaces()
+ && aCtx->ShaderManager()->BindOutlineProgram())
+ {
+ const Graphic3d_Vec2i aViewSize (aCtx->Viewport()[2], aCtx->Viewport()[3]);
+ const Standard_Integer aMin = aViewSize.minComp();
+ const GLfloat anEdgeWidth = (GLfloat )anAspectFace->Aspect()->EdgeWidth() * aCtx->LineWidthScale() / (GLfloat )aMin;
+ const GLfloat anOrthoScale = theWorkspace->View()->Camera()->IsOrthographic() ? (GLfloat )theWorkspace->View()->Camera()->Scale() : -1.0f;
+
+ const Handle(OpenGl_ShaderProgram)& anOutlineProgram = aCtx->ActiveProgram();
+ anOutlineProgram->SetUniform (aCtx, anOutlineProgram->GetStateLocation (OpenGl_OCCT_SILHOUETTE_THICKNESS), anEdgeWidth);
+ anOutlineProgram->SetUniform (aCtx, anOutlineProgram->GetStateLocation (OpenGl_OCCT_ORTHO_SCALE), anOrthoScale);
+ aCtx->SetColor4fv (anAspectFace->Aspect()->EdgeColorRGBA());
+
+ aCtx->core11fwd->glCullFace (GL_FRONT);
+ drawArray (theWorkspace, NULL, false);
+
+ aCtx->core11fwd->glCullFace (GL_BACK);
+ }
}
+
#if !defined(GL_ES_VERSION_2_0)
- else if (toDrawInteriorEdges == 2)
+ // draw triangulation edges using Polygon Mode
+ if (toDrawInteriorEdges == 2)
{
if (anAspectFace->Aspect()->InteriorStyle() == Aspect_IS_HOLLOW
&& anAspectFace->Aspect()->EdgeLineType() == Aspect_TOL_SOLID)
OpenGl_PO_Point = 0x0001, //!< point marker
OpenGl_PO_VertColor = 0x0002, //!< per-vertex color
OpenGl_PO_TextureRGB = 0x0004, //!< handle RGB texturing
- OpenGl_PO_TextureA = 0x0008, //!< handle Alpha texturing
+ OpenGl_PO_TextureA = 0x0008, //!< handle Alpha texturing (point sprites only)
OpenGl_PO_TextureEnv = 0x0010, //!< handle environment map
OpenGl_PO_StippleLine = 0x0020, //!< stipple line
OpenGl_PO_ClipPlanes1 = 0x0040, //!< handle 1 clipping plane
OpenGl_PO_WriteOit = 0x0800, //!< write coverage buffer for Blended Order-Independent Transparency
//
OpenGl_PO_NB = 0x1000, //!< overall number of combinations
+ OpenGl_PO_HasTextures = OpenGl_PO_TextureRGB|OpenGl_PO_TextureA,
OpenGl_PO_NeedsGeomShader = OpenGl_PO_MeshEdges,
};
//! Alias to programs array of predefined length
+class OpenGl_SetOfPrograms : public Standard_Transient
+{
+ DEFINE_STANDARD_RTTI_INLINE(OpenGl_SetOfPrograms, Standard_Transient)
+public:
+
+ //! Empty constructor
+ OpenGl_SetOfPrograms() {}
+
+ //! Access program by index
+ Handle(OpenGl_ShaderProgram)& ChangeValue (Standard_Integer theProgramBits) { return myPrograms[theProgramBits]; }
+
+protected:
+ Handle(OpenGl_ShaderProgram) myPrograms[OpenGl_PO_NB]; //!< programs array
+};
+
+//! Alias to 2D programs array of predefined length
class OpenGl_SetOfShaderPrograms : public Standard_Transient
{
DEFINE_STANDARD_RTTI_INLINE(OpenGl_SetOfShaderPrograms, Standard_Transient)
//! Empty constructor
OpenGl_SetOfShaderPrograms() {}
+ //! Constructor
+ OpenGl_SetOfShaderPrograms (const Handle(OpenGl_SetOfPrograms)& thePrograms)
+ {
+ for (Standard_Integer aSetIter = 0; aSetIter < Graphic3d_TypeOfShadingModel_NB - 1; ++aSetIter)
+ {
+ myPrograms[aSetIter] = thePrograms;
+ }
+ }
+
//! Access program by index
Handle(OpenGl_ShaderProgram)& ChangeValue (Graphic3d_TypeOfShadingModel theShadingModel,
Standard_Integer theProgramBits)
{
- return myPrograms[theShadingModel][theProgramBits];
+ Handle(OpenGl_SetOfPrograms)& aSet = myPrograms[theShadingModel - 1];
+ if (aSet.IsNull())
+ {
+ aSet = new OpenGl_SetOfPrograms();
+ }
+ return aSet->ChangeValue (theProgramBits);
}
protected:
- Handle(OpenGl_ShaderProgram) myPrograms[Graphic3d_TypeOfShadingModel_NB][OpenGl_PO_NB]; //!< programs array
+ Handle(OpenGl_SetOfPrograms) myPrograms[Graphic3d_TypeOfShadingModel_NB - 1]; //!< programs array, excluding Graphic3d_TOSM_UNLIT
};
-DEFINE_STANDARD_HANDLE(OpenGl_SetOfShaderPrograms, Standard_Transient)
-
typedef NCollection_DataMap<TCollection_AsciiString, Handle(OpenGl_SetOfShaderPrograms)> OpenGl_MapOfShaderPrograms;
#endif // _OpenGl_SetOfShaderPrograms_HeaderFile
EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
EOL" }"
EOL
- EOL"Diffuse += occLight_Diffuse (theId).rgb * aNdotL * anAtten;"
- EOL"Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;"
+ EOL" Diffuse += occLight_Diffuse (theId).rgb * aNdotL * anAtten;"
+ EOL" Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;"
EOL"}";
//! Function computes contribution of spotlight source
EOL" return aMixColor;"
EOL"}";
+//! Compute gl_Position vertex shader output.
+const char THE_VERT_gl_Position[] =
+EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;";
+
+//! Displace gl_Position alongside vertex normal for outline rendering.
+//! This code adds silhouette only for smooth surfaces of closed primitive, and produces visual artifacts on sharp edges.
+const char THE_VERT_gl_Position_OUTLINE[] =
+EOL" float anOutlineDisp = occOrthoScale > 0.0 ? occOrthoScale : gl_Position.w;"
+EOL" vec4 anOutlinePos = occVertex + vec4 (occNormal * (occSilhouetteThickness * anOutlineDisp), 0.0);"
+EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * anOutlinePos;";
+
#if !defined(GL_ES_VERSION_2_0)
static const GLfloat THE_DEFAULT_AMBIENT[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
OpenGl_ShaderManager::OpenGl_ShaderManager (OpenGl_Context* theContext)
: myFfpProgram (new OpenGl_ShaderProgramFFP()),
myShadingModel (Graphic3d_TOSM_VERTEX),
- myUnlitPrograms (new OpenGl_SetOfShaderPrograms()),
+ myUnlitPrograms (new OpenGl_SetOfPrograms()),
myContext (theContext),
myHasLocalOrigin (Standard_False),
myLastView (NULL)
{
myProgramList.Clear();
myLightPrograms.Nullify();
- myUnlitPrograms = new OpenGl_SetOfShaderPrograms();
+ myUnlitPrograms = new OpenGl_SetOfPrograms();
+ myOutlinePrograms.Nullify();
myMapOfLightPrograms.Clear();
myFontProgram.Nullify();
myBlitProgram.Nullify();
const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
if (aLights.IsNull())
{
- myLightPrograms = myUnlitPrograms;
+ if (!myMapOfLightPrograms.Find ("unlit", myLightPrograms))
+ {
+ myLightPrograms = new OpenGl_SetOfShaderPrograms (myUnlitPrograms);
+ myMapOfLightPrograms.Bind ("unlit", myLightPrograms);
+ }
return;
}
OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
- TCollection_AsciiString aSrcVert =
- EOL"void main()"
+ TCollection_AsciiString aSrcVert = TCollection_AsciiString()
+ + EOL"void main()"
EOL"{"
EOL" TexCoord = occTexCoord.st;"
- EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
- EOL"}";
+ + THE_VERT_gl_Position
+ + EOL"}";
TCollection_AsciiString
aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).a; }";
TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").a; }";
#if !defined(GL_ES_VERSION_2_0)
if (myContext->core11 == NULL
- && (theBits & OpenGl_PO_TextureA) != 0)
+ && (theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureA)
{
aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").r; }";
}
return aSrcGetAlpha;
}
-namespace
-{
-
- // =======================================================================
- // function : textureUsed
- // purpose :
- // =======================================================================
- static bool textureUsed (const Standard_Integer theBits)
- {
- return (theBits & OpenGl_PO_TextureA) != 0 || (theBits & OpenGl_PO_TextureRGB) != 0;
- }
-
-}
-
// =======================================================================
// function : defaultGlslVersion
// purpose :
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderManager::prepareStdProgramUnlit (Handle(OpenGl_ShaderProgram)& theProgram,
- const Standard_Integer theBits)
+ Standard_Integer theBits,
+ Standard_Boolean theIsOutline)
{
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
TCollection_AsciiString aSrcVert, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha, aSrcVertEndMain;
aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
#endif
- if ((theBits & OpenGl_PO_TextureRGB) != 0)
+ if ((theBits & OpenGl_PO_HasTextures) != 0)
{
- aSrcFragGetColor =
- EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord "); }";
- }
+ if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
+ {
+ aSrcFragGetColor =
+ EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord "); }";
+ }
- if (textureUsed (theBits))
- {
aSrcGetAlpha = pointSpriteAlphaSrc (theBits);
#if !defined(GL_ES_VERSION_2_0)
aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
}
- if ((theBits & OpenGl_PO_TextureRGB) != 0)
+ if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
{
aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
aProgramSrc->SetWeightOitOutput (true);
}
- if ((theBits & OpenGl_PO_StippleLine) != 0)
+ if (theIsOutline)
+ {
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occOrthoScale", Graphic3d_TOS_VERTEX));
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occSilhouetteThickness", Graphic3d_TOS_VERTEX));
+ aSrcVertEndMain = THE_VERT_gl_Position_OUTLINE;
+ }
+ else if ((theBits & OpenGl_PO_StippleLine) != 0)
{
const Standard_Integer aBits = defaultGlslVersion (aProgramSrc, "unlit", theBits);
if ((aBits & OpenGl_PO_StippleLine) != 0)
+ EOL"void main()"
EOL"{"
+ aSrcVertExtraMain
- + EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
+ + THE_VERT_gl_Position
+ aSrcVertEndMain
+ EOL"}";
+ aSrcFragMainGetColor
+ EOL"}";
- defaultGlslVersion (aProgramSrc, "unlit", theBits);
+ defaultGlslVersion (aProgramSrc, theIsOutline ? "outline" : "unlit", theBits);
aProgramSrc->SetNbLightsMax (0);
aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
const Standard_Integer theBits)
{
TCollection_AsciiString aSrcFragGetColor;
- if ((theBits & OpenGl_PO_TextureA) != 0)
+ if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureA)
{
aSrcFragGetColor = pointSpriteAlphaSrc (theBits) +
EOL"vec4 getColor(void)"
EOL" return aColor;"
EOL"}";
}
- else if ((theBits & OpenGl_PO_TextureRGB) != 0)
+ else if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
{
aSrcFragGetColor = TCollection_AsciiString() +
EOL"vec4 getColor(void)"
aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
#endif
- if (textureUsed (theBits))
+ if ((theBits & OpenGl_PO_HasTextures) != 0)
{
#if !defined(GL_ES_VERSION_2_0)
if (myContext->core11 != NULL
}
else
{
- if ((theBits & OpenGl_PO_TextureRGB) != 0)
+ if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
{
aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
EOL" FrontColor = computeLighting (normalize (aNormal), normalize (aView), aPosition, true);"
EOL" BackColor = computeLighting (normalize (aNormal), normalize (aView), aPosition, false);"
+ aSrcVertExtraMain
- + EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
- EOL"}";
+ + THE_VERT_gl_Position
+ + EOL"}";
TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
#endif
- if (textureUsed (theBits))
+ if ((theBits & OpenGl_PO_HasTextures) != 0)
{
#if !defined(GL_ES_VERSION_2_0)
if (myContext->core11 != NULL
}
else
{
- if ((theBits & OpenGl_PO_TextureRGB) != 0)
+ if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
{
aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
EOL" Position = occWorldViewMatrix * PositionWorld;"
+ EOL" View = vec3 (0.0, 0.0, 1.0);"
+ aSrcVertExtraMain
- + EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
- EOL"}";
+ + THE_VERT_gl_Position
+ + EOL"}";
TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
Standard_Boolean theEnableEnvMap,
const Handle(OpenGl_ShaderProgram)& theCustomProgram)
{
- return BindFaceProgram (theTextures, theShadingModel, theAlphaMode, Aspect_IS_SOLID, theHasVertColor, theEnableEnvMap, false, theCustomProgram);
+ return BindFaceProgram (theTextures, theShadingModel, theAlphaMode, Aspect_IS_SOLID,
+ theHasVertColor, theEnableEnvMap, false, theCustomProgram);
}
//! Bind program for filled primitives rendering
return bindProgramWithState (myFontProgram);
}
+ //! Bind program for outline rendering
+ Standard_Boolean BindOutlineProgram()
+ {
+ if (myContext->caps->ffpEnable)
+ {
+ return false;
+ }
+
+ const Standard_Integer aBits = getProgramBits (Handle(OpenGl_TextureSet)(), Graphic3d_AlphaMode_Opaque, Aspect_IS_SOLID, false, false, false);
+ if (myOutlinePrograms.IsNull())
+ {
+ myOutlinePrograms = new OpenGl_SetOfPrograms();
+ }
+ Handle(OpenGl_ShaderProgram)& aProgram = myOutlinePrograms->ChangeValue (aBits);
+ if (aProgram.IsNull())
+ {
+ prepareStdProgramUnlit (aProgram, aBits, true);
+ }
+ return bindProgramWithState (aProgram);
+ }
+
//! Bind program for FBO blit operation.
Standard_Boolean BindFboBlitProgram()
{
{
// If environment map is enabled lighting calculations are
// not needed (in accordance with default OCCT behavior)
- Handle(OpenGl_ShaderProgram)& aProgram = myUnlitPrograms->ChangeValue (Graphic3d_TOSM_UNLIT, theBits);
+ Handle(OpenGl_ShaderProgram)& aProgram = myUnlitPrograms->ChangeValue (theBits);
if (aProgram.IsNull())
{
- prepareStdProgramUnlit (aProgram, theBits);
+ prepareStdProgramUnlit (aProgram, theBits, false);
}
return aProgram;
}
//! Prepare standard GLSL program without lighting.
Standard_EXPORT Standard_Boolean prepareStdProgramUnlit (Handle(OpenGl_ShaderProgram)& theProgram,
- const Standard_Integer theBits);
+ Standard_Integer theBits,
+ Standard_Boolean theIsOutline = false);
//! Prepare standard GLSL program with lighting.
Standard_Boolean prepareStdProgramLight (Handle(OpenGl_ShaderProgram)& theProgram,
{
switch (theShadingModel)
{
- case Graphic3d_TOSM_UNLIT: return prepareStdProgramUnlit (theProgram, theBits);
+ case Graphic3d_TOSM_UNLIT: return prepareStdProgramUnlit (theProgram, theBits, false);
case Graphic3d_TOSM_FACET: return prepareStdProgramPhong (theProgram, theBits, true);
case Graphic3d_TOSM_VERTEX: return prepareStdProgramGouraud(theProgram, theBits);
case Graphic3d_TOSM_DEFAULT:
Graphic3d_TypeOfShadingModel myShadingModel; //!< lighting shading model
OpenGl_ShaderProgramList myProgramList; //!< The list of shader programs
Handle(OpenGl_SetOfShaderPrograms) myLightPrograms; //!< pointer to active lighting programs matrix
- Handle(OpenGl_SetOfShaderPrograms) myUnlitPrograms; //!< programs matrix without lighting
+ Handle(OpenGl_SetOfPrograms) myUnlitPrograms; //!< programs matrix without lighting
+ Handle(OpenGl_SetOfPrograms) myOutlinePrograms; //!< programs matrix without lighting for outline presentation
Handle(OpenGl_ShaderProgram) myFontProgram; //!< standard program for textured text
Handle(OpenGl_ShaderProgram) myBlitProgram; //!< standard program for FBO blit emulation
Handle(OpenGl_ShaderProgram) myBoundBoxProgram; //!< standard program for bounding box
"occLineFeather", // OpenGl_OCCT_LINE_FEATHER
"occWireframeColor", // OpenGl_OCCT_WIREFRAME_COLOR
"occIsQuadMode", // OpenGl_OCCT_QUAD_MODE_STATE
+
+ "occOrthoScale", // OpenGl_OCCT_ORTHO_SCALE
+ "occSilhouetteThickness" // OpenGl_OCCT_SILHOUETTE_THICKNESS
};
namespace
OpenGl_OCCT_WIREFRAME_COLOR,
OpenGl_OCCT_QUAD_MODE_STATE,
+ // Parameters of outline (silhouette) shader
+ OpenGl_OCCT_ORTHO_SCALE,
+ OpenGl_OCCT_SILHOUETTE_THICKNESS,
+
// DON'T MODIFY THIS ITEM (insert new items before it)
OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES
};
Standard_Integer ToSetInterior;
Aspect_InteriorStyle InteriorStyle;
+ Standard_Integer ToSetDrawSilhouette;
+
Standard_Integer ToSetDrawEdges;
Standard_Integer ToSetQuadEdges;
ShadingModel (Graphic3d_TOSM_DEFAULT),
ToSetInterior (0),
InteriorStyle (Aspect_IS_SOLID),
+ ToSetDrawSilhouette (0),
ToSetDrawEdges (0),
ToSetQuadEdges (0),
ToSetEdgeColor (0),
&& ToSetHatch == 0
&& ToSetShadingModel == 0
&& ToSetInterior == 0
+ && ToSetDrawSilhouette == 0
&& ToSetDrawEdges == 0
&& ToSetQuadEdges == 0
&& ToSetEdgeColor == 0
}
}
}
+ if (ToSetDrawSilhouette != 0)
+ {
+ if (ToSetDrawSilhouette != -1
+ || theDrawer->HasOwnShadingAspect())
+ {
+ toRecompute = theDrawer->SetupOwnShadingAspect (aDefDrawer) || toRecompute;
+ theDrawer->ShadingAspect()->Aspect()->SetDrawSilhouette (ToSetDrawSilhouette == 1);
+ }
+ }
if (ToSetDrawEdges != 0)
{
if (ToSetDrawEdges != -1
aChangeSet->ToSetInterior = -1;
aChangeSet->InteriorStyle = Aspect_IS_SOLID;
}
+ else if (anArg == "-setdrawoutline"
+ || anArg == "-setdrawsilhouette"
+ || anArg == "-setoutline"
+ || anArg == "-setsilhouette"
+ || anArg == "-outline"
+ || anArg == "-outlined"
+ || anArg == "-silhouette")
+ {
+ bool toDrawOutline = true;
+ if (anArgIter + 1 < theArgNb
+ && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toDrawOutline))
+ {
+ ++anArgIter;
+ }
+ aChangeSet->ToSetDrawSilhouette = toDrawOutline ? 1 : -1;
+ }
else if (anArg == "-setdrawedges"
|| anArg == "-setdrawedge"
|| anArg == "-drawedges"
aChangeSet->ShadingModel = Graphic3d_TOSM_DEFAULT;
aChangeSet->ToSetInterior = -1;
aChangeSet->InteriorStyle = Aspect_IS_SOLID;
+ aChangeSet->ToSetDrawSilhouette = -1;
aChangeSet->ToSetDrawEdges = -1;
aChangeSet->ToSetQuadEdges = -1;
aChangeSet->ToSetEdgeColor = -1;
"\n\t\t: [-setFaceBoundaryDraw {0|1}] [-setMostContinuity {c0|c1|c2|c3|cn}"
"\n\t\t: [-setFaceBoundaryWidth LineWidth] [-setFaceBoundaryColor R G B] [-setFaceBoundaryType LineType]"
"\n\t\t: [-setDrawEdges {0|1}] [-setEdgeType LineType] [-setEdgeColor R G B] [-setQuadEdges {0|1}]"
+ "\n\t\t: [-setDrawSilhouette {0|1}]"
"\n\t\t: [-setAlphaMode {opaque|mask|blend|blendauto} [alphaCutOff=0.5]]"
"\n\t\t: Manage presentation properties of all, selected or named objects."
"\n\t\t: When -subshapes is specified than following properties will be"
--- /dev/null
+puts "========"
+puts "0024437: Visualization - silhouette edges based on OpenGL"
+puts "Draw box and sphere primitives"
+puts "========"
+puts ""
+
+pload MODELING VISUALIZATION
+
+vclear
+vinit View1
+vsetcolorbg 220 220 220
+#vsetgradientbg 180 200 255 180 180 180 2
+vaxo
+
+psphere s 1.0
+box b 2 -2 -2 1 2 3
+
+vdisplay -dispMode 1 b s
+vfit
+
+vaspects b s -setDrawSilhouette 1 -setEdgeColor RED -setEdgeWidth 4 -setFaceBoundaryDraw 1 -setFaceBoundaryColor BLUE1 -setFaceBoundaryWidth 1 -setInteriorStyle HIDDENLINE
+vdump $::imagedir/${::casename}_0.png
+
+vaspects b s -setDrawSilhouette 1 -setEdgeColor RED -setEdgeWidth 4 -setFaceBoundaryDraw 1 -setFaceBoundaryColor RED -setFaceBoundaryWidth 4 -setInteriorStyle HIDDENLINE
+vdump $::imagedir/${::casename}_1.png
--- /dev/null
+puts "========"
+puts "0024437: Visualization - silhouette edges based on OpenGL"
+puts "Draw bottle sample"
+puts "========"
+puts ""
+
+pload MODELING VISUALIZATION
+
+# test for creation of bottle as in tutorial (script is in samples)
+source $env(CSF_OCCTSamplesPath)/tcl/bottle.tcl
+
+vsetcolorbg 255 255 255
+vzbufftrihedron -type wireframe -colorLabels BLACK
+vaspects bottle -setDrawSilhouette 1 -setEdgeColor BLACK -setFaceBoundaryDraw 1 -setMostContinuity c0 -setFaceBoundaryColor BLACK -setInteriorStyle HIDDENLINE
+vrenderparams -rendScale 2
+
+vcamera -ortho
+vfit
+vaspects bottle -setDrawSilhouette 0
+vdump $::imagedir/${::casename}_ortho0.png
+
+vaspects bottle -setDrawSilhouette 1
+vdump $::imagedir/${::casename}_ortho1.png
+
+vcamera -persp
+vfit
+vaspects bottle -setDrawSilhouette 0
+vdump $::imagedir/${::casename}_persp0.png
+
+vaspects bottle -setDrawSilhouette 1
+vdump $::imagedir/${::casename}_persp1.png