src/OpenGl/OpenGl_AspectFace.cxx

   1 // Created on: 2011-07-13
   2 // Created by: Sergey ZERCHANINOV
   3 // Copyright (c) 2011-2012 OPEN CASCADE SAS
   4 //
   5 // The content of this file is subject to the Open CASCADE Technology Public
   6 // License Version 6.5 (the "License"). You may not use the content of this file
   7 // except in compliance with the License. Please obtain a copy of the License
   8 // at http://www.opencascade.org and read it completely before using this file.
   9 //
  10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  12 //
  13 // The Original Code and all software distributed under the License is
  14 // distributed on an "AS IS" basis, without warranty of any kind, and the
  15 // Initial Developer hereby disclaims all such warranties, including without
  16 // limitation, any warranties of merchantability, fitness for a particular
  17 // purpose or non-infringement. Please see the License for the specific terms
  18 // and conditions governing the rights and limitations under the License.
  19
  20 #include <OpenGl_AspectFace.hxx>
  21 #include <OpenGl_Texture.hxx>
  22 #include <OpenGl_Workspace.hxx>
  23 #include <OpenGl_Context.hxx>
  24
  25 #include <Aspect_PolygonOffsetMode.hxx>
  26 #include <Graphic3d_CGroup.hxx>
  27 #include <Graphic3d_TextureMap.hxx>
  28 #include <Graphic3d_TypeOfReflection.hxx>
  29 #include <Graphic3d_MaterialAspect.hxx>
  30
  31 #include <NCollection_Vec3.hxx>
  32
  33 namespace
  34 {
  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, 0.0F,       // trans, shine, 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   };
  48
  49   static TEL_POFFSET_PARAM THE_DEFAULT_POFFSET = { Aspect_POM_Fill, 1.0F, 0.0F };
  50   static const TCollection_AsciiString THE_EMPTY_KEY;
  51
  52 };
  53
  54 // =======================================================================
  55 // function : convertMaterial
  56 // purpose  :
  57 // =======================================================================
  58 void OpenGl_AspectFace::convertMaterial (const CALL_DEF_MATERIAL& theMat,
  59                                          OPENGL_SURF_PROP&        theSurf)
  60 {
  61   theSurf.amb  = theMat.IsAmbient  ? theMat.Ambient  : 0.0f;
  62   theSurf.diff = theMat.IsDiffuse  ? theMat.Diffuse  : 0.0f;
  63   theSurf.spec = theMat.IsSpecular ? theMat.Specular : 0.0f;
  64   theSurf.emsv = theMat.IsEmission ? theMat.Emission : 0.0f;
  65
  66   theSurf.isphysic = theMat.IsPhysic ? 1 : 0; // type of material
  67
  68   // color of material
  69   theSurf.color_mask = 0;
  70   if (theMat.IsAmbient)
  71   {
  72     theSurf.color_mask |= OPENGL_AMBIENT_MASK;
  73   }
  74   if (theMat.IsDiffuse)
  75   {
  76     theSurf.color_mask |= OPENGL_DIFFUSE_MASK;
  77   }
  78   if (theMat.IsSpecular)
  79   {
  80     theSurf.color_mask |= OPENGL_SPECULAR_MASK;
  81   }
  82   if (theMat.IsEmission)
  83   {
  84     theSurf.color_mask |= OPENGL_EMISSIVE_MASK;
  85   }
  86
  87   // ambient color
  88   theSurf.ambcol.rgb[0] = theMat.ColorAmb.r;
  89   theSurf.ambcol.rgb[1] = theMat.ColorAmb.g;
  90   theSurf.ambcol.rgb[2] = theMat.ColorAmb.b;
  91   theSurf.ambcol.rgb[3] = 1.0f;
  92
  93   // diffuse color
  94   theSurf.difcol.rgb[0] = theMat.ColorDif.r;
  95   theSurf.difcol.rgb[1] = theMat.ColorDif.g;
  96   theSurf.difcol.rgb[2] = theMat.ColorDif.b;
  97   theSurf.difcol.rgb[3] = 1.0f;
  98
  99   // specular color
 100   theSurf.speccol.rgb[0] = theMat.ColorSpec.r;
 101   theSurf.speccol.rgb[1] = theMat.ColorSpec.g;
 102   theSurf.speccol.rgb[2] = theMat.ColorSpec.b;
 103   theSurf.speccol.rgb[3] = 1.0f;
 104
 105   // emission color
 106   theSurf.emscol.rgb[0] = theMat.ColorEms.r;
 107   theSurf.emscol.rgb[1] = theMat.ColorEms.g;
 108   theSurf.emscol.rgb[2] = theMat.ColorEms.b;
 109   theSurf.emscol.rgb[3] = 1.0f;
 110
 111   theSurf.shine = 128.0f * float(theMat.Shininess);
 112   theSurf.env_reflexion = theMat.EnvReflexion;
 113
 114   // trans = 0. => opaque
 115   // trans = 1. => transparent
 116   // in OpenGl it is opposite.
 117   theSurf.trans = 1.0f - theMat.Transparency;
 118 }
 119
 120 // =======================================================================
 121 // function : OpenGl_AspectFace
 122 // purpose  :
 123 // =======================================================================
 124 OpenGl_AspectFace::OpenGl_AspectFace()
 125 : myInteriorStyle (Aspect_IS_SOLID),
 126   myEdge (TOff),
 127   myHatch (TEL_HS_SOLID),
 128   myDistinguishingMode (TOff),
 129   myCullingMode (TelCullNone),
 130   myIntFront (THE_DEFAULT_MATERIAL),
 131   myIntBack (THE_DEFAULT_MATERIAL),
 132   myPolygonOffset (THE_DEFAULT_POFFSET),
 133   myDoTextureMap (false),
 134   myTextureMap(),
 135   myIsTextureInit (Standard_False),
 136   myTextureRes(),
 137   myTextureId()
 138 {}
 139
 140 // =======================================================================
 141 // function : SetAspect
 142 // purpose  :
 143 // =======================================================================
 144 void OpenGl_AspectFace::SetAspect (const CALL_DEF_CONTEXTFILLAREA& theAspect)
 145 {
 146   myInteriorStyle = (Aspect_InteriorStyle )theAspect.Style;
 147   myEdge = theAspect.Edge ? TOn : TOff;
 148
 149   //TelInteriorStyleIndex
 150   switch (theAspect.Hatch)
 151   {
 152     case 0: /* Aspect_HS_HORIZONTAL */
 153       myHatch = TEL_HS_HORIZONTAL;
 154       break;
 155     case 1: /* Aspect_HS_HORIZONTAL_WIDE */
 156       myHatch = TEL_HS_HORIZONTAL_SPARSE;
 157       break;
 158     case 2: /* Aspect_HS_VERTICAL */
 159       myHatch = TEL_HS_VERTICAL;
 160       break;
 161     case 3: /* Aspect_HS_VERTICAL_WIDE */
 162       myHatch = TEL_HS_VERTICAL_SPARSE;
 163       break;
 164     case 4: /* Aspect_HS_DIAGONAL_45 */
 165       myHatch = TEL_HS_DIAG_45;
 166       break;
 167     case 5: /* Aspect_HS_DIAGONAL_45_WIDE */
 168       myHatch = TEL_HS_DIAG_45_SPARSE;
 169       break;
 170     case 6: /* Aspect_HS_DIAGONAL_135 */
 171       myHatch = TEL_HS_DIAG_135;
 172       break;
 173     case 7: /* Aspect_HS_DIAGONAL_135_WIDE */
 174       myHatch = TEL_HS_DIAG_135_SPARSE;
 175       break;
 176     case 8: /* Aspect_HS_GRID */
 177       myHatch = TEL_HS_GRID;
 178       break;
 179     case 9: /* Aspect_HS_GRID_WIDE */
 180       myHatch = TEL_HS_GRID_SPARSE;
 181       break;
 182     case 10: /* Aspect_HS_GRID_DIAGONAL */
 183       myHatch = TEL_HS_CROSS;
 184       break;
 185     case 11: /* Aspect_HS_GRID_DIAGONAL_WIDE */
 186       myHatch = TEL_HS_CROSS_SPARSE;
 187       break;
 188     default:
 189       myHatch = 0;
 190       break;
 191   }
 192
 193   myDistinguishingMode = theAspect.Distinguish ? TOn : TOff;
 194   myCullingMode = theAspect.BackFace ? TelCullBack : TelCullNone;
 195
 196   convertMaterial (theAspect.Front, myIntFront);
 197   convertMaterial (theAspect.Back,  myIntBack);
 198
 199   //TelInteriorColour
 200   myIntFront.matcol.rgb[0] = (float )theAspect.IntColor.r;
 201   myIntFront.matcol.rgb[1] = (float )theAspect.IntColor.g;
 202   myIntFront.matcol.rgb[2] = (float )theAspect.IntColor.b;
 203   myIntFront.matcol.rgb[3] = 1.0f;
 204
 205   //TelBackInteriorColour
 206   myIntBack.matcol.rgb[0] = (float )theAspect.BackIntColor.r;
 207   myIntBack.matcol.rgb[1] = (float )theAspect.BackIntColor.g;
 208   myIntBack.matcol.rgb[2] = (float )theAspect.BackIntColor.b;
 209   myIntBack.matcol.rgb[3] = 1.0f;
 210
 211   myDoTextureMap  = (theAspect.Texture.doTextureMap != 0);
 212   myTextureMap    = theAspect.Texture.TextureMap;
 213
 214   const TCollection_AsciiString& aNewKey = myTextureMap.IsNull() ? THE_EMPTY_KEY : myTextureMap->GetId();
 215   myIsTextureInit = (!aNewKey.IsEmpty() && myTextureId == aNewKey);
 216
 217   //TelPolygonOffset
 218   myPolygonOffset.mode   = (Aspect_PolygonOffsetMode )theAspect.PolygonOffsetMode;
 219   myPolygonOffset.factor = theAspect.PolygonOffsetFactor;
 220   myPolygonOffset.units  = theAspect.PolygonOffsetUnits;
 221
 222   CALL_DEF_CONTEXTLINE anEdgeAspect;
 223   anEdgeAspect.Color.r  = (float )theAspect.EdgeColor.r;
 224   anEdgeAspect.Color.g  = (float )theAspect.EdgeColor.g;
 225   anEdgeAspect.Color.b  = (float )theAspect.EdgeColor.b;
 226   anEdgeAspect.LineType = (Aspect_TypeOfLine )theAspect.LineType;
 227   anEdgeAspect.Width    = (float )theAspect.Width;
 228   myAspectEdge.SetAspect (anEdgeAspect);
 229 }
 230
 231 // =======================================================================
 232 // function : SetAspect
 233 // purpose  :
 234 // =======================================================================
 235 void OpenGl_AspectFace::SetAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect)
 236 {
 237   CALL_DEF_CONTEXTFILLAREA aFaceContext;
 238   Standard_Real           aWidth;
 239   Quantity_Color          aBackIntColor;
 240   Quantity_Color          aEdgeColor;
 241   Aspect_TypeOfLine       aLType;
 242   Quantity_Color          aIntColor;
 243   Aspect_InteriorStyle    aIntStyle;
 244   NCollection_Vec3<Standard_Real> aColor;
 245
 246   theAspect->Values (aIntStyle, aIntColor, aBackIntColor, aEdgeColor, aLType, aWidth);
 247   aIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
 248
 249   aFaceContext.Style      = int (aIntStyle);
 250   aFaceContext.IntColor.r = float (aColor.r());
 251   aFaceContext.IntColor.g = float (aColor.g());
 252   aFaceContext.IntColor.b = float (aColor.b());
 253
 254   if (theAspect->Distinguish())
 255   {
 256     aBackIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
 257   }
 258
 259   aFaceContext.BackIntColor.r = float (aColor.r());
 260   aFaceContext.BackIntColor.g = float (aColor.g());
 261   aFaceContext.BackIntColor.b = float (aColor.b());
 262
 263   aFaceContext.Edge = theAspect->Edge () ? 1:0;
 264   aEdgeColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
 265
 266   aFaceContext.EdgeColor.r = float (aColor.r());
 267   aFaceContext.EdgeColor.g = float (aColor.g());
 268   aFaceContext.EdgeColor.b = float (aColor.b());
 269   aFaceContext.LineType    = int (aLType);
 270   aFaceContext.Width       = float (aWidth);
 271   aFaceContext.Hatch       = int (theAspect->HatchStyle ());
 272
 273   aFaceContext.Distinguish = theAspect->Distinguish () ? 1:0;
 274   aFaceContext.BackFace    = theAspect->BackFace ()    ? 1:0;
 275
 276   aFaceContext.Back.Shininess = float ((theAspect->BackMaterial ()).Shininess ());
 277   aFaceContext.Back.Ambient   = float ((theAspect->BackMaterial ()).Ambient ());
 278   aFaceContext.Back.Diffuse   = float ((theAspect->BackMaterial ()).Diffuse ());
 279   aFaceContext.Back.Specular  = float ((theAspect->BackMaterial ()).Specular ());
 280   aFaceContext.Back.Transparency  = float ((theAspect->BackMaterial ()).Transparency ());
 281   aFaceContext.Back.Emission      = float ((theAspect->BackMaterial ()).Emissive ());
 282
 283   // Reflection mode
 284   aFaceContext.Back.IsAmbient = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
 285   aFaceContext.Back.IsDiffuse = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
 286   aFaceContext.Back.IsSpecular = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
 287   aFaceContext.Back.IsEmission = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
 288
 289   // Material type
 290   const Graphic3d_MaterialAspect aBackMat = theAspect->BackMaterial ();
 291   Standard_Boolean isBackPhys = aBackMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
 292   aFaceContext.Back.IsPhysic = (isBackPhys ? 1 : 0 );
 293
 294   // Specular Color
 295   aFaceContext.Back.ColorSpec.r = float (((theAspect->BackMaterial ()).SpecularColor ()).Red ());
 296   aFaceContext.Back.ColorSpec.g = float (((theAspect->BackMaterial ()).SpecularColor ()).Green ());
 297   aFaceContext.Back.ColorSpec.b = float (((theAspect->BackMaterial ()).SpecularColor ()).Blue ());
 298
 299   // Ambient color
 300   aFaceContext.Back.ColorAmb.r = float (((theAspect->BackMaterial ()).AmbientColor ()).Red ());
 301   aFaceContext.Back.ColorAmb.g = float (((theAspect->BackMaterial ()).AmbientColor ()).Green ());
 302   aFaceContext.Back.ColorAmb.b = float (((theAspect->BackMaterial ()).AmbientColor ()).Blue ());
 303
 304   // Diffuse color
 305   aFaceContext.Back.ColorDif.r = float (((theAspect->BackMaterial ()).DiffuseColor ()).Red ());
 306   aFaceContext.Back.ColorDif.g = float (((theAspect->BackMaterial ()).DiffuseColor ()).Green ());
 307   aFaceContext.Back.ColorDif.b = float (((theAspect->BackMaterial ()).DiffuseColor ()).Blue ());
 308
 309   // Emissive color
 310   aFaceContext.Back.ColorEms.r = float (((theAspect->BackMaterial ()).EmissiveColor ()).Red ());
 311   aFaceContext.Back.ColorEms.g = float (((theAspect->BackMaterial ()).EmissiveColor ()).Green ());
 312   aFaceContext.Back.ColorEms.b = float (((theAspect->BackMaterial ()).EmissiveColor ()).Blue ());
 313
 314   aFaceContext.Back.EnvReflexion = float ((theAspect->BackMaterial ()).EnvReflexion());
 315
 316   aFaceContext.Front.Shininess    = float ((theAspect->FrontMaterial ()).Shininess ());
 317   aFaceContext.Front.Ambient      = float ((theAspect->FrontMaterial ()).Ambient ());
 318   aFaceContext.Front.Diffuse      = float ((theAspect->FrontMaterial ()).Diffuse ());
 319   aFaceContext.Front.Specular     = float ((theAspect->FrontMaterial ()).Specular ());
 320   aFaceContext.Front.Transparency = float ((theAspect->FrontMaterial ()).Transparency ());
 321   aFaceContext.Front.Emission     = float ((theAspect->FrontMaterial ()).Emissive ());
 322
 323   // Reflection mode
 324   aFaceContext.Front.IsAmbient    = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0);
 325   aFaceContext.Front.IsDiffuse    = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0);
 326   aFaceContext.Front.IsSpecular   = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0);
 327   aFaceContext.Front.IsEmission   = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0);
 328
 329   // Material type
 330   const Graphic3d_MaterialAspect aFrontMat = theAspect->FrontMaterial ();
 331   Standard_Boolean isFrontPhys = aFrontMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
 332   aFaceContext.Front.IsPhysic = (isFrontPhys ? 1 : 0 );
 333
 334   // Specular Color
 335   aFaceContext.Front.ColorSpec.r = float (((theAspect->FrontMaterial ()).SpecularColor ()).Red ());
 336   aFaceContext.Front.ColorSpec.g = float (((theAspect->FrontMaterial ()).SpecularColor ()).Green ());
 337   aFaceContext.Front.ColorSpec.b = float (((theAspect->FrontMaterial ()).SpecularColor ()).Blue ());
 338
 339   // Ambient color
 340   aFaceContext.Front.ColorAmb.r = float (((theAspect->FrontMaterial ()).AmbientColor ()).Red ());
 341   aFaceContext.Front.ColorAmb.g = float (((theAspect->FrontMaterial ()).AmbientColor ()).Green ());
 342   aFaceContext.Front.ColorAmb.b = float (((theAspect->FrontMaterial ()).AmbientColor ()).Blue ());
 343
 344   // Diffuse color
 345   aFaceContext.Front.ColorDif.r = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Red ());
 346   aFaceContext.Front.ColorDif.g = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Green ());
 347   aFaceContext.Front.ColorDif.b = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Blue ());
 348
 349   // Emissive color
 350   aFaceContext.Front.ColorEms.r = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Red ());
 351   aFaceContext.Front.ColorEms.g = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Green ());
 352   aFaceContext.Front.ColorEms.b = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Blue ());
 353
 354   aFaceContext.Front.EnvReflexion = float ((theAspect->FrontMaterial ()).EnvReflexion());
 355   aFaceContext.IsDef = 1;
 356   aFaceContext.Texture.TextureMap   = theAspect->TextureMap();
 357   aFaceContext.Texture.doTextureMap = theAspect->TextureMapState() ? 1 : 0;
 358
 359   Standard_Integer aPolyMode;
 360   Standard_ShortReal aPolyFactor, aPolyUnits;
 361   theAspect->PolygonOffsets (aPolyMode, aPolyFactor, aPolyUnits);
 362   aFaceContext.PolygonOffsetMode   = aPolyMode;
 363   aFaceContext.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor;
 364   aFaceContext.PolygonOffsetUnits  = (Standard_ShortReal)aPolyUnits;
 365
 366   SetAspect (aFaceContext);
 367 }
 368
 369 // =======================================================================
 370 // function : Render
 371 // purpose  :
 372 // =======================================================================
 373 void OpenGl_AspectFace::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
 374 {
 375   theWorkspace->SetAspectFace (this);
 376 }
 377
 378 // =======================================================================
 379 // function : Release
 380 // purpose  :
 381 // =======================================================================
 382 void OpenGl_AspectFace::Release (const Handle(OpenGl_Context)& theContext)
 383 {
 384   if (!myTextureRes.IsNull())
 385   {
 386     if (!theContext.IsNull())
 387     {
 388       if (myTextureId.IsEmpty())
 389       {
 390         theContext->DelayedRelease (myTextureRes);
 391       }
 392       else
 393       {
 394         myTextureRes.Nullify(); // we need nullify all handles before ReleaseResource() call
 395         theContext->ReleaseResource (myTextureId);
 396       }
 397     }
 398     myTextureRes.Nullify();
 399   }
 400   myTextureId.Clear();
 401 }
 402
 403 // =======================================================================
 404 // function : buildTexure
 405 // purpose  :
 406 // =======================================================================
 407 void OpenGl_AspectFace::buildTexture (const Handle(OpenGl_Workspace)& theWorkspace) const
 408 {
 409   const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
 410
 411   const TCollection_AsciiString& aNewKey = myTextureMap.IsNull() ? THE_EMPTY_KEY : myTextureMap->GetId();
 412   if (aNewKey.IsEmpty() || myTextureId != aNewKey)
 413   {
 414     if (!myTextureRes.IsNull())
 415     {
 416       if (myTextureId.IsEmpty())
 417       {
 418         aContext->DelayedRelease (myTextureRes);
 419         myTextureRes.Nullify();
 420       }
 421       else
 422       {
 423         myTextureRes.Nullify(); // we need nullify all handles before ReleaseResource() call
 424         aContext->ReleaseResource (myTextureId);
 425       }
 426     }
 427     myTextureId = aNewKey;
 428
 429     if (!myTextureMap.IsNull())
 430     {
 431       if (aNewKey.IsEmpty() || !aContext->GetResource<Handle(OpenGl_Texture)> (aNewKey, myTextureRes))
 432       {
 433         myTextureRes = new OpenGl_Texture (myTextureMap->GetParams());
 434         Handle(Image_PixMap) anImage = myTextureMap->GetImage();
 435         if (!anImage.IsNull())
 436         {
 437           myTextureRes->Init (aContext, *anImage.operator->(), myTextureMap->Type());
 438         }
 439         if (!aNewKey.IsEmpty())
 440         {
 441           aContext->ShareResource (aNewKey, myTextureRes);
 442         }
 443       }
 444     }
 445   }
 446 }