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

0024228: TKOpenGL - destroy GL context at view close

Browse Source 
- OpenGl_Display - release GL resources correctly on closing views
- OpenGl_AspectFace, OpenGl_AspectText, OpenGl_AspectLine, OpenGl_AspectMarker - initialize OpenGl resources on demand, when context is available.
- Graphic3d_TextureRoot - use const modifier for GetId method to avoid asynchronous resource state at OpenGl.
- Do not call OpenGL functions if no active GL context has been left
- Reset thread's context before deletion for Mesa WNT
This commit is contained in:
apl 2013-10-24 12:53:42 +04:00 committed by abv
parent ab2db9a59e
commit fd4a696350
42 changed files with 956 additions and 624 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/Graphic3d/Graphic3d_TextureRoot.cdl
View File

@ -82,6 +82,7 @@ is
-- for each instance of Graphic3d_AspectFillArea3d where texture will be used. -- for each instance of Graphic3d_AspectFillArea3d where texture will be used.
-- . -- .
-- @return texture identifier. -- @return texture identifier.
---C++: return const &
GetImage (me) returns PixMap_Handle from Image GetImage (me) returns PixMap_Handle from Image
is virtual; is virtual;

2
src/Graphic3d/Graphic3d_TextureRoot.cxx
View File

@ -108,7 +108,7 @@ void Graphic3d_TextureRoot::Destroy() const
// function : GetId // function : GetId
// purpose : // purpose :
// ======================================================================= // =======================================================================
TCollection_AsciiString Graphic3d_TextureRoot::GetId() const const TCollection_AsciiString& Graphic3d_TextureRoot::GetId() const
{ {
return myTexId; return myTexId;
} }

352
src/OpenGl/OpenGl_AspectFace.cxx
View File

@ -47,6 +47,7 @@ namespace
}; };
static TEL_POFFSET_PARAM THE_DEFAULT_POFFSET = { Aspect_POM_Fill, 1.0F, 0.0F }; static TEL_POFFSET_PARAM THE_DEFAULT_POFFSET = { Aspect_POM_Fill, 1.0F, 0.0F };
static const TCollection_AsciiString THE_EMPTY_KEY;
}; };
@ -121,153 +122,119 @@ void OpenGl_AspectFace::convertMaterial (const CALL_DEF_MATERIAL& theMat,
// purpose : // purpose :
// ======================================================================= // =======================================================================
OpenGl_AspectFace::OpenGl_AspectFace() OpenGl_AspectFace::OpenGl_AspectFace()
: InteriorStyle (Aspect_IS_SOLID), : myInteriorStyle (Aspect_IS_SOLID),
Edge (Aspect_IS_SOLID), myEdge (TOff),
Hatch (TOn), myHatch (TEL_HS_SOLID),
DistinguishingMode (TEL_HS_SOLID), myDistinguishingMode (TOff),
CullingMode (TelCullNone), myCullingMode (TelCullNone),
doTextureMap (0) myIntFront (THE_DEFAULT_MATERIAL),
{ myIntBack (THE_DEFAULT_MATERIAL),
IntFront = THE_DEFAULT_MATERIAL; myPolygonOffset (THE_DEFAULT_POFFSET),
IntBack = THE_DEFAULT_MATERIAL; myDoTextureMap (false),
PolygonOffset = THE_DEFAULT_POFFSET; myTextureMap(),
} myIsTextureInit (Standard_False),
myTextureRes(),
myTextureId()
{}
// ======================================================================= // =======================================================================
// function : Init // function : SetAspect
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_AspectFace::Init (const Handle(OpenGl_Context)& theContext, void OpenGl_AspectFace::SetAspect (const CALL_DEF_CONTEXTFILLAREA& theAspect)
const CALL_DEF_CONTEXTFILLAREA& theAspect)
{ {
InteriorStyle = (Aspect_InteriorStyle )theAspect.Style; myInteriorStyle = (Aspect_InteriorStyle )theAspect.Style;
Edge = theAspect.Edge ? TOn : TOff; myEdge = theAspect.Edge ? TOn : TOff;
//TelInteriorStyleIndex //TelInteriorStyleIndex
switch (theAspect.Hatch) switch (theAspect.Hatch)
{ {
case 0: /* Aspect_HS_HORIZONTAL */ case 0: /* Aspect_HS_HORIZONTAL */
Hatch = TEL_HS_HORIZONTAL; myHatch = TEL_HS_HORIZONTAL;
break; break;
case 1: /* Aspect_HS_HORIZONTAL_WIDE */ case 1: /* Aspect_HS_HORIZONTAL_WIDE */
Hatch = TEL_HS_HORIZONTAL_SPARSE; myHatch = TEL_HS_HORIZONTAL_SPARSE;
break; break;
case 2: /* Aspect_HS_VERTICAL */ case 2: /* Aspect_HS_VERTICAL */
Hatch = TEL_HS_VERTICAL; myHatch = TEL_HS_VERTICAL;
break; break;
case 3: /* Aspect_HS_VERTICAL_WIDE */ case 3: /* Aspect_HS_VERTICAL_WIDE */
Hatch = TEL_HS_VERTICAL_SPARSE; myHatch = TEL_HS_VERTICAL_SPARSE;
break; break;
case 4: /* Aspect_HS_DIAGONAL_45 */ case 4: /* Aspect_HS_DIAGONAL_45 */
Hatch = TEL_HS_DIAG_45; myHatch = TEL_HS_DIAG_45;
break; break;
case 5: /* Aspect_HS_DIAGONAL_45_WIDE */ case 5: /* Aspect_HS_DIAGONAL_45_WIDE */
Hatch = TEL_HS_DIAG_45_SPARSE; myHatch = TEL_HS_DIAG_45_SPARSE;
break; break;
case 6: /* Aspect_HS_DIAGONAL_135 */ case 6: /* Aspect_HS_DIAGONAL_135 */
Hatch = TEL_HS_DIAG_135; myHatch = TEL_HS_DIAG_135;
break; break;
case 7: /* Aspect_HS_DIAGONAL_135_WIDE */ case 7: /* Aspect_HS_DIAGONAL_135_WIDE */
Hatch = TEL_HS_DIAG_135_SPARSE; myHatch = TEL_HS_DIAG_135_SPARSE;
break; break;
case 8: /* Aspect_HS_GRID */ case 8: /* Aspect_HS_GRID */
Hatch = TEL_HS_GRID; myHatch = TEL_HS_GRID;
break; break;
case 9: /* Aspect_HS_GRID_WIDE */ case 9: /* Aspect_HS_GRID_WIDE */
Hatch = TEL_HS_GRID_SPARSE; myHatch = TEL_HS_GRID_SPARSE;
break; break;
case 10: /* Aspect_HS_GRID_DIAGONAL */ case 10: /* Aspect_HS_GRID_DIAGONAL */
Hatch = TEL_HS_CROSS; myHatch = TEL_HS_CROSS;
break; break;
case 11: /* Aspect_HS_GRID_DIAGONAL_WIDE */ case 11: /* Aspect_HS_GRID_DIAGONAL_WIDE */
Hatch = TEL_HS_CROSS_SPARSE; myHatch = TEL_HS_CROSS_SPARSE;
break; break;
default: default:
Hatch = 0; myHatch = 0;
break; break;
} }
DistinguishingMode = theAspect.Distinguish ? TOn : TOff; myDistinguishingMode = theAspect.Distinguish ? TOn : TOff;
CullingMode = theAspect.BackFace ? TelCullBack : TelCullNone; myCullingMode = theAspect.BackFace ? TelCullBack : TelCullNone;
convertMaterial (theAspect.Front, IntFront); convertMaterial (theAspect.Front, myIntFront);
convertMaterial (theAspect.Back, IntBack); convertMaterial (theAspect.Back, myIntBack);
//TelInteriorColour //TelInteriorColour
IntFront.matcol.rgb[0] = (float )theAspect.IntColor.r; myIntFront.matcol.rgb[0] = (float )theAspect.IntColor.r;
IntFront.matcol.rgb[1] = (float )theAspect.IntColor.g; myIntFront.matcol.rgb[1] = (float )theAspect.IntColor.g;
IntFront.matcol.rgb[2] = (float )theAspect.IntColor.b; myIntFront.matcol.rgb[2] = (float )theAspect.IntColor.b;
IntFront.matcol.rgb[3] = 1.0f; myIntFront.matcol.rgb[3] = 1.0f;
//TelBackInteriorColour //TelBackInteriorColour
IntBack.matcol.rgb[0] = (float )theAspect.BackIntColor.r; myIntBack.matcol.rgb[0] = (float )theAspect.BackIntColor.r;
IntBack.matcol.rgb[1] = (float )theAspect.BackIntColor.g; myIntBack.matcol.rgb[1] = (float )theAspect.BackIntColor.g;
IntBack.matcol.rgb[2] = (float )theAspect.BackIntColor.b; myIntBack.matcol.rgb[2] = (float )theAspect.BackIntColor.b;
IntBack.matcol.rgb[3] = 1.0f; myIntBack.matcol.rgb[3] = 1.0f;
// setup texture myDoTextureMap = (theAspect.Texture.doTextureMap != 0);
doTextureMap = theAspect.Texture.doTextureMap; myTextureMap = theAspect.Texture.TextureMap;
const Handle(Graphic3d_TextureMap)& aNewTexture = theAspect.Texture.TextureMap;
TCollection_AsciiString aNewKey = aNewTexture.IsNull() ? TCollection_AsciiString() : aNewTexture->GetId();
TextureParams = aNewTexture.IsNull() ? NULL : aNewTexture->GetParams();
if (aNewKey.IsEmpty()
|| myTextureId != aNewKey)
{
if (!TextureRes.IsNull())
{
if (myTextureId.IsEmpty())
{
theContext->DelayedRelease (TextureRes);
TextureRes.Nullify();
}
else
{
TextureRes.Nullify(); // we need nullify all handles before ReleaseResource() call
theContext->ReleaseResource (myTextureId);
}
}
myTextureId = aNewKey;
if (!aNewTexture.IsNull()) const TCollection_AsciiString& aNewKey = myTextureMap.IsNull() ? THE_EMPTY_KEY : myTextureMap->GetId();
{ myIsTextureInit = (!aNewKey.IsEmpty() && myTextureId == aNewKey);
if (aNewKey.IsEmpty() || !theContext->GetResource<Handle(OpenGl_Texture)> (aNewKey, TextureRes))
{
TextureRes = new OpenGl_Texture (TextureParams);
Handle(Image_PixMap) anImage = aNewTexture->GetImage();
if (!anImage.IsNull())
{
TextureRes->Init (theContext, *anImage.operator->(), aNewTexture->Type());
}
if (!aNewKey.IsEmpty())
{
theContext->ShareResource (aNewKey, TextureRes);
}
}
}
}
//TelPolygonOffset //TelPolygonOffset
PolygonOffset.mode = (Aspect_PolygonOffsetMode )theAspect.PolygonOffsetMode; myPolygonOffset.mode = (Aspect_PolygonOffsetMode )theAspect.PolygonOffsetMode;
PolygonOffset.factor = theAspect.PolygonOffsetFactor; myPolygonOffset.factor = theAspect.PolygonOffsetFactor;
PolygonOffset.units = theAspect.PolygonOffsetUnits; myPolygonOffset.units = theAspect.PolygonOffsetUnits;
CALL_DEF_CONTEXTLINE anEdgeContext; CALL_DEF_CONTEXTLINE anEdgeAspect;
anEdgeContext.Color.r = (float )theAspect.EdgeColor.r; anEdgeAspect.Color.r = (float )theAspect.EdgeColor.r;
anEdgeContext.Color.g = (float )theAspect.EdgeColor.g; anEdgeAspect.Color.g = (float )theAspect.EdgeColor.g;
anEdgeContext.Color.b = (float )theAspect.EdgeColor.b; anEdgeAspect.Color.b = (float )theAspect.EdgeColor.b;
anEdgeContext.LineType = (Aspect_TypeOfLine )theAspect.LineType; anEdgeAspect.LineType = (Aspect_TypeOfLine )theAspect.LineType;
anEdgeContext.Width = (float )theAspect.Width; anEdgeAspect.Width = (float )theAspect.Width;
myAspectEdge.SetContext (anEdgeContext); myAspectEdge.SetAspect (anEdgeAspect);
} }
// ======================================================================= // =======================================================================
// function : Init // function : SetAspect
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_AspectFace::Init (const Handle(OpenGl_Context)& theContext, void OpenGl_AspectFace::SetAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect)
const Handle(Graphic3d_AspectFillArea3d)& theAspect)
{ {
CALL_DEF_CONTEXTFILLAREA aCAspect; CALL_DEF_CONTEXTFILLAREA aFaceContext;
Standard_Real aWidth; Standard_Real aWidth;
Quantity_Color aBackIntColor; Quantity_Color aBackIntColor;
Quantity_Color aEdgeColor; Quantity_Color aEdgeColor;
@ -279,124 +246,124 @@ void OpenGl_AspectFace::Init (const Handle(OpenGl_Context)& theContext,
theAspect->Values (aIntStyle, aIntColor, aBackIntColor, aEdgeColor, aLType, aWidth); theAspect->Values (aIntStyle, aIntColor, aBackIntColor, aEdgeColor, aLType, aWidth);
aIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB); aIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
aCAspect.Style = int (aIntStyle); aFaceContext.Style = int (aIntStyle);
aCAspect.IntColor.r = float (aColor.r()); aFaceContext.IntColor.r = float (aColor.r());
aCAspect.IntColor.g = float (aColor.g()); aFaceContext.IntColor.g = float (aColor.g());
aCAspect.IntColor.b = float (aColor.b()); aFaceContext.IntColor.b = float (aColor.b());
if (theAspect->Distinguish()) if (theAspect->Distinguish())
{ {
aBackIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB); aBackIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
} }
aCAspect.BackIntColor.r = float (aColor.r()); aFaceContext.BackIntColor.r = float (aColor.r());
aCAspect.BackIntColor.g = float (aColor.g()); aFaceContext.BackIntColor.g = float (aColor.g());
aCAspect.BackIntColor.b = float (aColor.b()); aFaceContext.BackIntColor.b = float (aColor.b());
aCAspect.Edge = theAspect->Edge () ? 1:0; aFaceContext.Edge = theAspect->Edge () ? 1:0;
aEdgeColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB); aEdgeColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
aCAspect.EdgeColor.r = float (aColor.r()); aFaceContext.EdgeColor.r = float (aColor.r());
aCAspect.EdgeColor.g = float (aColor.g()); aFaceContext.EdgeColor.g = float (aColor.g());
aCAspect.EdgeColor.b = float (aColor.b()); aFaceContext.EdgeColor.b = float (aColor.b());
aCAspect.LineType = int (aLType); aFaceContext.LineType = int (aLType);
aCAspect.Width = float (aWidth); aFaceContext.Width = float (aWidth);
aCAspect.Hatch = int (theAspect->HatchStyle ()); aFaceContext.Hatch = int (theAspect->HatchStyle ());
aCAspect.Distinguish = theAspect->Distinguish () ? 1:0; aFaceContext.Distinguish = theAspect->Distinguish () ? 1:0;
aCAspect.BackFace = theAspect->BackFace () ? 1:0; aFaceContext.BackFace = theAspect->BackFace () ? 1:0;
aCAspect.Back.Shininess = float ((theAspect->BackMaterial ()).Shininess ()); aFaceContext.Back.Shininess = float ((theAspect->BackMaterial ()).Shininess ());
aCAspect.Back.Ambient = float ((theAspect->BackMaterial ()).Ambient ()); aFaceContext.Back.Ambient = float ((theAspect->BackMaterial ()).Ambient ());
aCAspect.Back.Diffuse = float ((theAspect->BackMaterial ()).Diffuse ()); aFaceContext.Back.Diffuse = float ((theAspect->BackMaterial ()).Diffuse ());
aCAspect.Back.Specular = float ((theAspect->BackMaterial ()).Specular ()); aFaceContext.Back.Specular = float ((theAspect->BackMaterial ()).Specular ());
aCAspect.Back.Transparency = float ((theAspect->BackMaterial ()).Transparency ()); aFaceContext.Back.Transparency = float ((theAspect->BackMaterial ()).Transparency ());
aCAspect.Back.Emission = float ((theAspect->BackMaterial ()).Emissive ()); aFaceContext.Back.Emission = float ((theAspect->BackMaterial ()).Emissive ());
// Reflection mode // Reflection mode
aCAspect.Back.IsAmbient = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 ); aFaceContext.Back.IsAmbient = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
aCAspect.Back.IsDiffuse = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 ); aFaceContext.Back.IsDiffuse = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
aCAspect.Back.IsSpecular = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 ); aFaceContext.Back.IsSpecular = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
aCAspect.Back.IsEmission = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 ); aFaceContext.Back.IsEmission = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
// Material type // Material type
const Graphic3d_MaterialAspect aBackMat = theAspect->BackMaterial (); const Graphic3d_MaterialAspect aBackMat = theAspect->BackMaterial ();
Standard_Boolean isBackPhys = aBackMat.MaterialType (Graphic3d_MATERIAL_PHYSIC); Standard_Boolean isBackPhys = aBackMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
aCAspect.Back.IsPhysic = (isBackPhys ? 1 : 0 ); aFaceContext.Back.IsPhysic = (isBackPhys ? 1 : 0 );
// Specular Color // Specular Color
aCAspect.Back.ColorSpec.r = float (((theAspect->BackMaterial ()).SpecularColor ()).Red ()); aFaceContext.Back.ColorSpec.r = float (((theAspect->BackMaterial ()).SpecularColor ()).Red ());
aCAspect.Back.ColorSpec.g = float (((theAspect->BackMaterial ()).SpecularColor ()).Green ()); aFaceContext.Back.ColorSpec.g = float (((theAspect->BackMaterial ()).SpecularColor ()).Green ());
aCAspect.Back.ColorSpec.b = float (((theAspect->BackMaterial ()).SpecularColor ()).Blue ()); aFaceContext.Back.ColorSpec.b = float (((theAspect->BackMaterial ()).SpecularColor ()).Blue ());
// Ambient color // Ambient color
aCAspect.Back.ColorAmb.r = float (((theAspect->BackMaterial ()).AmbientColor ()).Red ()); aFaceContext.Back.ColorAmb.r = float (((theAspect->BackMaterial ()).AmbientColor ()).Red ());
aCAspect.Back.ColorAmb.g = float (((theAspect->BackMaterial ()).AmbientColor ()).Green ()); aFaceContext.Back.ColorAmb.g = float (((theAspect->BackMaterial ()).AmbientColor ()).Green ());
aCAspect.Back.ColorAmb.b = float (((theAspect->BackMaterial ()).AmbientColor ()).Blue ()); aFaceContext.Back.ColorAmb.b = float (((theAspect->BackMaterial ()).AmbientColor ()).Blue ());
// Diffuse color // Diffuse color
aCAspect.Back.ColorDif.r = float (((theAspect->BackMaterial ()).DiffuseColor ()).Red ()); aFaceContext.Back.ColorDif.r = float (((theAspect->BackMaterial ()).DiffuseColor ()).Red ());
aCAspect.Back.ColorDif.g = float (((theAspect->BackMaterial ()).DiffuseColor ()).Green ()); aFaceContext.Back.ColorDif.g = float (((theAspect->BackMaterial ()).DiffuseColor ()).Green ());
aCAspect.Back.ColorDif.b = float (((theAspect->BackMaterial ()).DiffuseColor ()).Blue ()); aFaceContext.Back.ColorDif.b = float (((theAspect->BackMaterial ()).DiffuseColor ()).Blue ());
// Emissive color // Emissive color
aCAspect.Back.ColorEms.r = float (((theAspect->BackMaterial ()).EmissiveColor ()).Red ()); aFaceContext.Back.ColorEms.r = float (((theAspect->BackMaterial ()).EmissiveColor ()).Red ());
aCAspect.Back.ColorEms.g = float (((theAspect->BackMaterial ()).EmissiveColor ()).Green ()); aFaceContext.Back.ColorEms.g = float (((theAspect->BackMaterial ()).EmissiveColor ()).Green ());
aCAspect.Back.ColorEms.b = float (((theAspect->BackMaterial ()).EmissiveColor ()).Blue ()); aFaceContext.Back.ColorEms.b = float (((theAspect->BackMaterial ()).EmissiveColor ()).Blue ());
aCAspect.Back.EnvReflexion = float ((theAspect->BackMaterial ()).EnvReflexion()); aFaceContext.Back.EnvReflexion = float ((theAspect->BackMaterial ()).EnvReflexion());
aCAspect.Front.Shininess = float ((theAspect->FrontMaterial ()).Shininess ()); aFaceContext.Front.Shininess = float ((theAspect->FrontMaterial ()).Shininess ());
aCAspect.Front.Ambient = float ((theAspect->FrontMaterial ()).Ambient ()); aFaceContext.Front.Ambient = float ((theAspect->FrontMaterial ()).Ambient ());
aCAspect.Front.Diffuse = float ((theAspect->FrontMaterial ()).Diffuse ()); aFaceContext.Front.Diffuse = float ((theAspect->FrontMaterial ()).Diffuse ());
aCAspect.Front.Specular = float ((theAspect->FrontMaterial ()).Specular ()); aFaceContext.Front.Specular = float ((theAspect->FrontMaterial ()).Specular ());
aCAspect.Front.Transparency = float ((theAspect->FrontMaterial ()).Transparency ()); aFaceContext.Front.Transparency = float ((theAspect->FrontMaterial ()).Transparency ());
aCAspect.Front.Emission = float ((theAspect->FrontMaterial ()).Emissive ()); aFaceContext.Front.Emission = float ((theAspect->FrontMaterial ()).Emissive ());
// Reflection mode // Reflection mode
aCAspect.Front.IsAmbient = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0); aFaceContext.Front.IsAmbient = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0);
aCAspect.Front.IsDiffuse = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0); aFaceContext.Front.IsDiffuse = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0);
aCAspect.Front.IsSpecular = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0); aFaceContext.Front.IsSpecular = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0);
aCAspect.Front.IsEmission = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0); aFaceContext.Front.IsEmission = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0);
// Materail type // Material type
const Graphic3d_MaterialAspect aFrontMat = theAspect->FrontMaterial (); const Graphic3d_MaterialAspect aFrontMat = theAspect->FrontMaterial ();
Standard_Boolean isFrontPhys = aFrontMat.MaterialType (Graphic3d_MATERIAL_PHYSIC); Standard_Boolean isFrontPhys = aFrontMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
aCAspect.Front.IsPhysic = (isFrontPhys ? 1 : 0 ); aFaceContext.Front.IsPhysic = (isFrontPhys ? 1 : 0 );
// Specular Color // Specular Color
aCAspect.Front.ColorSpec.r = float (((theAspect->FrontMaterial ()).SpecularColor ()).Red ()); aFaceContext.Front.ColorSpec.r = float (((theAspect->FrontMaterial ()).SpecularColor ()).Red ());
aCAspect.Front.ColorSpec.g = float (((theAspect->FrontMaterial ()).SpecularColor ()).Green ()); aFaceContext.Front.ColorSpec.g = float (((theAspect->FrontMaterial ()).SpecularColor ()).Green ());
aCAspect.Front.ColorSpec.b = float (((theAspect->FrontMaterial ()).SpecularColor ()).Blue ()); aFaceContext.Front.ColorSpec.b = float (((theAspect->FrontMaterial ()).SpecularColor ()).Blue ());
// Ambient color // Ambient color
aCAspect.Front.ColorAmb.r = float (((theAspect->FrontMaterial ()).AmbientColor ()).Red ()); aFaceContext.Front.ColorAmb.r = float (((theAspect->FrontMaterial ()).AmbientColor ()).Red ());
aCAspect.Front.ColorAmb.g = float (((theAspect->FrontMaterial ()).AmbientColor ()).Green ()); aFaceContext.Front.ColorAmb.g = float (((theAspect->FrontMaterial ()).AmbientColor ()).Green ());
aCAspect.Front.ColorAmb.b = float (((theAspect->FrontMaterial ()).AmbientColor ()).Blue ()); aFaceContext.Front.ColorAmb.b = float (((theAspect->FrontMaterial ()).AmbientColor ()).Blue ());
// Diffuse color // Diffuse color
aCAspect.Front.ColorDif.r = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Red ()); aFaceContext.Front.ColorDif.r = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Red ());
aCAspect.Front.ColorDif.g = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Green ()); aFaceContext.Front.ColorDif.g = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Green ());
aCAspect.Front.ColorDif.b = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Blue ()); aFaceContext.Front.ColorDif.b = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Blue ());
// Emissive color // Emissive color
aCAspect.Front.ColorEms.r = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Red ()); aFaceContext.Front.ColorEms.r = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Red ());
aCAspect.Front.ColorEms.g = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Green ()); aFaceContext.Front.ColorEms.g = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Green ());
aCAspect.Front.ColorEms.b = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Blue ()); aFaceContext.Front.ColorEms.b = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Blue ());
aCAspect.Front.EnvReflexion = float ((theAspect->FrontMaterial ()).EnvReflexion()); aFaceContext.Front.EnvReflexion = float ((theAspect->FrontMaterial ()).EnvReflexion());
aCAspect.IsDef = 1; aFaceContext.IsDef = 1;
aCAspect.Texture.TextureMap = theAspect->TextureMap(); aFaceContext.Texture.TextureMap = theAspect->TextureMap();
aCAspect.Texture.doTextureMap = theAspect->TextureMapState() ? 1 : 0; aFaceContext.Texture.doTextureMap = theAspect->TextureMapState() ? 1 : 0;
Standard_Integer aPolyMode; Standard_Integer aPolyMode;
Standard_ShortReal aPolyFactor, aPolyUnits; Standard_ShortReal aPolyFactor, aPolyUnits;
theAspect->PolygonOffsets (aPolyMode, aPolyFactor, aPolyUnits); theAspect->PolygonOffsets (aPolyMode, aPolyFactor, aPolyUnits);
aCAspect.PolygonOffsetMode = aPolyMode; aFaceContext.PolygonOffsetMode = aPolyMode;
aCAspect.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor; aFaceContext.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor;
aCAspect.PolygonOffsetUnits = (Standard_ShortReal)aPolyUnits; aFaceContext.PolygonOffsetUnits = (Standard_ShortReal)aPolyUnits;
Init (theContext, aCAspect); SetAspect (aFaceContext);
} }
// ======================================================================= // =======================================================================
@ -414,21 +381,66 @@ void OpenGl_AspectFace::Render (const Handle(OpenGl_Workspace)& theWorkspace) co
// ======================================================================= // =======================================================================
void OpenGl_AspectFace::Release (const Handle(OpenGl_Context)& theContext) void OpenGl_AspectFace::Release (const Handle(OpenGl_Context)& theContext)
{ {
if (!TextureRes.IsNull()) if (!myTextureRes.IsNull())
{ {
if (!theContext.IsNull()) if (!theContext.IsNull())
{ {
if (myTextureId.IsEmpty()) if (myTextureId.IsEmpty())
{ {
theContext->DelayedRelease (TextureRes); theContext->DelayedRelease (myTextureRes);
} }
else else
{ {
TextureRes.Nullify(); // we need nullify all handles before ReleaseResource() call myTextureRes.Nullify(); // we need nullify all handles before ReleaseResource() call
theContext->ReleaseResource (myTextureId); theContext->ReleaseResource (myTextureId);
} }
} }
TextureRes.Nullify(); myTextureRes.Nullify();
} }
myTextureId.Clear(); myTextureId.Clear();
} }
// =======================================================================
// function : buildTexure
// purpose :
// =======================================================================
void OpenGl_AspectFace::buildTexture (const Handle(OpenGl_Workspace)& theWorkspace) const
{
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
const TCollection_AsciiString& aNewKey = myTextureMap.IsNull() ? THE_EMPTY_KEY : myTextureMap->GetId();
if (aNewKey.IsEmpty() || myTextureId != aNewKey)
{
if (!myTextureRes.IsNull())
{
if (myTextureId.IsEmpty())
{
aContext->DelayedRelease (myTextureRes);
myTextureRes.Nullify();
}
else
{
myTextureRes.Nullify(); // we need nullify all handles before ReleaseResource() call
aContext->ReleaseResource (myTextureId);
}
}
myTextureId = aNewKey;
if (!myTextureMap.IsNull())
{
if (aNewKey.IsEmpty() || !aContext->GetResource<Handle(OpenGl_Texture)> (aNewKey, myTextureRes))
{
myTextureRes = new OpenGl_Texture (myTextureMap->GetParams());
Handle(Image_PixMap) anImage = myTextureMap->GetImage();
if (!anImage.IsNull())
{
myTextureRes->Init (aContext, *anImage.operator->(), myTextureMap->Type());
}
if (!aNewKey.IsEmpty())
{
aContext->ShareResource (aNewKey, myTextureRes);
}
}
}
}
}

182
src/OpenGl/OpenGl_AspectFace.hxx
View File

@ -23,11 +23,14 @@
#include <InterfaceGraphic_telem.hxx> #include <InterfaceGraphic_telem.hxx>
#include <Aspect_InteriorStyle.hxx> #include <Aspect_InteriorStyle.hxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <Handle_Graphic3d_TextureParams.hxx>
#include <OpenGl_AspectLine.hxx> #include <OpenGl_AspectLine.hxx>
#include <OpenGl_Element.hxx> #include <OpenGl_Element.hxx>
#include <Handle_OpenGl_Texture.hxx> #include <Handle_OpenGl_Texture.hxx>
#include <Graphic3d_TextureMap.hxx>
#include <Graphic3d_AspectFillArea3d.hxx> #include <Graphic3d_AspectFillArea3d.hxx>
#include <Handle_Graphic3d_TextureParams.hxx>
#define OPENGL_AMBIENT_MASK (1<<0) #define OPENGL_AMBIENT_MASK (1<<0)
#define OPENGL_DIFFUSE_MASK (1<<1) #define OPENGL_DIFFUSE_MASK (1<<1)
@ -54,43 +57,178 @@ public:
OpenGl_AspectFace(); OpenGl_AspectFace();
void Init (const Handle(OpenGl_Context)& theContext, //! Copy parameters
const CALL_DEF_CONTEXTFILLAREA& theAspect); void SetAspect (const CALL_DEF_CONTEXTFILLAREA& theAspect);
void SetAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect);
void Init (const Handle(OpenGl_Context)& theContext, //! Set edge aspect.
const Handle(Graphic3d_AspectFillArea3d)& theAspect); void SetAspectEdge (const OpenGl_AspectLine* theAspectEdge)
{
myAspectEdge = *theAspectEdge;
}
void SetAspectEdge (const OpenGl_AspectLine* theAspectEdge) { myAspectEdge = *theAspectEdge; } //! @return edge aspect.
const OpenGl_AspectLine* AspectEdge() const
{
return &myAspectEdge;
}
const OpenGl_AspectLine* AspectEdge() const { return &myAspectEdge; } //! @return interior style
const Aspect_InteriorStyle InteriorStyle() const
{
return myInteriorStyle;
}
Aspect_InteriorStyle& ChangeInteriorStyle()
{
return myInteriorStyle;
}
//! @return edge on flag.
int Edge() const
{
return myEdge;
}
//! @return edge on flag.
int& ChangeEdge()
{
return myEdge;
}
//! @return hatch type.
int Hatch() const
{
return myHatch;
}
//! @return hatch type variable.
int& ChangeHatch()
{
return myHatch;
}
//! @return distinguishing mode.
int DistinguishingMode() const
{
return myDistinguishingMode;
}
//! @return distinguishing mode.
int& ChangeDistinguishingMode()
{
return myDistinguishingMode;
}
//! @return culling mode.
int CullingMode() const
{
return myCullingMode;
}
//! @return culling mode.
int& ChangeCullingMode()
{
return myCullingMode;
}
//! @return front material properties.
const OPENGL_SURF_PROP& IntFront() const
{
return myIntFront;
}
//! @return front material properties.
OPENGL_SURF_PROP& ChangeIntFront()
{
return myIntFront;
}
//! @return back material properties.
const OPENGL_SURF_PROP& IntBack() const
{
return myIntBack;
}
//! @return back material properties.
OPENGL_SURF_PROP& ChangeIntBack()
{
return myIntBack;
}
//! @return polygon offset parameters.
const TEL_POFFSET_PARAM& PolygonOffset() const
{
return myPolygonOffset;
}
//! @return polygon offset parameters.
TEL_POFFSET_PARAM& ChangePolygonOffset()
{
return myPolygonOffset;
}
//! @return texture mapping flag.
bool DoTextureMap() const
{
return myDoTextureMap;
}
//! @return texture mapping flag.
bool& ChangeDoTextureMap()
{
return myDoTextureMap;
}
//! @return texture map.
const Handle(OpenGl_Texture)& TextureRes (const Handle(OpenGl_Workspace)& theWorkspace) const
{
if (!myIsTextureInit)
{
buildTexture (theWorkspace);
myIsTextureInit = Standard_True;
}
return myTextureRes;
}
//! @return texture mapping parameters.
const Handle(Graphic3d_TextureParams)& TextureParams() const
{
return myTextureMap->GetParams();
}
virtual void Render (const Handle(OpenGl_Workspace)& theWorkspace) const; virtual void Render (const Handle(OpenGl_Workspace)& theWorkspace) const;
virtual void Release (const Handle(OpenGl_Context)& theContext); virtual void Release (const Handle(OpenGl_Context)& theContext);
private: protected:
void buildTexture (const Handle(OpenGl_Workspace)& theWorkspace) const;
void convertMaterial (const CALL_DEF_MATERIAL& theMat, void convertMaterial (const CALL_DEF_MATERIAL& theMat,
OPENGL_SURF_PROP& theSurf); OPENGL_SURF_PROP& theSurf);
public: protected: //! @name ordinary aspect properties
Aspect_InteriorStyle InteriorStyle; Aspect_InteriorStyle myInteriorStyle;
int Edge; int myEdge;
int Hatch; int myHatch;
int DistinguishingMode; int myDistinguishingMode;
int CullingMode; int myCullingMode;
OPENGL_SURF_PROP IntFront; OPENGL_SURF_PROP myIntFront;
OPENGL_SURF_PROP IntBack; OPENGL_SURF_PROP myIntBack;
TEL_POFFSET_PARAM PolygonOffset; TEL_POFFSET_PARAM myPolygonOffset;
bool myDoTextureMap;
Handle(Graphic3d_TextureMap) myTextureMap;
int doTextureMap; protected: //! @name OpenGl resources
Handle(OpenGl_Texture) TextureRes;
Handle(Graphic3d_TextureParams) TextureParams; mutable Standard_Boolean myIsTextureInit;
mutable Handle(OpenGl_Texture) myTextureRes;
mutable TCollection_AsciiString myTextureId;
protected: protected:
TCollection_AsciiString myTextureId; OpenGl_AspectLine myAspectEdge;
OpenGl_AspectLine myAspectEdge;
public: public:

12
src/OpenGl/OpenGl_AspectLine.cxx
View File

@ -40,14 +40,14 @@ OpenGl_AspectLine::OpenGl_AspectLine (const OpenGl_AspectLine &AnOther)
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
void OpenGl_AspectLine::SetContext (const CALL_DEF_CONTEXTLINE &AContext) void OpenGl_AspectLine::SetAspect (const CALL_DEF_CONTEXTLINE &theAspect)
{ {
myColor.rgb[0] = (float) AContext.Color.r; myColor.rgb[0] = (float) theAspect.Color.r;
myColor.rgb[1] = (float) AContext.Color.g; myColor.rgb[1] = (float) theAspect.Color.g;
myColor.rgb[2] = (float) AContext.Color.b; myColor.rgb[2] = (float) theAspect.Color.b;
myColor.rgb[3] = 1.0f; myColor.rgb[3] = 1.0f;
myType = (Aspect_TypeOfLine) AContext.LineType; myType = (Aspect_TypeOfLine) theAspect.LineType;
myWidth = (float) AContext.Width; myWidth = (float) theAspect.Width;
} }
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/

2
src/OpenGl/OpenGl_AspectLine.hxx
View File

@ -32,7 +32,7 @@ class OpenGl_AspectLine : public OpenGl_Element
OpenGl_AspectLine (); OpenGl_AspectLine ();
OpenGl_AspectLine (const OpenGl_AspectLine &AnOther); OpenGl_AspectLine (const OpenGl_AspectLine &AnOther);
void SetContext (const CALL_DEF_CONTEXTLINE &AContext); void SetAspect (const CALL_DEF_CONTEXTLINE &theAspect);
const TEL_COLOUR & Color() const { return myColor; } const TEL_COLOUR & Color() const { return myColor; }
Aspect_TypeOfLine Type() const { return myType; } Aspect_TypeOfLine Type() const { return myType; }

140
src/OpenGl/OpenGl_AspectMarker.cxx
View File

@ -26,6 +26,7 @@
#include <Image_PixMap.hxx> #include <Image_PixMap.hxx>
#include <Graphic3d_MarkerImage.hxx> #include <Graphic3d_MarkerImage.hxx>
#include <NCollection_Vec4.hxx> #include <NCollection_Vec4.hxx>
#include <TColStd_HArray1OfByte.hxx>
static const TEL_COLOUR myDefaultColor = {{ 1.0F, 1.0F, 1.0F, 1.0F }}; static const TEL_COLOUR myDefaultColor = {{ 1.0F, 1.0F, 1.0F, 1.0F }};
@ -1447,54 +1448,44 @@ OpenGl_AspectMarker::OpenGl_AspectMarker()
: myColor (myDefaultColor), : myColor (myDefaultColor),
myType (Aspect_TOM_PLUS), myType (Aspect_TOM_PLUS),
myScale (1.0f), myScale (1.0f),
myMarkerImage(),
myMarkerSize (1.0f), myMarkerSize (1.0f),
mySpriteKey (""), mySpriteKey (""),
mySpriteAKey ("") mySpriteAKey (""),
myIsSpriteInit (Standard_False)
{} {}
// ======================================================================= // =======================================================================
// function : Init // function : SetAspect
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_AspectMarker::Init (const Handle(OpenGl_Context)& theCtx, void OpenGl_AspectMarker::SetAspect (const CALL_DEF_CONTEXTMARKER& theAspect)
const CALL_DEF_CONTEXTMARKER& theAspect)
{ {
myColor.rgb[0] = (float )theAspect.Color.r; myColor.rgb[0] = (float )theAspect.Color.r;
myColor.rgb[1] = (float )theAspect.Color.g; myColor.rgb[1] = (float )theAspect.Color.g;
myColor.rgb[2] = (float )theAspect.Color.b; myColor.rgb[2] = (float )theAspect.Color.b;
myColor.rgb[3] = 1.0f; myColor.rgb[3] = 1.0f;
myType = theAspect.MarkerType; myMarkerImage = theAspect.MarkerImage;
myType = theAspect.MarkerType;
myScale = myMarkerSize = theAspect.Scale; myScale = myMarkerSize = theAspect.Scale;
// generate key for shared resource // check that the resources need to be renewed
TCollection_AsciiString aNewKey, aNewKeyA; TCollection_AsciiString aNewKey, aNewKeyA;
if (myType == Aspect_TOM_USERDEFINED) resourceKeys (myMarkerImage, myType, myScale, myColor, aNewKey, aNewKeyA);
{ myIsSpriteInit = !aNewKey.IsEmpty() && mySpriteKey == aNewKey;
if (!theAspect.MarkerImage.IsNull()) myIsSpriteInit &= !aNewKeyA.IsEmpty() && mySpriteAKey == aNewKeyA;
{ }
aNewKey = theAspect.MarkerImage->GetImageId();
aNewKeyA = theAspect.MarkerImage->GetImageAlphaId(); // =======================================================================
} // function : buildSprites
} // purpose :
else if (myType != Aspect_TOM_POINT) // =======================================================================
{ void OpenGl_AspectMarker::buildSprites (const Handle(OpenGl_Workspace)& theWorkspace) const
// pre-defined markers {
const Standard_Integer aScale = Standard_Integer(myScale + 0.5f); const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
aNewKey = TCollection_AsciiString ("OpenGl_AspectMarker") + myType + "_" + aScale;
aNewKeyA = aNewKey + "A"; TCollection_AsciiString aNewKey, aNewKeyA;
if (myType == Aspect_TOM_BALL) resourceKeys (myMarkerImage, myType, myMarkerSize, myColor, aNewKey, aNewKeyA);
{
unsigned int aColor[3] =
{
(unsigned int )(255.0f * myColor.rgb[0]),
(unsigned int )(255.0f * myColor.rgb[1]),
(unsigned int )(255.0f * myColor.rgb[2])
};
char aBytes[8];
sprintf (aBytes, "%02X%02X%02X", aColor[0], aColor[1], aColor[2]);
aNewKey += aBytes;
}
}
// release old shared resources // release old shared resources
const Standard_Boolean aNewResource = aNewKey.IsEmpty() || mySpriteKey != aNewKey; const Standard_Boolean aNewResource = aNewKey.IsEmpty() || mySpriteKey != aNewKey;
@ -1504,13 +1495,13 @@ void OpenGl_AspectMarker::Init (const Handle(OpenGl_Context)& theCtx,
{ {
if (mySpriteKey.IsEmpty()) if (mySpriteKey.IsEmpty())
{ {
theCtx->DelayedRelease (mySprite); aContext->DelayedRelease (mySprite);
mySprite.Nullify(); mySprite.Nullify();
} }
else else
{ {
mySprite.Nullify(); // we need nullify all handles before ReleaseResource() call mySprite.Nullify(); // we need nullify all handles before ReleaseResource() call
theCtx->ReleaseResource (mySpriteKey); aContext->ReleaseResource (mySpriteKey);
} }
} }
mySpriteKey = aNewKey; mySpriteKey = aNewKey;
@ -1522,28 +1513,28 @@ void OpenGl_AspectMarker::Init (const Handle(OpenGl_Context)& theCtx,
{ {
if (mySpriteAKey.IsEmpty()) if (mySpriteAKey.IsEmpty())
{ {
theCtx->DelayedRelease (mySpriteA); aContext->DelayedRelease (mySpriteA);
mySpriteA.Nullify(); mySpriteA.Nullify();
} }
else else
{ {
mySpriteA.Nullify(); // we need nullify all handles before ReleaseResource() call mySpriteA.Nullify(); // we need nullify all handles before ReleaseResource() call
theCtx->ReleaseResource (mySpriteKey); aContext->ReleaseResource (mySpriteKey);
} }
} }
mySpriteAKey = aNewKeyA; mySpriteAKey = aNewKeyA;
} }
if (myType == Aspect_TOM_POINT if (myType == Aspect_TOM_POINT
|| !aNewResource || !aNewResource
|| (myType == Aspect_TOM_USERDEFINED && theAspect.MarkerImage.IsNull())) || (myType == Aspect_TOM_USERDEFINED && myMarkerImage.IsNull()))
{ {
// nothing to do - just simple point // nothing to do - just simple point
return; return;
} }
if (!aNewKey.IsEmpty() if (!aNewKey.IsEmpty()
&& theCtx->GetResource<Handle(OpenGl_PointSprite)> (aNewKeyA, mySpriteA) // alpha sprite could be shared && aContext->GetResource<Handle(OpenGl_PointSprite)> (aNewKeyA, mySpriteA) // alpha sprite could be shared
&& theCtx->GetResource<Handle(OpenGl_PointSprite)> (aNewKey, mySprite)) && aContext->GetResource<Handle(OpenGl_PointSprite)> (aNewKey, mySprite))
{ {
// reuse shared resource // reuse shared resource
if (!mySprite->IsDisplayList()) if (!mySprite->IsDisplayList())
@ -1561,24 +1552,24 @@ void OpenGl_AspectMarker::Init (const Handle(OpenGl_Context)& theCtx,
mySprite = new OpenGl_PointSprite(); mySprite = new OpenGl_PointSprite();
if (!aNewKey.IsEmpty()) if (!aNewKey.IsEmpty())
{ {
theCtx->ShareResource (aNewKey, mySprite); aContext->ShareResource (aNewKey, mySprite);
if (!hadAlreadyAlpha) if (!hadAlreadyAlpha)
{ {
theCtx->ShareResource (aNewKeyA, mySpriteA); aContext->ShareResource (aNewKeyA, mySpriteA);
} }
} }
if (!theCtx.IsNull() if (!aContext.IsNull()
&& theCtx->IsGlGreaterEqual (2, 0) && aContext->IsGlGreaterEqual (2, 0)
&& !theCtx->caps->pntSpritesDisable) && !aContext->caps->pntSpritesDisable)
{ {
// Creating texture resource for using it with point sprites // Creating texture resource for using it with point sprites
Handle(Graphic3d_MarkerImage) aNewMarkerImage; Handle(Graphic3d_MarkerImage) aNewMarkerImage;
Handle(Image_PixMap) anImage, anImageA; Handle(Image_PixMap) anImage, anImageA;
if (myType == Aspect_TOM_USERDEFINED && !theAspect.MarkerImage.IsNull()) if (myType == Aspect_TOM_USERDEFINED && !myMarkerImage.IsNull())
{ {
aNewMarkerImage = theAspect.MarkerImage; aNewMarkerImage = myMarkerImage;
anImage = aNewMarkerImage->GetImage(); anImage = aNewMarkerImage->GetImage();
} }
else else
@ -1697,7 +1688,7 @@ void OpenGl_AspectMarker::Init (const Handle(OpenGl_Context)& theCtx,
myMarkerSize = Max ((Standard_ShortReal )anImage->Width(),(Standard_ShortReal )anImage->Height()); myMarkerSize = Max ((Standard_ShortReal )anImage->Width(),(Standard_ShortReal )anImage->Height());
mySprite->Init (theCtx, *anImage.operator->(), Graphic3d_TOT_2D); mySprite->Init (aContext, *anImage.operator->(), Graphic3d_TOT_2D);
if (!hadAlreadyAlpha) if (!hadAlreadyAlpha)
{ {
if (anImageA.IsNull() if (anImageA.IsNull()
@ -1708,7 +1699,7 @@ void OpenGl_AspectMarker::Init (const Handle(OpenGl_Context)& theCtx,
} }
if (!anImageA.IsNull()) if (!anImageA.IsNull())
{ {
mySpriteA->Init (theCtx, *anImageA.operator->(), Graphic3d_TOT_2D); mySpriteA->Init (aContext, *anImageA.operator->(), Graphic3d_TOT_2D);
} }
} }
} }
@ -1716,15 +1707,15 @@ void OpenGl_AspectMarker::Init (const Handle(OpenGl_Context)& theCtx,
{ {
// Creating list with bitmap for using it in compatibility mode // Creating list with bitmap for using it in compatibility mode
GLuint aBitmapList = glGenLists (1); GLuint aBitmapList = glGenLists (1);
mySprite->SetDisplayList (theCtx, aBitmapList); mySprite->SetDisplayList (aContext, aBitmapList);
Standard_Integer aWidth, aHeight, anOffset, aNumOfBytes; Standard_Integer aWidth, aHeight, anOffset, aNumOfBytes;
if (myType == Aspect_TOM_USERDEFINED && !theAspect.MarkerImage.IsNull()) if (myType == Aspect_TOM_USERDEFINED && !myMarkerImage.IsNull())
{ {
// Reading userdefined marker // Reading user defined marker
Handle(TColStd_HArray1OfByte) aBitMap = theAspect.MarkerImage->GetBitMapArray(); Handle(TColStd_HArray1OfByte) aBitMap = myMarkerImage->GetBitMapArray();
Standard_Byte* aBitMapArray = new Standard_Byte[aBitMap->Length()]; Standard_Byte* aBitMapArray = new Standard_Byte[aBitMap->Length()];
theAspect.MarkerImage->GetTextureSize (aWidth, aHeight); myMarkerImage->GetTextureSize (aWidth, aHeight);
// We should pass bitmap to glBitmap with reversed line order as it draws it from // We should pass bitmap to glBitmap with reversed line order as it draws it from
// bottom to top // bottom to top
@ -1825,6 +1816,47 @@ void OpenGl_AspectMarker::Init (const Handle(OpenGl_Context)& theCtx,
} }
} }
// =======================================================================
// function : resourceKeys
// purpose :
// =======================================================================
void OpenGl_AspectMarker::resourceKeys (const Handle(Graphic3d_MarkerImage)& theMarkerImage,
const Aspect_TypeOfMarker theType,
const Standard_ShortReal theScale,
const TEL_COLOUR& theColor,
TCollection_AsciiString& theKey,
TCollection_AsciiString& theKeyA) const
{
// generate key for shared resource
if (theType == Aspect_TOM_USERDEFINED)
{
if (!theMarkerImage.IsNull())
{
theKey = theMarkerImage->GetImageId();
theKeyA = theMarkerImage->GetImageAlphaId();
}
}
else if (theType != Aspect_TOM_POINT)
{
// predefined markers
const Standard_Integer aScale = Standard_Integer(theScale + 0.5f);
theKey = TCollection_AsciiString ("OpenGl_AspectMarker") + theType + "_" + aScale;
theKeyA = theKey + "A";
if (theType == Aspect_TOM_BALL)
{
unsigned int aColor[3] =
{
(unsigned int )(255.0f * theColor.rgb[0]),
(unsigned int )(255.0f * theColor.rgb[1]),
(unsigned int )(255.0f * theColor.rgb[2])
};
char aBytes[8];
sprintf (aBytes, "%02X%02X%02X", aColor[0], aColor[1], aColor[2]);
theKey += aBytes;
}
}
}
// ======================================================================= // =======================================================================
// function : Render // function : Render
// purpose : // purpose :

90
src/OpenGl/OpenGl_AspectMarker.hxx
View File

@ -36,29 +36,87 @@ public:
OpenGl_AspectMarker(); OpenGl_AspectMarker();
void Init (const Handle(OpenGl_Context)& theContext, //! Copy parameters
const CALL_DEF_CONTEXTMARKER& theAspect); void SetAspect (const CALL_DEF_CONTEXTMARKER& theAspect);
const TEL_COLOUR& Color() const { return myColor; } //! @return marker color
Aspect_TypeOfMarker Type() const { return myType; } const TEL_COLOUR& Color() const
Standard_ShortReal Scale() const { return myScale; } {
Standard_ShortReal MarkerSize() const { return myMarkerSize; } return myColor;
const Handle(OpenGl_PointSprite)& Sprite() const { return mySprite; } }
const Handle(OpenGl_PointSprite)& SpriteHighlight() const { return mySpriteA; }
//! @return maker type
Aspect_TypeOfMarker Type() const
{
return myType;
}
//! @return marker scale
Standard_ShortReal Scale() const
{
return myScale;
}
//! @return marker size
Standard_ShortReal MarkerSize() const
{
return myMarkerSize;
}
//! Init and return OpenGl point sprite resource.
//! @return point sprite texture.
const Handle(OpenGl_PointSprite)& Sprite (const Handle(OpenGl_Workspace)& theWorkspace) const
{
if (!myIsSpriteInit)
{
buildSprites (theWorkspace);
myIsSpriteInit = Standard_True;
}
return mySprite;
}
//! Init and return OpenGl highlight point sprite resource.
//! @return point sprite texture for highlight.
const Handle(OpenGl_PointSprite)& SpriteHighlight (const Handle(OpenGl_Workspace)& theWorkspace) const
{
if (!myIsSpriteInit)
{
buildSprites (theWorkspace);
myIsSpriteInit = Standard_True;
}
return mySpriteA;
}
virtual void Render (const Handle(OpenGl_Workspace)& theWorkspace) const; virtual void Render (const Handle(OpenGl_Workspace)& theWorkspace) const;
virtual void Release (const Handle(OpenGl_Context)& theContext); virtual void Release (const Handle(OpenGl_Context)& theContext);
protected: protected:
TEL_COLOUR myColor; void buildSprites (const Handle(OpenGl_Workspace)& theWorkspace) const;
Aspect_TypeOfMarker myType; void resourceKeys (const Handle(Graphic3d_MarkerImage)& theMarkerImage,
Standard_ShortReal myScale; const Aspect_TypeOfMarker theType,
Standard_ShortReal myMarkerSize; const Standard_ShortReal theScale,
TCollection_AsciiString mySpriteKey; //!< shared resource ID const TEL_COLOUR& theColor,
TCollection_AsciiString mySpriteAKey; //!< shared resource ID TCollection_AsciiString& theKey,
Handle(OpenGl_PointSprite) mySprite; //!< normal sprite TCollection_AsciiString& theKeyA) const;
Handle(OpenGl_PointSprite) mySpriteA; //!< extra alphs-only sprite for RGB sprites
protected: //! @name ordinary aspect properties
TEL_COLOUR myColor;
Aspect_TypeOfMarker myType;
Standard_ShortReal myScale;
Handle(Graphic3d_MarkerImage) myMarkerImage;
protected: //! @name OpenGl resources
mutable Standard_ShortReal myMarkerSize;
mutable TCollection_AsciiString mySpriteKey;
mutable TCollection_AsciiString mySpriteAKey;
mutable Standard_Boolean myIsSpriteInit;
mutable Handle(OpenGl_PointSprite) mySprite; //!< normal sprite
mutable Handle(OpenGl_PointSprite) mySpriteA; //!< extra alpha-only sprite for RGB sprites
public: public:

28
src/OpenGl/OpenGl_AspectText.cxx
View File

@ -52,25 +52,25 @@ OpenGl_AspectText::~OpenGl_AspectText()
} }
// ======================================================================= // =======================================================================
// function : SetContext // function : SetAspect
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_AspectText::SetContext (const CALL_DEF_CONTEXTTEXT& theContext) void OpenGl_AspectText::SetAspect (const CALL_DEF_CONTEXTTEXT& theAspect)
{ {
myFont = theContext.Font; myFont = theAspect.Font;
myColor.rgb[0] = (float )theContext.Color.r; myColor.rgb[0] = (float )theAspect.Color.r;
myColor.rgb[1] = (float )theContext.Color.g; myColor.rgb[1] = (float )theAspect.Color.g;
myColor.rgb[2] = (float )theContext.Color.b; myColor.rgb[2] = (float )theAspect.Color.b;
myColor.rgb[3] = 1.0f; myColor.rgb[3] = 1.0f;
mySubtitleColor.rgb[0] = (float )theContext.ColorSubTitle.r; mySubtitleColor.rgb[0] = (float )theAspect.ColorSubTitle.r;
mySubtitleColor.rgb[1] = (float )theContext.ColorSubTitle.g; mySubtitleColor.rgb[1] = (float )theAspect.ColorSubTitle.g;
mySubtitleColor.rgb[2] = (float )theContext.ColorSubTitle.b; mySubtitleColor.rgb[2] = (float )theAspect.ColorSubTitle.b;
mySubtitleColor.rgb[3] = 1.0f; mySubtitleColor.rgb[3] = 1.0f;
myAngle = (float )theContext.TextAngle; myAngle = (float )theAspect.TextAngle;
myStyleType = (Aspect_TypeOfStyleText )theContext.Style; myStyleType = (Aspect_TypeOfStyleText )theAspect.Style;
myDisplayType = (Aspect_TypeOfDisplayText )theContext.DisplayType; myDisplayType = (Aspect_TypeOfDisplayText )theAspect.DisplayType;
myFontAspect = (Font_FontAspect )theContext.TextFontAspect; myFontAspect = (Font_FontAspect )theAspect.TextFontAspect;
myZoomable = (theContext.TextZoomable != 0); myZoomable = (theAspect.TextZoomable != 0);
} }
// ======================================================================= // =======================================================================

2
src/OpenGl/OpenGl_AspectText.hxx
View File

@ -39,7 +39,7 @@ public:
virtual ~OpenGl_AspectText(); virtual ~OpenGl_AspectText();
//! Copy parameters //! Copy parameters
void SetContext (const CALL_DEF_CONTEXTTEXT& theContext); void SetAspect (const CALL_DEF_CONTEXTTEXT& theAspect);
//! @return font family name //! @return font family name
const TCollection_AsciiString& FontName() const const TCollection_AsciiString& FontName() const

8
src/OpenGl/OpenGl_CappingAlgo.cxx
View File

@ -246,11 +246,11 @@ void OpenGl_CappingAlgo::Init()
return; return;
myRenderFilter = new OpenGl_CappingAlgoFilter(); myRenderFilter = new OpenGl_CappingAlgoFilter();
myNoneCulling.CullingMode = TelCullNone; myNoneCulling.ChangeCullingMode() = TelCullNone;
myNoneCulling.Edge = 0; myNoneCulling.ChangeEdge() = 0;
myFrontCulling.CullingMode = TelCullBack; myFrontCulling.ChangeCullingMode() = TelCullBack;
myFrontCulling.Edge = 0; myFrontCulling.ChangeEdge() = 0;
myIsInit = Standard_True; myIsInit = Standard_True;
} }

4
src/OpenGl/OpenGl_CappingPlaneResource.cxx
View File

@ -79,7 +79,7 @@ void OpenGl_CappingPlaneResource::UpdateAspect (const Handle(OpenGl_Context)& th
if (myAspectMod == myPlaneRoot->MCountAspect()) if (myAspectMod == myPlaneRoot->MCountAspect())
return; // noting to update return; // noting to update
myAspect->Init (theContext, aCappingAsp); myAspect->SetAspect (aCappingAsp);
myAspectMod = myPlaneRoot->MCountAspect(); myAspectMod = myPlaneRoot->MCountAspect();
return; return;
} }
@ -96,7 +96,7 @@ void OpenGl_CappingPlaneResource::UpdateAspect (const Handle(OpenGl_Context)& th
if (myAspect == NULL && !aCappingAsp.IsNull()) if (myAspect == NULL && !aCappingAsp.IsNull())
{ {
myAspect = new OpenGl_AspectFace(); myAspect = new OpenGl_AspectFace();
myAspect->Init (theContext, aCappingAsp); myAspect->SetAspect (aCappingAsp);
myAspectMod = myPlaneRoot->MCountAspect(); myAspectMod = myPlaneRoot->MCountAspect();
} }
} }

2
src/OpenGl/OpenGl_Context.cxx
View File

@ -262,6 +262,7 @@ Standard_Boolean OpenGl_Context::MakeCurrent()
LocalFree (aMsgBuff); LocalFree (aMsgBuff);
} }
PushMessage (GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB, GL_DEBUG_TYPE_ERROR_ARB, (unsigned int )anErrorCode, GL_DEBUG_SEVERITY_HIGH_ARB, aMsg); PushMessage (GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB, GL_DEBUG_TYPE_ERROR_ARB, (unsigned int )anErrorCode, GL_DEBUG_SEVERITY_HIGH_ARB, aMsg);
myIsInitialized = Standard_False;
return Standard_False; return Standard_False;
} }
#else #else
@ -276,6 +277,7 @@ Standard_Boolean OpenGl_Context::MakeCurrent()
// if there is no current context it might be impossible to use glGetError() correctly // if there is no current context it might be impossible to use glGetError() correctly
PushMessage (GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB, GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, PushMessage (GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB, GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB,
"glXMakeCurrent() has failed!"); "glXMakeCurrent() has failed!");
myIsInitialized = Standard_False;
return Standard_False; return Standard_False;
} }
#endif #endif

6
src/OpenGl/OpenGl_Context.hxx
View File

@ -120,6 +120,12 @@ public:
//! GL context should be active! //! GL context should be active!
Standard_EXPORT Standard_Boolean Init(); Standard_EXPORT Standard_Boolean Init();
//! @return true if this context is valid (has been initialized)
inline Standard_Boolean IsValid() const
{
return myIsInitialized;
}
#if defined(_WIN32) #if defined(_WIN32)
Standard_EXPORT Standard_Boolean Init (const Aspect_Handle theWindow, Standard_EXPORT Standard_Boolean Init (const Aspect_Handle theWindow,
const Aspect_Handle theWindowDC, const Aspect_Handle theWindowDC,

51
src/OpenGl/OpenGl_Display.cxx
View File

@ -17,17 +17,16 @@
// purpose or non-infringement. Please see the License for the specific terms // purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License. // and conditions governing the rights and limitations under the License.
#include <OpenGl_GlCore11.hxx> #include <OpenGl_GlCore11.hxx>
#include <OpenGl_Display.hxx> #include <OpenGl_Display.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_Light.hxx>
#include <OSD_Environment.hxx> #include <OSD_Environment.hxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <Aspect_GraphicDeviceDefinitionError.hxx> #include <Aspect_GraphicDeviceDefinitionError.hxx>
#include <OpenGl_Light.hxx>
#if (!defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))) #if (!defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX)))
#include <X11/Xlib.h> // XOpenDisplay() #include <X11/Xlib.h> // XOpenDisplay()
#endif #endif
@ -35,8 +34,6 @@
IMPLEMENT_STANDARD_HANDLE(OpenGl_Display,MMgt_TShared) IMPLEMENT_STANDARD_HANDLE(OpenGl_Display,MMgt_TShared)
IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Display,MMgt_TShared) IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Display,MMgt_TShared)
Handle(OpenGl_Display) openglDisplay;
namespace namespace
{ {
#if (defined(_WIN32) || defined(__WIN32__)) || (defined(__APPLE__) && !defined(MACOSX_USE_GLX)) #if (defined(_WIN32) || defined(__WIN32__)) || (defined(__APPLE__) && !defined(MACOSX_USE_GLX))
@ -78,41 +75,29 @@ OpenGl_Display::OpenGl_Display (const Handle(Aspect_DisplayConnection)& theDispl
OpenGl_Display::~OpenGl_Display () OpenGl_Display::~OpenGl_Display ()
{ {
// Delete line styles ReleaseAttributes (NULL);
if (myLinestyleBase)
{
glDeleteLists((GLuint)myLinestyleBase,5);
myLinestyleBase = 0;
}
// Delete surface patterns
if (myPatternBase)
{
glDeleteLists((GLuint)myPatternBase,TEL_HS_USER_DEF_START);
myPatternBase = 0;
}
myDisplay = NULL; myDisplay = NULL;
} }
/*----------------------------------------------------------------------*/ void OpenGl_Display::ReleaseAttributes (const OpenGl_Context* theGlCtx)
Handle(OpenGl_Window) OpenGl_Display::GetWindow (const Aspect_Drawable AParent) const
{ {
Handle(OpenGl_Window) aWindow; // Delete line styles
if ( myMapOfWindows.IsBound( AParent ) ) if (myLinestyleBase != 0)
{ {
aWindow = myMapOfWindows.Find( AParent ); if (theGlCtx->IsValid())
{
glDeleteLists ((GLuint )myLinestyleBase, 5);
}
myLinestyleBase = 0;
} }
return aWindow; // Delete surface patterns
} if (myPatternBase != 0)
/*----------------------------------------------------------------------*/
void OpenGl_Display::SetWindow (const Aspect_Drawable AParent, const Handle(OpenGl_Window) &AWindow)
{
if ( !myMapOfWindows.IsBound( AParent ) )
{ {
myMapOfWindows.Bind( AParent, AWindow ); if (theGlCtx->IsValid())
{
glDeleteLists ((GLuint )myPatternBase, TEL_HS_USER_DEF_START);
}
myPatternBase = 0;
} }
} }

33
src/OpenGl/OpenGl_Display.hxx
View File

@ -23,13 +23,8 @@
#include <Handle_OpenGl_Display.hxx> #include <Handle_OpenGl_Display.hxx>
#include <MMgt_TShared.hxx> #include <MMgt_TShared.hxx>
#include <Standard_CString.hxx>
#include <TColStd_HArray1OfByte.hxx>
#include <NCollection_DataMap.hxx>
#include <Aspect_Display.hxx> #include <Aspect_Display.hxx>
#include <Aspect_DisplayConnection.hxx> #include <Aspect_DisplayConnection.hxx>
#include <Aspect_Drawable.hxx>
#include <Aspect_TypeOfLine.hxx> #include <Aspect_TypeOfLine.hxx>
#include <Aspect_TypeOfMarker.hxx> #include <Aspect_TypeOfMarker.hxx>
@ -49,20 +44,17 @@ struct OpenGl_Facilities
int MaxViews; int MaxViews;
}; };
class OpenGl_AspectText; class OpenGl_Context;
struct OpenGl_TextParam;
class OpenGl_Display : public MMgt_TShared class OpenGl_Display : public MMgt_TShared
{ {
public: public:
OpenGl_Display (const Handle(Aspect_DisplayConnection)& theDisplayConnection); OpenGl_Display (const Handle(Aspect_DisplayConnection)& theDisplayConnection);
virtual ~OpenGl_Display (); virtual ~OpenGl_Display ();
Aspect_Display GetDisplay () const { return myDisplay; } Aspect_Display GetDisplay () const { return myDisplay; }
Handle(OpenGl_Window) GetWindow (const Aspect_Drawable AParent) const;
void SetWindow (const Aspect_Drawable AParent, const Handle(OpenGl_Window) &AWindow);
const OpenGl_Facilities & Facilities () const { return myFacilities; } const OpenGl_Facilities & Facilities () const { return myFacilities; }
Standard_Boolean DBuffer () const { return myDBuffer; } Standard_Boolean DBuffer () const { return myDBuffer; }
@ -80,7 +72,8 @@ class OpenGl_Display : public MMgt_TShared
// System attributes // System attributes
void InitAttributes (); void InitAttributes();
void ReleaseAttributes (const OpenGl_Context* theGlCtx);
void SetTypeOfLine (const Aspect_TypeOfLine AType) const; void SetTypeOfLine (const Aspect_TypeOfLine AType) const;
@ -96,12 +89,6 @@ class OpenGl_Display : public MMgt_TShared
void Init (); void Init ();
void ExportText (const wchar_t *text, const int is2d, const float x, const float y, const float z, const OpenGl_AspectText *aspect, const OpenGl_TextParam *param, const short height);
#ifdef HAVE_GL2PS
static void getGL2PSFontName(const char *src_font, char *ps_font);
#endif
Aspect_Display myDisplay; Aspect_Display myDisplay;
OpenGl_Facilities myFacilities; OpenGl_Facilities myFacilities;
@ -114,12 +101,6 @@ class OpenGl_Display : public MMgt_TShared
Standard_ShortReal myOffsetUnits; Standard_ShortReal myOffsetUnits;
Standard_Integer myAntiAliasingMode; Standard_Integer myAntiAliasingMode;
#if (defined(_WIN32) || defined(__WIN32__))
NCollection_DataMap<Aspect_Drawable, Handle(OpenGl_Window)> myMapOfWindows;
#else
NCollection_DataMap<Standard_Integer, Handle(OpenGl_Window)> myMapOfWindows;
#endif
unsigned int myLinestyleBase; unsigned int myLinestyleBase;
unsigned int myPatternBase; unsigned int myPatternBase;
@ -127,6 +108,4 @@ class OpenGl_Display : public MMgt_TShared
DEFINE_STANDARD_ALLOC DEFINE_STANDARD_ALLOC
}; };
extern Handle(OpenGl_Display) openglDisplay; #endif // _OpenGl_Display_Header
#endif //OpenGl_Workspace_Header

190
src/OpenGl/OpenGl_FrameBuffer.cxx
View File

@ -16,12 +16,12 @@
// purpose or non-infringement. Please see the License for the specific terms // purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License. // and conditions governing the rights and limitations under the License.
#include <OpenGl_FrameBuffer.hxx> #include <OpenGl_FrameBuffer.hxx>
#ifdef DEB #include <Standard_Assert.hxx>
#include <iostream>
#endif IMPLEMENT_STANDARD_HANDLE (OpenGl_FrameBuffer, OpenGl_Resource)
IMPLEMENT_STANDARD_RTTIEXT(OpenGl_FrameBuffer, OpenGl_Resource)
static inline bool isOddNumber (const GLsizei theNumber) static inline bool isOddNumber (const GLsizei theNumber)
{ {
@ -39,6 +39,10 @@ static inline bool isPowerOfTwo (const GLsizei theNumber)
return !(theNumber & (theNumber - 1)); return !(theNumber & (theNumber - 1));
} }
// =======================================================================
// function : OpenGl_FrameBuffer
// purpose :
// =======================================================================
OpenGl_FrameBuffer::OpenGl_FrameBuffer (GLint theTextureFormat) OpenGl_FrameBuffer::OpenGl_FrameBuffer (GLint theTextureFormat)
: mySizeX (0), : mySizeX (0),
mySizeY (0), mySizeY (0),
@ -53,21 +57,31 @@ OpenGl_FrameBuffer::OpenGl_FrameBuffer (GLint theTextureFormat)
// //
} }
// =======================================================================
// function : ~OpenGl_FrameBuffer
// purpose :
// =======================================================================
OpenGl_FrameBuffer::~OpenGl_FrameBuffer()
{
Release (NULL);
}
// =======================================================================
// function : Init
// purpose :
// =======================================================================
Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext, Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
GLsizei theViewportSizeX, const GLsizei theViewportSizeX,
GLsizei theViewportSizeY, const GLsizei theViewportSizeY,
GLboolean toForcePowerOfTwo) const GLboolean toForcePowerOfTwo)
{ {
if (theGlContext->extFBO == NULL) if (theGlContext->extFBO == NULL)
{ {
#ifdef DEB
std::cerr << "OpenGl_FrameBuffer, FBO extension not supported!\n";
#endif
return Standard_False; return Standard_False;
} }
// clean up previous state // clean up previous state
Release (theGlContext); Release (theGlContext.operator->());
// upscale width/height if numbers are odd // upscale width/height if numbers are odd
if (toForcePowerOfTwo) if (toForcePowerOfTwo)
@ -86,13 +100,13 @@ Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlCo
myVPSizeY = theViewportSizeY; myVPSizeY = theViewportSizeY;
// Create the texture (will be used as color buffer) // Create the texture (will be used as color buffer)
if (!InitTrashTexture (theGlContext)) if (!initTrashTexture (theGlContext))
{ {
if (!isPowerOfTwo (mySizeX) || !isPowerOfTwo (mySizeY)) if (!isPowerOfTwo (mySizeX) || !isPowerOfTwo (mySizeY))
{ {
return Init (theGlContext, theViewportSizeX, theViewportSizeY, GL_TRUE); return Init (theGlContext, theViewportSizeX, theViewportSizeY, GL_TRUE);
} }
Release (theGlContext); Release (theGlContext.operator->());
return Standard_False; return Standard_False;
} }
@ -131,68 +145,72 @@ Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlCo
{ {
return Init (theGlContext, theViewportSizeX, theViewportSizeY, GL_TRUE); return Init (theGlContext, theViewportSizeX, theViewportSizeY, GL_TRUE);
} }
Release (theGlContext); Release (theGlContext.operator->());
return Standard_False; return Standard_False;
} }
UnbindBuffer (theGlContext); UnbindBuffer (theGlContext);
UnbindTexture(); UnbindTexture (theGlContext);
theGlContext->extFBO->glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, NO_RENDERBUFFER); theGlContext->extFBO->glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, NO_RENDERBUFFER);
#ifdef DEB
std::cerr << "OpenGl_FrameBuffer, created FBO " << mySizeX << "x" << mySizeY
<< " for viewport " << theViewportSizeX << "x" << theViewportSizeY << "\n";
#endif
return Standard_True; return Standard_True;
} }
void OpenGl_FrameBuffer::Release (const Handle(OpenGl_Context)& theGlContext) // =======================================================================
// function : Release
// purpose :
// =======================================================================
void OpenGl_FrameBuffer::Release (const OpenGl_Context* theGlCtx)
{ {
if (IsValidDepthBuffer()) if (isValidDepthBuffer()
|| isValidStencilBuffer()
|| isValidTexture()
|| isValidFrameBuffer())
{ {
if (!theGlContext.IsNull() && theGlContext->extFBO != NULL) // application can not handle this case by exception - this is bug in code
{ Standard_ASSERT_RETURN (theGlCtx != NULL,
theGlContext->extFBO->glDeleteRenderbuffersEXT (1, &myGlDepthRBId); "OpenGl_FrameBuffer destroyed without GL context! Possible GPU memory leakage...",);
myGlDepthRBId = NO_RENDERBUFFER;
}
else
{
std::cerr << "OpenGl_FrameBuffer::Release() called with invalid OpenGl_Context!\n";
}
} }
if (IsValidStencilBuffer()) if (isValidStencilBuffer())
{ {
if (!theGlContext.IsNull() && theGlContext->extFBO != NULL) if (theGlCtx->IsValid()
&& myGlStencilRBId != myGlDepthRBId)
{ {
theGlContext->extFBO->glDeleteRenderbuffersEXT (1, &myGlStencilRBId); theGlCtx->extFBO->glDeleteRenderbuffersEXT (1, &myGlStencilRBId);
myGlStencilRBId = NO_RENDERBUFFER;
}
else
{
std::cerr << "OpenGl_FrameBuffer::Release() called with invalid OpenGl_Context!\n";
} }
myGlStencilRBId = NO_RENDERBUFFER;
} }
if (IsValidTexture()) if (isValidDepthBuffer())
{ {
glDeleteTextures (1, &myGlTextureId); if (theGlCtx->IsValid())
{
theGlCtx->extFBO->glDeleteRenderbuffersEXT (1, &myGlDepthRBId);
}
myGlDepthRBId = NO_RENDERBUFFER;
}
if (isValidTexture())
{
if (theGlCtx->IsValid())
{
glDeleteTextures (1, &myGlTextureId);
}
myGlTextureId = NO_TEXTURE; myGlTextureId = NO_TEXTURE;
} }
mySizeX = mySizeY = myVPSizeX = myVPSizeY = 0; mySizeX = mySizeY = myVPSizeX = myVPSizeY = 0;
if (IsValidFrameBuffer()) if (isValidFrameBuffer())
{ {
if (!theGlContext.IsNull() && theGlContext->extFBO != NULL) if (theGlCtx->IsValid())
{ {
theGlContext->extFBO->glDeleteFramebuffersEXT (1, &myGlFBufferId); theGlCtx->extFBO->glDeleteFramebuffersEXT (1, &myGlFBufferId);
myGlFBufferId = NO_FRAMEBUFFER;
}
else
{
std::cerr << "OpenGl_FrameBuffer::Release() called with invalid OpenGl_Context!\n";
} }
myGlFBufferId = NO_FRAMEBUFFER;
} }
} }
Standard_Boolean OpenGl_FrameBuffer::IsProxySuccess() const // =======================================================================
// function : isProxySuccess
// purpose :
// =======================================================================
Standard_Boolean OpenGl_FrameBuffer::isProxySuccess() const
{ {
// use proxy to check texture could be created or not // use proxy to check texture could be created or not
glTexImage2D (GL_PROXY_TEXTURE_2D, glTexImage2D (GL_PROXY_TEXTURE_2D,
@ -206,7 +224,11 @@ Standard_Boolean OpenGl_FrameBuffer::IsProxySuccess() const
return aTestParamX != 0 && aTestParamY != 0; return aTestParamX != 0 && aTestParamY != 0;
} }
Standard_Boolean OpenGl_FrameBuffer::InitTrashTexture (const Handle(OpenGl_Context)& theGlContext) // =======================================================================
// function : initTrashTexture
// purpose :
// =======================================================================
Standard_Boolean OpenGl_FrameBuffer::initTrashTexture (const Handle(OpenGl_Context)& theGlContext)
{ {
// Check texture size is fit dimension maximum // Check texture size is fit dimension maximum
GLint aMaxTexDim = 2048; GLint aMaxTexDim = 2048;
@ -218,7 +240,7 @@ Standard_Boolean OpenGl_FrameBuffer::InitTrashTexture (const Handle(OpenGl_Conte
// generate new id // generate new id
glEnable (GL_TEXTURE_2D); glEnable (GL_TEXTURE_2D);
if (!IsValidTexture()) if (!isValidTexture())
{ {
glGenTextures (1, &myGlTextureId); // Create The Texture glGenTextures (1, &myGlTextureId); // Create The Texture
} }
@ -228,9 +250,9 @@ Standard_Boolean OpenGl_FrameBuffer::InitTrashTexture (const Handle(OpenGl_Conte
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
if (!IsProxySuccess()) if (!isProxySuccess())
{ {
Release (theGlContext); Release (theGlContext.operator->());
return Standard_False; return Standard_False;
} }
@ -241,3 +263,61 @@ Standard_Boolean OpenGl_FrameBuffer::InitTrashTexture (const Handle(OpenGl_Conte
GL_RGBA, GL_UNSIGNED_BYTE, NULL); // NULL pointer supported from OpenGL 1.1 GL_RGBA, GL_UNSIGNED_BYTE, NULL); // NULL pointer supported from OpenGL 1.1
return Standard_True; return Standard_True;
} }
// =======================================================================
// function : SetupViewport
// purpose :
// =======================================================================
void OpenGl_FrameBuffer::SetupViewport (const Handle(OpenGl_Context)& /*theGlCtx*/)
{
glViewport (0, 0, myVPSizeX, myVPSizeY);
}
// =======================================================================
// function : ChangeViewport
// purpose :
// =======================================================================
void OpenGl_FrameBuffer::ChangeViewport (const GLsizei theVPSizeX,
const GLsizei theVPSizeY)
{
myVPSizeX = theVPSizeX;
myVPSizeY = theVPSizeY;
}
// =======================================================================
// function : BindBuffer
// purpose :
// =======================================================================
void OpenGl_FrameBuffer::BindBuffer (const Handle(OpenGl_Context)& theGlCtx)
{
theGlCtx->extFBO->glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, myGlFBufferId);
}
// =======================================================================
// function : UnbindBuffer
// purpose :
// =======================================================================
void OpenGl_FrameBuffer::UnbindBuffer (const Handle(OpenGl_Context)& theGlCtx)
{
theGlCtx->extFBO->glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, NO_FRAMEBUFFER);
}
// =======================================================================
// function : BindTexture
// purpose :
// =======================================================================
void OpenGl_FrameBuffer::BindTexture (const Handle(OpenGl_Context)& /*theGlCtx*/)
{
glEnable (GL_TEXTURE_2D); // needed only for fixed pipeline rendering
glBindTexture (GL_TEXTURE_2D, myGlTextureId);
}
// =======================================================================
// function : UnbindTexture
// purpose :
// =======================================================================
void OpenGl_FrameBuffer::UnbindTexture (const Handle(OpenGl_Context)& /*theGlCtx*/)
{
glBindTexture (GL_TEXTURE_2D, NO_TEXTURE);
glDisable (GL_TEXTURE_2D); // needed only for fixed pipeline rendering
}

104
src/OpenGl/OpenGl_FrameBuffer.hxx
View File

@ -16,17 +16,19 @@
// purpose or non-infringement. Please see the License for the specific terms // purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License. // and conditions governing the rights and limitations under the License.
#ifndef OPENGL_FRAME_BUFFER_H #ifndef OPENGL_FRAME_BUFFER_H
#define OPENGL_FRAME_BUFFER_H #define OPENGL_FRAME_BUFFER_H
#include <OpenGl_Context.hxx> #include <OpenGl_Context.hxx>
#include <OpenGl_ExtFBO.hxx> #include <OpenGl_ExtFBO.hxx>
#include <OpenGl_Resource.hxx>
#include <Standard_Boolean.hxx> #include <Standard_Boolean.hxx>
#include <InterfaceGraphic.hxx> #include <InterfaceGraphic.hxx>
class OpenGl_FrameBuffer //! Class implements FrameBuffer Object (FBO) resource
//! intended for off-screen rendering.
class OpenGl_FrameBuffer : public OpenGl_Resource
{ {
public: public:
@ -38,12 +40,14 @@ public:
public: public:
OpenGl_FrameBuffer (GLint theTextureFormat = GL_RGBA8); //! Empty constructor
Standard_EXPORT OpenGl_FrameBuffer (GLint theTextureFormat = GL_RGBA8);
virtual ~OpenGl_FrameBuffer() //! Destructor
{ Standard_EXPORT virtual ~OpenGl_FrameBuffer();
Release (Handle(OpenGl_Context)());
} //! Destroy object - will release GPU memory if any.
Standard_EXPORT virtual void Release (const OpenGl_Context* theGlCtx);
//! Texture width. //! Texture width.
GLsizei GetSizeX() const GLsizei GetSizeX() const
@ -72,7 +76,7 @@ public:
//! Returns true if current object was initialized //! Returns true if current object was initialized
Standard_Boolean IsValid() const Standard_Boolean IsValid() const
{ {
return IsValidFrameBuffer() && IsValidTexture() && IsValidDepthBuffer() && IsValidStencilBuffer(); return isValidFrameBuffer() && isValidTexture() && isValidDepthBuffer() && isValidStencilBuffer();
} }
//! Notice! Obsolete hardware (GeForce FX etc) //! Notice! Obsolete hardware (GeForce FX etc)
@ -83,94 +87,76 @@ public:
//! current implementation will try to generate compatible FBO; //! current implementation will try to generate compatible FBO;
//! 2) FBO rendering will be done in software mode (ForceWare 'hack'); //! 2) FBO rendering will be done in software mode (ForceWare 'hack');
//! 3) FBO rendering will be incorrect (some obsolete Catalyst drivers). //! 3) FBO rendering will be incorrect (some obsolete Catalyst drivers).
Standard_Boolean Init (const Handle(OpenGl_Context)& theGlContext, Standard_EXPORT Standard_Boolean Init (const Handle(OpenGl_Context)& theGlCtx,
GLsizei theViewportSizeX, const GLsizei theViewportSizeX,
GLsizei theViewportSizeY, const GLsizei theViewportSizeY,
GLboolean toForcePowerOfTwo = GL_FALSE); const GLboolean toForcePowerOfTwo = GL_FALSE);
//! Release GL objects
void Release (const Handle(OpenGl_Context)& theGlContext);
//! Setup viewport to render into FBO //! Setup viewport to render into FBO
void SetupViewport() Standard_EXPORT void SetupViewport (const Handle(OpenGl_Context)& theGlCtx);
{
glViewport (0, 0, myVPSizeX, myVPSizeY);
}
//! Override viewport settings //! Override viewport settings
void ChangeViewport (const GLsizei theVPSizeX, Standard_EXPORT void ChangeViewport (const GLsizei theVPSizeX,
const GLsizei theVPSizeY) const GLsizei theVPSizeY);
{
myVPSizeX = theVPSizeX;
myVPSizeY = theVPSizeY;
}
//! Bind frame buffer (to render into the texture). //! Bind frame buffer (to render into the texture).
void BindBuffer (const Handle(OpenGl_Context)& theGlContext) Standard_EXPORT void BindBuffer (const Handle(OpenGl_Context)& theGlCtx);
{
theGlContext->extFBO->glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, myGlFBufferId);
}
//! Unbind frame buffer. //! Unbind frame buffer.
void UnbindBuffer (const Handle(OpenGl_Context)& theGlContext) Standard_EXPORT void UnbindBuffer (const Handle(OpenGl_Context)& theGlCtx);
{
theGlContext->extFBO->glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, NO_FRAMEBUFFER);
}
//! Bind the texture. //! Bind the texture.
void BindTexture () Standard_EXPORT void BindTexture (const Handle(OpenGl_Context)& theGlCtx);
{
glEnable (GL_TEXTURE_2D); // needed only for fixed pipeline rendering
glBindTexture (GL_TEXTURE_2D, myGlTextureId);
}
//! Unbind the texture. //! Unbind the texture.
void UnbindTexture() Standard_EXPORT void UnbindTexture (const Handle(OpenGl_Context)& theGlCtx);
{
glBindTexture (GL_TEXTURE_2D, NO_TEXTURE);
glDisable (GL_TEXTURE_2D); // needed only for fixed pipeline rendering
}
private: private:
//! Check texture could be created //! Check texture could be created
Standard_Boolean IsProxySuccess() const; Standard_Boolean isProxySuccess() const;
//! Generate texture with undefined data //! Generate texture with undefined data
Standard_Boolean InitTrashTexture (const Handle(OpenGl_Context)& theGlContext); Standard_Boolean initTrashTexture (const Handle(OpenGl_Context)& theGlContext);
Standard_Boolean IsValidTexture() const Standard_Boolean isValidTexture() const
{ {
return myGlTextureId != NO_TEXTURE; return myGlTextureId != NO_TEXTURE;
} }
Standard_Boolean IsValidFrameBuffer() const Standard_Boolean isValidFrameBuffer() const
{ {
return myGlFBufferId != NO_FRAMEBUFFER; return myGlFBufferId != NO_FRAMEBUFFER;
} }
Standard_Boolean IsValidDepthBuffer() const Standard_Boolean isValidDepthBuffer() const
{ {
return myGlDepthRBId != NO_RENDERBUFFER; return myGlDepthRBId != NO_RENDERBUFFER;
} }
Standard_Boolean IsValidStencilBuffer() const Standard_Boolean isValidStencilBuffer() const
{ {
return myGlStencilRBId != NO_RENDERBUFFER; return myGlStencilRBId != NO_RENDERBUFFER;
} }
private: private:
GLsizei mySizeX; // texture width GLsizei mySizeX; //!< texture width
GLsizei mySizeY; // texture height GLsizei mySizeY; //!< texture height
GLsizei myVPSizeX; // viewport width (should be <= texture width) GLsizei myVPSizeX; //!< viewport width (should be <= texture width)
GLsizei myVPSizeY; // viewport height (should be <= texture height) GLsizei myVPSizeY; //!< viewport height (should be <= texture height)
GLint myTextFormat; // GL_RGB, GL_RGBA,... GLint myTextFormat; //!< GL_RGB, GL_RGBA,...
GLuint myGlTextureId; // GL texture ID GLuint myGlTextureId; //!< GL texture ID
GLuint myGlFBufferId; // FBO object ID GLuint myGlFBufferId; //!< FBO object ID
GLuint myGlDepthRBId; // RenderBuffer object for depth ID GLuint myGlDepthRBId; //!< RenderBuffer object for depth ID
GLuint myGlStencilRBId; // RenderBuffer object for stencil ID GLuint myGlStencilRBId; //!< RenderBuffer object for stencil ID
public:
DEFINE_STANDARD_RTTI(OpenGl_FrameBuffer) // Type definition
}; };
#endif //OPENGL_FRAME_BUFFER_H DEFINE_STANDARD_HANDLE(OpenGl_FrameBuffer, OpenGl_Resource)
#endif // OPENGL_FRAME_BUFFER_H

2
src/OpenGl/OpenGl_GraphicDriver.hxx
View File

@ -22,6 +22,7 @@
#include <Graphic3d_GraphicDriver.hxx> #include <Graphic3d_GraphicDriver.hxx>
#include <Handle_OpenGl_GraphicDriver.hxx> #include <Handle_OpenGl_GraphicDriver.hxx>
#include <Handle_OpenGl_Display.hxx>
#include <OpenGl_Context.hxx> #include <OpenGl_Context.hxx>
#include <OpenGl_PrinterContext.hxx> #include <OpenGl_PrinterContext.hxx>
@ -330,6 +331,7 @@ public:
private: private:
Handle(OpenGl_Display) myGlDisplay;
Handle(OpenGl_Caps) myCaps; Handle(OpenGl_Caps) myCaps;
NCollection_DataMap<Standard_Integer, Handle(OpenGl_View)> myMapOfView; NCollection_DataMap<Standard_Integer, Handle(OpenGl_View)> myMapOfView;
NCollection_DataMap<Standard_Integer, Handle(OpenGl_Workspace)> myMapOfWS; NCollection_DataMap<Standard_Integer, Handle(OpenGl_Workspace)> myMapOfWS;

2
src/OpenGl/OpenGl_GraphicDriver_1.cxx
View File

@ -36,7 +36,7 @@ Standard_Boolean OpenGl_GraphicDriver::Begin (const Handle(Aspect_DisplayConnect
myDisplayConnection = theDisplayConnection; myDisplayConnection = theDisplayConnection;
try try
{ {
openglDisplay = new OpenGl_Display (myDisplayConnection); myGlDisplay = new OpenGl_Display (myDisplayConnection);
return Standard_True; return Standard_True;
} }
catch (Standard_Failure) catch (Standard_Failure)

4
src/OpenGl/OpenGl_GraphicDriver_2.cxx
View File

@ -27,7 +27,7 @@
Standard_Integer OpenGl_GraphicDriver::InquireLightLimit () Standard_Integer OpenGl_GraphicDriver::InquireLightLimit ()
{ {
return (openglDisplay.IsNull()? 0 : openglDisplay->Facilities().MaxLights); return (myGlDisplay.IsNull() ? 0 : myGlDisplay->Facilities().MaxLights);
} }
void OpenGl_GraphicDriver::InquireMat (const Graphic3d_CView& ACView, TColStd_Array2OfReal& AMatO, TColStd_Array2OfReal& AMatM) void OpenGl_GraphicDriver::InquireMat (const Graphic3d_CView& ACView, TColStd_Array2OfReal& AMatO, TColStd_Array2OfReal& AMatM)
@ -39,7 +39,7 @@ void OpenGl_GraphicDriver::InquireMat (const Graphic3d_CView& ACView, TColStd_Ar
Standard_Integer OpenGl_GraphicDriver::InquireViewLimit () Standard_Integer OpenGl_GraphicDriver::InquireViewLimit ()
{ {
return (openglDisplay.IsNull()? 0 : openglDisplay->Facilities().MaxViews); return (myGlDisplay.IsNull() ? 0 : myGlDisplay->Facilities().MaxViews);
} }
Standard_Integer OpenGl_GraphicDriver::InquirePlaneLimit () Standard_Integer OpenGl_GraphicDriver::InquirePlaneLimit ()

4
src/OpenGl/OpenGl_GraphicDriver_3.cxx
View File

@ -39,7 +39,7 @@ void OpenGl_GraphicDriver::FaceContextGroup (const Graphic3d_CGroup& theCGroup,
if (!theCGroup.ContextFillArea.IsDef || theCGroup.ptrGroup == NULL) if (!theCGroup.ContextFillArea.IsDef || theCGroup.ptrGroup == NULL)
return; return;
((OpenGl_Group* )theCGroup.ptrGroup)->SetAspectFace (GetSharedContext(), theCGroup.ContextFillArea, theNoInsert); ((OpenGl_Group* )theCGroup.ptrGroup)->SetAspectFace (theCGroup.ContextFillArea, theNoInsert);
} }
void OpenGl_GraphicDriver::Group (Graphic3d_CGroup& theCGroup) void OpenGl_GraphicDriver::Group (Graphic3d_CGroup& theCGroup)
@ -64,7 +64,7 @@ void OpenGl_GraphicDriver::MarkerContextGroup (const Graphic3d_CGroup& theCGroup
{ {
if (!theCGroup.ContextMarker.IsDef || theCGroup.ptrGroup == NULL) return; if (!theCGroup.ContextMarker.IsDef || theCGroup.ptrGroup == NULL) return;
((OpenGl_Group* )theCGroup.ptrGroup)->SetAspectMarker (GetSharedContext(), theCGroup.ContextMarker, theNoInsert); ((OpenGl_Group* )theCGroup.ptrGroup)->SetAspectMarker (theCGroup.ContextMarker, theNoInsert);
} }
void OpenGl_GraphicDriver::RemoveGroup (const Graphic3d_CGroup& theCGroup) void OpenGl_GraphicDriver::RemoveGroup (const Graphic3d_CGroup& theCGroup)

4
src/OpenGl/OpenGl_GraphicDriver_4.cxx
View File

@ -45,10 +45,10 @@ void OpenGl_GraphicDriver::ContextStructure (const Graphic3d_CStructure& theCStr
aStructure->SetAspectLine (theCStructure.ContextLine); aStructure->SetAspectLine (theCStructure.ContextLine);
if (theCStructure.ContextFillArea.IsDef) if (theCStructure.ContextFillArea.IsDef)
aStructure->SetAspectFace (GetSharedContext(), theCStructure.ContextFillArea); aStructure->SetAspectFace (theCStructure.ContextFillArea);
if (theCStructure.ContextMarker.IsDef) if (theCStructure.ContextMarker.IsDef)
aStructure->SetAspectMarker (GetSharedContext(), theCStructure.ContextMarker); aStructure->SetAspectMarker (theCStructure.ContextMarker);
if (theCStructure.ContextText.IsDef) if (theCStructure.ContextText.IsDef)
aStructure->SetAspectText (theCStructure.ContextText); aStructure->SetAspectText (theCStructure.ContextText);

94
src/OpenGl/OpenGl_GraphicDriver_7.cxx
View File

@ -223,16 +223,19 @@ Graphic3d_PtrFrameBuffer OpenGl_GraphicDriver::FBOCreate (const Graphic3d_CView&
return (Graphic3d_PtrFrameBuffer)NULL; return (Graphic3d_PtrFrameBuffer)NULL;
} }
Graphic3d_PtrFrameBuffer OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth, const Standard_Integer theHeight) Graphic3d_PtrFrameBuffer OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth,
const Standard_Integer theHeight)
{ {
// activate OpenGL context // activate OpenGL context
if (!Activate()) if (!Activate())
return NULL; return NULL;
// create the FBO // create the FBO
const Handle(OpenGl_Context)& aCtx = GetGlContext();
OpenGl_FrameBuffer* aFrameBuffer = new OpenGl_FrameBuffer(); OpenGl_FrameBuffer* aFrameBuffer = new OpenGl_FrameBuffer();
if (!aFrameBuffer->Init (GetGlContext(), theWidth, theHeight)) if (!aFrameBuffer->Init (aCtx, theWidth, theHeight))
{ {
aFrameBuffer->Release (aCtx.operator->());
delete aFrameBuffer; delete aFrameBuffer;
return NULL; return NULL;
} }
@ -254,12 +257,18 @@ void OpenGl_GraphicDriver::FBORelease (const Graphic3d_CView& ACView, Graphic3d_
void OpenGl_Workspace::FBORelease (Graphic3d_PtrFrameBuffer theFBOPtr) void OpenGl_Workspace::FBORelease (Graphic3d_PtrFrameBuffer theFBOPtr)
{ {
// activate OpenGL context // activate OpenGL context
if (!Activate()) if (!Activate()
|| theFBOPtr == NULL)
{
return; return;
}
// release the object // release the object
OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer*)theFBOPtr; OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer*)theFBOPtr;
aFrameBuffer->Release (GetGlContext()); if (aFrameBuffer != NULL)
{
aFrameBuffer->Release (GetGlContext().operator->());
}
delete aFrameBuffer; delete aFrameBuffer;
} }
@ -417,14 +426,38 @@ Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer* theFB
void OpenGl_GraphicDriver::RemoveView (const Graphic3d_CView& theCView) void OpenGl_GraphicDriver::RemoveView (const Graphic3d_CView& theCView)
{ {
Handle(OpenGl_Context) aShareCtx = GetSharedContext(); Handle(OpenGl_Context) aCtx = GetSharedContext();
if (myMapOfView.IsBound (theCView.ViewId)) Handle(OpenGl_View) aView;
myMapOfView.UnBind (theCView.ViewId); Handle(OpenGl_Workspace) aWindow;
if (myMapOfWS.Find (theCView.WsId, aWindow))
if (myMapOfWS.IsBound (theCView.WsId)) {
myMapOfWS.UnBind (theCView.WsId); myMapOfWS.UnBind (theCView.WsId);
}
if (!aWindow.IsNull())
{
if (aWindow->GetGlContext()->MakeCurrent())
{
aCtx = aWindow->GetGlContext();
}
else
{
// try to hijack another context if any
const Handle(OpenGl_Context)& anOtherCtx = GetSharedContext();
if (!anOtherCtx.IsNull()
&& anOtherCtx != aWindow->GetGlContext())
{
aCtx = anOtherCtx;
aCtx->MakeCurrent();
}
}
}
if (myMapOfView.Find (theCView.ViewId, aView))
{
aView->ReleaseGlResources (aCtx);
myMapOfView.UnBind (theCView.ViewId);
}
if (myMapOfWS.IsEmpty() && !myMapOfStructure.IsEmpty()) if (myMapOfWS.IsEmpty())
{ {
// The last view removed but some objects still present. // The last view removed but some objects still present.
// Release GL resources now without object destruction. // Release GL resources now without object destruction.
@ -432,16 +465,20 @@ void OpenGl_GraphicDriver::RemoveView (const Graphic3d_CView& theCView)
aStructIt.More (); aStructIt.Next()) aStructIt.More (); aStructIt.Next())
{ {
OpenGl_Structure* aStruct = aStructIt.ChangeValue(); OpenGl_Structure* aStruct = aStructIt.ChangeValue();
aStruct->ReleaseGlResources (aShareCtx); aStruct->ReleaseGlResources (aCtx);
} }
myTempText->Release (aShareCtx); myTempText->Release (aCtx);
myDeviceLostFlag = Standard_True; myGlDisplay->ReleaseAttributes (aCtx.operator->());
myDeviceLostFlag = !myMapOfStructure.IsEmpty();
} }
OpenGl_CView* aCView = (OpenGl_CView* )theCView.ptrView; OpenGl_CView* aCView = (OpenGl_CView* )theCView.ptrView;
aCView->View->ReleaseGlResources (aShareCtx);
delete aCView; delete aCView;
((Graphic3d_CView *)&theCView)->ptrView = NULL; ((Graphic3d_CView *)&theCView)->ptrView = NULL;
aCtx.Nullify();
aView.Nullify();
aWindow.Nullify();
} }
void OpenGl_GraphicDriver::SetLight (const Graphic3d_CView& ACView) void OpenGl_GraphicDriver::SetLight (const Graphic3d_CView& ACView)
@ -502,31 +539,22 @@ void OpenGl_GraphicDriver::Update (const Graphic3d_CView& ACView, const Aspect_C
Standard_Boolean OpenGl_GraphicDriver::View (Graphic3d_CView& theCView) Standard_Boolean OpenGl_GraphicDriver::View (Graphic3d_CView& theCView)
{ {
if (openglDisplay.IsNull()) if (myGlDisplay.IsNull()
return Standard_False; || myMapOfView.IsBound (theCView.ViewId)
|| myMapOfWS .IsBound (theCView.WsId))
if (myMapOfView.IsBound (theCView.ViewId))
myMapOfView.UnBind (theCView.ViewId);
if (myMapOfWS.IsBound (theCView.WsId))
myMapOfWS.UnBind (theCView.WsId);
Handle(OpenGl_Workspace) aWS = Handle(OpenGl_Workspace)::DownCast(openglDisplay->GetWindow (theCView.DefWindow.XWindow));
if (aWS.IsNull())
{ {
Handle(OpenGl_Context) aShareCtx = GetSharedContext(); return Standard_False;
aWS = new OpenGl_Workspace (openglDisplay, theCView.DefWindow, theCView.GContext, myCaps, aShareCtx);
openglDisplay->SetWindow (theCView.DefWindow.XWindow, aWS);
} }
myMapOfWS.Bind (theCView.WsId, aWS); Handle(OpenGl_Context) aShareCtx = GetSharedContext();
Handle(OpenGl_Workspace) aWS = new OpenGl_Workspace (myGlDisplay, theCView.DefWindow, theCView.GContext, myCaps, aShareCtx);
Handle(OpenGl_View) aView = new OpenGl_View (theCView.Context); Handle(OpenGl_View) aView = new OpenGl_View (theCView.Context);
myMapOfWS .Bind (theCView.WsId, aWS);
myMapOfView.Bind (theCView.ViewId, aView); myMapOfView.Bind (theCView.ViewId, aView);
OpenGl_CView* aCView = new OpenGl_CView(); OpenGl_CView* aCView = new OpenGl_CView();
aCView->View = aView; aCView->View = aView;
aCView->WS = aWS; aCView->WS = aWS;
theCView.ptrView = aCView; theCView.ptrView = aCView;
return Standard_True; return Standard_True;
@ -537,7 +565,7 @@ void OpenGl_GraphicDriver::ViewMapping (const Graphic3d_CView& ACView, const Sta
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView) if (aCView)
{ {
aCView->View->SetMapping(ACView); aCView->View->SetMapping (myGlDisplay, ACView);
if (!AWait) if (!AWait)
{ {
aCView->WS->Resize(ACView.DefWindow); aCView->WS->Resize(ACView.DefWindow);

6
src/OpenGl/OpenGl_GraphicDriver_Layer.cxx
View File

@ -78,7 +78,7 @@ void InitLayerProp (const int AListId)
TheLayerProp.LineType = -1; TheLayerProp.LineType = -1;
TheLayerProp.LineWidth = -1.F; TheLayerProp.LineWidth = -1.F;
TheLayerProp.AspectText.SetContext(myDefaultContextText); TheLayerProp.AspectText.SetAspect (myDefaultContextText);
TheLayerProp.TextParam.HAlign = Graphic3d_HTA_LEFT; TheLayerProp.TextParam.HAlign = Graphic3d_HTA_LEFT;
TheLayerProp.TextParam.VAlign = Graphic3d_VTA_BOTTOM; TheLayerProp.TextParam.VAlign = Graphic3d_VTA_BOTTOM;
@ -230,12 +230,12 @@ void OpenGl_GraphicDriver::UnsetTransparency ()
void OpenGl_GraphicDriver::SetLineAttributes (const Standard_Integer Type, const Standard_ShortReal Width) void OpenGl_GraphicDriver::SetLineAttributes (const Standard_Integer Type, const Standard_ShortReal Width)
{ {
if (!TheLayerProp.ListId || openglDisplay.IsNull()) return; if (!TheLayerProp.ListId || myGlDisplay.IsNull()) return;
if (TheLayerProp.LineType != Type) if (TheLayerProp.LineType != Type)
{ {
TheLayerProp.LineType = Type; TheLayerProp.LineType = Type;
openglDisplay->SetTypeOfLine((Aspect_TypeOfLine) Type); myGlDisplay->SetTypeOfLine((Aspect_TypeOfLine) Type);
} }
if (TheLayerProp.LineWidth != Width) if (TheLayerProp.LineWidth != Width)
{ {

30
src/OpenGl/OpenGl_Group.cxx
View File

@ -48,19 +48,21 @@ OpenGl_Group::~OpenGl_Group()
// function : SetAspectLine // function : SetAspectLine
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_Group::SetAspectLine (const CALL_DEF_CONTEXTLINE& theContext, void OpenGl_Group::SetAspectLine (const CALL_DEF_CONTEXTLINE& theAspect,
const Standard_Boolean theIsGlobal) const Standard_Boolean theIsGlobal)
{ {
if (theIsGlobal || myFirst == NULL) if (theIsGlobal || myFirst == NULL)
{ {
if (myAspectLine == NULL) if (myAspectLine == NULL)
{
myAspectLine = new OpenGl_AspectLine(); myAspectLine = new OpenGl_AspectLine();
myAspectLine->SetContext (theContext); }
myAspectLine->SetAspect (theAspect);
} }
else else
{ {
OpenGl_AspectLine* anAspectLine = new OpenGl_AspectLine(); OpenGl_AspectLine* anAspectLine = new OpenGl_AspectLine();
anAspectLine->SetContext (theContext); anAspectLine->SetAspect (theAspect);
AddElement (TelNil/*TelAspectLine*/, anAspectLine); AddElement (TelNil/*TelAspectLine*/, anAspectLine);
} }
} }
@ -69,8 +71,7 @@ void OpenGl_Group::SetAspectLine (const CALL_DEF_CONTEXTLINE& theContext,
// function : SetAspectFace // function : SetAspectFace
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_Group::SetAspectFace (const Handle(OpenGl_Context)& theCtx, void OpenGl_Group::SetAspectFace (const CALL_DEF_CONTEXTFILLAREA& theAspect,
const CALL_DEF_CONTEXTFILLAREA& theAspect,
const Standard_Boolean theIsGlobal) const Standard_Boolean theIsGlobal)
{ {
if (theIsGlobal || myFirst == NULL) if (theIsGlobal || myFirst == NULL)
@ -79,12 +80,12 @@ void OpenGl_Group::SetAspectFace (const Handle(OpenGl_Context)& theCtx,
{ {
myAspectFace = new OpenGl_AspectFace(); myAspectFace = new OpenGl_AspectFace();
} }
myAspectFace->Init (theCtx, theAspect); myAspectFace->SetAspect (theAspect);
} }
else else
{ {
OpenGl_AspectFace* anAspectFace = new OpenGl_AspectFace(); OpenGl_AspectFace* anAspectFace = new OpenGl_AspectFace();
anAspectFace->Init (theCtx, theAspect); anAspectFace->SetAspect (theAspect);
AddElement (TelNil/*TelAspectFace*/, anAspectFace); AddElement (TelNil/*TelAspectFace*/, anAspectFace);
} }
} }
@ -93,8 +94,7 @@ void OpenGl_Group::SetAspectFace (const Handle(OpenGl_Context)& theCtx,
// function : SetAspectMarker // function : SetAspectMarker
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_Group::SetAspectMarker (const Handle(OpenGl_Context)& theCtx, void OpenGl_Group::SetAspectMarker (const CALL_DEF_CONTEXTMARKER& theAspect,
const CALL_DEF_CONTEXTMARKER& theAspect,
const Standard_Boolean theIsGlobal) const Standard_Boolean theIsGlobal)
{ {
if (theIsGlobal || myFirst == NULL) if (theIsGlobal || myFirst == NULL)
@ -103,12 +103,12 @@ void OpenGl_Group::SetAspectMarker (const Handle(OpenGl_Context)& theCtx,
{ {
myAspectMarker = new OpenGl_AspectMarker(); myAspectMarker = new OpenGl_AspectMarker();
} }
myAspectMarker->Init (theCtx, theAspect); myAspectMarker->SetAspect (theAspect);
} }
else else
{ {
OpenGl_AspectMarker* anAspectMarker = new OpenGl_AspectMarker(); OpenGl_AspectMarker* anAspectMarker = new OpenGl_AspectMarker();
anAspectMarker->Init (theCtx, theAspect); anAspectMarker->SetAspect (theAspect);
AddElement (TelNil/*TelAspectMarker*/, anAspectMarker); AddElement (TelNil/*TelAspectMarker*/, anAspectMarker);
} }
} }
@ -117,19 +117,21 @@ void OpenGl_Group::SetAspectMarker (const Handle(OpenGl_Context)& theCtx,
// function : SetAspectText // function : SetAspectText
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_Group::SetAspectText (const CALL_DEF_CONTEXTTEXT& theContext, void OpenGl_Group::SetAspectText (const CALL_DEF_CONTEXTTEXT& theAspect,
const Standard_Boolean theIsGlobal) const Standard_Boolean theIsGlobal)
{ {
if (theIsGlobal || myFirst == NULL) if (theIsGlobal || myFirst == NULL)
{ {
if (myAspectText == NULL) if (myAspectText == NULL)
{
myAspectText = new OpenGl_AspectText(); myAspectText = new OpenGl_AspectText();
myAspectText->SetContext (theContext); }
myAspectText->SetAspect (theAspect);
} }
else else
{ {
OpenGl_AspectText* anAspectText = new OpenGl_AspectText(); OpenGl_AspectText* anAspectText = new OpenGl_AspectText();
anAspectText->SetContext (theContext); anAspectText->SetAspect (theAspect);
AddElement ( TelNil/*TelAspectText*/, anAspectText); AddElement ( TelNil/*TelAspectText*/, anAspectText);
} }
} }

12
src/OpenGl/OpenGl_Group.hxx
View File

@ -51,14 +51,10 @@ public:
OpenGl_Group(); OpenGl_Group();
void SetAspectLine (const CALL_DEF_CONTEXTLINE &AContext, const Standard_Boolean IsGlobal = Standard_True); void SetAspectLine (const CALL_DEF_CONTEXTLINE& theAspect, const Standard_Boolean IsGlobal = Standard_True);
void SetAspectFace (const Handle(OpenGl_Context)& theCtx, void SetAspectFace (const CALL_DEF_CONTEXTFILLAREA& theAspect, const Standard_Boolean IsGlobal = Standard_True);
const CALL_DEF_CONTEXTFILLAREA& theAspect, void SetAspectMarker (const CALL_DEF_CONTEXTMARKER& theAspect, const Standard_Boolean IsGlobal = Standard_True);
const Standard_Boolean IsGlobal = Standard_True); void SetAspectText (const CALL_DEF_CONTEXTTEXT& theAspect, const Standard_Boolean IsGlobal = Standard_True);
void SetAspectMarker (const Handle(OpenGl_Context)& theCtx,
const CALL_DEF_CONTEXTMARKER& theAspect,
const Standard_Boolean IsGlobal = Standard_True);
void SetAspectText (const CALL_DEF_CONTEXTTEXT &AContext, const Standard_Boolean IsGlobal = Standard_True);
void AddElement (const TelType, OpenGl_Element * ); void AddElement (const TelType, OpenGl_Element * );

5
src/OpenGl/OpenGl_PointSprite.cxx
View File

@ -57,7 +57,10 @@ void OpenGl_PointSprite::Release (const OpenGl_Context* theGlCtx)
{ {
if (myBitmapList != 0) if (myBitmapList != 0)
{ {
glDeleteLists (myBitmapList, 1); if (theGlCtx->IsValid())
{
glDeleteLists (myBitmapList, 1);
}
myBitmapList = 0; myBitmapList = 0;
} }

18
src/OpenGl/OpenGl_PrimitiveArray.cxx
View File

@ -539,7 +539,7 @@ void OpenGl_PrimitiveArray::DrawMarkers (const Handle(OpenGl_Workspace)& theWork
{ {
const OpenGl_AspectMarker* anAspectMarker = theWorkspace->AspectMarker (Standard_True); const OpenGl_AspectMarker* anAspectMarker = theWorkspace->AspectMarker (Standard_True);
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext(); const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
const Handle(OpenGl_PointSprite)& aSpriteNorm = anAspectMarker->Sprite(); const Handle(OpenGl_PointSprite)& aSpriteNorm = anAspectMarker->Sprite(theWorkspace);
const Standard_Boolean isHilight = (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT); const Standard_Boolean isHilight = (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT);
if (aCtx->IsGlGreaterEqual (2, 0) if (aCtx->IsGlGreaterEqual (2, 0)
&& !aSpriteNorm.IsNull() && !aSpriteNorm->IsDisplayList()) && !aSpriteNorm.IsNull() && !aSpriteNorm->IsDisplayList())
@ -550,8 +550,8 @@ void OpenGl_PrimitiveArray::DrawMarkers (const Handle(OpenGl_Workspace)& theWork
Handle(OpenGl_Texture) aTextureBack; Handle(OpenGl_Texture) aTextureBack;
if (anAspectMarker->Type() != Aspect_TOM_POINT) if (anAspectMarker->Type() != Aspect_TOM_POINT)
{ {
const Handle(OpenGl_PointSprite)& aSprite = (isHilight && anAspectMarker->SpriteHighlight()->IsValid()) const Handle(OpenGl_PointSprite)& aSprite = (isHilight && anAspectMarker->SpriteHighlight(theWorkspace)->IsValid())
? anAspectMarker->SpriteHighlight() ? anAspectMarker->SpriteHighlight(theWorkspace)
: aSpriteNorm; : aSpriteNorm;
aTextureBack = theWorkspace->EnableTexture (aSprite); aTextureBack = theWorkspace->EnableTexture (aSprite);
@ -704,7 +704,7 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
if (!myIsVboInit if (!myIsVboInit
&& !aCtx->caps->vboDisable && !aCtx->caps->vboDisable
&& aCtx->core15 != NULL && aCtx->core15 != NULL
&& (myDrawMode != GL_POINTS || anAspectMarker->Sprite().IsNull() || !anAspectMarker->Sprite()->IsDisplayList())) && (myDrawMode != GL_POINTS || anAspectMarker->Sprite(theWorkspace).IsNull() || !anAspectMarker->Sprite(theWorkspace)->IsDisplayList()))
{ {
if (!BuildVBO (theWorkspace)) if (!BuildVBO (theWorkspace))
{ {
@ -730,8 +730,8 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
break; break;
} }
Tint aFrontLightingModel = anAspectFace->IntFront.color_mask; Tint aFrontLightingModel = anAspectFace->IntFront().color_mask;
const TEL_COLOUR* anInteriorColor = &anAspectFace->IntFront.matcol; const TEL_COLOUR* anInteriorColor = &anAspectFace->IntFront().matcol;
const TEL_COLOUR* anEdgeColor = &anAspectFace->AspectEdge()->Color(); const TEL_COLOUR* anEdgeColor = &anAspectFace->AspectEdge()->Color();
const TEL_COLOUR* aLineColor = (myPArray->type == TelPointsArrayType) ? &anAspectMarker->Color() : &anAspectLine->Color(); const TEL_COLOUR* aLineColor = (myPArray->type == TelPointsArrayType) ? &anAspectMarker->Color() : &anAspectLine->Color();
@ -743,11 +743,11 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
} }
DrawArray (aFrontLightingModel, DrawArray (aFrontLightingModel,
anAspectFace->InteriorStyle, anAspectFace->InteriorStyle(),
anAspectFace->Edge, anAspectFace->Edge(),
anInteriorColor, anInteriorColor,
aLineColor, aLineColor,
anEdgeColor, anEdgeColor,
&anAspectFace->IntFront, &anAspectFace->IntFront(),
theWorkspace); theWorkspace);
} }

22
src/OpenGl/OpenGl_Structure.cxx
View File

@ -187,50 +187,52 @@ void OpenGl_Structure::SetTransformPersistence(const CALL_DEF_TRANSFORM_PERSISTE
// function : SetAspectLine // function : SetAspectLine
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_Structure::SetAspectLine (const CALL_DEF_CONTEXTLINE &AContext) void OpenGl_Structure::SetAspectLine (const CALL_DEF_CONTEXTLINE &theAspect)
{ {
if (!myAspectLine) if (!myAspectLine)
{
myAspectLine = new OpenGl_AspectLine(); myAspectLine = new OpenGl_AspectLine();
myAspectLine->SetContext( AContext ); }
myAspectLine->SetAspect (theAspect);
} }
// ======================================================================= // =======================================================================
// function : SetAspectFace // function : SetAspectFace
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_Structure::SetAspectFace (const Handle(OpenGl_Context)& theCtx, void OpenGl_Structure::SetAspectFace (const CALL_DEF_CONTEXTFILLAREA& theAspect)
const CALL_DEF_CONTEXTFILLAREA& theAspect)
{ {
if (!myAspectFace) if (!myAspectFace)
{ {
myAspectFace = new OpenGl_AspectFace(); myAspectFace = new OpenGl_AspectFace();
} }
myAspectFace->Init (theCtx, theAspect); myAspectFace->SetAspect (theAspect);
} }
// ======================================================================= // =======================================================================
// function : SetAspectMarker // function : SetAspectMarker
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_Structure::SetAspectMarker (const Handle(OpenGl_Context)& theCtx, void OpenGl_Structure::SetAspectMarker (const CALL_DEF_CONTEXTMARKER& theAspect)
const CALL_DEF_CONTEXTMARKER& theAspect)
{ {
if (!myAspectMarker) if (!myAspectMarker)
{ {
myAspectMarker = new OpenGl_AspectMarker(); myAspectMarker = new OpenGl_AspectMarker();
} }
myAspectMarker->Init (theCtx, theAspect); myAspectMarker->SetAspect (theAspect);
} }
// ======================================================================= // =======================================================================
// function : SetAspectText // function : SetAspectText
// purpose : // purpose :
// ======================================================================= // =======================================================================
void OpenGl_Structure::SetAspectText (const CALL_DEF_CONTEXTTEXT &AContext) void OpenGl_Structure::SetAspectText (const CALL_DEF_CONTEXTTEXT &theAspect)
{ {
if (!myAspectText) if (!myAspectText)
{
myAspectText = new OpenGl_AspectText(); myAspectText = new OpenGl_AspectText();
myAspectText->SetContext( AContext ); }
myAspectText->SetAspect (theAspect);
} }
// ======================================================================= // =======================================================================

10
src/OpenGl/OpenGl_Structure.hxx
View File

@ -48,12 +48,10 @@ public:
void SetTransformPersistence (const CALL_DEF_TRANSFORM_PERSISTENCE &ATransPers); void SetTransformPersistence (const CALL_DEF_TRANSFORM_PERSISTENCE &ATransPers);
void SetAspectLine (const CALL_DEF_CONTEXTLINE &AContext); void SetAspectLine (const CALL_DEF_CONTEXTLINE &theAspect);
void SetAspectFace (const Handle(OpenGl_Context)& theCtx, void SetAspectFace (const CALL_DEF_CONTEXTFILLAREA& theAspect);
const CALL_DEF_CONTEXTFILLAREA& theAspect); void SetAspectMarker (const CALL_DEF_CONTEXTMARKER& theAspect);
void SetAspectMarker (const Handle(OpenGl_Context)& theCtx, void SetAspectText (const CALL_DEF_CONTEXTTEXT &theAspect);
const CALL_DEF_CONTEXTMARKER& theAspect);
void SetAspectText (const CALL_DEF_CONTEXTTEXT &AContext);
void SetHighlightBox (const Handle(OpenGl_Context)& theGlCtx, void SetHighlightBox (const Handle(OpenGl_Context)& theGlCtx,
const CALL_DEF_BOUNDBOX& theBoundBox); const CALL_DEF_BOUNDBOX& theBoundBox);

5
src/OpenGl/OpenGl_TextureBufferArb.cxx
View File

@ -66,7 +66,10 @@ void OpenGl_TextureBufferArb::Release (const OpenGl_Context* theGlCtx)
Standard_ASSERT_RETURN (theGlCtx != NULL, Standard_ASSERT_RETURN (theGlCtx != NULL,
"OpenGl_TextureBufferExt destroyed without GL context! Possible GPU memory leakage...",); "OpenGl_TextureBufferExt destroyed without GL context! Possible GPU memory leakage...",);
glDeleteTextures (1, &myTextureId); if (theGlCtx->IsValid())
{
glDeleteTextures (1, &myTextureId);
}
myTextureId = NO_TEXTURE; myTextureId = NO_TEXTURE;
} }
OpenGl_VertexBuffer::Release (theGlCtx); OpenGl_VertexBuffer::Release (theGlCtx);

20
src/OpenGl/OpenGl_Trihedron.cxx
View File

@ -576,17 +576,17 @@ OpenGl_Trihedron::OpenGl_Trihedron (const Aspect_TypeOfTriedronPosition thePosit
Quantity_Color aColor (theColor); Quantity_Color aColor (theColor);
aColor.Values (R, G, B, Quantity_TOC_RGB); aColor.Values (R, G, B, Quantity_TOC_RGB);
CALL_DEF_CONTEXTLINE aContextLine = myDefaultContextLine; CALL_DEF_CONTEXTLINE aLineAspect = myDefaultContextLine;
aContextLine.Color.r = (float)R; aLineAspect.Color.r = (float)R;
aContextLine.Color.g = (float)G; aLineAspect.Color.g = (float)G;
aContextLine.Color.b = (float)B; aLineAspect.Color.b = (float)B;
myAspectLine.SetContext(aContextLine); myAspectLine.SetAspect (aLineAspect);
CALL_DEF_CONTEXTTEXT aContextText = myDefaultContextText; CALL_DEF_CONTEXTTEXT aTextAspect = myDefaultContextText;
aContextText.Color.r = (float)R; aTextAspect.Color.r = (float)R;
aContextText.Color.g = (float)G; aTextAspect.Color.g = (float)G;
aContextText.Color.b = (float)B; aTextAspect.Color.b = (float)B;
myAspectText.SetContext(aContextText); myAspectText.SetAspect (aTextAspect);
myXColor = theXColor; myXColor = theXColor;
myYColor = theYColor; myYColor = theYColor;

5
src/OpenGl/OpenGl_VertexBuffer.cxx
View File

@ -84,7 +84,10 @@ void OpenGl_VertexBuffer::Release (const OpenGl_Context* theGlCtx)
Standard_ASSERT_RETURN (theGlCtx != NULL, Standard_ASSERT_RETURN (theGlCtx != NULL,
"OpenGl_VertexBuffer destroyed without GL context! Possible GPU memory leakage...",); "OpenGl_VertexBuffer destroyed without GL context! Possible GPU memory leakage...",);
theGlCtx->core15->glDeleteBuffers (1, &myBufferId); if (theGlCtx->IsValid())
{
theGlCtx->core15->glDeleteBuffers (1, &myBufferId);
}
myBufferId = NO_BUFFER; myBufferId = NO_BUFFER;
} }

7
src/OpenGl/OpenGl_View.cxx
View File

@ -291,7 +291,8 @@ void OpenGl_View::SetClipLimit (const Graphic3d_CView& theCView)
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
//call_togl_viewmapping //call_togl_viewmapping
void OpenGl_View::SetMapping (const Graphic3d_CView& theCView) void OpenGl_View::SetMapping (const Handle(OpenGl_Display)& theGlDisplay,
const Graphic3d_CView& theCView)
{ {
const float ratio = theCView.DefWindow.dy / theCView.DefWindow.dx; const float ratio = theCView.DefWindow.dy / theCView.DefWindow.dx;
const float r_ratio = theCView.DefWindow.dx / theCView.DefWindow.dy; const float r_ratio = theCView.DefWindow.dx / theCView.DefWindow.dy;
@ -325,7 +326,7 @@ void OpenGl_View::SetMapping (const Graphic3d_CView& theCView)
Map.prp[0] = theCView.Mapping.ProjectionReferencePoint.x; Map.prp[0] = theCView.Mapping.ProjectionReferencePoint.x;
Map.prp[1] = theCView.Mapping.ProjectionReferencePoint.y; Map.prp[1] = theCView.Mapping.ProjectionReferencePoint.y;
Map.prp[2] = theCView.Mapping.ProjectionReferencePoint.z; Map.prp[2] = theCView.Mapping.ProjectionReferencePoint.z;
if (!openglDisplay.IsNull() && !openglDisplay->Walkthrough()) if (!theGlDisplay.IsNull() && !theGlDisplay->Walkthrough())
Map.prp[2] += theCView.Mapping.FrontPlaneDistance; Map.prp[2] += theCView.Mapping.FrontPlaneDistance;
// view plane distance // view plane distance
@ -348,7 +349,7 @@ void OpenGl_View::SetMapping (const Graphic3d_CView& theCView)
myMappingMatrix[i][j] = theCView.Mapping.ProjectionMatrix[i][j]; myMappingMatrix[i][j] = theCView.Mapping.ProjectionMatrix[i][j];
} }
else else
TelEvalViewMappingMatrix( &Map, &err_ind, myMappingMatrix ); TelEvalViewMappingMatrix (theGlDisplay, &Map, &err_ind, myMappingMatrix);
if (!err_ind) if (!err_ind)
myExtra.map = Map; myExtra.map = Map;

3
src/OpenGl/OpenGl_View.hxx
View File

@ -45,6 +45,7 @@
#include <OpenGl_Light.hxx> #include <OpenGl_Light.hxx>
#include <Handle_OpenGl_Context.hxx> #include <Handle_OpenGl_Context.hxx>
#include <Handle_OpenGl_Display.hxx>
#include <Handle_OpenGl_Workspace.hxx> #include <Handle_OpenGl_Workspace.hxx>
#include <Handle_OpenGl_View.hxx> #include <Handle_OpenGl_View.hxx>
#include <Handle_OpenGl_Texture.hxx> #include <Handle_OpenGl_Texture.hxx>
@ -116,7 +117,7 @@ class OpenGl_View : public MMgt_TShared
void SetVisualisation (const CALL_DEF_VIEWCONTEXT &AContext); void SetVisualisation (const CALL_DEF_VIEWCONTEXT &AContext);
void SetClipLimit (const Graphic3d_CView& theCView); void SetClipLimit (const Graphic3d_CView& theCView);
void SetMapping (const Graphic3d_CView& theCView); void SetMapping (const Handle(OpenGl_Display)& theGlDisplay, const Graphic3d_CView& theCView);
void SetOrientation (const Graphic3d_CView& theCView); void SetOrientation (const Graphic3d_CView& theCView);
void SetFog (const Graphic3d_CView& theCView, const Standard_Boolean theFlag); void SetFog (const Graphic3d_CView& theCView, const Standard_Boolean theFlag);

29
src/OpenGl/OpenGl_Window.cxx
View File

@ -547,26 +547,39 @@ OpenGl_Window::OpenGl_Window (const Handle(OpenGl_Display)& theDisplay,
// ======================================================================= // =======================================================================
OpenGl_Window::~OpenGl_Window() OpenGl_Window::~OpenGl_Window()
{ {
if (!myOwnGContext)
{
myGlContext.Nullify();
return;
}
// release "GL" context if it is owned by window
#if defined(_WIN32) #if defined(_WIN32)
HWND aWindow = (HWND )myGlContext->myWindow; HWND aWindow = (HWND )myGlContext->myWindow;
HDC aWindowDC = (HDC )myGlContext->myWindowDC; HDC aWindowDC = (HDC )myGlContext->myWindowDC;
HGLRC aGContext = (HGLRC )myGlContext->myGContext; HGLRC aWindowGContext = (HGLRC )myGlContext->myGContext;
HGLRC aThreadGlContext = wglGetCurrentContext();
myGlContext.Nullify(); myGlContext.Nullify();
if (myOwnGContext) if (aThreadGlContext != NULL)
{ {
if (wglGetCurrentContext() != NULL) // Mesa implementation can fail to reset this thread's context if wglDeleteContext()
// called without this step. This might lead to crash when using newly created
// context if wglMakeCurrent() is not forced right after the wglCreateContext().
if (aThreadGlContext == aWindowGContext)
{ {
wglDeleteContext (aGContext); wglMakeCurrent (NULL, NULL);
} }
ReleaseDC (aWindow, aWindowDC);
wglDeleteContext (aWindowGContext);
} }
ReleaseDC (aWindow, aWindowDC);
#else #else
Display* aDisplay = (Display* )myGlContext->myDisplay; Display* aDisplay = (Display* )myGlContext->myDisplay;
GLXContext aGContext = (GLXContext )myGlContext->myGContext; GLXContext aGContext = (GLXContext )myGlContext->myGContext;
myGlContext.Nullify(); myGlContext.Nullify();
if (aDisplay != NULL && myOwnGContext) if (aDisplay != NULL)
{ {
// FSXXX sync necessary if non-direct rendering // FSXXX sync necessary if non-direct rendering
glXWaitGL(); glXWaitGL();

4
src/OpenGl/OpenGl_Workspace.cxx
View File

@ -478,8 +478,8 @@ void OpenGl_Workspace::Redraw (const Graphic3d_CView& theCView,
if (aFrameBuffer != NULL) if (aFrameBuffer != NULL)
{ {
glGetIntegerv (GL_VIEWPORT, aViewPortBack); glGetIntegerv (GL_VIEWPORT, aViewPortBack);
aFrameBuffer->SetupViewport(); aFrameBuffer->SetupViewport (aGlCtx);
aFrameBuffer->BindBuffer (aGlCtx); aFrameBuffer->BindBuffer (aGlCtx);
toSwap = 0; // no need to swap buffers toSwap = 0; // no need to swap buffers
} }

10
src/OpenGl/OpenGl_Workspace_2.cxx
View File

@ -489,7 +489,7 @@ Standard_Boolean OpenGl_Workspace::Print
if (!aViewBuffer) if (!aViewBuffer)
{ {
aFrameBuffer->Release (GetGlContext()); aFrameBuffer->Release (GetGlContext().operator->());
aViewBuffer = NULL; aViewBuffer = NULL;
aViewImage = NULL; aViewImage = NULL;
} }
@ -503,7 +503,7 @@ Standard_Boolean OpenGl_Workspace::Print
{ {
if (hViewBitmap) if (hViewBitmap)
DeleteObject (hViewBitmap); DeleteObject (hViewBitmap);
aFrameBuffer->Release (GetGlContext()); aFrameBuffer->Release (GetGlContext().operator->());
hViewBitmap = NULL; hViewBitmap = NULL;
} }
else else
@ -593,7 +593,7 @@ Standard_Boolean OpenGl_Workspace::Print
{ {
myPrintContext->SetScale ((GLfloat )aFrameWidth /viewWidth, myPrintContext->SetScale ((GLfloat )aFrameWidth /viewWidth,
(GLfloat )aFrameHeight/viewHeight); (GLfloat )aFrameHeight/viewHeight);
aFrameBuffer->SetupViewport (); aFrameBuffer->SetupViewport (GetGlContext());
Redraw1(ACView, ACUnderLayer, ACOverLayer, 0); Redraw1(ACView, ACUnderLayer, ACOverLayer, 0);
if (!myTransientDrawToFront) if (!myTransientDrawToFront)
{ {
@ -704,7 +704,7 @@ Standard_Boolean OpenGl_Workspace::Print
aFrameHeight; aFrameHeight;
// draw to the offscreen buffer and capture the result // draw to the offscreen buffer and capture the result
aFrameBuffer->SetupViewport (); aFrameBuffer->SetupViewport (GetGlContext());
Redraw1(ACView, ACUnderLayer, ACOverLayer, 0); Redraw1(ACView, ACUnderLayer, ACOverLayer, 0);
if (!myTransientDrawToFront) if (!myTransientDrawToFront)
{ {
@ -766,7 +766,7 @@ Standard_Boolean OpenGl_Workspace::Print
} }
else else
{ {
aFrameBuffer->Release (GetGlContext ()); aFrameBuffer->Release (GetGlContext().operator->());
delete aFrameBuffer; delete aFrameBuffer;
} }

50
src/OpenGl/OpenGl_Workspace_5.cxx
View File

@ -70,15 +70,15 @@ static void TelUpdatePolygonOffsets( const TEL_POFFSET_PARAM *pdata )
void OpenGl_Workspace::UpdateMaterial( const int flag ) void OpenGl_Workspace::UpdateMaterial( const int flag )
{ {
// Case of Hiddenline // Case of hidden line
if (AspectFace_set->InteriorStyle == Aspect_IS_HIDDENLINE) if (AspectFace_set->InteriorStyle() == Aspect_IS_HIDDENLINE)
{ {
myAspectFaceHl = *AspectFace_set; // copy all values including line edge aspect myAspectFaceHl = *AspectFace_set; // copy all values including line edge aspect
myAspectFaceHl.IntFront.matcol = BackgroundColor(); myAspectFaceHl.ChangeIntFront().matcol = BackgroundColor();
myAspectFaceHl.IntFront.color_mask = 0; myAspectFaceHl.ChangeIntFront().color_mask = 0;
myAspectFaceHl.IntBack.color_mask = 0; myAspectFaceHl.ChangeIntFront().color_mask = 0;
AspectFace_set = &myAspectFaceHl; AspectFace_set = &myAspectFaceHl;
return; return;
} }
@ -86,12 +86,12 @@ void OpenGl_Workspace::UpdateMaterial( const int flag )
GLenum face = 0; GLenum face = 0;
if ( flag == TEL_FRONT_MATERIAL ) if ( flag == TEL_FRONT_MATERIAL )
{ {
prop = &AspectFace_set->IntFront; prop = &AspectFace_set->IntFront();
face = GL_FRONT_AND_BACK; face = GL_FRONT_AND_BACK;
} }
else else
{ {
prop = &AspectFace_set->IntBack; prop = &AspectFace_set->IntBack();
face = GL_BACK; face = GL_BACK;
} }
@ -492,8 +492,8 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
return AspectFace_set; return AspectFace_set;
} }
const Aspect_InteriorStyle anIntstyle = AspectFace_set->InteriorStyle; const Aspect_InteriorStyle anIntstyle = AspectFace_set->InteriorStyle();
if (AspectFace_applied == NULL || AspectFace_applied->InteriorStyle != anIntstyle) if (AspectFace_applied == NULL || AspectFace_applied->InteriorStyle() != anIntstyle)
{ {
switch (anIntstyle) switch (anIntstyle)
{ {
@ -506,7 +506,7 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
case Aspect_IS_HATCH: case Aspect_IS_HATCH:
{ {
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
myDisplay->SetTypeOfHatch (AspectFace_applied != NULL ? AspectFace_applied->Hatch : TEL_HS_SOLID); myDisplay->SetTypeOfHatch (AspectFace_applied != NULL ? AspectFace_applied->Hatch() : TEL_HS_SOLID);
break; break;
} }
case Aspect_IS_SOLID: case Aspect_IS_SOLID:
@ -526,8 +526,8 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
if (anIntstyle == Aspect_IS_HATCH) if (anIntstyle == Aspect_IS_HATCH)
{ {
const Tint hatchstyle = AspectFace_set->Hatch; const Tint hatchstyle = AspectFace_set->Hatch();
if (AspectFace_applied == NULL || AspectFace_applied->Hatch != hatchstyle) if (AspectFace_applied == NULL || AspectFace_applied->Hatch() != hatchstyle)
{ {
myDisplay->SetTypeOfHatch(hatchstyle); myDisplay->SetTypeOfHatch(hatchstyle);
} }
@ -535,8 +535,8 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
if (!ActiveView()->Backfacing()) if (!ActiveView()->Backfacing())
{ {
const Tint aCullingMode = AspectFace_set->CullingMode; const Tint aCullingMode = AspectFace_set->CullingMode();
if (AspectFace_applied == NULL || AspectFace_applied->CullingMode != aCullingMode) if (AspectFace_applied == NULL || AspectFace_applied->CullingMode() != aCullingMode)
{ {
switch ((TelCullMode )aCullingMode) switch ((TelCullMode )aCullingMode)
{ {
@ -562,30 +562,30 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
} }
// Aspect_POM_None means: do not change current settings // Aspect_POM_None means: do not change current settings
if ((AspectFace_set->PolygonOffset.mode & Aspect_POM_None) != Aspect_POM_None) if ((AspectFace_set->PolygonOffset().mode & Aspect_POM_None) != Aspect_POM_None)
{ {
if (PolygonOffset_applied == NULL if (PolygonOffset_applied == NULL
|| PolygonOffset_applied->mode != AspectFace_set->PolygonOffset.mode || PolygonOffset_applied->mode != AspectFace_set->PolygonOffset().mode
|| PolygonOffset_applied->factor != AspectFace_set->PolygonOffset.factor || PolygonOffset_applied->factor != AspectFace_set->PolygonOffset().factor
|| PolygonOffset_applied->units != AspectFace_set->PolygonOffset.units) || PolygonOffset_applied->units != AspectFace_set->PolygonOffset().units)
{ {
PolygonOffset_applied = &AspectFace_set->PolygonOffset; PolygonOffset_applied = &AspectFace_set->PolygonOffset();
TelUpdatePolygonOffsets (PolygonOffset_applied); TelUpdatePolygonOffsets (PolygonOffset_applied);
} }
} }
UpdateMaterial (TEL_FRONT_MATERIAL); UpdateMaterial (TEL_FRONT_MATERIAL);
if (AspectFace_set->DistinguishingMode == TOn) if (AspectFace_set->DistinguishingMode() == TOn)
{ {
UpdateMaterial (TEL_BACK_MATERIAL); UpdateMaterial (TEL_BACK_MATERIAL);
} }
if ((NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0) if ((NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0)
{ {
if (AspectFace_set->doTextureMap) if (AspectFace_set->DoTextureMap())
{ {
EnableTexture (AspectFace_set->TextureRes, EnableTexture (AspectFace_set->TextureRes (this),
AspectFace_set->TextureParams); AspectFace_set->TextureParams());
} }
else else
{ {

22
src/OpenGl/OpenGl_telem_view.cxx
View File

@ -29,7 +29,8 @@ File OpenGl_telem_view :
#include <OpenGl_Display.hxx> #include <OpenGl_Display.hxx>
static void static void
EvalViewMappingMatrix( tel_view_mapping mapping /* View Mapping */, EvalViewMappingMatrix (const Handle(OpenGl_Display)& theGlDisplay,
tel_view_mapping mapping /* View Mapping */,
Tint* error_ind /* Out: Error Indicator */, Tint* error_ind /* Out: Error Indicator */,
Tmatrix3 mat /* Out: Mapping Matrix * */, Tmatrix3 mat /* Out: Mapping Matrix * */,
Tint flag, Tint flag,
@ -85,7 +86,7 @@ EvalViewMappingMatrix( tel_view_mapping mapping /* View Mapping */,
} }
/* prp between front and back planes */ /* prp between front and back planes */
if (openglDisplay.IsNull() || !openglDisplay->Walkthrough()) if (theGlDisplay.IsNull() || !theGlDisplay->Walkthrough())
{ {
if( mapping->prp[2] < mapping->fpd && if( mapping->prp[2] < mapping->fpd &&
mapping->prp[2] > mapping->bpd ) mapping->prp[2] > mapping->bpd )
@ -142,7 +143,7 @@ EvalViewMappingMatrix( tel_view_mapping mapping /* View Mapping */,
pmat[2][0] = -gx; pmat[3][0] = mapping->vpd*gx; pmat[2][0] = -gx; pmat[3][0] = mapping->vpd*gx;
pmat[2][1] = -gy; pmat[3][1] = mapping->vpd*gy; pmat[2][1] = -gy; pmat[3][1] = mapping->vpd*gy;
} }
else if (!openglDisplay.IsNull() && !openglDisplay->SymPerspective())/* TelPerspective */ else if (!theGlDisplay.IsNull() && !theGlDisplay->SymPerspective())/* TelPerspective */
{ {
pmat[0][0] = pmat[1][1] = mapping->prp[2] - mapping->vpd; pmat[0][0] = pmat[1][1] = mapping->prp[2] - mapping->vpd;
pmat[2][0] = -gx; pmat[2][0] = -gx;
@ -153,7 +154,7 @@ EvalViewMappingMatrix( tel_view_mapping mapping /* View Mapping */,
pmat[3][3] = mapping->prp[2]; pmat[3][3] = mapping->prp[2];
/* modify the next two cells to change clipping policy */ /* modify the next two cells to change clipping policy */
if (!openglDisplay.IsNull() && !openglDisplay->Walkthrough()) if (!theGlDisplay.IsNull() && !theGlDisplay->Walkthrough())
{ {
pmat[2][2] = mapping->prp[2] - ( fpd + bpd ); pmat[2][2] = mapping->prp[2] - ( fpd + bpd );
pmat[3][2] = fpd * bpd; pmat[3][2] = fpd * bpd;
@ -336,12 +337,11 @@ TelEvalViewOrientationMatrix( Tfloat *vrp /* View Reference Point */,
return; return;
} }
void void TelEvalViewMappingMatrix (const Handle(OpenGl_Display)& theGlDisplay,
TelEvalViewMappingMatrix( tel_view_mapping mapping /* View Mapping */, tel_view_mapping mapping /* View Mapping */,
Tint *error_ind /* Out: Error Indicator */, Tint *error_ind /* Out: Error Indicator */,
Tmatrix3 mat /* Out: Mapping Matrix */ Tmatrix3 mat /* Out: Mapping Matrix */
) )
{ {
EvalViewMappingMatrix( mapping, error_ind, mat, 0, ( float )0.0, ( float )0.0, 0, 0 ); EvalViewMappingMatrix (theGlDisplay, mapping, error_ind, mat, 0, ( float )0.0, ( float )0.0, 0, 0);
} }

3
src/OpenGl/OpenGl_telem_view.hxx
View File

@ -43,6 +43,7 @@ Suppression de TelPrintAllViews()
#define OPENGL_TELEM_VIEW_H #define OPENGL_TELEM_VIEW_H
#include <InterfaceGraphic_tgl_all.hxx> #include <InterfaceGraphic_tgl_all.hxx>
#include <Handle_OpenGl_Display.hxx>
typedef struct typedef struct
{ {
@ -82,6 +83,6 @@ extern void /* vrp, vpn, vup, error_ind, mat */
TelEvalViewOrientationMatrix(Tfloat*, Tfloat*, Tfloat*, Tfloat*, Tint*, Tmatrix3); TelEvalViewOrientationMatrix(Tfloat*, Tfloat*, Tfloat*, Tfloat*, Tint*, Tmatrix3);
extern void /* mapping, error_ind, mat */ extern void /* mapping, error_ind, mat */
TelEvalViewMappingMatrix( tel_view_mapping, Tint*, Tmatrix3 ); TelEvalViewMappingMatrix (const Handle(OpenGl_Display)& theGlDisplay, tel_view_mapping theMapping, Tint* theError, Tmatrix3 theMat);
#endif #endif