// Created on: 2011-07-13
// Created by: Sergey ZERCHANINOV
-// Copyright (c) 2011-2012 OPEN CASCADE SAS
+// Copyright (c) 2011-2013 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.
+// This file is part of Open CASCADE Technology software library.
//
-// 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.
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
//
-// 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.
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
-
-#include <OpenGl_ArbVBO.hxx>
+#include <OpenGl_Aspects.hxx>
#include <OpenGl_Context.hxx>
-
-#include <OpenGl_PrimitiveArray.hxx>
-
-#include <OpenGl_AspectFace.hxx>
#include <OpenGl_GraphicDriver.hxx>
-#include <OpenGl_ResourceCleaner.hxx>
-#include <OpenGl_ResourceVBO.hxx>
+#include <OpenGl_IndexBuffer.hxx>
+#include <OpenGl_PointSprite.hxx>
+#include <OpenGl_PrimitiveArray.hxx>
+#include <OpenGl_Sampler.hxx>
+#include <OpenGl_ShaderManager.hxx>
+#include <OpenGl_ShaderProgram.hxx>
#include <OpenGl_Structure.hxx>
-#include <OpenGl_TextureBox.hxx>
-
-#include <InterfaceGraphic_PrimitiveArray.hxx>
-
-enum
-{
- VBO_NOT_INITIALIZED = -1,
- VBO_ERROR = 0,
- VBO_OK = 1
-};
+#include <OpenGl_VertexBufferCompat.hxx>
+#include <OpenGl_View.hxx>
+#include <OpenGl_Workspace.hxx>
+#include <Graphic3d_TextureParams.hxx>
+#include <NCollection_AlignedAllocator.hxx>
namespace
{
- static unsigned long vRand = 1L;
- #define OGL_Rand() (vRand = vRand * 214013L + 2531011L)
-};
-
-// =======================================================================
-// function : clearMemoryOwn
-// purpose :
-// =======================================================================
-void OpenGl_PrimitiveArray::clearMemoryOwn() const
-{
- if (myPArray->bufferVBO[VBOEdges] != 0)
- {
- Standard::Free ((Standard_Address& )myPArray->edges);
- myPArray->edges = NULL;
- }
- if (myPArray->bufferVBO[VBOVertices] != 0)
- {
- Standard::Free ((Standard_Address& )myPArray->vertices);
- myPArray->vertices = NULL;
- }
- if (myPArray->bufferVBO[VBOVcolours] != 0)
- {
- Standard::Free ((Standard_Address& )myPArray->vcolours);
- myPArray->vcolours = NULL;
- }
- if (myPArray->bufferVBO[VBOVnormals] != 0)
- {
- Standard::Free ((Standard_Address& )myPArray->vnormals);
- myPArray->vnormals = NULL;
- }
- if (myPArray->bufferVBO[VBOVtexels] != 0)
- {
- Standard::Free ((Standard_Address& )myPArray->vtexels);
- myPArray->vtexels = NULL;
- }
- if (myPArray->edge_vis != NULL) /// ????
- {
- Standard::Free ((Standard_Address& )myPArray->edge_vis);
- myPArray->edge_vis = NULL;
- }
-}
-
-// =======================================================================
-// function : clearMemoryGL
-// purpose :
-// =======================================================================
-void OpenGl_PrimitiveArray::clearMemoryGL (const Handle(OpenGl_Context)& theGlContext) const
-{
- if (myPArray->bufferVBO[VBOEdges] != 0)
+ //! Convert data type to GL info
+ inline GLenum toGlDataType (const Graphic3d_TypeOfData theType,
+ GLint& theNbComp)
{
- theGlContext->arbVBO->glDeleteBuffersARB (1, &myPArray->bufferVBO[VBOEdges]);
- }
- if (myPArray->bufferVBO[VBOVertices] != 0)
- {
- theGlContext->arbVBO->glDeleteBuffersARB (1, &myPArray->bufferVBO[VBOVertices]);
- }
- if (myPArray->bufferVBO[VBOVcolours] != 0)
- {
- theGlContext->arbVBO->glDeleteBuffersARB (1, &myPArray->bufferVBO[VBOVcolours]);
- }
- if (myPArray->bufferVBO[VBOVnormals] != 0)
- {
- theGlContext->arbVBO->glDeleteBuffersARB (1, &myPArray->bufferVBO[VBOVnormals]);
- }
- if (myPArray->bufferVBO[VBOVtexels] != 0)
- {
- theGlContext->arbVBO->glDeleteBuffersARB (1, &myPArray->bufferVBO[VBOVtexels]);
- }
- theGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, 0);
- theGlContext->arbVBO->glBindBufferARB (GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
-}
-
-// =======================================================================
-// function : checkSizeForGraphicMemory
-// purpose :
-// =======================================================================
-Standard_Boolean OpenGl_PrimitiveArray::checkSizeForGraphicMemory (const Handle(OpenGl_Context)& theGlContext) const
-{
- if (glGetError() == GL_OUT_OF_MEMORY)
- {
- myPArray->flagBufferVBO = VBO_ERROR;
- clearMemoryGL (theGlContext);
- }
- else
- {
- myPArray->flagBufferVBO = VBO_OK;
- }
- return myPArray->flagBufferVBO == VBO_OK;
-}
-
-// =======================================================================
-// function : BuildVBO
-// purpose :
-// =======================================================================
-Standard_Boolean OpenGl_PrimitiveArray::BuildVBO (const Handle(OpenGl_Workspace)& theWorkspace) const
-{
- int size_reqd = 0;
- const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
- if (myPArray->edges != NULL)
- {
- size_reqd = myPArray->num_edges * sizeof(Tint);
- aGlContext->arbVBO->glGenBuffersARB (1, &myPArray->bufferVBO[VBOEdges]);
- aGlContext->arbVBO->glBindBufferARB (GL_ELEMENT_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOEdges]);
- aGlContext->arbVBO->glBufferDataARB (GL_ELEMENT_ARRAY_BUFFER_ARB, size_reqd, myPArray->edges, GL_STATIC_DRAW_ARB);
- if (!checkSizeForGraphicMemory (aGlContext))
- return Standard_False;
- }
-
- if (myPArray->vertices != NULL)
- {
- size_reqd = myPArray->num_vertexs * sizeof(TEL_POINT);
- aGlContext->arbVBO->glGenBuffersARB (1, &myPArray->bufferVBO[VBOVertices]);
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOVertices]);
- aGlContext->arbVBO->glBufferDataARB (GL_ARRAY_BUFFER_ARB, size_reqd, myPArray->vertices, GL_STATIC_DRAW_ARB);
- if (!checkSizeForGraphicMemory (aGlContext))
- return Standard_False;
- }
-
- if (myPArray->vcolours != NULL)
- {
- size_reqd = myPArray->num_vertexs * sizeof(Tint);
- aGlContext->arbVBO->glGenBuffersARB (1, &myPArray->bufferVBO[VBOVcolours]);
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOVcolours]);
- aGlContext->arbVBO->glBufferDataARB (GL_ARRAY_BUFFER_ARB, size_reqd, myPArray->vcolours, GL_STATIC_DRAW_ARB);
- if (!checkSizeForGraphicMemory (aGlContext))
- return Standard_False;
- }
-
- if (myPArray->vnormals != NULL)
- {
- size_reqd = myPArray->num_vertexs * sizeof(TEL_POINT);
- aGlContext->arbVBO->glGenBuffersARB (1, &myPArray->bufferVBO[VBOVnormals]);
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOVnormals]);
- aGlContext->arbVBO->glBufferDataARB (GL_ARRAY_BUFFER_ARB, size_reqd, myPArray->vnormals, GL_STATIC_DRAW_ARB);
- if (!checkSizeForGraphicMemory (aGlContext))
- return Standard_False;
- }
-
- if (myPArray->vtexels)
- {
- size_reqd = myPArray->num_vertexs * sizeof(TEL_TEXTURE_COORD);
- aGlContext->arbVBO->glGenBuffersARB (1, &myPArray->bufferVBO[VBOVtexels]);
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOVtexels]);
- aGlContext->arbVBO->glBufferDataARB (GL_ARRAY_BUFFER_ARB, size_reqd, myPArray->vtexels, GL_STATIC_DRAW_ARB);
- if (!checkSizeForGraphicMemory (aGlContext))
- return Standard_False;
+ switch (theType)
+ {
+ case Graphic3d_TOD_USHORT:
+ theNbComp = 1;
+ return GL_UNSIGNED_SHORT;
+ case Graphic3d_TOD_UINT:
+ theNbComp = 1;
+ return GL_UNSIGNED_INT;
+ case Graphic3d_TOD_VEC2:
+ theNbComp = 2;
+ return GL_FLOAT;
+ case Graphic3d_TOD_VEC3:
+ theNbComp = 3;
+ return GL_FLOAT;
+ case Graphic3d_TOD_VEC4:
+ theNbComp = 4;
+ return GL_FLOAT;
+ case Graphic3d_TOD_VEC4UB:
+ theNbComp = 4;
+ return GL_UNSIGNED_BYTE;
+ case Graphic3d_TOD_FLOAT:
+ theNbComp = 1;
+ return GL_FLOAT;
+ }
+ theNbComp = 0;
+ return GL_NONE;
}
- if (myPArray->flagBufferVBO == VBO_OK)
- clearMemoryOwn();
-
- // specify context for VBO resource
- myPArray->contextId = (Standard_Address )theWorkspace->GetGContext();
- return Standard_True;
}
-// =======================================================================
-// function : DrawArrays
-// purpose : Auxiliary method to split Feedback/Normal rendering modes
-// =======================================================================
-inline void DrawArrays (const Handle(OpenGl_Workspace)& theWorkspace,
- const CALL_DEF_PARRAY* thePArray,
- const Standard_Boolean theIsFeedback,
- GLenum theMode,
- GLint theFirst,
- GLsizei theCount)
+//! Auxiliary template for VBO with interleaved attributes.
+template<class TheBaseClass, int NbAttributes>
+class OpenGl_VertexBufferT : public TheBaseClass
{
- if (!theIsFeedback)
- {
- glDrawArrays (theMode, theFirst, theCount);
- return;
- }
+public:
- glBegin (theMode);
- for (int anIter = theFirst; anIter < (theFirst + theCount); ++anIter)
+ //! Create uninitialized VBO.
+ OpenGl_VertexBufferT (const Graphic3d_Buffer& theAttribs)
+ : Stride (theAttribs.IsInterleaved() ? theAttribs.Stride : 0)
{
- if (thePArray->vnormals != NULL)
- glNormal3fv (thePArray->vnormals[anIter].xyz);
- if (thePArray->vtexels != NULL && (theWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0)
- glTexCoord3fv (thePArray->vtexels[anIter].xy);
- if (thePArray->vertices != NULL)
- glVertex3fv (thePArray->vertices[anIter].xyz);
- if (thePArray->vcolours != NULL)
- glColor4ubv((GLubyte* )thePArray->vcolours[anIter]);
+ memcpy (Attribs, theAttribs.AttributesArray(), sizeof(Graphic3d_Attribute) * NbAttributes);
}
- glEnd();
-}
-// =======================================================================
-// function : DrawElements
-// purpose : Auxiliary method to split Feedback/Normal rendering modes
-// =======================================================================
-inline void DrawElements (const Handle(OpenGl_Workspace)& theWorkspace,
- const CALL_DEF_PARRAY* thePArray,
- const Standard_Boolean theIsFeedback,
- GLenum theMode,
- GLsizei theCount,
- GLenum* theIndices)
-{
- if (!theIsFeedback)
+ virtual bool HasColorAttribute() const
{
- glDrawElements (theMode, theCount, GL_UNSIGNED_INT, theIndices);
- return;
- }
-
- GLenum anIndex;
- glBegin (theMode);
- for (GLsizei anIter = 0; anIter < theCount; ++anIter)
- {
- anIndex = theIndices[anIter];
- if (thePArray->vnormals != NULL)
- glNormal3fv (thePArray->vnormals[anIndex].xyz);
- if (thePArray->vtexels != NULL && (theWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0)
- glTexCoord3fv (thePArray->vtexels[anIndex].xy);
- if (thePArray->vertices != NULL)
- glVertex3fv (thePArray->vertices[anIndex].xyz);
- if (thePArray->vcolours != NULL)
- glColor4ubv ((GLubyte* )thePArray->vcolours[anIndex]);
- }
- glEnd();
-}
-
-// =======================================================================
-// function : DrawArray
-// purpose :
-// =======================================================================
-void OpenGl_PrimitiveArray::DrawArray (Tint theLightingModel,
- const Aspect_InteriorStyle theInteriorStyle,
- Tint theEdgeFlag,
- const TEL_COLOUR* theInteriorColour,
- const TEL_COLOUR* theLineColour,
- const TEL_COLOUR* theEdgeColour,
- const OPENGL_SURF_PROP* theFaceProp,
- const Handle(OpenGl_Workspace)& theWorkspace) const
-{
- const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
-
- Tint i,n;
- Tint transp = 0;
- GLint renderMode;
- // Following pointers have been provided for performance improvement
- tel_colour pfc = myPArray->fcolours;
- Tint* pvc = myPArray->vcolours;
- if (pvc != NULL)
- {
- for (i = 0; i < myPArray->num_vertexs; ++i)
+ for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
{
- transp = int(theFaceProp->trans * 255.0f);
- #if defined (sparc) || defined (__sparc__) || defined (__sparc)
- pvc[i] = (pvc[i] & 0xffffff00);
- pvc[i] += transp;
- #else
- pvc[i] = (pvc[i] & 0x00ffffff);
- pvc[i] += transp << 24;
- #endif
+ const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
+ if (anAttrib.Id == Graphic3d_TOA_COLOR)
+ {
+ return true;
+ }
}
+ return false;
}
- switch (myPArray->type)
+ virtual bool HasNormalAttribute() const
{
- case TelPointsArrayType:
- case TelPolylinesArrayType:
- case TelSegmentsArrayType:
- glColor3fv (theLineColour->rgb);
- break;
- case TelPolygonsArrayType:
- case TelTrianglesArrayType:
- case TelQuadranglesArrayType:
- case TelTriangleStripsArrayType:
- case TelQuadrangleStripsArrayType:
- case TelTriangleFansArrayType:
- glColor3fv (theInteriorColour->rgb);
- break;
- }
-
- // Temporarily disable environment mapping
- if (myDrawMode <= GL_LINE_STRIP)
- {
- glPushAttrib (GL_ENABLE_BIT);
- glDisable (GL_TEXTURE_1D);
- glDisable (GL_TEXTURE_2D);
- }
-
- if (theWorkspace->DegenerateModel < 2 &&
- ((myDrawMode > GL_LINE_STRIP && theInteriorStyle != Aspect_IS_EMPTY) ||
- (myDrawMode <= GL_LINE_STRIP)))
- {
- if (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)
- {
- pfc = NULL;
- pvc = NULL;
- }
-
- if (theInteriorStyle == Aspect_IS_HIDDENLINE)
- {
- theEdgeFlag = 1;
- pfc = NULL;
- pvc = NULL;
- }
-
- // Sometimes the GL_LIGHTING mode is activated here
- // without glEnable(GL_LIGHTING) call for an unknown reason, so it is necessary
- // to call glEnable(GL_LIGHTING) to synchronize Light On/Off mechanism*
- if (theLightingModel == 0 || myDrawMode <= GL_LINE_STRIP)
- glDisable (GL_LIGHTING);
- else
- glEnable (GL_LIGHTING);
-
- glGetIntegerv (GL_RENDER_MODE, &renderMode);
-
- if (myPArray->num_vertexs > 0
- && myPArray->flagBufferVBO != VBO_OK
- && renderMode != GL_FEEDBACK)
+ for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
{
- if (myPArray->vertices != NULL)
+ const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
+ if (anAttrib.Id == Graphic3d_TOA_NORM)
{
- glVertexPointer (3, GL_FLOAT, 0, myPArray->vertices); // array of vertices
- glEnableClientState (GL_VERTEX_ARRAY);
- }
- if (myPArray->vnormals != NULL)
- {
- glNormalPointer (GL_FLOAT, 0, myPArray->vnormals); // array of normals
- glEnableClientState (GL_NORMAL_ARRAY);
- }
- if (myPArray->vtexels != NULL)
- {
- glTexCoordPointer (2, GL_FLOAT, 0, myPArray->vtexels); // array of texture coordinates
- glEnableClientState (GL_TEXTURE_COORD_ARRAY);
- }
-
- if (pvc != NULL)
- {
- glColorPointer (4, GL_UNSIGNED_BYTE, 0, pvc); // array of colors
- glEnableClientState (GL_COLOR_ARRAY);
- glColorMaterial (GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
- glEnable (GL_COLOR_MATERIAL);
+ return true;
}
}
- else if (myPArray->num_vertexs > 0
- && myPArray->flagBufferVBO == VBO_OK)
+ return false;
+ }
+
+ virtual void BindPositionAttribute (const Handle(OpenGl_Context)& theGlCtx) const
+ {
+ if (!TheBaseClass::IsValid())
{
- // Bindings concrete pointer in accordance with VBO buffer
- if (myPArray->bufferVBO[VBOVertices] != 0)
- {
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOVertices]);
- glVertexPointer (3, GL_FLOAT, 0, NULL); // array of vertices
- glEnableClientState (GL_VERTEX_ARRAY);
- }
- if (myPArray->bufferVBO[VBOVnormals] != 0)
- {
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOVnormals]);
- glNormalPointer (GL_FLOAT, 0, NULL); // array of normals
- glEnableClientState (GL_NORMAL_ARRAY);
- }
- if (myPArray->bufferVBO[VBOVtexels] != 0 && (theWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0)
- {
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOVtexels]);
- glTexCoordPointer (2, GL_FLOAT, 0, NULL); // array of texture coordinates
- glEnableClientState (GL_TEXTURE_COORD_ARRAY);
- }
- if (myPArray->bufferVBO[VBOVcolours] != 0)
- {
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOVcolours]);
- glColorPointer (4, GL_UNSIGNED_BYTE, 0, NULL); // array of colors
- glEnableClientState (GL_COLOR_ARRAY);
- glColorMaterial (GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
- glEnable (GL_COLOR_MATERIAL);
- }
+ return;
}
- // OCC22236 NOTE: draw for all situations:
- // 1) draw elements from myPArray->bufferVBO[VBOEdges] indicies array
- // 2) draw elements from vertice array, when bounds defines count of primitive's verts.
- // 3) draw primitive by vertexes if no edges and bounds array is specified
- if (myPArray->flagBufferVBO == VBO_OK)
+ TheBaseClass::Bind (theGlCtx);
+ GLint aNbComp;
+ const GLubyte* anOffset = TheBaseClass::myOffset;
+ const Standard_Size aMuliplier = Stride != 0 ? 1 : TheBaseClass::myElemsNb;
+ for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
{
- if (myPArray->num_edges > 0 && myPArray->bufferVBO[VBOEdges] != 0)
+ const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
+ const GLenum aDataType = toGlDataType (anAttrib.DataType, aNbComp);
+ if (anAttrib.Id == Graphic3d_TOA_POS
+ && aDataType != GL_NONE)
{
- aGlContext->arbVBO->glBindBufferARB (GL_ELEMENT_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOEdges]); // for edge indices
- if (myPArray->num_bounds > 0)
- {
- // draw primitives by vertex count with the indicies
- Tint* anOffset = NULL;
- for (i = 0; i < myPArray->num_bounds; ++i)
- {
- glDrawElements (myDrawMode, myPArray->bounds[i], GL_UNSIGNED_INT, anOffset);
- anOffset += myPArray->bounds[i];
- }
- }
- else
- {
- // draw one (or sequential) primitive by the indicies
- glDrawElements (myDrawMode, myPArray->num_edges, GL_UNSIGNED_INT, NULL);
- }
- }
- else if (myPArray->num_bounds > 0)
- {
- for (i = n = 0; i < myPArray->num_bounds; ++i)
- {
- glDrawArrays (myDrawMode, n, myPArray->bounds[i]);
- n += myPArray->bounds[i];
- }
- }
- else
- {
- glDrawArrays (myDrawMode, 0, myPArray->num_vertexs);
+ TheBaseClass::bindAttribute (theGlCtx, Graphic3d_TOA_POS, aNbComp, aDataType, Stride, anOffset);
+ break;
}
- // bind with 0
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, 0);
- aGlContext->arbVBO->glBindBufferARB (GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
- }
- else
- {
- if (myPArray->num_bounds > 0)
- {
- if (myPArray->num_edges > 0)
- {
- for (i = n = 0; i < myPArray->num_bounds; ++i)
- {
- if (pfc != NULL) glColor3fv (pfc[i].rgb);
- DrawElements (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- myPArray->bounds[i], (GLenum* )&myPArray->edges[n]);
- n += myPArray->bounds[i];
- }
- }
- else
- {
- for (i = n = 0; i < myPArray->num_bounds; ++i)
- {
- if (pfc != NULL)
- {
- glColor3fv (pfc[i].rgb);
- }
- DrawArrays (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- n, myPArray->bounds[i]);
- n += myPArray->bounds[i];
- }
- }
- }
- else if (myPArray->num_edges > 0)
- {
- DrawElements (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- myPArray->num_edges, (GLenum* )myPArray->edges);
- }
- else
- {
- DrawArrays (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- 0, myPArray->num_vertexs);
- }
+ anOffset += aMuliplier * Graphic3d_Attribute::Stride (anAttrib.DataType);
}
+ }
- if (myPArray->bufferVBO[VBOVcolours] != 0 || pvc != NULL)
+ virtual void BindAllAttributes (const Handle(OpenGl_Context)& theGlCtx) const
+ {
+ if (!TheBaseClass::IsValid())
{
- glDisable (GL_COLOR_MATERIAL);
- theWorkspace->NamedStatus |= OPENGL_NS_RESMAT; // Reset material
+ return;
}
- if (myPArray->bufferVBO[VBOVertices] != 0 || myPArray->vertices != NULL)
- glDisableClientState (GL_VERTEX_ARRAY);
- if (myPArray->bufferVBO[VBOVcolours] != 0 || myPArray->vcolours != NULL)
- glDisableClientState (GL_COLOR_ARRAY);
- if (myPArray->bufferVBO[VBOVnormals] != 0 || myPArray->vnormals != NULL)
- glDisableClientState (GL_NORMAL_ARRAY);
- if ((myPArray->bufferVBO[VBOVtexels] != 0 && (theWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0) || myPArray->vtexels != NULL)
- glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-
- if (theWorkspace->DegenerateModel)
+ TheBaseClass::Bind (theGlCtx);
+ GLint aNbComp;
+ const GLubyte* anOffset = TheBaseClass::myOffset;
+ const Standard_Size aMuliplier = Stride != 0 ? 1 : TheBaseClass::myElemsNb;
+ for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
{
- if (myDrawMode <= GL_LINE_STRIP)
+ const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
+ const GLenum aDataType = toGlDataType (anAttrib.DataType, aNbComp);
+ if (aDataType != GL_NONE)
{
- glPopAttrib();
+ TheBaseClass::bindAttribute (theGlCtx, anAttrib.Id, aNbComp, aDataType, Stride, anOffset);
}
- return;
+ anOffset += aMuliplier * Graphic3d_Attribute::Stride (anAttrib.DataType);
}
}
- if (theEdgeFlag || theWorkspace->DegenerateModel)
+ virtual void UnbindAllAttributes (const Handle(OpenGl_Context)& theGlCtx) const
{
- switch (theWorkspace->DegenerateModel)
+ if (!TheBaseClass::IsValid())
{
- default: // XXX_TDM_NODE or TINY
- // On some NVIDIA graphic cards, using glEdgeFlagPointer() in
- // combination with VBO ( edge flag data put into a VBO buffer)
- // leads to a crash in a driver. Therefore, edge flags are simply
- // igonored when VBOs are enabled, so all the edges are drawn if
- // edge visibility is turned on. In order to draw edges selectively,
- // either disable VBO or turn off edge visibilty in the current
- // primitive array and create a separate primitive array (segments)
- // and put edges to be drawn into it.
- DrawEdges (theEdgeFlag ? theEdgeColour : theInteriorColour, theWorkspace);
- break;
- // DegenerateModel(as Lines, Points, BBoxs) are used only without VBO
- case 2: // XXX_TDM_WIREFRAME
- if (myPArray->VBOEnabled == 0)
- DrawDegeneratesAsLines ((theEdgeFlag ? theEdgeColour : theInteriorColour), theWorkspace);
- break;
- case 3: // XXX_TDM_MARKER
- if (myPArray->VBOEnabled == 0)
- DrawDegeneratesAsPoints ((theEdgeFlag ? theEdgeColour : theInteriorColour), theWorkspace->SkipRatio);
- break;
- case 4: // XXX_TDM_BBOX
- if (myPArray->VBOEnabled == 0)
- DrawDegeneratesAsBBoxs (theEdgeFlag ? theEdgeColour : theInteriorColour);
- break;
+ return;
}
- }
-
- if (myDrawMode <= GL_LINE_STRIP)
- glPopAttrib();
-}
-
-// =======================================================================
-// function : DrawEdges
-// purpose :
-// =======================================================================
-void OpenGl_PrimitiveArray::DrawEdges (const TEL_COLOUR* theEdgeColour,
- const Handle(OpenGl_Workspace)& theWorkspace) const
-{
- glDisable (GL_LIGHTING);
+ TheBaseClass::Unbind (theGlCtx);
- const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
- const OpenGl_AspectLine* anAspectLineOld = NULL;
- if (myDrawMode > GL_LINE_STRIP)
- {
- anAspectLineOld = theWorkspace->SetAspectLine (theWorkspace->AspectFace (Standard_True)->AspectEdge());
- theWorkspace->AspectLine (Standard_True);
-
- glPushAttrib (GL_POLYGON_BIT);
- glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
- }
-
- Tint i, j, n;
- GLint renderMode;
-
- // OCC22236 NOTE: draw edges for all situations:
- // 1) draw elements with GL_LINE style as edges from myPArray->bufferVBO[VBOEdges] indicies array
- // 2) draw elements from vertice array, when bounds defines count of primitive's verts.
- // 3) draw primitive's edges by vertexes if no edges and bounds array is specified
- if (myPArray->flagBufferVBO == VBO_OK)
- {
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOVertices]);
- glEnableClientState (GL_VERTEX_ARRAY);
- glColor3fv (theEdgeColour->rgb);
- if (myPArray->num_edges > 0 && myPArray->bufferVBO[VBOEdges])
- {
- aGlContext->arbVBO->glBindBufferARB (GL_ELEMENT_ARRAY_BUFFER_ARB, myPArray->bufferVBO[VBOEdges]);
-
- // draw primitives by vertex count with the indicies
- if (myPArray->num_bounds > 0)
- {
- Tint* offset = 0;
- for (i = 0, offset = 0; i < myPArray->num_bounds; ++i)
- {
- glDrawElements (myDrawMode, myPArray->bounds[i], GL_UNSIGNED_INT, offset);
- offset += myPArray->bounds[i];
- }
- }
- // draw one (or sequential) primitive by the indicies
- else
- {
- glDrawElements (myDrawMode, myPArray->num_edges, GL_UNSIGNED_INT, NULL);
- }
- }
- else if (myPArray->num_bounds > 0)
- {
- for (i = n = 0; i < myPArray->num_bounds; ++i)
- {
- glDrawArrays (myDrawMode, n, myPArray->bounds[i]);
- n += myPArray->bounds[i];
- }
- }
- else
+ for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
{
- glDrawArrays (myDrawMode, 0, myPArray->num_vertexs);
+ const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
+ TheBaseClass::unbindAttribute (theGlCtx, anAttrib.Id);
}
-
- // unbind buffers
- glDisableClientState (GL_VERTEX_ARRAY);
- aGlContext->arbVBO->glBindBufferARB (GL_ARRAY_BUFFER_ARB, 0);
- aGlContext->arbVBO->glBindBufferARB (GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
}
- else
- {
- glEnableClientState (GL_VERTEX_ARRAY);
- glVertexPointer (3, GL_FLOAT, 0, myPArray->vertices); // array of vertices
- glGetIntegerv (GL_RENDER_MODE, &renderMode);
- glColor3fv (theEdgeColour->rgb);
- if (myPArray->num_bounds > 0)
- {
- if (myPArray->num_edges > 0)
- {
- for (i = n = 0; i < myPArray->num_bounds; ++i)
- {
- if (myPArray->edge_vis)
- {
- glBegin (myDrawMode);
- for (j = 0; j < myPArray->bounds[i]; ++j)
- {
- glEdgeFlag (myPArray->edge_vis[n+j]);
- glVertex3fv (&myPArray->vertices[myPArray->edges[n+j]].xyz[0]);
- }
- glEnd();
- }
- else
- {
- DrawElements (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- myPArray->bounds[i], (GLenum* )&myPArray->edges[n]);
- }
- n += myPArray->bounds[i];
- }
- }
- else
- {
- for (i = n = 0 ; i < myPArray->num_bounds; ++i)
- {
- DrawArrays (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- n, myPArray->bounds[i]);
- n += myPArray->bounds[i];
- }
- }
- }
- else if (myPArray->num_edges > 0)
- {
- if (myPArray->edge_vis)
- {
- glBegin (myDrawMode);
- for (i = 0; i < myPArray->num_edges; ++i)
- {
- glEdgeFlag (myPArray->edge_vis[i]);
- glVertex3fv (&myPArray->vertices[myPArray->edges[i]].xyz[0]);
- }
- glEnd();
- }
- else
- {
- DrawElements (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- myPArray->num_edges, (GLenum* )myPArray->edges);
- }
- }
- else
- {
- DrawArrays (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- 0, myPArray->num_vertexs);
- }
- }
+private:
- if (myDrawMode > GL_LINE_STRIP)
- {
- // Restore line context
- theWorkspace->SetAspectLine (anAspectLineOld);
- glPopAttrib();
- }
-}
+ Graphic3d_Attribute Attribs[NbAttributes];
+ Standard_Integer Stride;
-// =======================================================================
-// function : DrawDegeneratesPointsAsPoints
-// purpose :
-// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesPointsAsPoints() const
-{
- tel_point pv = myPArray->vertices;
- for (Tint aVertId = 0; aVertId < myPArray->num_vertexs; ++aVertId)
- {
- glVertex3fv (&pv[aVertId].xyz[0]);
- }
-}
+};
// =======================================================================
-// function : DrawDegeneratesLinesAsPoints
+// function : clearMemoryGL
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesLinesAsPoints() const
+void OpenGl_PrimitiveArray::clearMemoryGL (const Handle(OpenGl_Context)& theGlCtx) const
{
- GLfloat pt[3];
- tel_point pv = myPArray->vertices;
-
- Tint j = 0;
- while (j < myPArray->num_vertexs)
+ if (!myVboIndices.IsNull())
{
- pt[0] = pv[j].xyz[0];
- pt[1] = pv[j].xyz[1];
- pt[2] = pv[j].xyz[2]; ++j;
- pt[0] += pv[j].xyz[0];
- pt[1] += pv[j].xyz[1];
- pt[2] += pv[j].xyz[2]; ++j;
- pt[0] *= 0.5f;
- pt[1] *= 0.5f;
- pt[2] *= 0.5f;
- glVertex3fv (pt);
+ myVboIndices->Release (theGlCtx.operator->());
+ myVboIndices.Nullify();
}
-}
+ if (!myVboAttribs.IsNull())
+ {
+ myVboAttribs->Release (theGlCtx.operator->());
+ myVboAttribs.Nullify();
+ }
+}
// =======================================================================
-// function : DrawDegeneratesTrianglesAsPoints
+// function : initNormalVbo
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesTrianglesAsPoints() const
+Standard_Boolean OpenGl_PrimitiveArray::initNormalVbo (const Handle(OpenGl_Context)& theCtx) const
{
- Tint i, j, iv;
- GLfloat pt[ 3 ];
- tel_point pv = myPArray->vertices;
-
- if (myPArray->num_edges > 0)
+ switch (myAttribs->NbAttributes)
{
- for (j = 0; j < myPArray->num_edges; j += 3)
- {
- iv = myPArray->edges[j];
- pt[0] = pv[iv].xyz[0];
- pt[1] = pv[iv].xyz[1];
- pt[2] = pv[iv].xyz[2];
- for (i = 1; i < 3; ++i)
- {
- iv = myPArray->edges[j+i];
- pt[0] += pv[iv].xyz[0];
- pt[1] += pv[iv].xyz[1];
- pt[2] += pv[iv].xyz[2];
- }
- pt[0] /= 3.f;
- pt[1] /= 3.f;
- pt[2] /= 3.f;
- glVertex3fv (pt);
- }
+ case 1: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 1> (*myAttribs); break;
+ case 2: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 2> (*myAttribs); break;
+ case 3: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 3> (*myAttribs); break;
+ case 4: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 4> (*myAttribs); break;
+ case 5: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 5> (*myAttribs); break;
+ case 6: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 6> (*myAttribs); break;
+ case 7: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 7> (*myAttribs); break;
+ case 8: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 8> (*myAttribs); break;
+ case 9: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 9> (*myAttribs); break;
+ case 10: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 10>(*myAttribs); break;
}
- else
+
+ const Standard_Boolean isAttribMutable = myAttribs->IsMutable();
+ const Standard_Boolean isAttribInterleaved = myAttribs->IsInterleaved();
+ if (myAttribs->NbElements != myAttribs->NbMaxElements()
+ && myIndices.IsNull()
+ && (!isAttribInterleaved || isAttribMutable))
{
- for (j = 0; j < myPArray->num_vertexs; j += 3)
- {
- pt[0] = pv[j].xyz[0];
- pt[1] = pv[j].xyz[1];
- pt[2] = pv[j].xyz[2];
- for (i = 1; i < 3; ++i)
- {
- pt[0] += pv[j+i].xyz[0];
- pt[1] += pv[j+i].xyz[1];
- pt[2] += pv[j+i].xyz[2];
- }
- pt[0] /= 3.f;
- pt[1] /= 3.f;
- pt[2] /= 3.f;
- glVertex3fv (pt);
- }
+ throw Standard_ProgramError ("OpenGl_PrimitiveArray::buildVBO() - vertex attribute data with reserved size is not supported");
}
-}
-// =======================================================================
-// function : DrawDegeneratesTrianglesAsPoints
-// purpose :
-// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesTrianglestripsAsPoints() const
-{
- Tint i, j, k, n;
- GLfloat pt[ 3 ];
- tel_point pv = myPArray->vertices;
-
- if (myPArray->num_bounds > 0)
+ // specify data type as Byte and NbComponents as Stride, so that OpenGl_VertexBuffer::EstimatedDataSize() will return correct value
+ const Standard_Integer aNbVertexes = (isAttribMutable || !isAttribInterleaved) ? myAttribs->NbMaxElements() : myAttribs->NbElements;
+ if (!myVboAttribs->init (theCtx, myAttribs->Stride, aNbVertexes, myAttribs->Data(), GL_UNSIGNED_BYTE, myAttribs->Stride))
{
- for (k = n = 0; k < myPArray->num_bounds; ++k)
- {
- for (j = 0; j < myPArray->bounds[k] - 2; ++j)
- {
- pt[0] = pv[n+j].xyz[0];
- pt[1] = pv[n+j].xyz[1];
- pt[2] = pv[n+j].xyz[2];
- for (i = 1; i < 3; ++i)
- {
- pt[0] += pv[n+j+i].xyz[0];
- pt[1] += pv[n+j+i].xyz[1];
- pt[2] += pv[n+j+i].xyz[2];
- }
- pt[0] /= 3.f;
- pt[1] /= 3.f;
- pt[2] /= 3.f;
- glVertex3fv (pt);
- }
- n += myPArray->bounds[k];
- }
+ TCollection_ExtendedString aMsg = TCollection_ExtendedString("VBO creation for Primitive Array has failed for ") + aNbVertexes + " vertices. Out of memory?";
+ theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PERFORMANCE, 0, GL_DEBUG_SEVERITY_LOW, aMsg);
+
+ clearMemoryGL (theCtx);
+ return Standard_False;
}
- else
+ else if (myIndices.IsNull())
{
- for (j = 0; j < myPArray->num_vertexs - 2; ++j)
+ if (isAttribMutable && isAttribInterleaved)
{
- pt[0] = pv[j].xyz[0];
- pt[1] = pv[j].xyz[1];
- pt[2] = pv[j].xyz[2];
- for (i = 1; i < 3; ++i)
- {
- pt[0] += pv[j+i].xyz[0];
- pt[1] += pv[j+i].xyz[1];
- pt[2] += pv[j+i].xyz[2];
- }
- pt[0] /= 3.f;
- pt[1] /= 3.f;
- pt[2] /= 3.f;
- glVertex3fv (pt);
+ // for mutable interlaced array we can change dynamically number of vertexes (they will be just skipped at the end of buffer);
+ // this doesn't matter in case if we have indexed array
+ myVboAttribs->SetElemsNb (myAttribs->NbElements);
}
+ return Standard_True;
}
-}
-
-// =======================================================================
-// function : DrawDegeneratesPolygonsAsPoints
-// purpose :
-// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesPolygonsAsPoints() const
-{
- Tint j, k, n, iv;
- GLfloat pt[3];
- tel_point pv = myPArray->vertices;
- if (myPArray->num_bounds > 0)
+ const Standard_Integer aNbIndexes = !myIndices->IsMutable() ? myIndices->NbElements : myIndices->NbMaxElements();
+ myVboIndices = new OpenGl_IndexBuffer();
+ bool isOk = false;
+ switch (myIndices->Stride)
{
- if (myPArray->num_edges > 0)
+ case 2:
{
- for (k = n = 0; k < myPArray->num_bounds; ++k)
- {
- pt[0] = pt[1] = pt[2] = 0.0;
- for (j = 0; j < myPArray->bounds[k]; ++j)
- {
- iv = myPArray->edges[n+j];
- pt[0] += pv[iv].xyz[0];
- pt[1] += pv[iv].xyz[1];
- pt[2] += pv[iv].xyz[2];
- }
- pt[0] /= myPArray->bounds[k];
- pt[1] /= myPArray->bounds[k];
- pt[2] /= myPArray->bounds[k];
- glVertex3fv (pt);
- n += myPArray->bounds[k];
- }
+ isOk = myVboIndices->Init (theCtx, 1, aNbIndexes, reinterpret_cast<const GLushort*> (myIndices->Data()));
+ myVboIndices->SetElemsNb (myIndices->NbElements);
+ myIndices->Validate();
+ break;
}
- else
+ case 4:
{
- for (k = n = 0; k < myPArray->num_bounds; ++k)
- {
- pt[0] = pt[1] = pt[2] = 0.0;
- for (j = 0; j < myPArray->bounds[k]; ++j)
- {
- pt[0] += pv[n+j].xyz[0];
- pt[1] += pv[n+j].xyz[1];
- pt[2] += pv[n+j].xyz[2];
- }
- pt[0] /= myPArray->bounds[k];
- pt[1] /= myPArray->bounds[k];
- pt[2] /= myPArray->bounds[k];
- glVertex3fv (pt);
- n += myPArray->bounds[k];
- }
+ isOk = myVboIndices->Init (theCtx, 1, aNbIndexes, reinterpret_cast<const GLuint*> (myIndices->Data()));
+ myVboIndices->SetElemsNb (myIndices->NbElements);
+ myIndices->Validate();
+ break;
}
- }
- else if (myPArray->num_edges > 0)
- {
- pt[0] = pt[1] = pt[2] = 0.0;
- for (j = 0; j < myPArray->num_edges; ++j)
+ default:
{
- iv = myPArray->edges[j];
- pt[0] += pv[iv].xyz[0];
- pt[1] += pv[iv].xyz[1];
- pt[2] += pv[iv].xyz[2];
+ clearMemoryGL (theCtx);
+ return Standard_False;
}
- pt[0] /= myPArray->num_edges;
- pt[1] /= myPArray->num_edges;
- pt[2] /= myPArray->num_edges;
- glVertex3fv (pt);
}
- else
+ if (!isOk)
{
- pt[0] = pt[1] = pt[2] = 0.0;
- for (j = 0; j < myPArray->num_vertexs; ++j)
- {
- pt[0] += pv[j].xyz[0];
- pt[1] += pv[j].xyz[1];
- pt[2] += pv[j].xyz[2];
- }
- pt[0] /= myPArray->num_vertexs;
- pt[1] /= myPArray->num_vertexs;
- pt[2] /= myPArray->num_vertexs;
- glVertex3fv (pt);
+ TCollection_ExtendedString aMsg = TCollection_ExtendedString("VBO creation for Primitive Array has failed for ") + aNbIndexes + " indices. Out of memory?";
+ theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PERFORMANCE, 0, GL_DEBUG_SEVERITY_LOW, aMsg);
+ clearMemoryGL (theCtx);
+ return Standard_False;
}
+ return Standard_True;
}
// =======================================================================
-// function : DrawDegeneratesQuadranglesAsPoints
+// function : buildVBO
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesQuadranglesAsPoints() const
+Standard_Boolean OpenGl_PrimitiveArray::buildVBO (const Handle(OpenGl_Context)& theCtx,
+ const Standard_Boolean theToKeepData) const
{
- Tint i, j, iv;
- GLfloat pt[ 3 ];
- tel_point pv = myPArray->vertices;
+ bool isNormalMode = theCtx->ToUseVbo();
+ clearMemoryGL (theCtx);
+ if (myAttribs.IsNull()
+ || myAttribs->IsEmpty()
+ || myAttribs->NbElements < 1
+ || myAttribs->NbAttributes < 1
+ || myAttribs->NbAttributes > 10)
+ {
+ // vertices should be always defined - others are optional
+ return Standard_False;
+ }
- if (myPArray->num_edges > 0)
+ if (isNormalMode
+ && initNormalVbo (theCtx))
{
- for (j = 0; j < myPArray->num_edges; j += 4)
+ if (!theCtx->caps->keepArrayData
+ && !theToKeepData
+ && !myAttribs->IsMutable())
{
- pt[0] = pt[1] = pt[2] = 0.0;
- for (i = 0; i < 4; ++i)
- {
- iv = myPArray->edges[j+i];
- pt[0] += pv[iv].xyz[0];
- pt[1] += pv[iv].xyz[1];
- pt[2] += pv[iv].xyz[2];
- }
- pt[0] /= 4;
- pt[1] /= 4;
- pt[2] /= 4;
- glVertex3fv ( pt );
+ myIndices.Nullify();
+ myAttribs.Nullify();
}
+ else
+ {
+ myAttribs->Validate();
+ }
+ return Standard_True;
}
- else
+
+ Handle(OpenGl_VertexBufferCompat) aVboAttribs;
+ switch (myAttribs->NbAttributes)
+ {
+ case 1: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 1> (*myAttribs); break;
+ case 2: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 2> (*myAttribs); break;
+ case 3: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 3> (*myAttribs); break;
+ case 4: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 4> (*myAttribs); break;
+ case 5: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 5> (*myAttribs); break;
+ case 6: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 6> (*myAttribs); break;
+ case 7: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 7> (*myAttribs); break;
+ case 8: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 8> (*myAttribs); break;
+ case 9: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 9> (*myAttribs); break;
+ case 10: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 10>(*myAttribs); break;
+ }
+ aVboAttribs->initLink (myAttribs, 0, myAttribs->NbElements, GL_NONE);
+ if (!myIndices.IsNull())
{
- for (j = 0; j < myPArray->num_vertexs; j += 4)
+ Handle(OpenGl_VertexBufferCompat) aVboIndices = new OpenGl_VertexBufferCompat();
+ switch (myIndices->Stride)
{
- pt[0] = pt[1] = pt[2] = 0.0;
- for (i = 0; i < 4; ++i)
+ case 2:
+ {
+ aVboIndices->initLink (myIndices, 1, myIndices->NbElements, GL_UNSIGNED_SHORT);
+ break;
+ }
+ case 4:
{
- pt[0] += pv[j+i].xyz[0];
- pt[1] += pv[j+i].xyz[1];
- pt[2] += pv[j+i].xyz[2];
+ aVboIndices->initLink (myIndices, 1, myIndices->NbElements, GL_UNSIGNED_INT);
+ break;
+ }
+ default:
+ {
+ return Standard_False;
}
- pt[0] /= 4;
- pt[1] /= 4;
- pt[2] /= 4;
- glVertex3fv (pt);
}
+ myVboIndices = aVboIndices;
+ }
+ myVboAttribs = aVboAttribs;
+ if (!theCtx->caps->keepArrayData
+ && !theToKeepData)
+ {
+ // does not make sense for compatibility mode
+ //myIndices.Nullify();
+ //myAttribs.Nullify();
}
-}
+
+ return Standard_True;
+}
// =======================================================================
-// function : DrawDegeneratesAsPoints
+// function : updateVBO
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesQuadranglestripsAsPoints() const
-{
- Tint i, j, k, n;
- GLfloat pt[3];
- tel_point pv = myPArray->vertices;
-
- if (myPArray->num_bounds > 0)
+void OpenGl_PrimitiveArray::updateVBO (const Handle(OpenGl_Context)& theCtx) const
+{
+ if (!myAttribs.IsNull())
{
- for (k = n = 0; k < myPArray->num_bounds; ++k)
+ Graphic3d_BufferRange aRange = myAttribs->InvalidatedRange();
+ if (!aRange.IsEmpty()
+ && myVboAttribs->IsValid()
+ && !myVboAttribs->IsVirtual())
{
- for (j = 0; j < myPArray->bounds[k] - 2; j += 2)
+ myVboAttribs->Bind (theCtx);
+ theCtx->core15fwd->glBufferSubData (myVboAttribs->GetTarget(),
+ aRange.Start,
+ aRange.Length,
+ myAttribs->Data() + aRange.Start);
+ myVboAttribs->Unbind (theCtx);
+ if (myAttribs->IsInterleaved())
{
- pt[0] = pt[1] = pt[2] = 0.;
- for (i = 0; i < 4; ++i)
- {
- pt[0] += pv[n+j+i].xyz[0];
- pt[1] += pv[n+j+i].xyz[1];
- pt[2] += pv[n+j+i].xyz[2];
- }
- pt[0] /= 4;
- pt[1] /= 4;
- pt[2] /= 4;
- glVertex3fv (pt);
+ myVboAttribs->SetElemsNb (myAttribs->NbElements);
}
- n += myPArray->bounds[k];
}
+ myAttribs->Validate();
}
- else
+ if (!myIndices.IsNull())
{
- for (j = 0; j < myPArray->num_vertexs - 2; j += 2)
+ Graphic3d_BufferRange aRange = myIndices->InvalidatedRange();
+ if (!aRange.IsEmpty()
+ && myVboIndices->IsValid()
+ && !myVboIndices->IsVirtual())
{
- pt[0] = pt[1] = pt[2] = 0.;
- for (i = 0; i < 4; ++i)
- {
- pt[0] += pv[j+i].xyz[0];
- pt[1] += pv[j+i].xyz[1];
- pt[2] += pv[j+i].xyz[2];
- }
- pt[0] /= 4;
- pt[1] /= 4;
- pt[2] /= 4;
- glVertex3fv (pt);
+ myVboIndices->Bind (theCtx);
+ theCtx->core15fwd->glBufferSubData (myVboIndices->GetTarget(),
+ aRange.Start,
+ aRange.Length,
+ myIndices->Data() + aRange.Start);
+ myVboIndices->Unbind (theCtx);
+ myVboIndices->SetElemsNb (myIndices->NbElements);
}
+ myIndices->Validate();
}
}
// =======================================================================
-// function : DrawDegeneratesAsPoints
+// function : drawArray
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesAsPoints (const TEL_COLOUR* theEdgeColour,
- const float theSkipRatio) const
+void OpenGl_PrimitiveArray::drawArray (const Handle(OpenGl_Workspace)& theWorkspace,
+ const Graphic3d_Vec4* theFaceColors,
+ const Standard_Boolean theHasVertColor) const
{
- if (theSkipRatio >= 1.0f)
- return;
-
- GLboolean zbuff_state = glIsEnabled (GL_DEPTH_TEST);
- glDisable (GL_LIGHTING);
- if (zbuff_state)
- glDisable (GL_DEPTH_TEST);
- glColor3fv (theEdgeColour->rgb);
-
- glBegin (GL_POINTS);
- switch (myDrawMode)
- {
- case GL_POINTS:
- DrawDegeneratesPointsAsPoints();
- break;
- case GL_LINES:
- DrawDegeneratesLinesAsPoints();
- break;
- case GL_LINE_STRIP:
- case GL_POLYGON:
- DrawDegeneratesPolygonsAsPoints();
- break;
- case GL_TRIANGLES:
- DrawDegeneratesTrianglesAsPoints();
- break;
- case GL_QUADS:
- DrawDegeneratesQuadranglesAsPoints();
- break;
- case GL_TRIANGLE_FAN:
- case GL_TRIANGLE_STRIP:
- DrawDegeneratesTrianglestripsAsPoints();
- break;
- case GL_QUAD_STRIP:
- DrawDegeneratesQuadranglestripsAsPoints();
- break;
- default:
- break;
- }
- glEnd();
- if (zbuff_state)
- glEnable (GL_DEPTH_TEST);
-}
-
-// =======================================================================
-// function : DrawDegeneratesLinesAsLines
-// purpose :
-// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesLinesAsLines (const float theSkipRatio) const
-{
- Tint i, iv;
- tel_point pv = myPArray->vertices;
-
- Tint n = myPArray->num_vertexs;
- Tint j = int((1.0f - theSkipRatio) * n);
- for (; j > 0; --j)
+ if (myVboAttribs.IsNull())
{
- i = OGL_Rand() % n;
- myPArray->keys[i] = -myPArray->keys[i];
+ #if !defined(GL_ES_VERSION_2_0)
+ if (myDrawMode == GL_POINTS)
+ {
+ // extreme compatibility mode - without sprites but with markers
+ drawMarkers (theWorkspace);
+ }
+ #endif
+ return;
}
- if (myPArray->num_bounds > 0)
- {
- if (myPArray->num_edges > 0)
+ const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
+ const bool toHilight = theWorkspace->ToHighlight();
+ const GLenum aDrawMode = !aGlContext->ActiveProgram().IsNull()
+ && aGlContext->ActiveProgram()->HasTessellationStage()
+ ? GL_PATCHES
+ : myDrawMode;
+ myVboAttribs->BindAllAttributes (aGlContext);
+ if (theHasVertColor && toHilight)
+ {
+ // disable per-vertex color
+ OpenGl_VertexBuffer::unbindAttribute (aGlContext, Graphic3d_TOA_COLOR);
+ }
+ if (!myVboIndices.IsNull())
+ {
+ myVboIndices->Bind (aGlContext);
+ GLubyte* anOffset = myVboIndices->GetDataOffset();
+ if (!myBounds.IsNull())
{
- for (i = n = 0; i < myPArray->num_bounds; ++i)
+ // draw primitives by vertex count with the indices
+ const size_t aStride = myVboIndices->GetDataType() == GL_UNSIGNED_SHORT ? sizeof(unsigned short) : sizeof(unsigned int);
+ for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
{
- glBegin (GL_LINES);
- for (j = 0; j < myPArray->bounds[i]; ++j)
- {
- iv = myPArray->edges[n + j];
- if (myPArray->keys[iv] < 0)
- {
- myPArray->keys[iv] = -myPArray->keys[iv];
- glVertex3fv (pv[iv].xyz);
- }
- }
- glEnd();
- n += myPArray->bounds[i];
+ const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
+ if (theFaceColors != NULL) aGlContext->SetColor4fv (theFaceColors[aGroupIter]);
+ glDrawElements (aDrawMode, aNbElemsInGroup, myVboIndices->GetDataType(), anOffset);
+ anOffset += aStride * aNbElemsInGroup;
}
}
else
{
- for (i = n = 0; i < myPArray->num_bounds; ++i)
- {
- glBegin (GL_LINES);
- for (j = 0; j < myPArray->bounds[i]; ++j)
- {
- if (myPArray->keys[n+j] < 0)
- {
- myPArray->keys[n+j] = -myPArray->keys[n+j];
- glVertex3fv (pv[n+j].xyz);
- }
- }
- glEnd();
- n += myPArray->bounds[i];
- }
+ // draw one (or sequential) primitive by the indices
+ glDrawElements (aDrawMode, myVboIndices->GetElemsNb(), myVboIndices->GetDataType(), anOffset);
}
+ myVboIndices->Unbind (aGlContext);
}
- else if (myPArray->num_edges > 0)
+ else if (!myBounds.IsNull())
{
- glBegin (GL_LINES);
- for (j = 0; j < myPArray->num_edges; ++j)
+ GLint aFirstElem = 0;
+ for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
{
- iv = myPArray->edges[j];
- if (myPArray->keys[iv] < 0)
- {
- myPArray->keys[iv] = -myPArray->keys[iv];
- glVertex3fv (pv[iv].xyz);
- }
+ const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
+ if (theFaceColors != NULL) aGlContext->SetColor4fv (theFaceColors[aGroupIter]);
+ glDrawArrays (aDrawMode, aFirstElem, aNbElemsInGroup);
+ aFirstElem += aNbElemsInGroup;
}
- glEnd();
}
else
{
- glBegin (GL_LINES);
- for (j = 0; j < myPArray->num_vertexs; ++j)
+ if (myDrawMode == GL_POINTS)
{
- if (myPArray->keys[j] < 0)
- {
- myPArray->keys[j] = -myPArray->keys[j];
- glVertex3fv (pv[j].xyz);
- }
+ drawMarkers (theWorkspace);
+ }
+ else
+ {
+ glDrawArrays (aDrawMode, 0, myVboAttribs->GetElemsNb());
}
- glEnd();
}
+
+ // bind with 0
+ myVboAttribs->UnbindAllAttributes (aGlContext);
}
// =======================================================================
-// function : DrawDegeneratesTrianglesAsLines
+// function : drawEdges
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesTrianglesAsLines (const float theSkipRatio) const
-{
- Tint i, iv;
- tel_point pv = myPArray->vertices;
-
- Tint n = myPArray->num_vertexs / 3;
- Tint j = int((1.0f - theSkipRatio) * n);
- for (; j > 0; --j)
+void OpenGl_PrimitiveArray::drawEdges (const Handle(OpenGl_Workspace)& theWorkspace) const
+{
+ const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
+ if (myVboAttribs.IsNull())
+ {
+ return;
+ }
+
+ const OpenGl_Aspects* anAspect = theWorkspace->Aspects();
+#if !defined(GL_ES_VERSION_2_0)
+ const Standard_Integer aPolyModeOld = aGlContext->SetPolygonMode (GL_LINE);
+#endif
+
+ if (aGlContext->core20fwd != NULL)
{
- i = OGL_Rand() % n; i *= 3;
- myPArray->keys[i] = -myPArray->keys[i];
+ aGlContext->ShaderManager()->BindLineProgram (Handle(OpenGl_TextureSet)(), anAspect->Aspect()->EdgeLineType(),
+ Graphic3d_TOSM_UNLIT, Graphic3d_AlphaMode_Opaque, Standard_False,
+ anAspect->ShaderProgramRes (aGlContext));
}
+ aGlContext->SetSampleAlphaToCoverage (aGlContext->ShaderManager()->MaterialState().HasAlphaCutoff());
+ const GLenum aDrawMode = !aGlContext->ActiveProgram().IsNull()
+ && aGlContext->ActiveProgram()->HasTessellationStage()
+ ? GL_PATCHES
+ : myDrawMode;
+#if !defined(GL_ES_VERSION_2_0)
+ if (aGlContext->ActiveProgram().IsNull()
+ && aGlContext->core11 != NULL)
+ {
+ glDisable (GL_LIGHTING);
+ }
+#endif
+
+ /// OCC22236 NOTE: draw edges for all situations:
+ /// 1) draw elements with GL_LINE style as edges from myPArray->bufferVBO[VBOEdges] indices array
+ /// 2) draw elements from vertex array, when bounds defines count of primitive's vertices.
+ /// 3) draw primitive's edges by vertexes if no edges and bounds array is specified
+ myVboAttribs->BindPositionAttribute (aGlContext);
+
+ aGlContext->SetColor4fv (theWorkspace->EdgeColor().a() >= 0.1f
+ ? theWorkspace->EdgeColor()
+ : theWorkspace->View()->BackgroundColor());
+ aGlContext->SetTypeOfLine (anAspect->Aspect()->EdgeLineType());
+ aGlContext->SetLineWidth (anAspect->Aspect()->EdgeWidth());
- if (myPArray->num_edges > 0)
+ if (!myVboIndices.IsNull())
{
- for (j = 0; j < myPArray->num_edges; j += 3)
+ myVboIndices->Bind (aGlContext);
+ GLubyte* anOffset = myVboIndices->GetDataOffset();
+
+ // draw primitives by vertex count with the indices
+ if (!myBounds.IsNull())
{
- iv = myPArray->edges[j];
- if (myPArray->keys[iv] < 0)
- {
- myPArray->keys[iv] = -myPArray->keys[iv];
- glBegin (GL_LINE_LOOP);
- for (i = 0; i < 3; ++i)
- {
- iv = myPArray->edges[j+i];
- glVertex3fv (pv[iv].xyz);
- }
- glEnd();
+ const size_t aStride = myVboIndices->GetDataType() == GL_UNSIGNED_SHORT ? sizeof(unsigned short) : sizeof(unsigned int);
+ for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
+ {
+ const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
+ glDrawElements (aDrawMode, aNbElemsInGroup, myVboIndices->GetDataType(), anOffset);
+ anOffset += aStride * aNbElemsInGroup;
}
}
+ // draw one (or sequential) primitive by the indices
+ else
+ {
+ glDrawElements (aDrawMode, myVboIndices->GetElemsNb(), myVboIndices->GetDataType(), anOffset);
+ }
+ myVboIndices->Unbind (aGlContext);
}
- else
+ else if (!myBounds.IsNull())
{
- for (j = 0; j < myPArray->num_vertexs; j += 3)
+ GLint aFirstElem = 0;
+ for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
{
- if (myPArray->keys[j] < 0)
- {
- myPArray->keys[j] = -myPArray->keys[j];
- glBegin (GL_LINE_LOOP);
- for (i = 0; i < 3; ++i)
- {
- glVertex3fv (pv[j+i].xyz);
- }
- glEnd();
- }
+ const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
+ glDrawArrays (aDrawMode, aFirstElem, aNbElemsInGroup);
+ aFirstElem += aNbElemsInGroup;
}
}
+ else
+ {
+ glDrawArrays (aDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
+ }
+
+ // unbind buffers
+ myVboAttribs->UnbindAttribute (aGlContext, Graphic3d_TOA_POS);
+
+ // restore line context
+#if !defined(GL_ES_VERSION_2_0)
+ aGlContext->SetPolygonMode (aPolyModeOld);
+#endif
}
// =======================================================================
-// function : DrawDegeneratesTrianglesAsLines
+// function : drawMarkers
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesTrianglestripsAsLines (const float theSkipRatio) const
-{
- Tint i, j, k, n, ni;
- tel_point pv = myPArray->vertices;
+void OpenGl_PrimitiveArray::drawMarkers (const Handle(OpenGl_Workspace)& theWorkspace) const
+{
+ const OpenGl_Aspects* anAspectMarker = theWorkspace->Aspects();
+ const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
+ const GLenum aDrawMode = !aCtx->ActiveProgram().IsNull()
+ && aCtx->ActiveProgram()->HasTessellationStage()
+ ? GL_PATCHES
+ : myDrawMode;
+ if (anAspectMarker->HasPointSprite (aCtx))
+ {
+ // Textured markers will be drawn with the point sprites
+ aCtx->SetPointSize (anAspectMarker->MarkerSize());
+ aCtx->SetPointSpriteOrigin();
+ #if !defined(GL_ES_VERSION_2_0)
+ if (aCtx->core11 != NULL)
+ {
+ aCtx->core11fwd->glEnable (GL_ALPHA_TEST);
+ aCtx->core11fwd->glAlphaFunc (GL_GEQUAL, 0.1f);
+ }
+ #endif
- if (myPArray->num_bounds > 0)
- {
- for (i = n = 0; i < myPArray->num_bounds; ++i)
+ aCtx->core11fwd->glEnable (GL_BLEND);
+ aCtx->core11fwd->glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ aCtx->core11fwd->glDrawArrays (aDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
+
+ aCtx->core11fwd->glDisable (GL_BLEND);
+ #if !defined(GL_ES_VERSION_2_0)
+ if (aCtx->core11 != NULL)
{
- ni = myPArray->bounds[i] - 2;
- k = int((1.0f - theSkipRatio) * ni);
- for (; k > 0; --k)
+ if (aCtx->ShaderManager()->MaterialState().AlphaCutoff() >= ShortRealLast())
{
- j = OGL_Rand() % ni; j += 2;
- myPArray->keys[n+j] = -myPArray->keys[n+j];
+ aCtx->core11fwd->glDisable (GL_ALPHA_TEST);
}
- for (j = 2; j < myPArray->bounds[i]; ++j)
+ else
{
- if (myPArray->keys[n+j] < 0)
- {
- myPArray->keys[n+j] = -myPArray->keys[n+j];
- glBegin (GL_LINE_LOOP);
- glVertex3fv (pv[n+j-2].xyz);
- glVertex3fv (pv[n+j-1].xyz);
- glVertex3fv (pv[n+j].xyz);
- glEnd();
- }
+ aCtx->core11fwd->glAlphaFunc (GL_GEQUAL, aCtx->ShaderManager()->MaterialState().AlphaCutoff());
}
- n += myPArray->bounds[i];
}
+ #endif
+ aCtx->SetPointSize (1.0f);
+ return;
}
- else
+ else if (anAspectMarker->Aspect()->MarkerType() == Aspect_TOM_POINT)
{
- ni = myPArray->num_vertexs - 2;
- k = int((1.0f - theSkipRatio) * ni);
- for (; k > 0; --k)
+ aCtx->SetPointSize (anAspectMarker->MarkerSize());
+ aCtx->core11fwd->glDrawArrays (aDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
+ aCtx->SetPointSize (1.0f);
+ }
+#if !defined(GL_ES_VERSION_2_0)
+ // Textured markers will be drawn with the glBitmap
+ else if (anAspectMarker->Aspect()->MarkerType() != Aspect_TOM_POINT)
+ {
+ const Handle(OpenGl_PointSprite)& aSpriteNorm = anAspectMarker->SpriteRes (aCtx, false);
+ if (aSpriteNorm.IsNull())
+ {
+ return;
+ }
+
+ /**if (!isHilight && (myPArray->vcolours != NULL))
{
- j = OGL_Rand() % ni; j += 2;
- myPArray->keys[j] = -myPArray->keys[j];
+ for (Standard_Integer anIter = 0; anIter < myAttribs->NbElements; anIter++)
+ {
+ glColor4ubv (myPArray->vcolours[anIter].GetData());
+ glRasterPos3fv (myAttribs->Value<Graphic3d_Vec3> (anIter).GetData());
+ aSpriteNorm->DrawBitmap (theWorkspace->GetGlContext());
+ }
}
- for (j = 2; j < myPArray->num_vertexs; ++j)
+ else*/
{
- if (myPArray->keys[j] < 0)
+ for (Standard_Integer anIter = 0; anIter < myAttribs->NbElements; anIter++)
{
- myPArray->keys[j] = -myPArray->keys[j];
- glBegin (GL_LINE_LOOP);
- glVertex3fv (pv[j-2].xyz);
- glVertex3fv (pv[j-1].xyz);
- glVertex3fv (pv[j].xyz);
- glEnd();
+ aCtx->core11->glRasterPos3fv (myAttribs->Value<Graphic3d_Vec3> (anIter).GetData());
+ aSpriteNorm->DrawBitmap (theWorkspace->GetGlContext());
}
}
}
+#endif
}
// =======================================================================
-// function : DrawDegeneratesPolygonsAsLines
+// function : OpenGl_PrimitiveArray
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesPolygonsAsLines (const float theSkipRatio) const
-{
- Tint i, iv;
- tel_point pv = myPArray->vertices;
-
- Tint n = myPArray->num_vertexs;
- Tint j = int((1.0f - theSkipRatio) * n);
- for (; j > 0; --j)
- {
- i = OGL_Rand() % n;
- myPArray->keys[i] = -myPArray->keys[i];
- }
+OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (const OpenGl_GraphicDriver* theDriver)
- if (myPArray->num_bounds > 0)
+: myDrawMode (DRAW_MODE_NONE),
+ myIsFillType(Standard_False),
+ myIsVboInit (Standard_False)
+{
+ if (theDriver != NULL)
{
- if (myPArray->num_edges > 0)
- {
- for (i = n = 0; i < myPArray->num_bounds; ++i)
- {
- glBegin (GL_LINE_LOOP);
- for (j = 0; j < myPArray->bounds[i]; ++j)
- {
- iv = myPArray->edges[n+j];
- if (myPArray->keys[iv] < 0)
- {
- myPArray->keys[iv] = -myPArray->keys[iv];
- glVertex3fv (pv[iv].xyz);
- }
- }
- glEnd();
- n += myPArray->bounds[i];
- }
- }
- else
- {
- for (i = n = 0; i < myPArray->num_bounds; ++i)
- {
- glBegin (GL_LINE_LOOP);
- for (j = 0; j < myPArray->bounds[i]; ++j)
- {
- if (myPArray->keys[n+j] < 0)
- {
- myPArray->keys[n+j] = -myPArray->keys[n+j];
- glVertex3fv (pv[n+j].xyz);
- }
- }
- glEnd();
- n += myPArray->bounds[i];
- }
- }
+ myUID = theDriver->GetNextPrimitiveArrayUID();
}
- else if (myPArray->num_edges > 0)
+}
+
+// =======================================================================
+// function : OpenGl_PrimitiveArray
+// purpose :
+// =======================================================================
+OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (const OpenGl_GraphicDriver* theDriver,
+ const Graphic3d_TypeOfPrimitiveArray theType,
+ const Handle(Graphic3d_IndexBuffer)& theIndices,
+ const Handle(Graphic3d_Buffer)& theAttribs,
+ const Handle(Graphic3d_BoundBuffer)& theBounds)
+
+: myIndices (theIndices),
+ myAttribs (theAttribs),
+ myBounds (theBounds),
+ myDrawMode (DRAW_MODE_NONE),
+ myIsFillType(Standard_False),
+ myIsVboInit (Standard_False)
+{
+ if (!myIndices.IsNull()
+ && myIndices->NbElements < 1)
{
- glBegin (GL_LINE_LOOP);
- for (j = 0; j < myPArray->num_edges; ++j)
- {
- iv = myPArray->edges[j];
- if (myPArray->keys[iv] < 0)
- {
- myPArray->keys[iv] = -myPArray->keys[iv];
- glVertex3fv (pv[iv].xyz);
- }
- }
- glEnd();
+ // dummy index buffer?
+ myIndices.Nullify();
}
- else
+
+ if (theDriver != NULL)
{
- glBegin (GL_LINE_LOOP);
- for (j = 0; j < myPArray->num_vertexs; ++j)
+ myUID = theDriver->GetNextPrimitiveArrayUID();
+ #if defined (GL_ES_VERSION_2_0)
+ const Handle(OpenGl_Context)& aCtx = theDriver->GetSharedContext();
+ if (!aCtx.IsNull())
{
- if (myPArray->keys[j] < 0)
- {
- myPArray->keys[j] = -myPArray->keys[j];
- glVertex3fv (pv[j].xyz);
- }
+ processIndices (aCtx);
}
- glEnd();
+ #endif
}
-}
+
+ setDrawMode (theType);
+}
// =======================================================================
-// function : DrawDegeneratesQuadranglesAsLines
+// function : ~OpenGl_PrimitiveArray
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesQuadranglesAsLines (const float theSkipRatio) const
+OpenGl_PrimitiveArray::~OpenGl_PrimitiveArray()
{
- Tint i, iv;
- tel_point pv = myPArray->vertices;
-
- Tint n = myPArray->num_vertexs / 4;
- Tint j = int((1.0f - theSkipRatio) * n);
- for (; j > 0; --j)
- {
- i = OGL_Rand() % n; i *= 4;
- myPArray->keys[i] = -myPArray->keys[i];
- }
+ //
+}
- if (myPArray->num_edges > 0)
+// =======================================================================
+// function : Release
+// purpose :
+// =======================================================================
+void OpenGl_PrimitiveArray::Release (OpenGl_Context* theContext)
+{
+ myIsVboInit = Standard_False;
+ if (!myVboIndices.IsNull())
{
- for (j = 0; j < myPArray->num_edges; j += 4)
+ if (theContext)
{
- iv = myPArray->edges[j];
- if (myPArray->keys[iv] < 0)
- {
- myPArray->keys[iv] = -myPArray->keys[iv];
- glBegin (GL_LINE_LOOP);
- for (i = 0; i < 4; ++i)
- {
- iv = myPArray->edges[j+i];
- glVertex3fv (pv[iv].xyz);
- }
- glEnd();
- }
+ theContext->DelayedRelease (myVboIndices);
}
+ myVboIndices.Nullify();
}
- else
+ if (!myVboAttribs.IsNull())
{
- for (j = 0; j < myPArray->num_vertexs; j += 4)
+ if (theContext)
{
- if (myPArray->keys[j] < 0)
- {
- myPArray->keys[j] = -myPArray->keys[j];
- glBegin (GL_LINE_LOOP);
- for (i = 0; i < 4; ++i)
- {
- glVertex3fv (pv[j+i].xyz);
- }
- glEnd();
- }
+ theContext->DelayedRelease (myVboAttribs);
}
+ myVboAttribs.Nullify();
}
}
// =======================================================================
-// function : DrawDegeneratesQuadranglesAsLines
+// function : Render
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesQuadranglestripsAsLines (const float theSkipRatio) const
-{
- Tint i, j, k, n, ni;
- tel_point pv = myPArray->vertices;
+void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
+{
+ if (myDrawMode == DRAW_MODE_NONE)
+ {
+ return;
+ }
- if (myPArray->num_bounds > 0)
+ const OpenGl_Aspects* anAspectFace = theWorkspace->ApplyAspects();
+ const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
+
+ const bool toEnableEnvMap = !aCtx->ActiveTextures().IsNull()
+ && aCtx->ActiveTextures() == theWorkspace->EnvironmentTexture();
+ bool toDrawArray = true;
+ int toDrawInteriorEdges = 0; // 0 - no edges, 1 - glsl edges, 2 - polygonMode
+ if (myIsFillType)
{
- for (i = n = 0; i < myPArray->num_bounds; ++i)
+ toDrawArray = anAspectFace->Aspect()->InteriorStyle() != Aspect_IS_EMPTY;
+ if (anAspectFace->Aspect()->ToDrawEdges())
{
- ni = myPArray->bounds[i] / 2 - 2;
- k = int((1.0f - theSkipRatio) * ni);
- for (; k > 0; --k)
- {
- j = OGL_Rand() % ni; j = j * 2 + 2;
- myPArray->keys[n+j] = -myPArray->keys[n+j];
- }
- for (j = 3; j < myPArray->bounds[i]; j += 2)
+ toDrawInteriorEdges = 1;
+ toDrawArray = true;
+ #if !defined(GL_ES_VERSION_2_0)
+ if (anAspectFace->Aspect()->EdgeLineType() != Aspect_TOL_SOLID
+ || aCtx->hasGeometryStage == OpenGl_FeatureNotAvailable
+ || aCtx->caps->usePolygonMode)
{
- if (myPArray->keys[n+j] < 0)
+ toDrawInteriorEdges = 2;
+ if (anAspectFace->Aspect()->InteriorStyle() == Aspect_IS_EMPTY)
{
- myPArray->keys[n+j] = -myPArray->keys[n+j];
- glBegin (GL_LINE_LOOP);
- glVertex3fv (pv[n+j-3].xyz);
- glVertex3fv (pv[n+j-2].xyz);
- glVertex3fv (pv[n+j-1].xyz);
- glVertex3fv (pv[n+j].xyz);
- glEnd();
+ if (anAspectFace->Aspect()->EdgeLineType() != Aspect_TOL_SOLID)
+ {
+ toDrawArray = false;
+ }
+ else
+ {
+ aCtx->SetPolygonMode (GL_LINE);
+ }
}
}
- n += myPArray->bounds[i];
+ #endif
}
}
else
{
- ni = myPArray->num_vertexs / 2 - 2;
- k = int((1.0f - theSkipRatio) * ni);
- for (; k > 0; --k)
+ if (myDrawMode == GL_POINTS)
{
- j = OGL_Rand() % ni; j = j * 2 + 2;
- myPArray->keys[j] = -myPArray->keys[j];
+ if (anAspectFace->Aspect()->MarkerType() == Aspect_TOM_EMPTY)
+ {
+ return;
+ }
}
- for (j = 3; j < myPArray->num_vertexs; j += 2)
+ else
{
- if (myPArray->keys[j] < 0)
+ if (anAspectFace->Aspect()->LineType() == Aspect_TOL_EMPTY)
{
- myPArray->keys[j] = -myPArray->keys[j];
- glBegin (GL_LINE_LOOP);
- glVertex3fv (pv[j-3].xyz);
- glVertex3fv (pv[j-2].xyz);
- glVertex3fv (pv[j-1].xyz);
- glVertex3fv (pv[j].xyz);
- glEnd();
+ return;
}
}
}
-}
-
-// =======================================================================
-// function : DrawDegeneratesAsLines
-// purpose :
-// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesAsLines (const TEL_COLOUR* theEdgeColour,
- const Handle(OpenGl_Workspace)& theWorkspace) const
-{
- const float aSkipRatio = theWorkspace->SkipRatio;
- GLboolean zbuff_state = glIsEnabled (GL_DEPTH_TEST);
-
- glDisable (GL_LIGHTING);
-
- if (zbuff_state)
- glDisable (GL_DEPTH_TEST);
-
- glColor3fv (theEdgeColour->rgb);
+ // create VBOs on first render call
+ if (!myIsVboInit)
+ {
+ // compatibility - keep data to draw markers using display lists
+ Standard_Boolean toKeepData = myDrawMode == GL_POINTS
+ && anAspectFace->IsDisplayListSprite (aCtx);
+ #if defined (GL_ES_VERSION_2_0)
+ processIndices (aCtx);
+ #endif
+ buildVBO (aCtx, toKeepData);
+ myIsVboInit = Standard_True;
+ }
+ else if ((!myAttribs.IsNull()
+ && myAttribs->IsMutable())
+ || (!myIndices.IsNull()
+ && myIndices->IsMutable()))
+ {
+ updateVBO (aCtx);
+ }
- if (aSkipRatio != 0.0f)
+ Graphic3d_TypeOfShadingModel aShadingModel = Graphic3d_TOSM_UNLIT;
+ if (toDrawArray)
{
+ const bool hasColorAttrib = !myVboAttribs.IsNull()
+ && myVboAttribs->HasColorAttribute();
+ const bool toHilight = theWorkspace->ToHighlight();
+ const bool hasVertColor = hasColorAttrib && !toHilight;
+ const bool hasVertNorm = !myVboAttribs.IsNull() && myVboAttribs->HasNormalAttribute();
switch (myDrawMode)
{
case GL_POINTS:
- if (aSkipRatio < 1.0f)
- DrawDegeneratesPointsAsPoints();
+ {
+ aShadingModel = aCtx->ShaderManager()->ChooseMarkerShadingModel (anAspectFace->ShadingModel(), hasVertNorm);
+ aCtx->ShaderManager()->BindMarkerProgram (aCtx->ActiveTextures(),
+ aShadingModel, Graphic3d_AlphaMode_Opaque,
+ hasVertColor, anAspectFace->ShaderProgramRes (aCtx));
break;
+ }
case GL_LINES:
- DrawDegeneratesLinesAsLines (aSkipRatio);
- break;
case GL_LINE_STRIP:
- case GL_POLYGON:
- DrawDegeneratesPolygonsAsLines (aSkipRatio);
- break;
- case GL_TRIANGLES:
- DrawDegeneratesTrianglesAsLines (aSkipRatio);
- break;
- case GL_QUADS:
- DrawDegeneratesQuadranglesAsLines (aSkipRatio);
- break;
- case GL_TRIANGLE_FAN:
- case GL_TRIANGLE_STRIP:
- DrawDegeneratesTrianglestripsAsLines (aSkipRatio);
- break;
- case GL_QUAD_STRIP:
- DrawDegeneratesQuadranglestripsAsLines (aSkipRatio);
+ {
+ aShadingModel = aCtx->ShaderManager()->ChooseLineShadingModel (anAspectFace->ShadingModel(), hasVertNorm);
+ aCtx->ShaderManager()->BindLineProgram (Handle(OpenGl_TextureSet)(),
+ anAspectFace->Aspect()->LineType(),
+ aShadingModel,
+ Graphic3d_AlphaMode_Opaque,
+ hasVertColor,
+ anAspectFace->ShaderProgramRes (aCtx));
break;
+ }
default:
+ {
+ aShadingModel = aCtx->ShaderManager()->ChooseFaceShadingModel (anAspectFace->ShadingModel(), hasVertNorm);
+ aCtx->ShaderManager()->BindFaceProgram (aCtx->ActiveTextures(),
+ aShadingModel,
+ aCtx->ShaderManager()->MaterialState().HasAlphaCutoff() ? Graphic3d_AlphaMode_Mask : Graphic3d_AlphaMode_Opaque,
+ toDrawInteriorEdges == 1 ? anAspectFace->Aspect()->InteriorStyle() : Aspect_IS_SOLID,
+ hasVertColor,
+ toEnableEnvMap,
+ toDrawInteriorEdges == 1,
+ anAspectFace->ShaderProgramRes (aCtx));
+ if (toDrawInteriorEdges == 1)
+ {
+ aCtx->ShaderManager()->PushInteriorState (aCtx->ActiveProgram(), anAspectFace->Aspect());
+ }
break;
+ }
}
- }
- else
- {
- int i,n;
- glPushAttrib (GL_POLYGON_BIT);
- glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
-
- GLboolean color_array_mode = glIsEnabled (GL_COLOR_ARRAY);
- GLboolean edge_flag_array_mode = glIsEnabled (GL_EDGE_FLAG_ARRAY);
- GLboolean index_array_mode = glIsEnabled (GL_INDEX_ARRAY);
- GLboolean normal_array_mode = glIsEnabled (GL_NORMAL_ARRAY);
- GLboolean texture_coord_array_mode = glIsEnabled (GL_TEXTURE_COORD_ARRAY);
- GLboolean vertex_array_mode = glIsEnabled (GL_VERTEX_ARRAY);
-
- glDisableClientState (GL_COLOR_ARRAY);
- glDisableClientState (GL_EDGE_FLAG_ARRAY);
- glDisableClientState (GL_INDEX_ARRAY);
- glDisableClientState (GL_NORMAL_ARRAY);
- glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-
- if (!vertex_array_mode)
- glEnableClientState (GL_VERTEX_ARRAY);
-
- glVertexPointer (3, GL_FLOAT, 0, myPArray->vertices); // array of vertices
- GLint renderMode;
- glGetIntegerv (GL_RENDER_MODE, &renderMode);
-
- if (myPArray->num_bounds > 0)
+ #if !defined(GL_ES_VERSION_2_0)
+ // manage FFP lighting
+ if (aCtx->ActiveProgram().IsNull()
+ && aCtx->core11 != NULL)
{
- if (myPArray->num_edges > 0)
+ if (aShadingModel == Graphic3d_TOSM_UNLIT)
{
- for (i = n = 0; i < myPArray->num_bounds; ++i)
- {
- DrawElements (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- myPArray->bounds[i], (GLenum* )&myPArray->edges[n]);
- n += myPArray->bounds[i];
- }
+ glDisable (GL_LIGHTING);
}
else
{
- for (i = n = 0; i < myPArray->num_bounds; ++i)
- {
- DrawArrays (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- n, myPArray->bounds[i]);
- n += myPArray->bounds[i];
- }
+ glEnable (GL_LIGHTING);
}
}
- else if (myPArray->num_edges > 0)
+ #endif
+
+ if (!aCtx->ActiveTextures().IsNull()
+ && !aCtx->ActiveTextures()->IsEmpty()
+ && !aCtx->ActiveTextures()->First().IsNull()
+ && myDrawMode != GL_POINTS) // transformation is not supported within point sprites
{
- DrawElements (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- myPArray->num_edges, (GLenum* )myPArray->edges);
+ aCtx->SetTextureMatrix (aCtx->ActiveTextures()->First()->Sampler()->Parameters());
}
- else
+ aCtx->SetSampleAlphaToCoverage (aCtx->ShaderManager()->MaterialState().HasAlphaCutoff());
+
+ const Graphic3d_Vec4* aFaceColors = !myBounds.IsNull() && !toHilight && anAspectFace->Aspect()->InteriorStyle() != Aspect_IS_HIDDENLINE
+ ? myBounds->Colors
+ : NULL;
+ const OpenGl_Vec4& anInteriorColor = theWorkspace->InteriorColor();
+ aCtx->SetColor4fv (anInteriorColor);
+ if (!myIsFillType)
{
- DrawArrays (theWorkspace, myPArray, (renderMode == GL_FEEDBACK), myDrawMode,
- 0, myPArray->num_vertexs);
- }
-
- if (!vertex_array_mode) glDisableClientState (GL_VERTEX_ARRAY);
+ if (myDrawMode == GL_LINES
+ || myDrawMode == GL_LINE_STRIP)
+ {
+ aCtx->SetTypeOfLine (anAspectFace->Aspect()->LineType());
+ aCtx->SetLineWidth (anAspectFace->Aspect()->LineWidth());
+ }
- if (color_array_mode) glEnableClientState (GL_COLOR_ARRAY);
- if (edge_flag_array_mode) glEnableClientState (GL_EDGE_FLAG_ARRAY);
- if (index_array_mode) glEnableClientState (GL_INDEX_ARRAY);
- if (normal_array_mode) glEnableClientState (GL_NORMAL_ARRAY);
- if (texture_coord_array_mode) glEnableClientState (GL_TEXTURE_COORD_ARRAY);
+ drawArray (theWorkspace, aFaceColors, hasColorAttrib);
+ return;
+ }
- glPopAttrib();
- }
+ drawArray (theWorkspace, aFaceColors, hasColorAttrib);
- if (zbuff_state)
- glEnable(GL_DEPTH_TEST);
-}
+ // draw outline - only closed triangulation with defined vertex normals can be drawn in this way
+ if (anAspectFace->Aspect()->ToDrawSilhouette()
+ && aCtx->ToCullBackFaces()
+ && aCtx->ShaderManager()->BindOutlineProgram())
+ {
+ const Graphic3d_Vec2i aViewSize (aCtx->Viewport()[2], aCtx->Viewport()[3]);
+ const Standard_Integer aMin = aViewSize.minComp();
+ const GLfloat anEdgeWidth = (GLfloat )anAspectFace->Aspect()->EdgeWidth() * aCtx->LineWidthScale() / (GLfloat )aMin;
+ const GLfloat anOrthoScale = theWorkspace->View()->Camera()->IsOrthographic() ? (GLfloat )theWorkspace->View()->Camera()->Scale() : -1.0f;
-// =======================================================================
-// function : DrawDegeneratesAsBBoxs
-// purpose :
-// =======================================================================
-void OpenGl_PrimitiveArray::DrawDegeneratesAsBBoxs (const TEL_COLOUR* theEdgeColour) const
-{
- GLfloat minp[3] = { FLT_MAX, FLT_MAX, FLT_MAX };
- GLfloat maxp[3] = { FLT_MIN, FLT_MIN, FLT_MIN };
- tel_point pv = myPArray->vertices;
+ const Handle(OpenGl_ShaderProgram)& anOutlineProgram = aCtx->ActiveProgram();
+ anOutlineProgram->SetUniform (aCtx, anOutlineProgram->GetStateLocation (OpenGl_OCCT_SILHOUETTE_THICKNESS), anEdgeWidth);
+ anOutlineProgram->SetUniform (aCtx, anOutlineProgram->GetStateLocation (OpenGl_OCCT_ORTHO_SCALE), anOrthoScale);
+ aCtx->SetColor4fv (anAspectFace->Aspect()->EdgeColorRGBA());
- glDisable (GL_LIGHTING);
+ aCtx->core11fwd->glCullFace (GL_FRONT);
+ drawArray (theWorkspace, NULL, false);
- glColor3fv (theEdgeColour->rgb);
+ aCtx->core11fwd->glCullFace (GL_BACK);
+ }
+ }
- for (Tint i = 0; i < myPArray->num_vertexs; ++i)
+#if !defined(GL_ES_VERSION_2_0)
+ // draw triangulation edges using Polygon Mode
+ if (toDrawInteriorEdges == 2)
{
- if (pv[i].xyz[0] < minp[0])
- minp[0] = pv[i].xyz[0];
- if (pv[i].xyz[1] < minp[1])
- minp[1] = pv[i].xyz[1];
- if (pv[i].xyz[2] < minp[2])
- minp[2] = pv[i].xyz[2];
-
- if (pv[i].xyz[0] > maxp[0])
- maxp[0] = pv[i].xyz[0];
- if (pv[i].xyz[1] > maxp[1])
- maxp[1] = pv[i].xyz[1];
- if (pv[i].xyz[2] > maxp[2])
- maxp[2] = pv[i].xyz[2];
+ if (anAspectFace->Aspect()->InteriorStyle() == Aspect_IS_HOLLOW
+ && anAspectFace->Aspect()->EdgeLineType() == Aspect_TOL_SOLID)
+ {
+ aCtx->SetPolygonMode (GL_FILL);
+ }
+ else
+ {
+ drawEdges (theWorkspace);
+ }
}
-
- glBegin (GL_LINE_STRIP);
-
- glVertex3fv (minp);
- glVertex3f (minp[0], maxp[1], minp[2]);
- glVertex3f (minp[0], maxp[1], maxp[2]);
- glVertex3f (minp[0], minp[1], maxp[2]);
- glVertex3f (minp[0], minp[1], minp[2]);
-
- glVertex3f (maxp[0], minp[1], minp[2]);
- glVertex3f (maxp[0], maxp[1], minp[2]);
- glVertex3f (maxp[0], maxp[1], maxp[2]);
- glVertex3f (maxp[0], minp[1], maxp[2]);
- glVertex3f (maxp[0], minp[1], minp[2]);
-
- glVertex3f (maxp[0], minp[1], maxp[2]);
- glVertex3f (minp[0], minp[1], maxp[2]);
- glVertex3f (minp[0], maxp[1], maxp[2]);
- glVertex3fv (maxp);
- glVertex3f (maxp[0], maxp[1], minp[2]);
- glVertex3f (minp[0], maxp[1], minp[2]);
-
- glEnd();
+#endif
}
// =======================================================================
-// function : OpenGl_PrimitiveArray
+// function : setDrawMode
// purpose :
// =======================================================================
-OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (CALL_DEF_PARRAY* thePArray)
-: myPArray (thePArray),
- myDrawMode (GL_NONE)
+void OpenGl_PrimitiveArray::setDrawMode (const Graphic3d_TypeOfPrimitiveArray theType)
{
- switch (myPArray->type)
+ if (myAttribs.IsNull())
{
- case TelPointsArrayType:
- myDrawMode = GL_POINTS;
+ myDrawMode = DRAW_MODE_NONE;
+ myIsFillType = false;
+ return;
+ }
+
+ switch (theType)
+ {
+ case Graphic3d_TOPA_POINTS:
+ myDrawMode = GL_POINTS;
+ myIsFillType = false;
break;
- case TelPolylinesArrayType:
- myDrawMode = GL_LINE_STRIP;
+ case Graphic3d_TOPA_SEGMENTS:
+ myDrawMode = GL_LINES;
+ myIsFillType = false;
break;
- case TelSegmentsArrayType:
- myDrawMode = GL_LINES;
+ case Graphic3d_TOPA_POLYLINES:
+ myDrawMode = GL_LINE_STRIP;
+ myIsFillType = false;
break;
- case TelPolygonsArrayType:
- myDrawMode = GL_POLYGON;
+ case Graphic3d_TOPA_TRIANGLES:
+ myDrawMode = GL_TRIANGLES;
+ myIsFillType = true;
break;
- case TelTrianglesArrayType:
- myDrawMode = GL_TRIANGLES;
+ case Graphic3d_TOPA_TRIANGLESTRIPS:
+ myDrawMode = GL_TRIANGLE_STRIP;
+ myIsFillType = true;
break;
- case TelQuadranglesArrayType:
- myDrawMode = GL_QUADS;
+ case Graphic3d_TOPA_TRIANGLEFANS:
+ myDrawMode = GL_TRIANGLE_FAN;
+ myIsFillType = true;
break;
- case TelTriangleStripsArrayType:
- myDrawMode = GL_TRIANGLE_STRIP;
+ //
+ case Graphic3d_TOPA_LINES_ADJACENCY:
+ myDrawMode = GL_LINES_ADJACENCY;
+ myIsFillType = false;
break;
- case TelQuadrangleStripsArrayType:
- myDrawMode = GL_QUAD_STRIP;
+ case Graphic3d_TOPA_LINE_STRIP_ADJACENCY:
+ myDrawMode = GL_LINE_STRIP_ADJACENCY;
+ myIsFillType = false;
break;
- case TelTriangleFansArrayType:
- myDrawMode = GL_TRIANGLE_FAN;
+ case Graphic3d_TOPA_TRIANGLES_ADJACENCY:
+ myDrawMode = GL_TRIANGLES_ADJACENCY;
+ myIsFillType = true;
+ break;
+ case Graphic3d_TOPA_TRIANGLE_STRIP_ADJACENCY:
+ myDrawMode = GL_TRIANGLE_STRIP_ADJACENCY;
+ myIsFillType = true;
+ break;
+ //
+ #if !defined(GL_ES_VERSION_2_0)
+ case Graphic3d_TOPA_QUADRANGLES:
+ myDrawMode = GL_QUADS;
+ myIsFillType = true;
+ break;
+ case Graphic3d_TOPA_QUADRANGLESTRIPS:
+ myDrawMode = GL_QUAD_STRIP;
+ myIsFillType = true;
+ break;
+ case Graphic3d_TOPA_POLYGONS:
+ myDrawMode = GL_POLYGON;
+ myIsFillType = true;
+ break;
+ #else
+ case Graphic3d_TOPA_QUADRANGLES:
+ case Graphic3d_TOPA_QUADRANGLESTRIPS:
+ case Graphic3d_TOPA_POLYGONS:
+ #endif
+ case Graphic3d_TOPA_UNDEFINED:
+ myDrawMode = DRAW_MODE_NONE;
+ myIsFillType = false;
break;
}
}
// =======================================================================
-// function : ~OpenGl_PrimitiveArray
-// purpose :
-// =======================================================================
-OpenGl_PrimitiveArray::~OpenGl_PrimitiveArray ()
-{
- if (myPArray == NULL)
- return;
-
- if (myPArray->VBOEnabled == VBO_OK)
- {
- OpenGl_ResourceCleaner* aResCleaner = OpenGl_ResourceCleaner::GetInstance();
- if (myPArray->bufferVBO[VBOEdges] != 0)
- aResCleaner->AddResource ((GLCONTEXT )myPArray->contextId,
- new OpenGl_ResourceVBO (myPArray->bufferVBO[VBOEdges]));
- if (myPArray->bufferVBO[VBOVertices] != 0)
- aResCleaner->AddResource ((GLCONTEXT )myPArray->contextId,
- new OpenGl_ResourceVBO (myPArray->bufferVBO[VBOVertices]));
- if (myPArray->bufferVBO[VBOVcolours] != 0)
- aResCleaner->AddResource ((GLCONTEXT )myPArray->contextId,
- new OpenGl_ResourceVBO (myPArray->bufferVBO[VBOVcolours]));
- if (myPArray->bufferVBO[VBOVnormals] != 0)
- aResCleaner->AddResource ((GLCONTEXT )myPArray->contextId,
- new OpenGl_ResourceVBO (myPArray->bufferVBO[VBOVnormals]));
- if (myPArray->bufferVBO[VBOVtexels] != 0)
- aResCleaner->AddResource ((GLCONTEXT )myPArray->contextId,
- new OpenGl_ResourceVBO (myPArray->bufferVBO[VBOVtexels]));
- }
-}
-
-// =======================================================================
-// function : Render
+// function : processIndices
// purpose :
// =======================================================================
-void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
+Standard_Boolean OpenGl_PrimitiveArray::processIndices (const Handle(OpenGl_Context)& theContext) const
{
- if (myPArray == NULL || myDrawMode == GL_NONE)
- return;
-
- // create VBOs on first render call
- if (myPArray->VBOEnabled == -1) // special value for uninitialized state
+ if (myIndices.IsNull()
+ || myAttribs.IsNull()
+ || theContext->hasUintIndex)
{
- myPArray->VBOEnabled = OpenGl_GraphicDriver::ToUseVBO() && (theWorkspace->GetGlContext()->arbVBO != NULL);
- if (myPArray->VBOEnabled != 0)
- BuildVBO (theWorkspace);
+ return Standard_True;
}
- switch (myPArray->type)
+ if (myAttribs->NbElements > std::numeric_limits<GLushort>::max())
{
- case TelPointsArrayType:
- case TelPolylinesArrayType:
- case TelSegmentsArrayType:
+ Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (new NCollection_AlignedAllocator (16));
+ if (!anAttribs->Init (myIndices->NbElements, myAttribs->AttributesArray(), myAttribs->NbAttributes))
{
- glDisable (GL_LIGHTING);
-
- if ((theWorkspace->NamedStatus & OPENGL_NS_ANIMATION) != 0 &&
- (theWorkspace->NamedStatus & OPENGL_NS_WIREFRAME) == 0 &&
- theWorkspace->DegenerateModel)
- {
- glDisable (GL_DEPTH_TEST);
- if (theWorkspace->NamedStatus & OPENGL_NS_TEXTURE)
- DisableTexture();
- theWorkspace->NamedStatus |= OPENGL_NS_WIREFRAME;
- }
- break;
+ return Standard_False; // failed to initialize attribute array
}
- case TelPolygonsArrayType:
- case TelTrianglesArrayType:
- case TelQuadranglesArrayType:
- case TelTriangleStripsArrayType:
- case TelTriangleFansArrayType:
- case TelQuadrangleStripsArrayType:
+
+ for (Standard_Integer anIdxIdx = 0; anIdxIdx < myIndices->NbElements; ++anIdxIdx)
{
- if ((theWorkspace->NamedStatus & OPENGL_NS_ANIMATION) != 0 &&
- (theWorkspace->NamedStatus & OPENGL_NS_WIREFRAME) != 0 &&
- theWorkspace->DegenerateModel < 2)
- {
- if (theWorkspace->NamedStatus & OPENGL_NS_TEXTURE)
- EnableTexture();
- glEnable (GL_DEPTH_TEST);
- theWorkspace->NamedStatus &= ~OPENGL_NS_WIREFRAME;
- }
- break;
+ const Standard_Integer anIndex = myIndices->Index (anIdxIdx);
+ memcpy (anAttribs->ChangeData() + myAttribs->Stride * anIdxIdx,
+ myAttribs->Data() + myAttribs->Stride * anIndex,
+ myAttribs->Stride);
}
- default:
- break;
- }
- const OpenGl_AspectFace* anAspectFace = theWorkspace->AspectFace (Standard_True);
- const OpenGl_AspectLine* anAspectLine = theWorkspace->AspectLine (Standard_True);
+ myIndices.Nullify();
+ myAttribs = anAttribs;
+ }
- Tint aFrontLightingModel = anAspectFace->Context().IntFront.color_mask;
- const TEL_COLOUR* anInteriorColor = &anAspectFace->Context().IntFront.matcol;
- const TEL_COLOUR* anEdgeColor = &anAspectFace->AspectEdge()->Color();
- const TEL_COLOUR* aLineColor = &anAspectLine->Color();
+ return Standard_True;
+}
- // Use highlight colors
- if (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)
- {
- anEdgeColor = anInteriorColor = aLineColor = theWorkspace->HighlightColor;
- aFrontLightingModel = 0;
- }
+// =======================================================================
+// function : InitBuffers
+// purpose :
+// =======================================================================
+void OpenGl_PrimitiveArray::InitBuffers (const Handle(OpenGl_Context)& theContext,
+ const Graphic3d_TypeOfPrimitiveArray theType,
+ const Handle(Graphic3d_IndexBuffer)& theIndices,
+ const Handle(Graphic3d_Buffer)& theAttribs,
+ const Handle(Graphic3d_BoundBuffer)& theBounds)
+{
+ // Release old graphic resources
+ Release (theContext.get());
- DrawArray (aFrontLightingModel,
- anAspectFace->Context().InteriorStyle,
- anAspectFace->Context().Edge,
- anInteriorColor,
- aLineColor,
- anEdgeColor,
- &anAspectFace->Context().IntFront,
- theWorkspace);
+ myIndices = theIndices;
+ myAttribs = theAttribs;
+ myBounds = theBounds;
+#if defined(GL_ES_VERSION_2_0)
+ processIndices (theContext);
+#endif
- switch (myPArray->type)
- {
- case TelPointsArrayType:
- case TelPolylinesArrayType:
- case TelSegmentsArrayType:
- {
- if (theWorkspace->NamedStatus & OPENGL_NS_TEXTURE)
- EnableTexture();
- }
- }
+ setDrawMode (theType);
}
projects / occt.git / blobdiff