[occt.git] / src / OpenGl / OpenGl_AspectFace.cxx

// Created on: 2011-07-13
// Created by: Sergey ZERCHANINOV
// Copyright (c) 2011-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.

#include <OpenGl_AspectFace.hxx>
#include <OpenGl_Texture.hxx>
#include <OpenGl_Workspace.hxx>
#include <OpenGl_Context.hxx>

#include <Aspect_PolygonOffsetMode.hxx>
#include <Graphic3d_CGroup.hxx>
#include <Graphic3d_TextureMap.hxx>
#include <Graphic3d_TypeOfReflection.hxx>
#include <Graphic3d_MaterialAspect.hxx>

#include <NCollection_Vec3.hxx>

namespace
{

  static OPENGL_SURF_PROP THE_DEFAULT_MATERIAL =
  {
    0.2F,  0.8F, 0.1F, 0.0F, // amb, diff, spec, emsv
    1.0F, 10.0F, 0.0F,       // trans, shine, env_reflexion
    0, // isphysic
    (OPENGL_AMBIENT_MASK | OPENGL_DIFFUSE_MASK | OPENGL_SPECULAR_MASK), // color_mask
    {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // ambient color
    {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // diffuse color
    {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // specular color
    {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // emissive color
    {{ 1.0F, 1.0F, 1.0F, 1.0F }}  // material color
  };

  static TEL_POFFSET_PARAM THE_DEFAULT_POFFSET = { Aspect_POM_Fill, 1.0F, 0.0F };

};

// =======================================================================
// function : convertMaterial
// purpose  :
// =======================================================================
void OpenGl_AspectFace::convertMaterial (const CALL_DEF_MATERIAL& theMat,
                                         OPENGL_SURF_PROP&        theSurf)
{
  theSurf.amb  = theMat.IsAmbient  ? theMat.Ambient  : 0.0f;
  theSurf.diff = theMat.IsDiffuse  ? theMat.Diffuse  : 0.0f;
  theSurf.spec = theMat.IsSpecular ? theMat.Specular : 0.0f;
  theSurf.emsv = theMat.IsEmission ? theMat.Emission : 0.0f;

  theSurf.isphysic = theMat.IsPhysic ? 1 : 0; // type of material

  // color of material
  theSurf.color_mask = 0;
  if (theMat.IsAmbient)
  {
    theSurf.color_mask |= OPENGL_AMBIENT_MASK;
  }
  if (theMat.IsDiffuse)
  {
    theSurf.color_mask |= OPENGL_DIFFUSE_MASK;
  }
  if (theMat.IsSpecular)
  {
    theSurf.color_mask |= OPENGL_SPECULAR_MASK;
  }
  if (theMat.IsEmission)
  {
    theSurf.color_mask |= OPENGL_EMISSIVE_MASK;
  }

  // ambient color
  theSurf.ambcol.rgb[0] = theMat.ColorAmb.r;
  theSurf.ambcol.rgb[1] = theMat.ColorAmb.g;
  theSurf.ambcol.rgb[2] = theMat.ColorAmb.b;
  theSurf.ambcol.rgb[3] = 1.0f;

  // diffuse color
  theSurf.difcol.rgb[0] = theMat.ColorDif.r;
  theSurf.difcol.rgb[1] = theMat.ColorDif.g;
  theSurf.difcol.rgb[2] = theMat.ColorDif.b;
  theSurf.difcol.rgb[3] = 1.0f;

  // specular color
  theSurf.speccol.rgb[0] = theMat.ColorSpec.r;
  theSurf.speccol.rgb[1] = theMat.ColorSpec.g;
  theSurf.speccol.rgb[2] = theMat.ColorSpec.b;
  theSurf.speccol.rgb[3] = 1.0f;

  // emission color
  theSurf.emscol.rgb[0] = theMat.ColorEms.r;
  theSurf.emscol.rgb[1] = theMat.ColorEms.g;
  theSurf.emscol.rgb[2] = theMat.ColorEms.b;
  theSurf.emscol.rgb[3] = 1.0f;

  theSurf.shine = 128.0f * float(theMat.Shininess);
  theSurf.env_reflexion = theMat.EnvReflexion;

  // trans = 0. => opaque
  // trans = 1. => transparent
  // in OpenGl it is opposite.
  theSurf.trans = 1.0f - theMat.Transparency;
}

// =======================================================================
// function : OpenGl_AspectFace
// purpose  :
// =======================================================================
OpenGl_AspectFace::OpenGl_AspectFace()
: InteriorStyle (Aspect_IS_SOLID),
  Edge (Aspect_IS_SOLID),
  Hatch (TOn),
  DistinguishingMode (TEL_HS_SOLID),
  CullingMode (TelCullNone),
  doTextureMap (0)
{
  IntFront      = THE_DEFAULT_MATERIAL;
  IntBack       = THE_DEFAULT_MATERIAL;
  PolygonOffset = THE_DEFAULT_POFFSET;
}

// =======================================================================
// function : Init
// purpose  :
// =======================================================================
void OpenGl_AspectFace::Init (const Handle(OpenGl_Context)&   theContext,
                              const CALL_DEF_CONTEXTFILLAREA& theAspect)
{
  InteriorStyle = (Aspect_InteriorStyle )theAspect.Style;
  Edge = theAspect.Edge ? TOn : TOff;

  //TelInteriorStyleIndex
  switch (theAspect.Hatch)
  {
    case 0: /* Aspect_HS_HORIZONTAL */
      Hatch = TEL_HS_HORIZONTAL;
      break;
    case 1: /* Aspect_HS_HORIZONTAL_WIDE */
      Hatch = TEL_HS_HORIZONTAL_SPARSE;
      break;
    case 2: /* Aspect_HS_VERTICAL */
      Hatch = TEL_HS_VERTICAL;
      break;
    case 3: /* Aspect_HS_VERTICAL_WIDE */
      Hatch = TEL_HS_VERTICAL_SPARSE;
      break;
    case 4: /* Aspect_HS_DIAGONAL_45 */
      Hatch = TEL_HS_DIAG_45;
      break;
    case 5: /* Aspect_HS_DIAGONAL_45_WIDE */
      Hatch = TEL_HS_DIAG_45_SPARSE;
      break;
    case 6: /* Aspect_HS_DIAGONAL_135 */
      Hatch = TEL_HS_DIAG_135;
      break;
    case 7: /* Aspect_HS_DIAGONAL_135_WIDE */
      Hatch = TEL_HS_DIAG_135_SPARSE;
      break;
    case 8: /* Aspect_HS_GRID */
      Hatch = TEL_HS_GRID;
      break;
    case 9: /* Aspect_HS_GRID_WIDE */
      Hatch = TEL_HS_GRID_SPARSE;
      break;
    case 10: /* Aspect_HS_GRID_DIAGONAL */
      Hatch = TEL_HS_CROSS;
      break;
    case 11: /* Aspect_HS_GRID_DIAGONAL_WIDE */
      Hatch = TEL_HS_CROSS_SPARSE;
      break;
    default:
      Hatch = 0;
      break;
  }

  DistinguishingMode = theAspect.Distinguish ? TOn : TOff;
  CullingMode = theAspect.BackFace ? TelCullBack : TelCullNone;

  convertMaterial (theAspect.Front, IntFront);
  convertMaterial (theAspect.Back,  IntBack);

  //TelInteriorColour
  IntFront.matcol.rgb[0] = (float )theAspect.IntColor.r;
  IntFront.matcol.rgb[1] = (float )theAspect.IntColor.g;
  IntFront.matcol.rgb[2] = (float )theAspect.IntColor.b;
  IntFront.matcol.rgb[3] = 1.0f;

  //TelBackInteriorColour
  IntBack.matcol.rgb[0] = (float )theAspect.BackIntColor.r;
  IntBack.matcol.rgb[1] = (float )theAspect.BackIntColor.g;
  IntBack.matcol.rgb[2] = (float )theAspect.BackIntColor.b;
  IntBack.matcol.rgb[3] = 1.0f;

  // setup texture
  doTextureMap = theAspect.Texture.doTextureMap;
  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())
    {
      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
  PolygonOffset.mode   = (Aspect_PolygonOffsetMode )theAspect.PolygonOffsetMode;
  PolygonOffset.factor = theAspect.PolygonOffsetFactor;
  PolygonOffset.units  = theAspect.PolygonOffsetUnits;

  CALL_DEF_CONTEXTLINE anEdgeContext;
  anEdgeContext.Color.r  = (float )theAspect.EdgeColor.r;
  anEdgeContext.Color.g  = (float )theAspect.EdgeColor.g;
  anEdgeContext.Color.b  = (float )theAspect.EdgeColor.b;
  anEdgeContext.LineType = (Aspect_TypeOfLine )theAspect.LineType;
  anEdgeContext.Width    = (float )theAspect.Width;
  myAspectEdge.SetContext (anEdgeContext);
}

// =======================================================================
// function : Init
// purpose  :
// =======================================================================
void OpenGl_AspectFace::Init (const Handle(OpenGl_Context)&   theContext,
                              const Handle(Graphic3d_AspectFillArea3d)& theAspect)
{
  CALL_DEF_CONTEXTFILLAREA aCAspect;
  Standard_Real           aWidth;
  Quantity_Color          aBackIntColor;
  Quantity_Color          aEdgeColor;
  Aspect_TypeOfLine       aLType;
  Quantity_Color          aIntColor;
  Aspect_InteriorStyle    aIntStyle;
  NCollection_Vec3<Standard_Real> aColor;

  theAspect->Values (aIntStyle, aIntColor, aBackIntColor, aEdgeColor, aLType, aWidth);
  aIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);

  aCAspect.Style      = int (aIntStyle);
  aCAspect.IntColor.r = float (aColor.r());
  aCAspect.IntColor.g = float (aColor.g());
  aCAspect.IntColor.b = float (aColor.b());

  if (theAspect->Distinguish())
  {
    aBackIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
  }

  aCAspect.BackIntColor.r = float (aColor.r());
  aCAspect.BackIntColor.g = float (aColor.g());
  aCAspect.BackIntColor.b = float (aColor.b());

  aCAspect.Edge = theAspect->Edge () ? 1:0;
  aEdgeColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);

  aCAspect.EdgeColor.r = float (aColor.r());
  aCAspect.EdgeColor.g = float (aColor.g());
  aCAspect.EdgeColor.b = float (aColor.b());
  aCAspect.LineType    = int (aLType);
  aCAspect.Width       = float (aWidth);
  aCAspect.Hatch       = int (theAspect->HatchStyle ());

  aCAspect.Distinguish = theAspect->Distinguish () ? 1:0;
  aCAspect.BackFace    = theAspect->BackFace ()    ? 1:0;

  aCAspect.Back.Shininess = float ((theAspect->BackMaterial ()).Shininess ());
  aCAspect.Back.Ambient   = float ((theAspect->BackMaterial ()).Ambient ());
  aCAspect.Back.Diffuse   = float ((theAspect->BackMaterial ()).Diffuse ());
  aCAspect.Back.Specular  = float ((theAspect->BackMaterial ()).Specular ());
  aCAspect.Back.Transparency  = float ((theAspect->BackMaterial ()).Transparency ());
  aCAspect.Back.Emission      = float ((theAspect->BackMaterial ()).Emissive ());

  // Reflection mode
  aCAspect.Back.IsAmbient = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
  aCAspect.Back.IsDiffuse = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
  aCAspect.Back.IsSpecular = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
  aCAspect.Back.IsEmission = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );

  // Material type
  const Graphic3d_MaterialAspect aBackMat = theAspect->BackMaterial ();
  Standard_Boolean isBackPhys = aBackMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
  aCAspect.Back.IsPhysic = (isBackPhys ? 1 : 0 );

  // Specular Color
  aCAspect.Back.ColorSpec.r = float (((theAspect->BackMaterial ()).SpecularColor ()).Red ());
  aCAspect.Back.ColorSpec.g = float (((theAspect->BackMaterial ()).SpecularColor ()).Green ());
  aCAspect.Back.ColorSpec.b = float (((theAspect->BackMaterial ()).SpecularColor ()).Blue ());

  // Ambient color
  aCAspect.Back.ColorAmb.r = float (((theAspect->BackMaterial ()).AmbientColor ()).Red ());
  aCAspect.Back.ColorAmb.g = float (((theAspect->BackMaterial ()).AmbientColor ()).Green ());
  aCAspect.Back.ColorAmb.b = float (((theAspect->BackMaterial ()).AmbientColor ()).Blue ());

  // Diffuse color
  aCAspect.Back.ColorDif.r = float (((theAspect->BackMaterial ()).DiffuseColor ()).Red ());
  aCAspect.Back.ColorDif.g = float (((theAspect->BackMaterial ()).DiffuseColor ()).Green ());
  aCAspect.Back.ColorDif.b = float (((theAspect->BackMaterial ()).DiffuseColor ()).Blue ());

  // Emissive color
  aCAspect.Back.ColorEms.r = float (((theAspect->BackMaterial ()).EmissiveColor ()).Red ());
  aCAspect.Back.ColorEms.g = float (((theAspect->BackMaterial ()).EmissiveColor ()).Green ());
  aCAspect.Back.ColorEms.b = float (((theAspect->BackMaterial ()).EmissiveColor ()).Blue ());

  aCAspect.Back.EnvReflexion = float ((theAspect->BackMaterial ()).EnvReflexion());

  aCAspect.Front.Shininess    = float ((theAspect->FrontMaterial ()).Shininess ());
  aCAspect.Front.Ambient      = float ((theAspect->FrontMaterial ()).Ambient ());
  aCAspect.Front.Diffuse      = float ((theAspect->FrontMaterial ()).Diffuse ());
  aCAspect.Front.Specular     = float ((theAspect->FrontMaterial ()).Specular ());
  aCAspect.Front.Transparency = float ((theAspect->FrontMaterial ()).Transparency ());
  aCAspect.Front.Emission     = float ((theAspect->FrontMaterial ()).Emissive ());

  // Reflection mode
  aCAspect.Front.IsAmbient    = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0);
  aCAspect.Front.IsDiffuse    = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0);
  aCAspect.Front.IsSpecular   = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0);
  aCAspect.Front.IsEmission   = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0);

  // Materail type
  const Graphic3d_MaterialAspect aFrontMat = theAspect->FrontMaterial ();
  Standard_Boolean isFrontPhys = aFrontMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
  aCAspect.Front.IsPhysic = (isFrontPhys ? 1 : 0 );

  // Specular Color
  aCAspect.Front.ColorSpec.r = float (((theAspect->FrontMaterial ()).SpecularColor ()).Red ());
  aCAspect.Front.ColorSpec.g = float (((theAspect->FrontMaterial ()).SpecularColor ()).Green ());
  aCAspect.Front.ColorSpec.b = float (((theAspect->FrontMaterial ()).SpecularColor ()).Blue ());

  // Ambient color
  aCAspect.Front.ColorAmb.r = float (((theAspect->FrontMaterial ()).AmbientColor ()).Red ());
  aCAspect.Front.ColorAmb.g = float (((theAspect->FrontMaterial ()).AmbientColor ()).Green ());
  aCAspect.Front.ColorAmb.b = float (((theAspect->FrontMaterial ()).AmbientColor ()).Blue ());

  // Diffuse color
  aCAspect.Front.ColorDif.r = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Red ());
  aCAspect.Front.ColorDif.g = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Green ());
  aCAspect.Front.ColorDif.b = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Blue ());

  // Emissive color
  aCAspect.Front.ColorEms.r = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Red ());
  aCAspect.Front.ColorEms.g = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Green ());
  aCAspect.Front.ColorEms.b = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Blue ());

  aCAspect.Front.EnvReflexion = float ((theAspect->FrontMaterial ()).EnvReflexion());
  aCAspect.IsDef = 1;
  aCAspect.Texture.TextureMap   = theAspect->TextureMap();
  aCAspect.Texture.doTextureMap = theAspect->TextureMapState() ? 1 : 0;

  Standard_Integer aPolyMode;
  Standard_ShortReal aPolyFactor, aPolyUnits;
  theAspect->PolygonOffsets (aPolyMode, aPolyFactor, aPolyUnits);
  aCAspect.PolygonOffsetMode   = aPolyMode;
  aCAspect.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor;
  aCAspect.PolygonOffsetUnits  = (Standard_ShortReal)aPolyUnits;

  Init (theContext, aCAspect);
}

// =======================================================================
// function : Render
// purpose  :
// =======================================================================
void OpenGl_AspectFace::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
{
  theWorkspace->SetAspectFace (this);
}

// =======================================================================
// function : Release
// purpose  :
// =======================================================================
void OpenGl_AspectFace::Release (const Handle(OpenGl_Context)& theContext)
{
  if (!TextureRes.IsNull())
  {
    if (!theContext.IsNull())
    {
      if (myTextureId.IsEmpty())
      {
        theContext->DelayedRelease (TextureRes);
      }
      else
      {
        TextureRes.Nullify(); // we need nullify all handles before ReleaseResource() call
        theContext->ReleaseResource (myTextureId);
      }
    }
    TextureRes.Nullify();
  }
  myTextureId.Clear();
}
Commit	Line	Data
b311480e	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
2166f0fa	20	#include <OpenGl_AspectFace.hxx>
bf75be98	21	#include <OpenGl_Texture.hxx>
	22	#include <OpenGl_Workspace.hxx>
	23	#include <OpenGl_Context.hxx>
2166f0fa	24
2166f0fa	25	#include <Aspect_PolygonOffsetMode.hxx>
bf75be98	26	#include <Graphic3d_CGroup.hxx>
bf75be98	27	#include <Graphic3d_TextureMap.hxx>
4269bd1b	28	#include <Graphic3d_TypeOfReflection.hxx>
	29	#include <Graphic3d_MaterialAspect.hxx>
	30
	31	#include <NCollection_Vec3.hxx>
2166f0fa	32
bf75be98	33	namespace
2166f0fa	34	{
2166f0fa	35
bf75be98	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
	51	};
2166f0fa	52
bf75be98	53	// =======================================================================
	54	// function : convertMaterial
	55	// purpose :
	56	// =======================================================================
	57	void OpenGl_AspectFace::convertMaterial (const CALL_DEF_MATERIAL& theMat,
	58	OPENGL_SURF_PROP& theSurf)
2166f0fa	59	{
bf75be98	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;
2166f0fa	64
bf75be98	65	theSurf.isphysic = theMat.IsPhysic ? 1 : 0; // type of material
2166f0fa	66
bf75be98	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	}
2166f0fa	85
bf75be98	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	}
2166f0fa	118
bf75be98	119	// =======================================================================
	120	// function : OpenGl_AspectFace
	121	// purpose :
	122	// =======================================================================
	123	OpenGl_AspectFace::OpenGl_AspectFace()
	124	: InteriorStyle (Aspect_IS_SOLID),
	125	Edge (Aspect_IS_SOLID),
	126	Hatch (TOn),
	127	DistinguishingMode (TEL_HS_SOLID),
	128	CullingMode (TelCullNone),
	129	doTextureMap (0)
2166f0fa	130	{
bf75be98	131	IntFront = THE_DEFAULT_MATERIAL;
	132	IntBack = THE_DEFAULT_MATERIAL;
	133	PolygonOffset = THE_DEFAULT_POFFSET;
	134	}
2166f0fa	135
bf75be98	136	// =======================================================================
	137	// function : Init
	138	// purpose :
	139	// =======================================================================
	140	void OpenGl_AspectFace::Init (const Handle(OpenGl_Context)& theContext,
	141	const CALL_DEF_CONTEXTFILLAREA& theAspect)
	142	{
	143	InteriorStyle = (Aspect_InteriorStyle )theAspect.Style;
	144	Edge = theAspect.Edge ? TOn : TOff;
2166f0fa SK	145
2166f0fa SK	146	//TelInteriorStyleIndex
bf75be98	147	switch (theAspect.Hatch)
2166f0fa	148	{
bf75be98	149	case 0: /* Aspect_HS_HORIZONTAL */
bf75be98	150	Hatch = TEL_HS_HORIZONTAL;
2166f0fa	151	break;
bf75be98	152	case 1: /* Aspect_HS_HORIZONTAL_WIDE */
bf75be98	153	Hatch = TEL_HS_HORIZONTAL_SPARSE;
2166f0fa	154	break;
bf75be98	155	case 2: /* Aspect_HS_VERTICAL */
bf75be98	156	Hatch = TEL_HS_VERTICAL;
2166f0fa	157	break;
bf75be98	158	case 3: /* Aspect_HS_VERTICAL_WIDE */
bf75be98	159	Hatch = TEL_HS_VERTICAL_SPARSE;
2166f0fa	160	break;
bf75be98	161	case 4: /* Aspect_HS_DIAGONAL_45 */
bf75be98	162	Hatch = TEL_HS_DIAG_45;
2166f0fa	163	break;
bf75be98	164	case 5: /* Aspect_HS_DIAGONAL_45_WIDE */
bf75be98	165	Hatch = TEL_HS_DIAG_45_SPARSE;
2166f0fa	166	break;
bf75be98	167	case 6: /* Aspect_HS_DIAGONAL_135 */
bf75be98	168	Hatch = TEL_HS_DIAG_135;
2166f0fa	169	break;
bf75be98	170	case 7: /* Aspect_HS_DIAGONAL_135_WIDE */
bf75be98	171	Hatch = TEL_HS_DIAG_135_SPARSE;
2166f0fa	172	break;
bf75be98	173	case 8: /* Aspect_HS_GRID */
bf75be98	174	Hatch = TEL_HS_GRID;
2166f0fa	175	break;
bf75be98	176	case 9: /* Aspect_HS_GRID_WIDE */
bf75be98	177	Hatch = TEL_HS_GRID_SPARSE;
2166f0fa	178	break;
bf75be98	179	case 10: /* Aspect_HS_GRID_DIAGONAL */
bf75be98	180	Hatch = TEL_HS_CROSS;
2166f0fa	181	break;
bf75be98	182	case 11: /* Aspect_HS_GRID_DIAGONAL_WIDE */
bf75be98	183	Hatch = TEL_HS_CROSS_SPARSE;
2166f0fa	184	break;
bf75be98	185	default:
bf75be98	186	Hatch = 0;
2166f0fa SK	187	break;
	188	}
	189
bf75be98	190	DistinguishingMode = theAspect.Distinguish ? TOn : TOff;
bf75be98	191	CullingMode = theAspect.BackFace ? TelCullBack : TelCullNone;
2166f0fa	192
bf75be98	193	convertMaterial (theAspect.Front, IntFront);
bf75be98	194	convertMaterial (theAspect.Back, IntBack);
2166f0fa SK	195
2166f0fa SK	196	//TelInteriorColour
bf75be98	197	IntFront.matcol.rgb[0] = (float )theAspect.IntColor.r;
	198	IntFront.matcol.rgb[1] = (float )theAspect.IntColor.g;
	199	IntFront.matcol.rgb[2] = (float )theAspect.IntColor.b;
	200	IntFront.matcol.rgb[3] = 1.0f;
2166f0fa SK	201
2166f0fa SK	202	//TelBackInteriorColour
bf75be98	203	IntBack.matcol.rgb[0] = (float )theAspect.BackIntColor.r;
	204	IntBack.matcol.rgb[1] = (float )theAspect.BackIntColor.g;
	205	IntBack.matcol.rgb[2] = (float )theAspect.BackIntColor.b;
	206	IntBack.matcol.rgb[3] = 1.0f;
	207
	208	// setup texture
	209	doTextureMap = theAspect.Texture.doTextureMap;
	210	const Handle(Graphic3d_TextureMap)& aNewTexture = theAspect.Texture.TextureMap;
	211	TCollection_AsciiString aNewKey = aNewTexture.IsNull() ? TCollection_AsciiString() : aNewTexture->GetId();
	212	TextureParams = aNewTexture.IsNull() ? NULL : aNewTexture->GetParams();
	213	if (aNewKey.IsEmpty()
	214	\|\| myTextureId != aNewKey)
	215	{
	216	if (!TextureRes.IsNull())
	217	{
	218	if (myTextureId.IsEmpty())
	219	{
	220	theContext->DelayedRelease (TextureRes);
	221	TextureRes.Nullify();
	222	}
	223	else
	224	{
	225	TextureRes.Nullify(); // we need nullify all handles before ReleaseResource() call
	226	theContext->ReleaseResource (myTextureId);
	227	}
	228	}
	229	myTextureId = aNewKey;
	230
	231	if (!aNewTexture.IsNull())
	232	{
	233	if (aNewKey.IsEmpty() \|\| !theContext->GetResource<Handle(OpenGl_Texture)> (aNewKey, TextureRes))
	234	{
	235	TextureRes = new OpenGl_Texture (TextureParams);
	236	Handle(Image_PixMap) anImage = aNewTexture->GetImage();
	237	if (!anImage.IsNull())
	238	{
	239	TextureRes->Init (theContext, *anImage.operator->(), aNewTexture->Type());
	240	}
	241	if (!aNewKey.IsEmpty())
	242	{
	243	theContext->ShareResource (aNewKey, TextureRes);
	244	}
	245	}
	246	}
	247	}
2166f0fa SK	248
2166f0fa SK	249	//TelPolygonOffset
bf75be98	250	PolygonOffset.mode = (Aspect_PolygonOffsetMode )theAspect.PolygonOffsetMode;
	251	PolygonOffset.factor = theAspect.PolygonOffsetFactor;
	252	PolygonOffset.units = theAspect.PolygonOffsetUnits;
2166f0fa SK	253
2166f0fa SK	254	CALL_DEF_CONTEXTLINE anEdgeContext;
bf75be98	255	anEdgeContext.Color.r = (float )theAspect.EdgeColor.r;
	256	anEdgeContext.Color.g = (float )theAspect.EdgeColor.g;
	257	anEdgeContext.Color.b = (float )theAspect.EdgeColor.b;
	258	anEdgeContext.LineType = (Aspect_TypeOfLine )theAspect.LineType;
	259	anEdgeContext.Width = (float )theAspect.Width;
	260	myAspectEdge.SetContext (anEdgeContext);
2166f0fa SK	261	}
2166f0fa SK	262
4269bd1b	263	// =======================================================================
	264	// function : Init
	265	// purpose :
	266	// =======================================================================
	267	void OpenGl_AspectFace::Init (const Handle(OpenGl_Context)& theContext,
	268	const Handle(Graphic3d_AspectFillArea3d)& theAspect)
	269	{
	270	CALL_DEF_CONTEXTFILLAREA aCAspect;
	271	Standard_Real aWidth;
	272	Quantity_Color aBackIntColor;
	273	Quantity_Color aEdgeColor;
	274	Aspect_TypeOfLine aLType;
	275	Quantity_Color aIntColor;
	276	Aspect_InteriorStyle aIntStyle;
	277	NCollection_Vec3<Standard_Real> aColor;
	278
	279	theAspect->Values (aIntStyle, aIntColor, aBackIntColor, aEdgeColor, aLType, aWidth);
	280	aIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
	281
	282	aCAspect.Style = int (aIntStyle);
	283	aCAspect.IntColor.r = float (aColor.r());
	284	aCAspect.IntColor.g = float (aColor.g());
	285	aCAspect.IntColor.b = float (aColor.b());
	286
	287	if (theAspect->Distinguish())
	288	{
	289	aBackIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
	290	}
	291
	292	aCAspect.BackIntColor.r = float (aColor.r());
	293	aCAspect.BackIntColor.g = float (aColor.g());
	294	aCAspect.BackIntColor.b = float (aColor.b());
	295
	296	aCAspect.Edge = theAspect->Edge () ? 1:0;
	297	aEdgeColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
	298
	299	aCAspect.EdgeColor.r = float (aColor.r());
	300	aCAspect.EdgeColor.g = float (aColor.g());
	301	aCAspect.EdgeColor.b = float (aColor.b());
	302	aCAspect.LineType = int (aLType);
	303	aCAspect.Width = float (aWidth);
	304	aCAspect.Hatch = int (theAspect->HatchStyle ());
	305
	306	aCAspect.Distinguish = theAspect->Distinguish () ? 1:0;
	307	aCAspect.BackFace = theAspect->BackFace () ? 1:0;
	308
	309	aCAspect.Back.Shininess = float ((theAspect->BackMaterial ()).Shininess ());
	310	aCAspect.Back.Ambient = float ((theAspect->BackMaterial ()).Ambient ());
	311	aCAspect.Back.Diffuse = float ((theAspect->BackMaterial ()).Diffuse ());
	312	aCAspect.Back.Specular = float ((theAspect->BackMaterial ()).Specular ());
	313	aCAspect.Back.Transparency = float ((theAspect->BackMaterial ()).Transparency ());
	314	aCAspect.Back.Emission = float ((theAspect->BackMaterial ()).Emissive ());
	315
	316	// Reflection mode
	317	aCAspect.Back.IsAmbient = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
	318	aCAspect.Back.IsDiffuse = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
	319	aCAspect.Back.IsSpecular = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
	320	aCAspect.Back.IsEmission = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
	321
	322	// Material type
	323	const Graphic3d_MaterialAspect aBackMat = theAspect->BackMaterial ();
	324	Standard_Boolean isBackPhys = aBackMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
	325	aCAspect.Back.IsPhysic = (isBackPhys ? 1 : 0 );
	326
327	// Specular Color
328	aCAspect.Back.ColorSpec.r = float (((theAspect->BackMaterial ()).SpecularColor ()).Red ());
329	aCAspect.Back.ColorSpec.g = float (((theAspect->BackMaterial ()).SpecularColor ()).Green ());
330	aCAspect.Back.ColorSpec.b = float (((theAspect->BackMaterial ()).SpecularColor ()).Blue ());
331
332	// Ambient color
333	aCAspect.Back.ColorAmb.r = float (((theAspect->BackMaterial ()).AmbientColor ()).Red ());
334	aCAspect.Back.ColorAmb.g = float (((theAspect->BackMaterial ()).AmbientColor ()).Green ());
335	aCAspect.Back.ColorAmb.b = float (((theAspect->BackMaterial ()).AmbientColor ()).Blue ());
336
337	// Diffuse color
338	aCAspect.Back.ColorDif.r = float (((theAspect->BackMaterial ()).DiffuseColor ()).Red ());
339	aCAspect.Back.ColorDif.g = float (((theAspect->BackMaterial ()).DiffuseColor ()).Green ());
340	aCAspect.Back.ColorDif.b = float (((theAspect->BackMaterial ()).DiffuseColor ()).Blue ());
341
342	// Emissive color
343	aCAspect.Back.ColorEms.r = float (((theAspect->BackMaterial ()).EmissiveColor ()).Red ());
344	aCAspect.Back.ColorEms.g = float (((theAspect->BackMaterial ()).EmissiveColor ()).Green ());
345	aCAspect.Back.ColorEms.b = float (((theAspect->BackMaterial ()).EmissiveColor ()).Blue ());
346
347	aCAspect.Back.EnvReflexion = float ((theAspect->BackMaterial ()).EnvReflexion());
348
349	aCAspect.Front.Shininess = float ((theAspect->FrontMaterial ()).Shininess ());
350	aCAspect.Front.Ambient = float ((theAspect->FrontMaterial ()).Ambient ());
351	aCAspect.Front.Diffuse = float ((theAspect->FrontMaterial ()).Diffuse ());
352	aCAspect.Front.Specular = float ((theAspect->FrontMaterial ()).Specular ());
353	aCAspect.Front.Transparency = float ((theAspect->FrontMaterial ()).Transparency ());
354	aCAspect.Front.Emission = float ((theAspect->FrontMaterial ()).Emissive ());
355
356	// Reflection mode
357	aCAspect.Front.IsAmbient = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0);
358	aCAspect.Front.IsDiffuse = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0);
359	aCAspect.Front.IsSpecular = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0);
360	aCAspect.Front.IsEmission = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0);
361
362	// Materail type
363	const Graphic3d_MaterialAspect aFrontMat = theAspect->FrontMaterial ();
364	Standard_Boolean isFrontPhys = aFrontMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
365	aCAspect.Front.IsPhysic = (isFrontPhys ? 1 : 0 );
366
367	// Specular Color
368	aCAspect.Front.ColorSpec.r = float (((theAspect->FrontMaterial ()).SpecularColor ()).Red ());
369	aCAspect.Front.ColorSpec.g = float (((theAspect->FrontMaterial ()).SpecularColor ()).Green ());
370	aCAspect.Front.ColorSpec.b = float (((theAspect->FrontMaterial ()).SpecularColor ()).Blue ());
371
372	// Ambient color
373	aCAspect.Front.ColorAmb.r = float (((theAspect->FrontMaterial ()).AmbientColor ()).Red ());
374	aCAspect.Front.ColorAmb.g = float (((theAspect->FrontMaterial ()).AmbientColor ()).Green ());
375	aCAspect.Front.ColorAmb.b = float (((theAspect->FrontMaterial ()).AmbientColor ()).Blue ());
376
377	// Diffuse color
378	aCAspect.Front.ColorDif.r = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Red ());
379	aCAspect.Front.ColorDif.g = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Green ());
380	aCAspect.Front.ColorDif.b = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Blue ());
381
382	// Emissive color
383	aCAspect.Front.ColorEms.r = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Red ());
384	aCAspect.Front.ColorEms.g = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Green ());
385	aCAspect.Front.ColorEms.b = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Blue ());
386
387	aCAspect.Front.EnvReflexion = float ((theAspect->FrontMaterial ()).EnvReflexion());
388	aCAspect.IsDef = 1;
389	aCAspect.Texture.TextureMap = theAspect->TextureMap();
390	aCAspect.Texture.doTextureMap = theAspect->TextureMapState() ? 1 : 0;
391
392	Standard_Integer aPolyMode;
393	Standard_ShortReal aPolyFactor, aPolyUnits;
394	theAspect->PolygonOffsets (aPolyMode, aPolyFactor, aPolyUnits);
395	aCAspect.PolygonOffsetMode = aPolyMode;
396	aCAspect.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor;
397	aCAspect.PolygonOffsetUnits = (Standard_ShortReal)aPolyUnits;
398
399	Init (theContext, aCAspect);
400	}
401
bf75be98	402	// =======================================================================
	403	// function : Render
	404	// purpose :
	405	// =======================================================================
5e27df78	406	void OpenGl_AspectFace::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
2166f0fa	407	{
5e27df78	408	theWorkspace->SetAspectFace (this);
2166f0fa SK	409	}
2166f0fa SK	410
bf75be98	411	// =======================================================================
	412	// function : Release
	413	// purpose :
	414	// =======================================================================
5e27df78	415	void OpenGl_AspectFace::Release (const Handle(OpenGl_Context)& theContext)
5e27df78	416	{
bf75be98	417	if (!TextureRes.IsNull())
	418	{
	419	if (!theContext.IsNull())
	420	{
	421	if (myTextureId.IsEmpty())
	422	{
	423	theContext->DelayedRelease (TextureRes);
	424	}
	425	else
	426	{
	427	TextureRes.Nullify(); // we need nullify all handles before ReleaseResource() call
	428	theContext->ReleaseResource (myTextureId);
	429	}
	430	}
	431	TextureRes.Nullify();
	432	}
	433	myTextureId.Clear();
5e27df78	434	}