src/OpenGl/OpenGl_AspectFace.cxx

   1 // Created on: 2011-07-13
   2 // Created by: Sergey ZERCHANINOV
   3 // Copyright (c) 2011-2014 OPEN CASCADE SAS
   4 //
   5 // This file is part of Open CASCADE Technology software library.
   6 //
   7 // This library is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU Lesser General Public License version 2.1 as published
   9 // by the Free Software Foundation, with special exception defined in the file
  10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  11 // distribution for complete text of the license and disclaimer of any warranty.
  12 //
  13 // Alternatively, this file may be used under the terms of Open CASCADE
  14 // commercial license or contractual agreement.
  15
  16 #include <Aspect_PolygonOffsetMode.hxx>
  17 #include <NCollection_Vec3.hxx>
  18
  19 #include <OpenGl_AspectFace.hxx>
  20 #include <OpenGl_Context.hxx>
  21 #include <OpenGl_ShaderManager.hxx>
  22 #include <OpenGl_ShaderProgram.hxx>
  23 #include <OpenGl_Texture.hxx>
  24 #include <OpenGl_Workspace.hxx>
  25
  26 #include <Graphic3d_ShaderProgram.hxx>
  27 #include <Graphic3d_TextureMap.hxx>
  28 #include <Graphic3d_TextureParams.hxx>
  29 #include <Graphic3d_TypeOfReflection.hxx>
  30 #include <Graphic3d_MaterialAspect.hxx>
  31
  32 #include <Image_PixMap.hxx>
  33
  34 namespace
  35 {
  36   static OPENGL_SURF_PROP THE_DEFAULT_MATERIAL =
  37   {
  38     0.2F,  0.8F, 0.1F, 0.0F, // amb, diff, spec, emsv
  39     1.0F, 10.0F, 1.0F, 0.0F, // trans, shine, index, env_reflexion
  40     0, // isphysic
  41     (OPENGL_AMBIENT_MASK | OPENGL_DIFFUSE_MASK | OPENGL_SPECULAR_MASK), // color_mask
  42     {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // ambient color
  43     {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // diffuse color
  44     {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // specular color
  45     {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // emissive color
  46     {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // material color
  47     Graphic3d_BSDF()
  48   };
  49
  50   static const TCollection_AsciiString THE_EMPTY_KEY;
  51 }
  52
  53 // =======================================================================
  54 // function : convertMaterial
  55 // purpose  :
  56 // =======================================================================
  57 void OpenGl_AspectFace::convertMaterial (const CALL_DEF_MATERIAL& theMat,
  58                                          OPENGL_SURF_PROP&        theSurf)
  59 {
  60   theSurf.amb  = theMat.IsAmbient  ? theMat.Ambient  : 0.0f;
  61   theSurf.diff = theMat.IsDiffuse  ? theMat.Diffuse  : 0.0f;
  62   theSurf.spec = theMat.IsSpecular ? theMat.Specular : 0.0f;
  63   theSurf.emsv = theMat.IsEmission ? theMat.Emission : 0.0f;
  64
  65   theSurf.isphysic = theMat.IsPhysic ? 1 : 0; // type of material
  66
  67   // color of material
  68   theSurf.color_mask = 0;
  69   if (theMat.IsAmbient)
  70   {
  71     theSurf.color_mask |= OPENGL_AMBIENT_MASK;
  72   }
  73   if (theMat.IsDiffuse)
  74   {
  75     theSurf.color_mask |= OPENGL_DIFFUSE_MASK;
  76   }
  77   if (theMat.IsSpecular)
  78   {
  79     theSurf.color_mask |= OPENGL_SPECULAR_MASK;
  80   }
  81   if (theMat.IsEmission)
  82   {
  83     theSurf.color_mask |= OPENGL_EMISSIVE_MASK;
  84   }
  85
  86   // ambient color
  87   theSurf.ambcol.rgb[0] = theMat.ColorAmb.r;
  88   theSurf.ambcol.rgb[1] = theMat.ColorAmb.g;
  89   theSurf.ambcol.rgb[2] = theMat.ColorAmb.b;
  90   theSurf.ambcol.rgb[3] = 1.0f;
  91
  92   // diffuse color
  93   theSurf.difcol.rgb[0] = theMat.ColorDif.r;
  94   theSurf.difcol.rgb[1] = theMat.ColorDif.g;
  95   theSurf.difcol.rgb[2] = theMat.ColorDif.b;
  96   theSurf.difcol.rgb[3] = 1.0f;
  97
  98   // specular color
  99   theSurf.speccol.rgb[0] = theMat.ColorSpec.r;
 100   theSurf.speccol.rgb[1] = theMat.ColorSpec.g;
 101   theSurf.speccol.rgb[2] = theMat.ColorSpec.b;
 102   theSurf.speccol.rgb[3] = 1.0f;
 103
 104   // emission color
 105   theSurf.emscol.rgb[0] = theMat.ColorEms.r;
 106   theSurf.emscol.rgb[1] = theMat.ColorEms.g;
 107   theSurf.emscol.rgb[2] = theMat.ColorEms.b;
 108   theSurf.emscol.rgb[3] = 1.0f;
 109
 110   theSurf.shine = 128.0f * float(theMat.Shininess);
 111   theSurf.env_reflexion = theMat.EnvReflexion;
 112
 113   // trans = 0. => opaque
 114   // trans = 1. => transparent
 115   // in OpenGl it is opposite.
 116   theSurf.trans = 1.0f - theMat.Transparency;
 117   theSurf.index = theMat.RefractionIndex;
 118
 119   // material BSDF (for physically-based rendering)
 120   theSurf.BSDF = theMat.BSDF;
 121 }
 122
 123 // =======================================================================
 124 // function : OpenGl_AspectFace
 125 // purpose  :
 126 // =======================================================================
 127 OpenGl_AspectFace::OpenGl_AspectFace()
 128 : myInteriorStyle (Aspect_IS_SOLID),
 129   myEdge (TOff),
 130   myHatch (TEL_HS_SOLID),
 131   myDistinguishingMode (TOff),
 132   myCullingMode (TelCullNone),
 133   myIntFront (THE_DEFAULT_MATERIAL),
 134   myIntBack (THE_DEFAULT_MATERIAL),
 135   myPolygonOffset (THE_DEFAULT_POFFSET),
 136   myDoTextureMap (false)
 137 {}
 138
 139 // =======================================================================
 140 // function : SetAspect
 141 // purpose  :
 142 // =======================================================================
 143 void OpenGl_AspectFace::SetAspect (const CALL_DEF_CONTEXTFILLAREA& theAspect)
 144 {
 145   myInteriorStyle = (Aspect_InteriorStyle )theAspect.Style;
 146   myEdge = theAspect.Edge ? TOn : TOff;
 147
 148   //TelInteriorStyleIndex
 149   switch (theAspect.Hatch)
 150   {
 151     case 0: /* Aspect_HS_HORIZONTAL */
 152       myHatch = TEL_HS_HORIZONTAL;
 153       break;
 154     case 1: /* Aspect_HS_HORIZONTAL_WIDE */
 155       myHatch = TEL_HS_HORIZONTAL_SPARSE;
 156       break;
 157     case 2: /* Aspect_HS_VERTICAL */
 158       myHatch = TEL_HS_VERTICAL;
 159       break;
 160     case 3: /* Aspect_HS_VERTICAL_WIDE */
 161       myHatch = TEL_HS_VERTICAL_SPARSE;
 162       break;
 163     case 4: /* Aspect_HS_DIAGONAL_45 */
 164       myHatch = TEL_HS_DIAG_45;
 165       break;
 166     case 5: /* Aspect_HS_DIAGONAL_45_WIDE */
 167       myHatch = TEL_HS_DIAG_45_SPARSE;
 168       break;
 169     case 6: /* Aspect_HS_DIAGONAL_135 */
 170       myHatch = TEL_HS_DIAG_135;
 171       break;
 172     case 7: /* Aspect_HS_DIAGONAL_135_WIDE */
 173       myHatch = TEL_HS_DIAG_135_SPARSE;
 174       break;
 175     case 8: /* Aspect_HS_GRID */
 176       myHatch = TEL_HS_GRID;
 177       break;
 178     case 9: /* Aspect_HS_GRID_WIDE */
 179       myHatch = TEL_HS_GRID_SPARSE;
 180       break;
 181     case 10: /* Aspect_HS_GRID_DIAGONAL */
 182       myHatch = TEL_HS_CROSS;
 183       break;
 184     case 11: /* Aspect_HS_GRID_DIAGONAL_WIDE */
 185       myHatch = TEL_HS_CROSS_SPARSE;
 186       break;
 187     default:
 188       myHatch = 0;
 189       break;
 190   }
 191
 192   myDistinguishingMode = theAspect.Distinguish ? TOn : TOff;
 193   myCullingMode = theAspect.BackFace ? TelCullBack : TelCullNone;
 194
 195   convertMaterial (theAspect.Front, myIntFront);
 196   convertMaterial (theAspect.Back,  myIntBack);
 197
 198   //TelInteriorColour
 199   myIntFront.matcol.rgb[0] = (float )theAspect.IntColor.r;
 200   myIntFront.matcol.rgb[1] = (float )theAspect.IntColor.g;
 201   myIntFront.matcol.rgb[2] = (float )theAspect.IntColor.b;
 202   myIntFront.matcol.rgb[3] = 1.0f;
 203
 204   //TelBackInteriorColour
 205   myIntBack.matcol.rgb[0] = (float )theAspect.BackIntColor.r;
 206   myIntBack.matcol.rgb[1] = (float )theAspect.BackIntColor.g;
 207   myIntBack.matcol.rgb[2] = (float )theAspect.BackIntColor.b;
 208   myIntBack.matcol.rgb[3] = 1.0f;
 209
 210   //TelPolygonOffset
 211   myPolygonOffset.mode   = (Aspect_PolygonOffsetMode )theAspect.PolygonOffsetMode;
 212   myPolygonOffset.factor = theAspect.PolygonOffsetFactor;
 213   myPolygonOffset.units  = theAspect.PolygonOffsetUnits;
 214
 215   CALL_DEF_CONTEXTLINE anEdgeAspect;
 216   anEdgeAspect.Color.r  = (float )theAspect.EdgeColor.r;
 217   anEdgeAspect.Color.g  = (float )theAspect.EdgeColor.g;
 218   anEdgeAspect.Color.b  = (float )theAspect.EdgeColor.b;
 219   anEdgeAspect.LineType = (Aspect_TypeOfLine )theAspect.LineType;
 220   anEdgeAspect.Width    = (float )theAspect.Width;
 221   myAspectEdge.SetAspect (anEdgeAspect);
 222
 223   myDoTextureMap = (theAspect.Texture.doTextureMap != 0);
 224
 225   // update texture binding
 226   myTexture = theAspect.Texture.TextureMap;
 227
 228   const TCollection_AsciiString& aTextureKey = myTexture.IsNull() ? THE_EMPTY_KEY : myTexture->GetId();
 229   if (aTextureKey.IsEmpty() || myResources.TextureId != aTextureKey)
 230   {
 231     myResources.ResetTextureReadiness();
 232   }
 233
 234   // update shader program binding
 235   myShaderProgram = theAspect.ShaderProgram;
 236
 237   const TCollection_AsciiString& aShaderKey = myShaderProgram.IsNull() ? THE_EMPTY_KEY : myShaderProgram->GetId();
 238   if (aShaderKey.IsEmpty() || myResources.ShaderProgramId != aShaderKey)
 239   {
 240     myResources.ResetShaderReadiness();
 241   }
 242 }
 243
 244 // =======================================================================
 245 // function : SetAspect
 246 // purpose  :
 247 // =======================================================================
 248 void OpenGl_AspectFace::SetAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect)
 249 {
 250   CALL_DEF_CONTEXTFILLAREA aFaceContext;
 251   Standard_Real           aWidth;
 252   Quantity_Color          aBackIntColor;
 253   Quantity_Color          aEdgeColor;
 254   Aspect_TypeOfLine       aLType;
 255   Quantity_Color          aIntColor;
 256   Aspect_InteriorStyle    aIntStyle;
 257   NCollection_Vec3<Standard_Real> aColor;
 258
 259   theAspect->Values (aIntStyle, aIntColor, aBackIntColor, aEdgeColor, aLType, aWidth);
 260   aIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
 261
 262   aFaceContext.Style      = int (aIntStyle);
 263   aFaceContext.IntColor.r = float (aColor.r());
 264   aFaceContext.IntColor.g = float (aColor.g());
 265   aFaceContext.IntColor.b = float (aColor.b());
 266
 267   if (theAspect->Distinguish())
 268   {
 269     aBackIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
 270   }
 271
 272   aFaceContext.BackIntColor.r = float (aColor.r());
 273   aFaceContext.BackIntColor.g = float (aColor.g());
 274   aFaceContext.BackIntColor.b = float (aColor.b());
 275
 276   aFaceContext.Edge = theAspect->Edge () ? 1:0;
 277   aEdgeColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
 278
 279   aFaceContext.EdgeColor.r = float (aColor.r());
 280   aFaceContext.EdgeColor.g = float (aColor.g());
 281   aFaceContext.EdgeColor.b = float (aColor.b());
 282   aFaceContext.LineType    = int (aLType);
 283   aFaceContext.Width       = float (aWidth);
 284   aFaceContext.Hatch       = int (theAspect->HatchStyle ());
 285
 286   aFaceContext.Distinguish = theAspect->Distinguish () ? 1:0;
 287   aFaceContext.BackFace    = theAspect->BackFace ()    ? 1:0;
 288
 289   aFaceContext.Back.Shininess = float ((theAspect->BackMaterial ()).Shininess ());
 290   aFaceContext.Back.Ambient   = float ((theAspect->BackMaterial ()).Ambient ());
 291   aFaceContext.Back.Diffuse   = float ((theAspect->BackMaterial ()).Diffuse ());
 292   aFaceContext.Back.Specular  = float ((theAspect->BackMaterial ()).Specular ());
 293   aFaceContext.Back.Transparency  = float ((theAspect->BackMaterial ()).Transparency ());
 294   aFaceContext.Back.Emission      = float ((theAspect->BackMaterial ()).Emissive ());
 295
 296   // Reflection mode
 297   aFaceContext.Back.IsAmbient = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
 298   aFaceContext.Back.IsDiffuse = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
 299   aFaceContext.Back.IsSpecular = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
 300   aFaceContext.Back.IsEmission = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
 301
 302   // Material type
 303   const Graphic3d_MaterialAspect aBackMat = theAspect->BackMaterial ();
 304   Standard_Boolean isBackPhys = aBackMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
 305   aFaceContext.Back.IsPhysic = (isBackPhys ? 1 : 0 );
 306
 307   // Specular Color
 308   aFaceContext.Back.ColorSpec.r = float (((theAspect->BackMaterial ()).SpecularColor ()).Red ());
 309   aFaceContext.Back.ColorSpec.g = float (((theAspect->BackMaterial ()).SpecularColor ()).Green ());
 310   aFaceContext.Back.ColorSpec.b = float (((theAspect->BackMaterial ()).SpecularColor ()).Blue ());
 311
 312   // Ambient color
 313   aFaceContext.Back.ColorAmb.r = float (((theAspect->BackMaterial ()).AmbientColor ()).Red ());
 314   aFaceContext.Back.ColorAmb.g = float (((theAspect->BackMaterial ()).AmbientColor ()).Green ());
 315   aFaceContext.Back.ColorAmb.b = float (((theAspect->BackMaterial ()).AmbientColor ()).Blue ());
 316
 317   // Diffuse color
 318   aFaceContext.Back.ColorDif.r = float (((theAspect->BackMaterial ()).DiffuseColor ()).Red ());
 319   aFaceContext.Back.ColorDif.g = float (((theAspect->BackMaterial ()).DiffuseColor ()).Green ());
 320   aFaceContext.Back.ColorDif.b = float (((theAspect->BackMaterial ()).DiffuseColor ()).Blue ());
 321
 322   // Emissive color
 323   aFaceContext.Back.ColorEms.r = float (((theAspect->BackMaterial ()).EmissiveColor ()).Red ());
 324   aFaceContext.Back.ColorEms.g = float (((theAspect->BackMaterial ()).EmissiveColor ()).Green ());
 325   aFaceContext.Back.ColorEms.b = float (((theAspect->BackMaterial ()).EmissiveColor ()).Blue ());
 326
 327   aFaceContext.Back.EnvReflexion = float ((theAspect->BackMaterial ()).EnvReflexion());
 328
 329   aFaceContext.Front.Shininess    = float ((theAspect->FrontMaterial ()).Shininess ());
 330   aFaceContext.Front.Ambient      = float ((theAspect->FrontMaterial ()).Ambient ());
 331   aFaceContext.Front.Diffuse      = float ((theAspect->FrontMaterial ()).Diffuse ());
 332   aFaceContext.Front.Specular     = float ((theAspect->FrontMaterial ()).Specular ());
 333   aFaceContext.Front.Transparency = float ((theAspect->FrontMaterial ()).Transparency ());
 334   aFaceContext.Front.Emission     = float ((theAspect->FrontMaterial ()).Emissive ());
 335
 336   // Reflection mode
 337   aFaceContext.Front.IsAmbient    = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0);
 338   aFaceContext.Front.IsDiffuse    = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0);
 339   aFaceContext.Front.IsSpecular   = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0);
 340   aFaceContext.Front.IsEmission   = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0);
 341
 342   // Material type
 343   const Graphic3d_MaterialAspect aFrontMat = theAspect->FrontMaterial ();
 344   Standard_Boolean isFrontPhys = aFrontMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
 345   aFaceContext.Front.IsPhysic = (isFrontPhys ? 1 : 0 );
 346
 347   // Specular Color
 348   aFaceContext.Front.ColorSpec.r = float (((theAspect->FrontMaterial ()).SpecularColor ()).Red ());
 349   aFaceContext.Front.ColorSpec.g = float (((theAspect->FrontMaterial ()).SpecularColor ()).Green ());
 350   aFaceContext.Front.ColorSpec.b = float (((theAspect->FrontMaterial ()).SpecularColor ()).Blue ());
 351
 352   // Ambient color
 353   aFaceContext.Front.ColorAmb.r = float (((theAspect->FrontMaterial ()).AmbientColor ()).Red ());
 354   aFaceContext.Front.ColorAmb.g = float (((theAspect->FrontMaterial ()).AmbientColor ()).Green ());
 355   aFaceContext.Front.ColorAmb.b = float (((theAspect->FrontMaterial ()).AmbientColor ()).Blue ());
 356
 357   // Diffuse color
 358   aFaceContext.Front.ColorDif.r = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Red ());
 359   aFaceContext.Front.ColorDif.g = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Green ());
 360   aFaceContext.Front.ColorDif.b = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Blue ());
 361
 362   // Emissive color
 363   aFaceContext.Front.ColorEms.r = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Red ());
 364   aFaceContext.Front.ColorEms.g = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Green ());
 365   aFaceContext.Front.ColorEms.b = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Blue ());
 366
 367   aFaceContext.Front.EnvReflexion = float ((theAspect->FrontMaterial ()).EnvReflexion());
 368   aFaceContext.IsDef = 1;
 369   aFaceContext.Texture.TextureMap   = theAspect->TextureMap();
 370   aFaceContext.Texture.doTextureMap = theAspect->TextureMapState() ? 1 : 0;
 371
 372   Standard_Integer aPolyMode;
 373   Standard_ShortReal aPolyFactor, aPolyUnits;
 374   theAspect->PolygonOffsets (aPolyMode, aPolyFactor, aPolyUnits);
 375   aFaceContext.PolygonOffsetMode   = aPolyMode;
 376   aFaceContext.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor;
 377   aFaceContext.PolygonOffsetUnits  = (Standard_ShortReal)aPolyUnits;
 378
 379   aFaceContext.ShaderProgram = theAspect->ShaderProgram();
 380
 381   SetAspect (aFaceContext);
 382 }
 383
 384 // =======================================================================
 385 // function : Render
 386 // purpose  :
 387 // =======================================================================
 388 void OpenGl_AspectFace::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
 389 {
 390   theWorkspace->SetAspectFace (this);
 391 }
 392
 393 // =======================================================================
 394 // function : Release
 395 // purpose  :
 396 // =======================================================================
 397 void OpenGl_AspectFace::Release (OpenGl_Context* theContext)
 398 {
 399   if (!myResources.Texture.IsNull())
 400   {
 401     if (theContext)
 402     {
 403       if (myResources.TextureId.IsEmpty())
 404       {
 405         theContext->DelayedRelease (myResources.Texture);
 406       }
 407       else
 408       {
 409         myResources.Texture.Nullify(); // we need nullify all handles before ReleaseResource() call
 410         theContext->ReleaseResource (myResources.TextureId, Standard_True);
 411       }
 412     }
 413     myResources.Texture.Nullify();
 414   }
 415   myResources.TextureId.Clear();
 416   myResources.ResetTextureReadiness();
 417
 418   if (!myResources.ShaderProgram.IsNull()
 419    && theContext)
 420   {
 421     theContext->ShaderManager()->Unregister (myResources.ShaderProgramId,
 422                                              myResources.ShaderProgram);
 423   }
 424   myResources.ShaderProgramId.Clear();
 425   myResources.ResetShaderReadiness();
 426 }
 427
 428 // =======================================================================
 429 // function : BuildTexture
 430 // purpose  :
 431 // =======================================================================
 432 void OpenGl_AspectFace::Resources::BuildTexture (const Handle(OpenGl_Context)&       theCtx,
 433                                                  const Handle(Graphic3d_TextureMap)& theTexture)
 434 {
 435   // release old texture resource
 436   if (!Texture.IsNull())
 437   {
 438     if (TextureId.IsEmpty())
 439     {
 440       theCtx->DelayedRelease (Texture);
 441       Texture.Nullify();
 442     }
 443     else
 444     {
 445       Texture.Nullify(); // we need nullify all handles before ReleaseResource() call
 446       theCtx->ReleaseResource (TextureId, Standard_True);
 447     }
 448   }
 449
 450   TextureId = theTexture.IsNull() ? THE_EMPTY_KEY : theTexture->GetId();
 451
 452   if (!theTexture.IsNull())
 453   {
 454     if (TextureId.IsEmpty() || !theCtx->GetResource<Handle(OpenGl_Texture)> (TextureId, Texture))
 455     {
 456       Texture = new OpenGl_Texture (theTexture->GetParams());
 457       Handle(Image_PixMap) anImage = theTexture->GetImage();
 458       if (!anImage.IsNull())
 459       {
 460         Texture->Init (theCtx, *anImage.operator->(), theTexture->Type());
 461       }
 462       if (!TextureId.IsEmpty())
 463       {
 464         theCtx->ShareResource (TextureId, Texture);
 465       }
 466     }
 467   }
 468 }
 469
 470 // =======================================================================
 471 // function : BuildShader
 472 // purpose  :
 473 // =======================================================================
 474 void OpenGl_AspectFace::Resources::BuildShader (const Handle(OpenGl_Context)&          theCtx,
 475                                                 const Handle(Graphic3d_ShaderProgram)& theShader)
 476 {
 477   if (theCtx->core20fwd == NULL)
 478   {
 479     return;
 480   }
 481
 482   // release old shader program resources
 483   if (!ShaderProgram.IsNull())
 484   {
 485     theCtx->ShaderManager()->Unregister (ShaderProgramId, ShaderProgram);
 486     ShaderProgramId.Clear();
 487     ShaderProgram.Nullify();
 488   }
 489   if (theShader.IsNull())
 490   {
 491     return;
 492   }
 493
 494   theCtx->ShaderManager()->Create (theShader, ShaderProgramId, ShaderProgram);
 495 }