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

// Created on: 2011-09-20
// 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_GlCore12.hxx>

#include <InterfaceGraphic.hxx>

#include <OpenGl_Workspace.hxx>

#include <OpenGl_AspectLine.hxx>
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_AspectMarker.hxx>
#include <OpenGl_AspectText.hxx>
#include <OpenGl_Context.hxx>

#include <OpenGl_Texture.hxx>

#include <Graphic3d_TextureParams.hxx>

IMPLEMENT_STANDARD_HANDLE(OpenGl_Workspace,OpenGl_Window)
IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Workspace,OpenGl_Window)

namespace
{
  static const TEL_COLOUR myDefaultHighlightColor = { { 1.F, 1.F, 1.F, 1.F } };

  static const OpenGl_AspectLine myDefaultAspectLine;
  static const OpenGl_AspectFace myDefaultAspectFace;
  static const OpenGl_AspectMarker myDefaultAspectMarker;
  static const OpenGl_AspectText myDefaultAspectText;

  static const OpenGl_TextParam myDefaultTextParam =
  {
    16, Graphic3d_HTA_LEFT, Graphic3d_VTA_BOTTOM
  };

  static const OpenGl_Matrix myDefaultMatrix =
  {
    {{ 1.0F, 0.0F, 0.0F, 0.0F },
     { 0.0F, 1.0F, 0.0F, 0.0F },
     { 0.0F, 0.0F, 1.0F, 0.0F },
     { 0.0F, 0.0F, 0.0F, 1.0F }}
  };

};

// =======================================================================
// function : OpenGl_Workspace
// purpose  :
// =======================================================================
OpenGl_Workspace::OpenGl_Workspace (const Handle(OpenGl_Display)& theDisplay,
                                    const CALL_DEF_WINDOW&        theCWindow,
                                    Aspect_RenderingContext       theGContext,
                                    const Handle(OpenGl_Context)& theShareCtx)
: OpenGl_Window (theDisplay, theCWindow, theGContext, theShareCtx),
  myTransientList (0),
  myIsTransientOpen (Standard_False),
  myRetainMode (Standard_False),
  myUseTransparency (Standard_False),
  myUseZBuffer (Standard_False),
  myUseDepthTest (Standard_True),
  myUseGLLight (Standard_True),
  myBackBufferRestored (Standard_False),
  //
  NamedStatus (0),
  DegenerateModel (0),
  SkipRatio (0.F),
  HighlightColor (&myDefaultHighlightColor),
  AspectLine_set (&myDefaultAspectLine),
  AspectLine_applied (NULL),
  AspectFace_set (&myDefaultAspectFace),
  AspectFace_applied (NULL),
  AspectMarker_set (&myDefaultAspectMarker),
  AspectMarker_applied (NULL),
  AspectText_set (&myDefaultAspectText),
  AspectText_applied (NULL),
  TextParam_set (&myDefaultTextParam),
  TextParam_applied (NULL),
  ViewMatrix_applied (&myDefaultMatrix),
  StructureMatrix_applied (&myDefaultMatrix),
  PolygonOffset_applied (NULL)
{
  theDisplay->InitAttributes();

  // General initialization of the context

  // Eviter d'avoir les faces mal orientees en noir.
  // Pourrait etre utiliser pour detecter les problemes d'orientation
  glLightModeli ((GLenum )GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

  // Optimisation pour le Fog et l'antialiasing
  glHint (GL_FOG_HINT,            GL_FASTEST);
  glHint (GL_POINT_SMOOTH_HINT,   GL_FASTEST);
  glHint (GL_LINE_SMOOTH_HINT,    GL_FASTEST);
  glHint (GL_POLYGON_SMOOTH_HINT, GL_FASTEST);

  // Polygon Offset
  EnablePolygonOffset();
}

// =======================================================================
// function : ~OpenGl_Workspace
// purpose  :
// =======================================================================
OpenGl_Workspace::~OpenGl_Workspace()
{
}

// =======================================================================
// function : Activate
// purpose  :
// =======================================================================
Standard_Boolean OpenGl_Workspace::Activate()
{
  if (!OpenGl_Window::Activate())
    return Standard_False;

  DegenerateModel         = 0;
  SkipRatio               = 0.0f;
  ViewMatrix_applied      = &myDefaultMatrix;
  StructureMatrix_applied = &myDefaultMatrix;

  ResetAppliedAspect();

  return Standard_True;
}

// =======================================================================
// function : UseTransparency
// purpose  : call_togl_transparency
// =======================================================================
void OpenGl_Workspace::UseTransparency (const Standard_Boolean theFlag)
{
  if ((myUseTransparency ? 1 : 0) != (theFlag ? 1 : 0))
  {
    myUseTransparency = theFlag;
    EraseAnimation();
  }
}

//=======================================================================
//function : ResetAppliedAspect
//purpose  : Sets default values of GL parameters in accordance with default aspects
//=======================================================================
void OpenGl_Workspace::ResetAppliedAspect()
{
  NamedStatus           = !myTextureBound.IsNull() ? OPENGL_NS_TEXTURE : 0;
  HighlightColor        = &myDefaultHighlightColor;
  AspectLine_set        = &myDefaultAspectLine;
  AspectLine_applied    = NULL;
  AspectFace_set        = &myDefaultAspectFace;
  AspectFace_applied    = NULL;
  AspectMarker_set      = &myDefaultAspectMarker;
  AspectMarker_applied  = NULL;
  AspectText_set        = &myDefaultAspectText;
  AspectText_applied    = NULL;
  TextParam_set         = &myDefaultTextParam;
  TextParam_applied     = NULL;
  PolygonOffset_applied = NULL;

  AspectLine(Standard_True);
  AspectFace(Standard_True);
  AspectMarker(Standard_True);
  AspectText(Standard_True);
}

// =======================================================================
// function : DisableTexture
// purpose  :
// =======================================================================
Handle(OpenGl_Texture) OpenGl_Workspace::DisableTexture()
{
  if (myTextureBound.IsNull())
  {
    return myTextureBound;
  }

  // reset texture matrix because some code may expect it is identity
  GLint aMatrixMode = GL_TEXTURE;
  glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
  glMatrixMode (GL_TEXTURE);
  glLoadIdentity();
  glMatrixMode (aMatrixMode);

  myTextureBound->Unbind (myGlContext);
  switch (myTextureBound->GetTarget())
  {
    case GL_TEXTURE_1D:
    {
      if (myTextureBound->GetParams()->GenMode() != GL_NONE)
      {
        glDisable (GL_TEXTURE_GEN_S);
      }
      glDisable (GL_TEXTURE_1D);
      break;
    }
    case GL_TEXTURE_2D:
    {
      if (myTextureBound->GetParams()->GenMode() != GL_NONE)
      {
        glDisable (GL_TEXTURE_GEN_S);
        glDisable (GL_TEXTURE_GEN_T);
      }
      glDisable (GL_TEXTURE_2D);
      break;
    }
    default: break;
  }

  Handle(OpenGl_Texture) aPrevTexture = myTextureBound;
  myTextureBound.Nullify();
  return aPrevTexture;
}

// =======================================================================
// function : setTextureParams
// purpose  :
// =======================================================================
void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&                theTexture,
                                         const Handle(Graphic3d_TextureParams)& theParams)
{
  const Handle(Graphic3d_TextureParams)& aParams = theParams.IsNull() ? theTexture->GetParams() : theParams;
  if (aParams.IsNull())
  {
    return;
  }

  GLint aMatrixMode = GL_TEXTURE;
  glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);

  // setup texture matrix
  glMatrixMode (GL_TEXTURE);
  glLoadIdentity();
  const Graphic3d_Vec2& aScale = aParams->Scale();
  const Graphic3d_Vec2& aTrans = aParams->Translation();
  glScalef     ( aScale.x(),  aScale.y(), 1.0f);
  glTranslatef (-aTrans.x(), -aTrans.y(), 0.0f);
  glRotatef (-aParams->Rotation(), 0.0f, 0.0f, 1.0f);

  // setup generation of texture coordinates
  switch (aParams->GenMode())
  {
    case Graphic3d_TOTM_OBJECT:
    {
      glTexGeni  (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
      glTexGenfv (GL_S, GL_OBJECT_PLANE,     aParams->GenPlaneS().GetData());
      if (theTexture->GetTarget() != GL_TEXTURE_1D)
      {
        glTexGeni  (GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
        glTexGenfv (GL_T, GL_OBJECT_PLANE,     aParams->GenPlaneT().GetData());
      }
      break;
    }
    case Graphic3d_TOTM_SPHERE:
    {
      glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
      if (theTexture->GetTarget() != GL_TEXTURE_1D)
      {
        glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
      }
      break;
    }
    case Graphic3d_TOTM_EYE:
    {
      glMatrixMode (GL_MODELVIEW);
      glPushMatrix();
      glLoadIdentity();

      glTexGeni  (GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
      glTexGenfv (GL_S, GL_EYE_PLANE,        aParams->GenPlaneS().GetData());

      if (theTexture->GetTarget() != GL_TEXTURE_1D)
      {
        glTexGeni  (GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
        glTexGenfv (GL_T, GL_EYE_PLANE,        aParams->GenPlaneT().GetData());
      }
      glPopMatrix();
      break;
    }
    case Graphic3d_TOTM_MANUAL:
    default: break;
  }

  // setup lighting
  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, aParams->IsModulate() ? GL_MODULATE : GL_DECAL);

  // setup texture filtering and wrapping
  //if (theTexture->GetParams() != theParams)
  const GLenum aFilter   = (aParams->Filter() == Graphic3d_TOTF_NEAREST) ? GL_NEAREST : GL_LINEAR;
  const GLenum aWrapMode = aParams->IsRepeat() ? GL_REPEAT : GL_CLAMP;
  switch (theTexture->GetTarget())
  {
    case GL_TEXTURE_1D:
    {
      glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, aFilter);
      glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, aFilter);
      glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_S,     aWrapMode);
      break;
    }
    case GL_TEXTURE_2D:
    {
      GLenum aFilterMin = aFilter;
      if (theTexture->HasMipmaps())
      {
        aFilterMin = GL_NEAREST_MIPMAP_NEAREST;
        if (aParams->Filter() == Graphic3d_TOTF_BILINEAR)
        {
          aFilterMin = GL_LINEAR_MIPMAP_NEAREST;
        }
        else if (aParams->Filter() == Graphic3d_TOTF_TRILINEAR)
        {
          aFilterMin = GL_LINEAR_MIPMAP_LINEAR;
        }

        if (myGlContext->extAnis)
        {
          // setup degree of anisotropy filter
          const GLint aMaxDegree = myGlContext->MaxDegreeOfAnisotropy();
          switch (aParams->AnisoFilter())
          {
            case Graphic3d_LOTA_QUALITY:
            {
              glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, aMaxDegree);
              break;
            }
            case Graphic3d_LOTA_MIDDLE:
            {

              glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (aMaxDegree <= 4) ? 2 : (aMaxDegree / 2));
              break;
            }
            case Graphic3d_LOTA_FAST:
            {
              glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2);
              break;
            }
            case Graphic3d_LOTA_OFF:
            default:
            {
              glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1);
              break;
            }
          }
        }
      }
      glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, aFilterMin);
      glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, aFilter);
      glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     aWrapMode);
      glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     aWrapMode);
      break;
    }
    default: break;
  }

  switch (theTexture->GetTarget())
  {
    case GL_TEXTURE_1D:
    {
      if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
      {
        glEnable (GL_TEXTURE_GEN_S);
      }
      glEnable (GL_TEXTURE_1D);
      break;
    }
    case GL_TEXTURE_2D:
    {
      if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
      {
        glEnable (GL_TEXTURE_GEN_S);
        glEnable (GL_TEXTURE_GEN_T);
      }
      glEnable (GL_TEXTURE_2D);
      break;
    }
    default: break;
  }

  glMatrixMode (aMatrixMode); // turn back active matrix
  theTexture->SetParams (aParams);
}

// =======================================================================
// function : EnableTexture
// purpose  :
// =======================================================================
Handle(OpenGl_Texture) OpenGl_Workspace::EnableTexture (const Handle(OpenGl_Texture)&          theTexture,
                                                        const Handle(Graphic3d_TextureParams)& theParams)
{
  if (theTexture.IsNull() || !theTexture->IsValid())
  {
    return DisableTexture();
  }

  if (myTextureBound == theTexture
   && (theParams.IsNull() || theParams == theTexture->GetParams()))
  {
    // already bound
    return myTextureBound;
  }

  Handle(OpenGl_Texture) aPrevTexture = DisableTexture();
  myTextureBound = theTexture;
  myTextureBound->Bind (myGlContext);
  setTextureParams (myTextureBound, theParams);

  return aPrevTexture;
}
Commit	Line	Data
b311480e	1	// Created on: 2011-09-20
	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
bf75be98	20	#include <OpenGl_GlCore12.hxx>
5f8b738e	21
2166f0fa SK	22	#include <InterfaceGraphic.hxx>
	23
	24	#include <OpenGl_Workspace.hxx>
	25
	26	#include <OpenGl_AspectLine.hxx>
	27	#include <OpenGl_AspectFace.hxx>
	28	#include <OpenGl_AspectMarker.hxx>
	29	#include <OpenGl_AspectText.hxx>
bf75be98	30	#include <OpenGl_Context.hxx>
	31
	32	#include <OpenGl_Texture.hxx>
2166f0fa	33
bf75be98	34	#include <Graphic3d_TextureParams.hxx>
2166f0fa SK	35
	36	IMPLEMENT_STANDARD_HANDLE(OpenGl_Workspace,OpenGl_Window)
	37	IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Workspace,OpenGl_Window)
	38
	39	namespace
	40	{
	41	static const TEL_COLOUR myDefaultHighlightColor = { { 1.F, 1.F, 1.F, 1.F } };
	42
	43	static const OpenGl_AspectLine myDefaultAspectLine;
	44	static const OpenGl_AspectFace myDefaultAspectFace;
	45	static const OpenGl_AspectMarker myDefaultAspectMarker;
	46	static const OpenGl_AspectText myDefaultAspectText;
	47
	48	static const OpenGl_TextParam myDefaultTextParam =
	49	{
	50	16, Graphic3d_HTA_LEFT, Graphic3d_VTA_BOTTOM
	51	};
	52
	53	static const OpenGl_Matrix myDefaultMatrix =
	54	{
	55	{{ 1.0F, 0.0F, 0.0F, 0.0F },
	56	{ 0.0F, 1.0F, 0.0F, 0.0F },
	57	{ 0.0F, 0.0F, 1.0F, 0.0F },
	58	{ 0.0F, 0.0F, 0.0F, 1.0F }}
	59	};
bf75be98	60
2166f0fa SK	61	};
	62
	63	// =======================================================================
	64	// function : OpenGl_Workspace
	65	// purpose :
	66	// =======================================================================
	67	OpenGl_Workspace::OpenGl_Workspace (const Handle(OpenGl_Display)& theDisplay,
	68	const CALL_DEF_WINDOW& theCWindow,
5e27df78	69	Aspect_RenderingContext theGContext,
	70	const Handle(OpenGl_Context)& theShareCtx)
	71	: OpenGl_Window (theDisplay, theCWindow, theGContext, theShareCtx),
2166f0fa SK	72	myTransientList (0),
	73	myIsTransientOpen (Standard_False),
	74	myRetainMode (Standard_False),
	75	myUseTransparency (Standard_False),
	76	myUseZBuffer (Standard_False),
	77	myUseDepthTest (Standard_True),
	78	myUseGLLight (Standard_True),
	79	myBackBufferRestored (Standard_False),
	80	//
	81	NamedStatus (0),
	82	DegenerateModel (0),
	83	SkipRatio (0.F),
	84	HighlightColor (&myDefaultHighlightColor),
	85	AspectLine_set (&myDefaultAspectLine),
	86	AspectLine_applied (NULL),
	87	AspectFace_set (&myDefaultAspectFace),
	88	AspectFace_applied (NULL),
	89	AspectMarker_set (&myDefaultAspectMarker),
	90	AspectMarker_applied (NULL),
	91	AspectText_set (&myDefaultAspectText),
	92	AspectText_applied (NULL),
	93	TextParam_set (&myDefaultTextParam),
	94	TextParam_applied (NULL),
	95	ViewMatrix_applied (&myDefaultMatrix),
	96	StructureMatrix_applied (&myDefaultMatrix),
	97	PolygonOffset_applied (NULL)
	98	{
	99	theDisplay->InitAttributes();
	100
	101	// General initialization of the context
	102
	103	// Eviter d'avoir les faces mal orientees en noir.
	104	// Pourrait etre utiliser pour detecter les problemes d'orientation
bf75be98	105	glLightModeli ((GLenum )GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
2166f0fa SK	106
	107	// Optimisation pour le Fog et l'antialiasing
	108	glHint (GL_FOG_HINT, GL_FASTEST);
	109	glHint (GL_POINT_SMOOTH_HINT, GL_FASTEST);
	110	glHint (GL_LINE_SMOOTH_HINT, GL_FASTEST);
	111	glHint (GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
	112
	113	// Polygon Offset
	114	EnablePolygonOffset();
	115	}
	116
	117	// =======================================================================
	118	// function : ~OpenGl_Workspace
	119	// purpose :
	120	// =======================================================================
	121	OpenGl_Workspace::~OpenGl_Workspace()
	122	{
	123	}
	124
	125	// =======================================================================
	126	// function : Activate
	127	// purpose :
	128	// =======================================================================
	129	Standard_Boolean OpenGl_Workspace::Activate()
	130	{
	131	if (!OpenGl_Window::Activate())
	132	return Standard_False;
	133
2166f0fa SK	134	DegenerateModel = 0;
2166f0fa SK	135	SkipRatio = 0.0f;
2166f0fa SK	136	ViewMatrix_applied = &myDefaultMatrix;
2166f0fa SK	137	StructureMatrix_applied = &myDefaultMatrix;
26395493	138
	139	ResetAppliedAspect();
	140
	141	return Standard_True;
2166f0fa SK	142	}
	143
	144	// =======================================================================
	145	// function : UseTransparency
	146	// purpose : call_togl_transparency
	147	// =======================================================================
	148	void OpenGl_Workspace::UseTransparency (const Standard_Boolean theFlag)
	149	{
	150	if ((myUseTransparency ? 1 : 0) != (theFlag ? 1 : 0))
	151	{
	152	myUseTransparency = theFlag;
	153	EraseAnimation();
2166f0fa SK	154	}
2166f0fa SK	155	}
26395493	156
	157	//=======================================================================
	158	//function : ResetAppliedAspect
	159	//purpose : Sets default values of GL parameters in accordance with default aspects
	160	//=======================================================================
	161	void OpenGl_Workspace::ResetAppliedAspect()
	162	{
bf75be98	163	NamedStatus = !myTextureBound.IsNull() ? OPENGL_NS_TEXTURE : 0;
26395493	164	HighlightColor = &myDefaultHighlightColor;
	165	AspectLine_set = &myDefaultAspectLine;
	166	AspectLine_applied = NULL;
	167	AspectFace_set = &myDefaultAspectFace;
	168	AspectFace_applied = NULL;
	169	AspectMarker_set = &myDefaultAspectMarker;
	170	AspectMarker_applied = NULL;
	171	AspectText_set = &myDefaultAspectText;
	172	AspectText_applied = NULL;
	173	TextParam_set = &myDefaultTextParam;
	174	TextParam_applied = NULL;
	175	PolygonOffset_applied = NULL;
	176
	177	AspectLine(Standard_True);
	178	AspectFace(Standard_True);
	179	AspectMarker(Standard_True);
	180	AspectText(Standard_True);
	181	}
bf75be98	182
	183	// =======================================================================
	184	// function : DisableTexture
	185	// purpose :
	186	// =======================================================================
	187	Handle(OpenGl_Texture) OpenGl_Workspace::DisableTexture()
	188	{
	189	if (myTextureBound.IsNull())
	190	{
	191	return myTextureBound;
	192	}
	193
	194	// reset texture matrix because some code may expect it is identity
	195	GLint aMatrixMode = GL_TEXTURE;
	196	glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
	197	glMatrixMode (GL_TEXTURE);
	198	glLoadIdentity();
	199	glMatrixMode (aMatrixMode);
	200
	201	myTextureBound->Unbind (myGlContext);
	202	switch (myTextureBound->GetTarget())
	203	{
	204	case GL_TEXTURE_1D:
	205	{
	206	if (myTextureBound->GetParams()->GenMode() != GL_NONE)
	207	{
	208	glDisable (GL_TEXTURE_GEN_S);
	209	}
	210	glDisable (GL_TEXTURE_1D);
	211	break;
	212	}
	213	case GL_TEXTURE_2D:
	214	{
	215	if (myTextureBound->GetParams()->GenMode() != GL_NONE)
	216	{
	217	glDisable (GL_TEXTURE_GEN_S);
	218	glDisable (GL_TEXTURE_GEN_T);
	219	}
	220	glDisable (GL_TEXTURE_2D);
	221	break;
	222	}
	223	default: break;
	224	}
	225
	226	Handle(OpenGl_Texture) aPrevTexture = myTextureBound;
	227	myTextureBound.Nullify();
	228	return aPrevTexture;
	229	}
	230
	231	// =======================================================================
	232	// function : setTextureParams
	233	// purpose :
	234	// =======================================================================
	235	void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)& theTexture,
	236	const Handle(Graphic3d_TextureParams)& theParams)
	237	{
	238	const Handle(Graphic3d_TextureParams)& aParams = theParams.IsNull() ? theTexture->GetParams() : theParams;
	239	if (aParams.IsNull())
	240	{
	241	return;
	242	}
	243
	244	GLint aMatrixMode = GL_TEXTURE;
	245	glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
246
247	// setup texture matrix
248	glMatrixMode (GL_TEXTURE);
249	glLoadIdentity();
250	const Graphic3d_Vec2& aScale = aParams->Scale();
251	const Graphic3d_Vec2& aTrans = aParams->Translation();
252	glScalef ( aScale.x(), aScale.y(), 1.0f);
253	glTranslatef (-aTrans.x(), -aTrans.y(), 0.0f);
254	glRotatef (-aParams->Rotation(), 0.0f, 0.0f, 1.0f);
255
256	// setup generation of texture coordinates
257	switch (aParams->GenMode())
258	{
259	case Graphic3d_TOTM_OBJECT:
260	{
261	glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
262	glTexGenfv (GL_S, GL_OBJECT_PLANE, aParams->GenPlaneS().GetData());
263	if (theTexture->GetTarget() != GL_TEXTURE_1D)
264	{
265	glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
266	glTexGenfv (GL_T, GL_OBJECT_PLANE, aParams->GenPlaneT().GetData());
267	}
268	break;
269	}
270	case Graphic3d_TOTM_SPHERE:
271	{
272	glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
273	if (theTexture->GetTarget() != GL_TEXTURE_1D)
274	{
275	glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
276	}
277	break;
278	}
279	case Graphic3d_TOTM_EYE:
280	{
281	glMatrixMode (GL_MODELVIEW);
282	glPushMatrix();
283	glLoadIdentity();
284
285	glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
286	glTexGenfv (GL_S, GL_EYE_PLANE, aParams->GenPlaneS().GetData());
287
288	if (theTexture->GetTarget() != GL_TEXTURE_1D)
289	{
290	glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
291	glTexGenfv (GL_T, GL_EYE_PLANE, aParams->GenPlaneT().GetData());
292	}
293	glPopMatrix();
294	break;
295	}
296	case Graphic3d_TOTM_MANUAL:
297	default: break;
298	}
299
300	// setup lighting
301	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, aParams->IsModulate() ? GL_MODULATE : GL_DECAL);
302
303	// setup texture filtering and wrapping
304	//if (theTexture->GetParams() != theParams)
305	const GLenum aFilter = (aParams->Filter() == Graphic3d_TOTF_NEAREST) ? GL_NEAREST : GL_LINEAR;
306	const GLenum aWrapMode = aParams->IsRepeat() ? GL_REPEAT : GL_CLAMP;
307	switch (theTexture->GetTarget())
308	{
309	case GL_TEXTURE_1D:
310	{
311	glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, aFilter);
312	glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, aFilter);
313	glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, aWrapMode);
314	break;
315	}
316	case GL_TEXTURE_2D:
317	{
318	GLenum aFilterMin = aFilter;
319	if (theTexture->HasMipmaps())
320	{
321	aFilterMin = GL_NEAREST_MIPMAP_NEAREST;
322	if (aParams->Filter() == Graphic3d_TOTF_BILINEAR)
323	{
324	aFilterMin = GL_LINEAR_MIPMAP_NEAREST;
325	}
326	else if (aParams->Filter() == Graphic3d_TOTF_TRILINEAR)
327	{
328	aFilterMin = GL_LINEAR_MIPMAP_LINEAR;
329	}
330
331	if (myGlContext->extAnis)
332	{
333	// setup degree of anisotropy filter
334	const GLint aMaxDegree = myGlContext->MaxDegreeOfAnisotropy();
335	switch (aParams->AnisoFilter())
336	{
337	case Graphic3d_LOTA_QUALITY:
338	{
339	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, aMaxDegree);
340	break;
341	}
342	case Graphic3d_LOTA_MIDDLE:
343	{
344
345	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (aMaxDegree <= 4) ? 2 : (aMaxDegree / 2));
346	break;
347	}
348	case Graphic3d_LOTA_FAST:
349	{
350	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2);
351	break;
352	}
353	case Graphic3d_LOTA_OFF:
354	default:
355	{
356	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1);
357	break;
358	}
359	}
360	}
361	}
362	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, aFilterMin);
363	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, aFilter);
364	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, aWrapMode);
365	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, aWrapMode);
366	break;
367	}
368	default: break;
369	}
370
371	switch (theTexture->GetTarget())
372	{
373	case GL_TEXTURE_1D:
374	{
375	if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
376	{
377	glEnable (GL_TEXTURE_GEN_S);
378	}
379	glEnable (GL_TEXTURE_1D);
380	break;
381	}
382	case GL_TEXTURE_2D:
383	{
384	if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
385	{
386	glEnable (GL_TEXTURE_GEN_S);
387	glEnable (GL_TEXTURE_GEN_T);
388	}
389	glEnable (GL_TEXTURE_2D);
390	break;
391	}
392	default: break;
393	}
394
395	glMatrixMode (aMatrixMode); // turn back active matrix
396	theTexture->SetParams (aParams);
397	}
398
399	// =======================================================================
400	// function : EnableTexture
401	// purpose :
402	// =======================================================================
403	Handle(OpenGl_Texture) OpenGl_Workspace::EnableTexture (const Handle(OpenGl_Texture)& theTexture,
404	const Handle(Graphic3d_TextureParams)& theParams)
405	{
406	if (theTexture.IsNull() \|\| !theTexture->IsValid())
407	{
408	return DisableTexture();
409	}
410
bca1d6e2	411	if (myTextureBound == theTexture
bca1d6e2	412	&& (theParams.IsNull() \|\| theParams == theTexture->GetParams()))
bf75be98	413	{
bca1d6e2	414	// already bound
bca1d6e2	415	return myTextureBound;
bf75be98	416	}
	417
	418	Handle(OpenGl_Texture) aPrevTexture = DisableTexture();
	419	myTextureBound = theTexture;
	420	myTextureBound->Bind (myGlContext);
	421	setTextureParams (myTextureBound, theParams);
	422
	423	return aPrevTexture;
	424	}