OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0029074: Visualization, TKOpenGl - support Geometry Shader definition

Browse Source 
Graphic3d_TypeOfShaderObject enumeration has been extended by Geometry shader object type.
OpenGl_ShaderProgram::Initialize() processes new shader object types when supported by OpenGL version.
Declarations.glsl has been fixed so that occFragColor is defined only for
Fragment Shader object only (by handling new FRAGMENT_SHADER macros).

Improved documentation of Graphic3d_ArrayOfPrimitives class.

vshader Draw Harness command has been extended to support definition
of Shader Object types other than Vertex and Fragment shader.
This commit is contained in:
kgv 2017-09-01 17:45:49 +03:00 committed by bugmaster
parent 3ed88facdb
commit 8e0a2b19ab
60 changed files with 1190 additions and 1210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/Graphic3d/FILES
View File

@ -1,22 +1,13 @@
Graphic3d_ArrayOfPoints.cxx
Graphic3d_ArrayOfPoints.hxx Graphic3d_ArrayOfPoints.hxx
Graphic3d_ArrayOfPolygons.cxx
Graphic3d_ArrayOfPolygons.hxx Graphic3d_ArrayOfPolygons.hxx
Graphic3d_ArrayOfPolylines.cxx
Graphic3d_ArrayOfPolylines.hxx Graphic3d_ArrayOfPolylines.hxx
Graphic3d_ArrayOfPrimitives.cxx Graphic3d_ArrayOfPrimitives.cxx
Graphic3d_ArrayOfPrimitives.hxx Graphic3d_ArrayOfPrimitives.hxx
Graphic3d_ArrayOfQuadrangles.cxx
Graphic3d_ArrayOfQuadrangles.hxx Graphic3d_ArrayOfQuadrangles.hxx
Graphic3d_ArrayOfQuadrangleStrips.cxx
Graphic3d_ArrayOfQuadrangleStrips.hxx Graphic3d_ArrayOfQuadrangleStrips.hxx
Graphic3d_ArrayOfSegments.cxx
Graphic3d_ArrayOfSegments.hxx Graphic3d_ArrayOfSegments.hxx
Graphic3d_ArrayOfTriangleFans.cxx
Graphic3d_ArrayOfTriangleFans.hxx Graphic3d_ArrayOfTriangleFans.hxx
Graphic3d_ArrayOfTriangles.cxx
Graphic3d_ArrayOfTriangles.hxx Graphic3d_ArrayOfTriangles.hxx
Graphic3d_ArrayOfTriangleStrips.cxx
Graphic3d_ArrayOfTriangleStrips.hxx Graphic3d_ArrayOfTriangleStrips.hxx
Graphic3d_AspectFillArea3d.cxx Graphic3d_AspectFillArea3d.cxx
Graphic3d_AspectFillArea3d.hxx Graphic3d_AspectFillArea3d.hxx

25
src/Graphic3d/Graphic3d_ArrayOfPoints.cxx
View File

@ -1,25 +0,0 @@
// Created on: 2001-01-04
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// 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.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_ArrayOfPoints.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfPoints,Graphic3d_ArrayOfPrimitives)
Graphic3d_ArrayOfPoints::Graphic3d_ArrayOfPoints (const Standard_Integer theMaxVertexs,
const Standard_Boolean theHasVColors,
const Standard_Boolean theHasVNormals)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_POINTS, theMaxVertexs, 0, 0, theHasVNormals, theHasVColors, Standard_False, Standard_False)
{}

47
src/Graphic3d/Graphic3d_ArrayOfPoints.hxx
View File

@ -15,52 +15,25 @@
#ifndef _Graphic3d_ArrayOfPoints_HeaderFile #ifndef _Graphic3d_ArrayOfPoints_HeaderFile
#define _Graphic3d_ArrayOfPoints_HeaderFile #define _Graphic3d_ArrayOfPoints_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx> #include <Graphic3d_ArrayOfPrimitives.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
//! Contains points array definition.
class Graphic3d_ArrayOfPoints;
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfPoints, Graphic3d_ArrayOfPrimitives)
//! Contains points array definition
class Graphic3d_ArrayOfPoints : public Graphic3d_ArrayOfPrimitives class Graphic3d_ArrayOfPoints : public Graphic3d_ArrayOfPrimitives
{ {
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfPoints, Graphic3d_ArrayOfPrimitives)
public: public:
//! Creates an array of points, a single pixel point is drawn at each vertex.
//! Creates an array of points,
//! a single pixel point is drawn at each vertex.
//! The array must be filled using the AddVertex(Point) method. //! The array must be filled using the AddVertex(Point) method.
//! When <hasVColors> is TRUE , you must use only AddVertex(Point,Color) method. //! @param theHasVColors when TRUE, AddVertex(Point,Color) should be used for specifying vertex color
//! When <hasVNormals> is TRUE , you must use only AddVertex(Point,Normal) method. //! @param theHasVNormals when TRUE, AddVertex(Point,Normal) should be used for specifying vertex normal
Standard_EXPORT Graphic3d_ArrayOfPoints(const Standard_Integer maxVertexs, const Standard_Boolean hasVColors = Standard_False, const Standard_Boolean hasVNormals = Standard_False); Graphic3d_ArrayOfPoints (const Standard_Integer theMaxVertexs,
const Standard_Boolean theHasVColors = Standard_False,
const Standard_Boolean theHasVNormals = Standard_False)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_POINTS, theMaxVertexs, 0, 0, theHasVNormals, theHasVColors, Standard_False, Standard_False) {}
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfPoints,Graphic3d_ArrayOfPrimitives)
protected:
private:
}; };
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfPoints, Graphic3d_ArrayOfPrimitives)
#endif // _Graphic3d_ArrayOfPoints_HeaderFile #endif // _Graphic3d_ArrayOfPoints_HeaderFile

29
src/Graphic3d/Graphic3d_ArrayOfPolygons.cxx
View File

@ -1,29 +0,0 @@
// Created on: 2001-01-04
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// 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.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_ArrayOfPolygons.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfPolygons,Graphic3d_ArrayOfPrimitives)
Graphic3d_ArrayOfPolygons::Graphic3d_ArrayOfPolygons (const Standard_Integer theMaxVertexs,
const Standard_Integer theMaxBounds,
const Standard_Integer theMaxEdges,
const Standard_Boolean theHasVNormals,
const Standard_Boolean theHasVColors,
const Standard_Boolean theHasFColors,
const Standard_Boolean theHasVTexels)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_POLYGONS, theMaxVertexs, theMaxBounds, theMaxEdges, theHasVNormals, theHasVColors, theHasFColors, theHasVTexels)
{}

193
src/Graphic3d/Graphic3d_ArrayOfPolygons.hxx
View File

@ -15,130 +15,91 @@
#ifndef _Graphic3d_ArrayOfPolygons_HeaderFile #ifndef _Graphic3d_ArrayOfPolygons_HeaderFile
#define _Graphic3d_ArrayOfPolygons_HeaderFile #define _Graphic3d_ArrayOfPolygons_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx> #include <Graphic3d_ArrayOfPrimitives.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
//! Contains polygons array definition.
class Graphic3d_ArrayOfPolygons; //! WARNING! Polygon primitives might be unsupported by graphics library.
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfPolygons, Graphic3d_ArrayOfPrimitives) //! Triangulation should be used instead of quads for better compatibility.
//! Contains polygons array definition
class Graphic3d_ArrayOfPolygons : public Graphic3d_ArrayOfPrimitives class Graphic3d_ArrayOfPolygons : public Graphic3d_ArrayOfPrimitives
{ {
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfPolygons, Graphic3d_ArrayOfPrimitives)
public: public:
//! Creates an array of polygons, a polygon can be filled as:
//! Creates an array of polygons, //! 1) Creating a single polygon defined with his vertexes, i.e:
//! a polygon can be filled as: //! @code
//! 1) creating a single polygon defined with his vertexs. //! myArray = Graphic3d_ArrayOfPolygons (7);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfPolygons(7) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x7, y7, z7);
//! .... //! @endcode
//! myArray->AddVertex(x7,y7,z7) //! 2) Creating separate polygons defined with a predefined number of bounds and the number of vertex per bound, i.e:
//! 2) creating separate polygons defined with a predefined //! @code
//! number of bounds and the number of vertex per bound. //! myArray = Graphic3d_ArrayOfPolygons (7, 2);
//! i.e: //! myArray->AddBound (4);
//! myArray = Graphic3d_ArrayOfPolygons(7,2) //! myArray->AddVertex (x1, y1, z1);
//! myArray->AddBound(4) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x4, y4, z4);
//! .... //! myArray->AddBound (3);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddVertex (x5, y5, z5);
//! myArray->AddBound(3) //! ....
//! myArray->AddVertex(x5,y5,z5) //! myArray->AddVertex (x7, y7, z7);
//! .... //! @endcode
//! myArray->AddVertex(x7,y7,z7) //! 3) Creating a single indexed polygon defined with his vertex ans edges, i.e:
//! 3) creating a single indexed polygon defined with his vertex //! @code
//! ans edges. //! myArray = Graphic3d_ArrayOfPolygons (4, 0, 6);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfPolygons(4,0,6) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x4, y4, z4);
//! .... //! myArray->AddEdge (1);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddEdge (2);
//! myArray->AddEdge(1) //! myArray->AddEdge (3);
//! myArray->AddEdge(2) //! myArray->AddEdge (1);
//! myArray->AddEdge(3) //! myArray->AddEdge (2);
//! myArray->AddEdge(1) //! myArray->AddEdge (4);
//! myArray->AddEdge(2) //! @endcode
//! myArray->AddEdge(4) //! 4) Creating separate polygons defined with a predefined number of bounds and the number of edges per bound, i.e:
//! 4) creating separate polygons defined with a predefined //! @code
//! number of bounds and the number of edges per bound. //! myArray = Graphic3d_ArrayOfPolygons (6, 4, 14);
//! i.e: //! myArray->AddBound (3);
//! myArray = Graphic3d_ArrayOfPolygons(6,4,14) //! myArray->AddVertex (x1, y1, z1);
//! myArray->AddBound(3) //! myArray->AddVertex (x2, y2, z2);
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x3, y3, z3);
//! myArray->AddVertex(x2,y2,z2) //! myArray->AddEdge (1);
//! myArray->AddVertex(x3,y3,z3) //! myArray->AddEdge (2);
//! myArray->AddEdge(1) //! myArray->AddEdge (3);
//! myArray->AddEdge(2) //! myArray->AddBound (3);
//! myArray->AddEdge(3) //! myArray->AddVertex (x4, y4, z4);
//! myArray->AddBound(3) //! myArray->AddVertex (x5, y5, z5);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddVertex (x6, y6, z6);
//! myArray->AddVertex(x5,y5,z5) //! myArray->AddEdge (4);
//! myArray->AddVertex(x6,y6,z6) //! myArray->AddEdge (5);
//! myArray->AddEdge(4) //! myArray->AddEdge (6);
//! myArray->AddEdge(5) //! myArray->AddBound (4);
//! myArray->AddEdge(6) //! myArray->AddEdge (2);
//! myArray->AddBound(4) //! myArray->AddEdge (3);
//! myArray->AddEdge(2) //! myArray->AddEdge (5);
//! myArray->AddEdge(3) //! myArray->AddEdge (6);
//! myArray->AddEdge(5) //! myArray->AddBound (4);
//! myArray->AddEdge(6) //! myArray->AddEdge (1);
//! myArray->AddBound(4) //! myArray->AddEdge (3);
//! myArray->AddEdge(1) //! myArray->AddEdge (5);
//! myArray->AddEdge(3) //! myArray->AddEdge (4);
//! myArray->AddEdge(5) //! @endcode
//! myArray->AddEdge(4) //! @param theMaxVertexs defines the maximum allowed vertex number in the array
//! <maxVertexs> defined the maximun allowed vertex number in the array. //! @param theMaxBounds defines the maximum allowed bound number in the array
//! <maxBounds> defined the maximun allowed bound number in the array. //! @param theMaxEdges defines the maximum allowed edge number in the array
//! <maxEdges> defined the maximun allowed edge number in the array. Graphic3d_ArrayOfPolygons (const Standard_Integer theMaxVertexs,
//! Warning: const Standard_Integer theMaxBounds = 0,
//! When <hasVNormals> is TRUE , you must use one of const Standard_Integer theMaxEdges = 0,
//! AddVertex(Point,Normal) const Standard_Boolean theHasVNormals = Standard_False,
//! or AddVertex(Point,Normal,Color) const Standard_Boolean theHasVColors = Standard_False,
//! or AddVertex(Point,Normal,Texel) methods. const Standard_Boolean theHasBColors = Standard_False,
//! When <hasVColors> is TRUE , you must use one of const Standard_Boolean theHasVTexels = Standard_False)
//! AddVertex(Point,Color) : Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_POLYGONS, theMaxVertexs, theMaxBounds, theMaxEdges, theHasVNormals, theHasVColors, theHasBColors, theHasVTexels) {}
//! or AddVertex(Point,Normal,Color) methods.
//! When <hasTexels> is TRUE , you must use one of
//! AddVertex(Point,Texel)
//! or AddVertex(Point,Normal,Texel) methods.
//! When <hasBColors> is TRUE , <maxBounds> must be > 0 and
//! you must use the
//! AddBound(number,Color) method.
//! Warning:
//! the user is responsible about the orientation of the polygon
//! depending of the order of the created vertex or edges and this
//! orientation must be coherent with the vertex normal optionnaly
//! given at each vertex (See the Orientate() methods).
Standard_EXPORT Graphic3d_ArrayOfPolygons(const Standard_Integer maxVertexs, const Standard_Integer maxBounds = 0, const Standard_Integer maxEdges = 0, const Standard_Boolean hasVNormals = Standard_False, const Standard_Boolean hasVColors = Standard_False, const Standard_Boolean hasBColors = Standard_False, const Standard_Boolean hasTexels = Standard_False);
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfPolygons,Graphic3d_ArrayOfPrimitives)
protected:
private:
}; };
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfPolygons, Graphic3d_ArrayOfPrimitives)
#endif // _Graphic3d_ArrayOfPolygons_HeaderFile #endif // _Graphic3d_ArrayOfPolygons_HeaderFile

27
src/Graphic3d/Graphic3d_ArrayOfPolylines.cxx
View File

@ -1,27 +0,0 @@
// Created on: 2001-01-04
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// 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.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_ArrayOfPolylines.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfPolylines,Graphic3d_ArrayOfPrimitives)
Graphic3d_ArrayOfPolylines::Graphic3d_ArrayOfPolylines (const Standard_Integer theMaxVertexs,
const Standard_Integer theMaxBounds,
const Standard_Integer theMaxEdges,
const Standard_Boolean theHasVColors,
const Standard_Boolean theHasFColors)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_POLYLINES, theMaxVertexs, theMaxBounds, theMaxEdges, Standard_False, theHasVColors, theHasFColors, Standard_False)
{}

180
src/Graphic3d/Graphic3d_ArrayOfPolylines.hxx
View File

@ -15,119 +15,89 @@
#ifndef _Graphic3d_ArrayOfPolylines_HeaderFile #ifndef _Graphic3d_ArrayOfPolylines_HeaderFile
#define _Graphic3d_ArrayOfPolylines_HeaderFile #define _Graphic3d_ArrayOfPolylines_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx> #include <Graphic3d_ArrayOfPrimitives.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
//! Contains polylines array definition.
class Graphic3d_ArrayOfPolylines;
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfPolylines, Graphic3d_ArrayOfPrimitives)
//! Contains polylines array definition
class Graphic3d_ArrayOfPolylines : public Graphic3d_ArrayOfPrimitives class Graphic3d_ArrayOfPolylines : public Graphic3d_ArrayOfPrimitives
{ {
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfPolylines, Graphic3d_ArrayOfPrimitives)
public: public:
//! Creates an array of polylines, a polyline can be filled as:
//! Creates an array of polylines, //! 1) Creating a single polyline defined with his vertexes, i.e:
//! a polyline can be filled as: //! @code
//! 1) creating a single polyline defined with his vertexs. //! myArray = Graphic3d_ArrayOfPolylines (7);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfPolylines(7) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x7, y7, z7);
//! .... //! @endcode
//! myArray->AddVertex(x7,y7,z7) //! 2) Creating separate polylines defined with a predefined number of bounds and the number of vertex per bound, i.e:
//! 2) creating separate polylines defined with a predefined //! @code
//! number of bounds and the number of vertex per bound. //! myArray = Graphic3d_ArrayOfPolylines (7, 2);
//! i.e: //! myArray->AddBound (4);
//! myArray = Graphic3d_ArrayOfPolylines(7,2) //! myArray->AddVertex (x1, y1, z1);
//! myArray->AddBound(4) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x4, y4, z4);
//! .... //! myArray->AddBound (3);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddVertex (x5, y5, z5);
//! myArray->AddBound(3) //! ....
//! myArray->AddVertex(x5,y5,z5) //! myArray->AddVertex (x7, y7, z7);
//! .... //! @endcode
//! myArray->AddVertex(x7,y7,z7) //! 3) Creating a single indexed polyline defined with his vertex and edges, i.e:
//! 3) creating a single indexed polyline defined with his vertex //! @code
//! ans edges. //! myArray = Graphic3d_ArrayOfPolylines (4, 0, 6);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfPolylines(4,0,6) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x4, y4, z4);
//! .... //! myArray->AddEdge (1);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddEdge (2);
//! myArray->AddEdge(1) //! myArray->AddEdge (3);
//! myArray->AddEdge(2) //! myArray->AddEdge (1);
//! myArray->AddEdge(3) //! myArray->AddEdge (2);
//! myArray->AddEdge(1) //! myArray->AddEdge (4);
//! myArray->AddEdge(2) //! @endcode
//! myArray->AddEdge(4) //! 4) creating separate polylines defined with a predefined number of bounds and the number of edges per bound, i.e:
//! 4) creating separate polylines defined with a predefined //! @code
//! number of bounds and the number of edges per bound. //! myArray = Graphic3d_ArrayOfPolylines (6, 4, 14);
//! i.e: //! myArray->AddBound (3);
//! myArray = Graphic3d_ArrayOfPolylines(6,4,14) //! myArray->AddVertex (x1, y1, z1);
//! myArray->AddBound(3) //! myArray->AddVertex (x2, y2, z2);
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x3, y3, z3);
//! myArray->AddVertex(x2,y2,z2) //! myArray->AddEdge (1);
//! myArray->AddVertex(x3,y3,z3) //! myArray->AddEdge (2);
//! myArray->AddEdge(1) //! myArray->AddEdge (3);
//! myArray->AddEdge(2) //! myArray->AddBound (3);
//! myArray->AddEdge(3) //! myArray->AddVertex (x4, y4, z4);
//! myArray->AddBound(3) //! myArray->AddVertex (x5, y5, z5);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddVertex (x6, y6, z6);
//! myArray->AddVertex(x5,y5,z5) //! myArray->AddEdge (4);
//! myArray->AddVertex(x6,y6,z6) //! myArray->AddEdge (5);
//! myArray->AddEdge(4) //! myArray->AddEdge (6);
//! myArray->AddEdge(5) //! myArray->AddBound (4);
//! myArray->AddEdge(6) //! myArray->AddEdge (2);
//! myArray->AddBound(4) //! myArray->AddEdge (3);
//! myArray->AddEdge(2) //! myArray->AddEdge (5);
//! myArray->AddEdge(3) //! myArray->AddEdge (6);
//! myArray->AddEdge(5) //! myArray->AddBound (4);
//! myArray->AddEdge(6) //! myArray->AddEdge (1);
//! myArray->AddBound(4) //! myArray->AddEdge (3);
//! myArray->AddEdge(1) //! myArray->AddEdge (5);
//! myArray->AddEdge(3) //! myArray->AddEdge (4);
//! myArray->AddEdge(5) //! @endcode
//! myArray->AddEdge(4) //! @param theMaxVertexs defines the maximum allowed vertex number in the array
//! //! @param theMaxBounds defines the maximum allowed bound number in the array
//! <maxVertexs> defined the maximun allowed vertex number in the array. //! @param theMaxEdges defines the maximum allowed edge number in the array
//! <maxBounds> defined the maximun allowed bound number in the array. //! @param theHasVColors when TRUE AddVertex(Point,Color) or AddVertex(Point,Normal,Color) should be used to specify per-vertex color values
//! <maxEdges> defined the maximun allowed edge number in the array. //! @param theHasBColors when TRUE AddBound(number,Color) should be used to specify sub-group color
//! Warning: Graphic3d_ArrayOfPolylines (const Standard_Integer theMaxVertexs,
//! When <hasVColors> is TRUE , you must use one of const Standard_Integer theMaxBounds = 0,
//! AddVertex(Point,Color) const Standard_Integer theMaxEdges = 0,
//! or AddVertex(Point,Normal,Color) methods. const Standard_Boolean theHasVColors = Standard_False,
//! When <hasBColors> is TRUE , <maxBounds> must be > 0 and const Standard_Boolean theHasBColors = Standard_False)
//! you must use the : Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_POLYLINES, theMaxVertexs, theMaxBounds, theMaxEdges, Standard_False, theHasVColors, theHasBColors, Standard_False) {}
//! AddBound(number,Color) method.
Standard_EXPORT Graphic3d_ArrayOfPolylines(const Standard_Integer maxVertexs, const Standard_Integer maxBounds = 0, const Standard_Integer maxEdges = 0, const Standard_Boolean hasVColors = Standard_False, const Standard_Boolean hasBColors = Standard_False);
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfPolylines,Graphic3d_ArrayOfPrimitives)
protected:
private:
}; };
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfPolylines, Graphic3d_ArrayOfPrimitives)
#endif // _Graphic3d_ArrayOfPolylines_HeaderFile #endif // _Graphic3d_ArrayOfPolylines_HeaderFile

58
src/Graphic3d/Graphic3d_ArrayOfPrimitives.cxx
View File

@ -14,6 +14,16 @@
#include <Graphic3d_ArrayOfPrimitives.hxx> #include <Graphic3d_ArrayOfPrimitives.hxx>
#include <Graphic3d_ArrayOfPoints.hxx>
#include <Graphic3d_ArrayOfSegments.hxx>
#include <Graphic3d_ArrayOfPolylines.hxx>
#include <Graphic3d_ArrayOfTriangles.hxx>
#include <Graphic3d_ArrayOfTriangleStrips.hxx>
#include <Graphic3d_ArrayOfTriangleFans.hxx>
#include <Graphic3d_ArrayOfQuadrangles.hxx>
#include <Graphic3d_ArrayOfQuadrangleStrips.hxx>
#include <Graphic3d_ArrayOfPolygons.hxx>
#include <NCollection_AlignedAllocator.hxx> #include <NCollection_AlignedAllocator.hxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
@ -22,6 +32,16 @@
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfPrimitives, Standard_Transient) IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfPrimitives, Standard_Transient)
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfPoints, Graphic3d_ArrayOfPrimitives)
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfSegments, Graphic3d_ArrayOfPrimitives)
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfPolylines, Graphic3d_ArrayOfPrimitives)
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangles, Graphic3d_ArrayOfPrimitives)
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangleStrips, Graphic3d_ArrayOfPrimitives)
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangleFans, Graphic3d_ArrayOfPrimitives)
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfQuadrangles, Graphic3d_ArrayOfPrimitives)
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfQuadrangleStrips, Graphic3d_ArrayOfPrimitives)
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfPolygons, Graphic3d_ArrayOfPrimitives)
// ======================================================================= // =======================================================================
// function : Graphic3d_ArrayOfPrimitives // function : Graphic3d_ArrayOfPrimitives
// purpose : // purpose :
@ -246,14 +266,18 @@ Standard_CString Graphic3d_ArrayOfPrimitives::StringType() const
switch (myType) switch (myType)
{ {
case Graphic3d_TOPA_POINTS: return "ArrayOfPoints"; case Graphic3d_TOPA_POINTS: return "ArrayOfPoints";
case Graphic3d_TOPA_POLYLINES: return "ArrayOfPolylines";
case Graphic3d_TOPA_SEGMENTS: return "ArrayOfSegments"; case Graphic3d_TOPA_SEGMENTS: return "ArrayOfSegments";
case Graphic3d_TOPA_POLYGONS: return "ArrayOfPolygons"; case Graphic3d_TOPA_POLYLINES: return "ArrayOfPolylines";
case Graphic3d_TOPA_TRIANGLES: return "ArrayOfTriangles"; case Graphic3d_TOPA_TRIANGLES: return "ArrayOfTriangles";
case Graphic3d_TOPA_QUADRANGLES: return "ArrayOfQuadrangles";
case Graphic3d_TOPA_TRIANGLESTRIPS: return "ArrayOfTriangleStrips"; case Graphic3d_TOPA_TRIANGLESTRIPS: return "ArrayOfTriangleStrips";
case Graphic3d_TOPA_QUADRANGLESTRIPS: return "ArrayOfQuadrangleStrips";
case Graphic3d_TOPA_TRIANGLEFANS: return "ArrayOfTriangleFans"; case Graphic3d_TOPA_TRIANGLEFANS: return "ArrayOfTriangleFans";
case Graphic3d_TOPA_LINES_ADJACENCY: return "ArrayOfLinesAdjacency";
case Graphic3d_TOPA_LINE_STRIP_ADJACENCY: return "ArrayOfLineStripAdjacency";
case Graphic3d_TOPA_TRIANGLES_ADJACENCY: return "ArrayOfTrianglesAdjacency";
case Graphic3d_TOPA_TRIANGLE_STRIP_ADJACENCY: return "ArrayOfTriangleStripAdjacency";
case Graphic3d_TOPA_QUADRANGLES: return "ArrayOfQuadrangles";
case Graphic3d_TOPA_QUADRANGLESTRIPS: return "ArrayOfQuadrangleStrips";
case Graphic3d_TOPA_POLYGONS: return "ArrayOfPolygons";
case Graphic3d_TOPA_UNDEFINED: return "UndefinedArray"; case Graphic3d_TOPA_UNDEFINED: return "UndefinedArray";
} }
return "UndefinedArray"; return "UndefinedArray";
@ -293,6 +317,18 @@ Standard_Integer Graphic3d_ArrayOfPrimitives::ItemNumber() const
case Graphic3d_TOPA_TRIANGLEFANS: return !myBounds.IsNull() case Graphic3d_TOPA_TRIANGLEFANS: return !myBounds.IsNull()
? myAttribs->NbElements - 2 * myBounds->NbBounds ? myAttribs->NbElements - 2 * myBounds->NbBounds
: myAttribs->NbElements - 2; : myAttribs->NbElements - 2;
case Graphic3d_TOPA_LINES_ADJACENCY: return myIndices.IsNull() || myIndices->NbElements < 1
? myAttribs->NbElements / 4
: myIndices->NbElements / 4;
case Graphic3d_TOPA_LINE_STRIP_ADJACENCY: return !myBounds.IsNull()
? myAttribs->NbElements - 4 * myBounds->NbBounds
: myAttribs->NbElements - 4;
case Graphic3d_TOPA_TRIANGLES_ADJACENCY: return myIndices.IsNull() || myIndices->NbElements < 1
? myAttribs->NbElements / 6
: myIndices->NbElements / 6;
case Graphic3d_TOPA_TRIANGLE_STRIP_ADJACENCY: return !myBounds.IsNull()
? myAttribs->NbElements - 4 * myBounds->NbBounds
: myAttribs->NbElements - 4;
case Graphic3d_TOPA_UNDEFINED: return -1; case Graphic3d_TOPA_UNDEFINED: return -1;
} }
return -1; return -1;
@ -407,6 +443,20 @@ Standard_Boolean Graphic3d_ArrayOfPrimitives::IsValid()
return Standard_False; return Standard_False;
} }
break; break;
case Graphic3d_TOPA_LINES_ADJACENCY:
case Graphic3d_TOPA_LINE_STRIP_ADJACENCY:
if (nvertexs < 4)
{
return Standard_False;
}
break;
case Graphic3d_TOPA_TRIANGLES_ADJACENCY:
case Graphic3d_TOPA_TRIANGLE_STRIP_ADJACENCY:
if (nvertexs < 6)
{
return Standard_False;
}
break;
case Graphic3d_TOPA_UNDEFINED: case Graphic3d_TOPA_UNDEFINED:
default: default:
return Standard_False; return Standard_False;

49
src/Graphic3d/Graphic3d_ArrayOfPrimitives.hxx
View File

@ -24,28 +24,41 @@
#include <Standard_OutOfRange.hxx> #include <Standard_OutOfRange.hxx>
#include <Quantity_Color.hxx> #include <Quantity_Color.hxx>
class Quantity_Color;
class Graphic3d_ArrayOfPrimitives; class Graphic3d_ArrayOfPrimitives;
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfPrimitives, Standard_Transient) DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfPrimitives, Standard_Transient)
//! This class furnish services to defined and fill an //! This class furnish services to defined and fill an array of primitives
//! array of primitives compatible with the use of //! which can be passed directly to graphics rendering API.
//! the OPENGl glDrawArrays() or glDrawElements() functions.
//! NOTE that the main goal of this kind of primitive
//! is to avoid multiple copies of datas between
//! each layer of the software.
//! So the array datas exist only one time and the use
//! of SetXxxxxx() methods enable to change dynamically
//! the aspect of this primitive.
//! //!
//! Advantages are : //! The basic interface consists of the following parts:
//! 1) Decrease strongly the loading time. //! 1) Specifying primitive type.
//! 2) Decrease strongly the display time using optimized Opengl //! WARNING! Particular primitive types might be unsupported by specific hardware/graphics API (like quads and polygons).
//! primitives. //! It is always preferred using one of basic types having maximum compatibility:
//! 3) Enable to change dynamically the components of the primitive //! Point, Triangle (or Triangle strip), Segment aka Lines (or Polyline aka Line Strip).
//! (vertice,normal,color,texture coordinates). //! Primitive strip types can be used to reduce memory usage as alternative to Indexed arrays.
//! 4) Add true triangle and quadrangle strips or fans capabilities. //! 2) Vertex array.
//! - Specifying the (maximum) number of vertexes within array.
//! - Specifying the vertex attributes, complementary to mandatory vertex Position (normal, color, UV texture coordinates).
//! - Defining vertex values by using various versions of AddVertex() or SetVertex*() methods.
//! 3) Index array (optional).
//! - Specifying the (maximum) number of indexes (edges).
//! - Defining index values by using AddEdge() method; the index value should be within number of defined Vertexes.
//!
//! Indexed array allows sharing vertex data across Primitives and thus reducing memory usage,
//! since index size is much smaller then size of vertex with all its attributes.
//! It is a preferred way for defining primitive array and main alternative to Primitive Strips for optimal memory usage,
//! although it is also possible (but unusual) defining Indexed Primitive Strip.
//! Note that it is NOT possible sharing Vertex Attributes partially (e.g. share Position, but have different Normals);
//! in such cases Vertex should be entirely duplicated with all Attributes.
//! 4) Bounds array (optional).
//! - Specifying the (maximum) number of bounds.
//! - Defining bounds using AddBound() methods.
//!
//! Bounds allow splitting Primitive Array into sub-groups.
//! This is useful only in two cases - for specifying per-group color and for restarting Primitive Strips.
//! WARNING! Bounds within Primitive Array break rendering batches into parts (additional for loops),
//! affecting rendering performance negatively (increasing CPU load).
class Graphic3d_ArrayOfPrimitives : public Standard_Transient class Graphic3d_ArrayOfPrimitives : public Standard_Transient
{ {
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfPrimitives, Standard_Transient) DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfPrimitives, Standard_Transient)

28
src/Graphic3d/Graphic3d_ArrayOfQuadrangleStrips.cxx
View File

@ -1,28 +0,0 @@
// Created on: 2001-01-04
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// 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.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_ArrayOfQuadrangleStrips.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfQuadrangleStrips,Graphic3d_ArrayOfPrimitives)
Graphic3d_ArrayOfQuadrangleStrips::Graphic3d_ArrayOfQuadrangleStrips (const Standard_Integer theMaxVertexs,
const Standard_Integer theMaxStrips,
const Standard_Boolean theHasVNormals,
const Standard_Boolean theHasVColors,
const Standard_Boolean theHasSColors,
const Standard_Boolean theHasVTexels)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_QUADRANGLESTRIPS, theMaxVertexs, theMaxStrips, 0, theHasVNormals, theHasVColors, theHasSColors, theHasVTexels)
{}

93
src/Graphic3d/Graphic3d_ArrayOfQuadrangleStrips.hxx
View File

@ -15,72 +15,49 @@
#ifndef _Graphic3d_ArrayOfQuadrangleStrips_HeaderFile #ifndef _Graphic3d_ArrayOfQuadrangleStrips_HeaderFile
#define _Graphic3d_ArrayOfQuadrangleStrips_HeaderFile #define _Graphic3d_ArrayOfQuadrangleStrips_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx> #include <Graphic3d_ArrayOfPrimitives.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
//! Contains quadrangles strip array definition.
class Graphic3d_ArrayOfQuadrangleStrips; //! WARNING! Quadrangle primitives might be unsupported by graphics library.
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfQuadrangleStrips, Graphic3d_ArrayOfPrimitives) //! Triangulation should be used instead of quads for better compatibility.
//! Contains quadrangles strip array definition
class Graphic3d_ArrayOfQuadrangleStrips : public Graphic3d_ArrayOfPrimitives class Graphic3d_ArrayOfQuadrangleStrips : public Graphic3d_ArrayOfPrimitives
{ {
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfQuadrangleStrips, Graphic3d_ArrayOfPrimitives)
public: public:
//! Creates an array of quadrangle strips, a polygon can be filled as:
//! Creates an array of quadrangle strips, //! 1) Creating a single strip defined with his vertexes, i.e:
//! a polygon can be filled as: //! @code
//! 1) creating a single strip defined with his vertexs. //! myArray = Graphic3d_ArrayOfQuadrangleStrips (7);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfQuadrangleStrips(7) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x7, y7, z7);
//! .... //! @endcode
//! myArray->AddVertex(x7,y7,z7) //! 2) Creating separate strips defined with a predefined number of strips and the number of vertex per strip, i.e:
//! 2) creating separate strips defined with a predefined //! @code
//! number of strips and the number of vertex per strip. //! myArray = Graphic3d_ArrayOfQuadrangleStrips (8, 2);
//! i.e: //! myArray->AddBound (4);
//! myArray = Graphic3d_ArrayOfQuadrangleStrips(8,2) //! myArray->AddVertex (x1, y1, z1);
//! myArray->AddBound(4) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x4, y4, z4);
//! .... //! myArray->AddBound (4);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddVertex (x5, y5, z5);
//! myArray->AddBound(4) //! ....
//! myArray->AddVertex(x5,y5,z5) //! myArray->AddVertex (x8, y8, z8);
//! .... //! @endcode
//! myArray->AddVertex(x8,y8,z8) //! @param theMaxVertexs defines the maximum allowed vertex number in the array
//! //! @param theMaxStrips defines the maximum allowed strip number in the array
//! <maxVertexs> defined the maximun allowed vertex number in the array. //! The number of quadrangle really drawn is: VertexNumber()/2 - Min(1, BoundNumber()).
//! <maxStrips> defined the maximun allowed strip number in the array. Graphic3d_ArrayOfQuadrangleStrips (const Standard_Integer theMaxVertexs,
//! The number of quadrangle really drawn is : const Standard_Integer theMaxStrips = 0,
//! VertexNumber()/2-Min(1,BoundNumber()) const Standard_Boolean theHasVNormals = Standard_False,
Standard_EXPORT Graphic3d_ArrayOfQuadrangleStrips(const Standard_Integer maxVertexs, const Standard_Integer maxStrips = 0, const Standard_Boolean hasVNormals = Standard_False, const Standard_Boolean hasVColors = Standard_False, const Standard_Boolean hasSColors = Standard_False, const Standard_Boolean hasTexels = Standard_False); const Standard_Boolean theHasVColors = Standard_False,
const Standard_Boolean theHasSColors = Standard_False,
const Standard_Boolean theHasVTexels = Standard_False)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_QUADRANGLESTRIPS, theMaxVertexs, theMaxStrips, 0, theHasVNormals, theHasVColors, theHasSColors, theHasVTexels) {}
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfQuadrangleStrips,Graphic3d_ArrayOfPrimitives)
protected:
private:
}; };
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfQuadrangleStrips, Graphic3d_ArrayOfPrimitives)
#endif // _Graphic3d_ArrayOfQuadrangleStrips_HeaderFile #endif // _Graphic3d_ArrayOfQuadrangleStrips_HeaderFile

28
src/Graphic3d/Graphic3d_ArrayOfQuadrangles.cxx
View File

@ -1,28 +0,0 @@
// Created on: 2001-01-04
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// 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.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_ArrayOfQuadrangles.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfQuadrangles,Graphic3d_ArrayOfPrimitives)
Graphic3d_ArrayOfQuadrangles::Graphic3d_ArrayOfQuadrangles (const Standard_Integer theMaxVertexs,
const Standard_Integer theMaxEdges,
const Standard_Boolean theHasVNormals,
const Standard_Boolean theHasVColors,
const Standard_Boolean theHasVTexels)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_QUADRANGLES, theMaxVertexs, 0, theMaxEdges, theHasVNormals, theHasVColors, Standard_False, theHasVTexels)
{}

112
src/Graphic3d/Graphic3d_ArrayOfQuadrangles.hxx
View File

@ -15,90 +15,50 @@
#ifndef _Graphic3d_ArrayOfQuadrangles_HeaderFile #ifndef _Graphic3d_ArrayOfQuadrangles_HeaderFile
#define _Graphic3d_ArrayOfQuadrangles_HeaderFile #define _Graphic3d_ArrayOfQuadrangles_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx> #include <Graphic3d_ArrayOfPrimitives.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Standard_OutOfRange;
//! Contains quadrangles array definition.
class Graphic3d_ArrayOfQuadrangles; //! WARNING! Quadrangle primitives might be unsupported by graphics library.
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfQuadrangles, Graphic3d_ArrayOfPrimitives) //! Triangulation should be used instead of quads for better compatibility.
//! Contains quatrangles array definition
class Graphic3d_ArrayOfQuadrangles : public Graphic3d_ArrayOfPrimitives class Graphic3d_ArrayOfQuadrangles : public Graphic3d_ArrayOfPrimitives
{ {
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfQuadrangles, Graphic3d_ArrayOfPrimitives)
public: public:
//! Creates an array of quadrangles, a quadrangle can be filled as:
//! Creates an array of quadrangles, //! 1) Creating a set of quadrangles defined with his vertexes, i.e:
//! a quadrangle can be filled as: //! @code
//! 1) creating a set of quadrangles defined with his vertexs. //! myArray = Graphic3d_ArrayOfQuadrangles (8);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfQuadrangles(8) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x8, y8, z8);
//! .... //! @endcode
//! myArray->AddVertex(x8,y8,z8) //! 2) Creating a set of indexed quadrangles defined with his vertex ans edges, i.e:
//! 3) creating a set of indexed quadrangles defined with his vertex //! @code
//! ans edges. //! myArray = Graphic3d_ArrayOfQuadrangles (6, 8);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfQuadrangles(6,8) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x6, y6, z6);
//! .... //! myArray->AddEdge (1);
//! myArray->AddVertex(x6,y6,z6) //! myArray->AddEdge (2);
//! myArray->AddEdge(1) //! myArray->AddEdge (3);
//! myArray->AddEdge(2) //! myArray->AddEdge (4);
//! myArray->AddEdge(3) //! myArray->AddEdge (3);
//! myArray->AddEdge(4) //! myArray->AddEdge (4);
//! myArray->AddEdge(3) //! myArray->AddEdge (5);
//! myArray->AddEdge(4) //! myArray->AddEdge (6);
//! myArray->AddEdge(5) //! @endcode
//! myArray->AddEdge(6) //! @param theMaxVertexs defines the maximum allowed vertex number in the array
//! //! @param theMaxEdges defines the maximum allowed edge number in the array (for indexed array)
//! <maxVertexs> defined the maximun allowed vertex number in the array. Graphic3d_ArrayOfQuadrangles (const Standard_Integer theMaxVertexs,
//! <maxEdges> defined the maximun allowed edge number in the array. const Standard_Integer theMaxEdges = 0,
//! Warning: const Standard_Boolean theHasVNormals = Standard_False,
//! When <hasVNormals> is TRUE , you must use one of const Standard_Boolean theHasVColors = Standard_False,
//! AddVertex(Point,Normal) const Standard_Boolean theHasVTexels = Standard_False)
//! or AddVertex(Point,Normal,Color) : Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_QUADRANGLES, theMaxVertexs, 0, theMaxEdges, theHasVNormals, theHasVColors, Standard_False, theHasVTexels) {}
//! or AddVertex(Point,Normal,Texel) methods.
//! When <hasVColors> is TRUE , you must use one of
//! AddVertex(Point,Color)
//! or AddVertex(Point,Normal,Color) methods.
//! When <hasTexels> is TRUE , you must use one of
//! AddVertex(Point,Texel)
//! or AddVertex(Point,Normal,Texel) methods.
//! Warning:
//! the user is responsible about the orientation of the quadrangle
//! depending of the order of the created vertex or edges and this
//! orientation must be coherent with the vertex normal optionnaly
//! given at each vertex (See the Orientate() methods).
Standard_EXPORT Graphic3d_ArrayOfQuadrangles(const Standard_Integer maxVertexs, const Standard_Integer maxEdges = 0, const Standard_Boolean hasVNormals = Standard_False, const Standard_Boolean hasVColors = Standard_False, const Standard_Boolean hasTexels = Standard_False);
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfQuadrangles,Graphic3d_ArrayOfPrimitives)
protected:
private:
}; };
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfQuadrangles, Graphic3d_ArrayOfPrimitives)
#endif // _Graphic3d_ArrayOfQuadrangles_HeaderFile #endif // _Graphic3d_ArrayOfQuadrangles_HeaderFile

25
src/Graphic3d/Graphic3d_ArrayOfSegments.cxx
View File

@ -1,25 +0,0 @@
// Created on: 2001-01-04
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// 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.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_ArrayOfSegments.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfSegments,Graphic3d_ArrayOfPrimitives)
Graphic3d_ArrayOfSegments::Graphic3d_ArrayOfSegments (const Standard_Integer theMaxVertexs,
const Standard_Integer theMaxEdges,
const Standard_Boolean theHasVColors)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_SEGMENTS, theMaxVertexs, 0, theMaxEdges, Standard_False, theHasVColors, Standard_False, Standard_False)
{}

95
src/Graphic3d/Graphic3d_ArrayOfSegments.hxx
View File

@ -15,76 +15,47 @@
#ifndef _Graphic3d_ArrayOfSegments_HeaderFile #ifndef _Graphic3d_ArrayOfSegments_HeaderFile
#define _Graphic3d_ArrayOfSegments_HeaderFile #define _Graphic3d_ArrayOfSegments_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx> #include <Graphic3d_ArrayOfPrimitives.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
//! Contains segments array definition.
class Graphic3d_ArrayOfSegments;
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfSegments, Graphic3d_ArrayOfPrimitives)
//! Contains segments array definition
class Graphic3d_ArrayOfSegments : public Graphic3d_ArrayOfPrimitives class Graphic3d_ArrayOfSegments : public Graphic3d_ArrayOfPrimitives
{ {
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfSegments, Graphic3d_ArrayOfPrimitives)
public: public:
//! Creates an array of segments, a segment can be filled as:
//! Creates an array of segments, //! 1) Creating a set of segments defined with his vertexes, i.e:
//! a segment can be filled as: //! @code
//! 1) creating a set of segments defined with his vertexs. //! myArray = Graphic3d_ArrayOfSegments (4);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfSegments(4) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x4, y4, z4);
//! .... //! @endcode
//! myArray->AddVertex(x4,y4,z4) //! 2) Creating a set of indexed segments defined with his vertex and edges, i.e:
//! 2) creating a set of indexed segments defined with his vertex //! @code
//! ans edges. //! myArray = Graphic3d_ArrayOfSegments (4, 0, 8);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfSegments(4,0,8) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x4, y4, z4);
//! .... //! myArray->AddEdge (1);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddEdge (2);
//! myArray->AddEdge(1) //! myArray->AddEdge (3);
//! myArray->AddEdge(2) //! myArray->AddEdge (4);
//! myArray->AddEdge(3) //! myArray->AddEdge (2);
//! myArray->AddEdge(4) //! myArray->AddEdge (4);
//! myArray->AddEdge(2) //! myArray->AddEdge (1);
//! myArray->AddEdge(4) //! myArray->AddEdge (3);
//! myArray->AddEdge(1) //! @endcode
//! myArray->AddEdge(3) //! @param theMaxVertexs defines the maximum allowed vertex number in the array
//! //! @param theMaxEdges defines the maximum allowed edge number in the array
//! <maxVertexs> defined the maximun allowed vertex number in the array. //! @param theHasVColors when TRUE, AddVertex(Point,Color) should be used for specifying vertex color
//! <maxEdges> defined the maximun allowed edge number in the array. Graphic3d_ArrayOfSegments (const Standard_Integer theMaxVertexs,
//! Warning: const Standard_Integer theMaxEdges = 0,
//! When <hasVColors> is TRUE , you must use only const Standard_Boolean theHasVColors = Standard_False)
//! AddVertex(Point,Color) method : Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_SEGMENTS, theMaxVertexs, 0, theMaxEdges, Standard_False, theHasVColors, Standard_False, Standard_False) {}
Standard_EXPORT Graphic3d_ArrayOfSegments(const Standard_Integer maxVertexs, const Standard_Integer maxEdges = 0, const Standard_Boolean hasVColors = Standard_False);
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfSegments,Graphic3d_ArrayOfPrimitives)
protected:
private:
}; };
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfSegments, Graphic3d_ArrayOfPrimitives)
#endif // _Graphic3d_ArrayOfSegments_HeaderFile #endif // _Graphic3d_ArrayOfSegments_HeaderFile

28
src/Graphic3d/Graphic3d_ArrayOfTriangleFans.cxx
View File

@ -1,28 +0,0 @@
// Created on: 2001-01-04
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// 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.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_ArrayOfTriangleFans.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangleFans,Graphic3d_ArrayOfPrimitives)
Graphic3d_ArrayOfTriangleFans::Graphic3d_ArrayOfTriangleFans (const Standard_Integer theMaxVertexs,
const Standard_Integer theMaxFans,
const Standard_Boolean theHasVNormals,
const Standard_Boolean theHasVColors,
const Standard_Boolean theHasFColors,
const Standard_Boolean theHasVTexels)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_TRIANGLEFANS, theMaxVertexs, theMaxFans, 0, theHasVNormals, theHasVColors, theHasFColors, theHasVTexels)
{}

89
src/Graphic3d/Graphic3d_ArrayOfTriangleFans.hxx
View File

@ -15,72 +15,47 @@
#ifndef _Graphic3d_ArrayOfTriangleFans_HeaderFile #ifndef _Graphic3d_ArrayOfTriangleFans_HeaderFile
#define _Graphic3d_ArrayOfTriangleFans_HeaderFile #define _Graphic3d_ArrayOfTriangleFans_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx> #include <Graphic3d_ArrayOfPrimitives.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Graphic3d_ArrayOfTriangleFans;
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfTriangleFans, Graphic3d_ArrayOfPrimitives)
//! Contains triangles fan array definition //! Contains triangles fan array definition
class Graphic3d_ArrayOfTriangleFans : public Graphic3d_ArrayOfPrimitives class Graphic3d_ArrayOfTriangleFans : public Graphic3d_ArrayOfPrimitives
{ {
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangleFans, Graphic3d_ArrayOfPrimitives)
public: public:
//! Creates an array of triangle fans, a polygon can be filled as:
//! Creates an array of triangle fans, //! 1) Creating a single fan defined with his vertexes, i.e:
//! a polygon can be filled as: //! @code
//! 1) creating a single fan defined with his vertexs. //! myArray = Graphic3d_ArrayOfTriangleFans (7);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfTriangleFans(7) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x7, y7, z7);
//! .... //! @endcode
//! myArray->AddVertex(x7,y7,z7) //! 2) creating separate fans defined with a predefined number of fans and the number of vertex per fan, i.e:
//! 2) creating separate fans defined with a predefined //! @code
//! number of fans and the number of vertex per fan. //! myArray = Graphic3d_ArrayOfTriangleFans (8, 2);
//! i.e: //! myArray->AddBound (4);
//! myArray = Graphic3d_ArrayOfTriangleFans(8,2) //! myArray->AddVertex (x1, y1, z1);
//! myArray->AddBound(4) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x4, y4, z4);
//! .... //! myArray->AddBound (4);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddVertex (x5, y5, z5);
//! myArray->AddBound(4) //! ....
//! myArray->AddVertex(x5,y5,z5) //! myArray->AddVertex (x8, y8, z8);
//! .... //! @endcode
//! myArray->AddVertex(x8,y8,z8) //! @param theMaxVertexs defines the maximum allowed vertex number in the array
//! //! @param theMaxFans defines the maximum allowed fan number in the array
//! <maxVertexs> defined the maximun allowed vertex number in the array. //! The number of triangle really drawn is: VertexNumber() - 2 * Min(1, BoundNumber())
//! <maxFans> defined the maximun allowed fan number in the array. Graphic3d_ArrayOfTriangleFans (const Standard_Integer theMaxVertexs,
//! The number of triangle really drawn is : const Standard_Integer theMaxFans = 0,
//! VertexNumber()-2*Min(1,BoundNumber()) const Standard_Boolean theHasVNormals = Standard_False,
Standard_EXPORT Graphic3d_ArrayOfTriangleFans(const Standard_Integer maxVertexs, const Standard_Integer maxFans = 0, const Standard_Boolean hasVNormals = Standard_False, const Standard_Boolean hasVColors = Standard_False, const Standard_Boolean hasFColors = Standard_False, const Standard_Boolean hasTexels = Standard_False); const Standard_Boolean theHasVColors = Standard_False,
const Standard_Boolean theHasBColors = Standard_False,
const Standard_Boolean theHasVTexels = Standard_False)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_TRIANGLEFANS, theMaxVertexs, theMaxFans, 0, theHasVNormals, theHasVColors, theHasBColors, theHasVTexels) {}
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangleFans,Graphic3d_ArrayOfPrimitives)
protected:
private:
}; };
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfTriangleFans, Graphic3d_ArrayOfPrimitives)
#endif // _Graphic3d_ArrayOfTriangleFans_HeaderFile #endif // _Graphic3d_ArrayOfTriangleFans_HeaderFile

28
src/Graphic3d/Graphic3d_ArrayOfTriangleStrips.cxx
View File

@ -1,28 +0,0 @@
// Created on: 2001-01-04
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// 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.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_ArrayOfTriangleStrips.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangleStrips,Graphic3d_ArrayOfPrimitives)
Graphic3d_ArrayOfTriangleStrips::Graphic3d_ArrayOfTriangleStrips (const Standard_Integer theMaxVertexs,
const Standard_Integer theMaxStrips,
const Standard_Boolean theHasVNormals,
const Standard_Boolean theHasVColors,
const Standard_Boolean theHasSColors,
const Standard_Boolean theHasVTexels)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_TRIANGLESTRIPS, theMaxVertexs, theMaxStrips, 0, theHasVNormals, theHasVColors, theHasSColors, theHasVTexels)
{}

115
src/Graphic3d/Graphic3d_ArrayOfTriangleStrips.hxx
View File

@ -15,91 +15,52 @@
#ifndef _Graphic3d_ArrayOfTriangleStrips_HeaderFile #ifndef _Graphic3d_ArrayOfTriangleStrips_HeaderFile
#define _Graphic3d_ArrayOfTriangleStrips_HeaderFile #define _Graphic3d_ArrayOfTriangleStrips_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx> #include <Graphic3d_ArrayOfPrimitives.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
//! Contains triangles strip array definition.
class Graphic3d_ArrayOfTriangleStrips;
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfTriangleStrips, Graphic3d_ArrayOfPrimitives)
//! Contains triangles strip array definition
class Graphic3d_ArrayOfTriangleStrips : public Graphic3d_ArrayOfPrimitives class Graphic3d_ArrayOfTriangleStrips : public Graphic3d_ArrayOfPrimitives
{ {
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangleStrips, Graphic3d_ArrayOfPrimitives)
public: public:
//! Creates an array of triangle strips, a polygon can be filled as:
//! Creates an array of triangle strips, //! 1) Creating a single strip defined with his vertexes, i.e:
//! a polygon can be filled as: //! @code
//! 1) creating a single strip defined with his vertexs. //! myArray = Graphic3d_ArrayOfTriangleStrips (7);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfTriangleStrips(7) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x7, y7, z7);
//! .... //! @endcode
//! myArray->AddVertex(x7,y7,z7) //! 2) Creating separate strips defined with a predefined number of strips and the number of vertex per strip, i.e:
//! 2) creating separate strips defined with a predefined //! @code
//! number of strips and the number of vertex per strip. //! myArray = Graphic3d_ArrayOfTriangleStrips (8, 2);
//! i.e: //! myArray->AddBound (4);
//! myArray = Graphic3d_ArrayOfTriangleStrips(8,2) //! myArray->AddVertex (x1, y1, z1);
//! myArray->AddBound(4) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x4, y4, z4);
//! .... //! myArray->AddBound (4);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddVertex (x5, y5, z5);
//! myArray->AddBound(4) //! ....
//! myArray->AddVertex(x5,y5,z5) //! myArray->AddVertex (x8, y8, z8);
//! .... //! @endcode
//! myArray->AddVertex(x8,y8,z8) //! @param theMaxVertexs defines the maximum allowed vertex number in the array
//! //! @param theMaxStrips defines the maximum allowed strip number in the array;
//! <maxVertexs> defined the maximun allowed vertex number in the array. //! the number of triangle really drawn is: VertexNumber() - 2 * Min(1, BoundNumber())
//! <maxStrips> defined the maximun allowed strip number in the array. //! @param theHasVNormals when TRUE, AddVertex(Point,Normal), AddVertex(Point,Normal,Color) or AddVertex(Point,Normal,Texel) should be used to specify vertex normal;
//! The number of triangle really drawn is : //! vertex normals should be specified coherent to triangle orientation (defined by order of vertexes within triangle) for proper rendering
//! VertexNumber()-2*Min(1,BoundNumber()) //! @param theHasVColors when TRUE, AddVertex(Point,Color) or AddVertex(Point,Normal,Color) should be used to specify vertex color
//! Warning: //! @param theHasBColors when TRUE, AddBound(number,Color) should be used to specify sub-group color
//! When <hasVNormals> is TRUE , you must use one of //! @param theHasVTexels when TRUE, AddVertex(Point,Texel) or AddVertex(Point,Normal,Texel) should be used to specify vertex UV coordinates
//! AddVertex(Point,Normal) Graphic3d_ArrayOfTriangleStrips (const Standard_Integer theMaxVertexs,
//! or AddVertex(Point,Normal,Color) const Standard_Integer theMaxStrips = 0,
//! or AddVertex(Point,Normal,Texel) methods. const Standard_Boolean theHasVNormals = Standard_False,
//! When <hasVColors> is TRUE , you must use one of const Standard_Boolean theHasVColors = Standard_False,
//! AddVertex(Point,Color) const Standard_Boolean theHasBColors = Standard_False,
//! or AddVertex(Point,Normal,Color) methods. const Standard_Boolean theHasVTexels = Standard_False)
//! When <hasTexels> is TRUE , you must use one of : Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_TRIANGLESTRIPS, theMaxVertexs, theMaxStrips, 0, theHasVNormals, theHasVColors, theHasBColors, theHasVTexels) {}
//! AddVertex(Point,Texel)
//! or AddVertex(Point,Normal,Texel) methods.
//! When <hasBColors> is TRUE , <maxBounds> must be > 0 and
//! you must use the
//! AddBound(number,Color) method.
//! Warning:
//! the user is responsible about the orientation of the strip
//! depending of the order of the created vertex and this
//! orientation must be coherent with the vertex normal optionnaly
//! given at each vertex (See the Orientate() methods).
Standard_EXPORT Graphic3d_ArrayOfTriangleStrips(const Standard_Integer maxVertexs, const Standard_Integer maxStrips = 0, const Standard_Boolean hasVNormals = Standard_False, const Standard_Boolean hasVColors = Standard_False, const Standard_Boolean hasSColors = Standard_False, const Standard_Boolean hasTexels = Standard_False);
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangleStrips,Graphic3d_ArrayOfPrimitives)
protected:
private:
}; };
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfTriangleStrips, Graphic3d_ArrayOfPrimitives)
#endif // _Graphic3d_ArrayOfTriangleStrips_HeaderFile #endif // _Graphic3d_ArrayOfTriangleStrips_HeaderFile

27
src/Graphic3d/Graphic3d_ArrayOfTriangles.cxx
View File

@ -1,27 +0,0 @@
// Created on: 2001-01-04
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// 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.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_ArrayOfTriangles.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangles,Graphic3d_ArrayOfPrimitives)
Graphic3d_ArrayOfTriangles::Graphic3d_ArrayOfTriangles (const Standard_Integer theMaxVertexs,
const Standard_Integer theMaxEdges,
const Standard_Boolean theHasVNormals,
const Standard_Boolean theHasVColors,
const Standard_Boolean theHasVTexels)
: Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_TRIANGLES, theMaxVertexs, 0, theMaxEdges, theHasVNormals, theHasVColors, Standard_False, theHasVTexels)
{}

109
src/Graphic3d/Graphic3d_ArrayOfTriangles.hxx
View File

@ -15,87 +15,50 @@
#ifndef _Graphic3d_ArrayOfTriangles_HeaderFile #ifndef _Graphic3d_ArrayOfTriangles_HeaderFile
#define _Graphic3d_ArrayOfTriangles_HeaderFile #define _Graphic3d_ArrayOfTriangles_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx> #include <Graphic3d_ArrayOfPrimitives.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Graphic3d_ArrayOfTriangles;
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfTriangles, Graphic3d_ArrayOfPrimitives)
//! Contains triangles array definition //! Contains triangles array definition
class Graphic3d_ArrayOfTriangles : public Graphic3d_ArrayOfPrimitives class Graphic3d_ArrayOfTriangles : public Graphic3d_ArrayOfPrimitives
{ {
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangles, Graphic3d_ArrayOfPrimitives)
public: public:
//! Creates an array of triangles, a triangle can be filled as:
//! Creates an array of triangles, //! 1) Creating a set of triangles defined with his vertexes, i.e:
//! a triangle can be filled as: //! @code
//! 1) creating a set of triangles defined with his vertexs. //! myArray = Graphic3d_ArrayOfTriangles (6);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfTriangles(6) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x6, y6, z6);
//! .... //! @endcode
//! myArray->AddVertex(x6,y6,z6) //! 3) Creating a set of indexed triangles defined with his vertex and edges, i.e:
//! 3) creating a set of indexed triangles defined with his vertex //! @code
//! ans edges. //! myArray = Graphic3d_ArrayOfTriangles (4, 6);
//! i.e: //! myArray->AddVertex (x1, y1, z1);
//! myArray = Graphic3d_ArrayOfTriangles(4,6) //! ....
//! myArray->AddVertex(x1,y1,z1) //! myArray->AddVertex (x4, y4, z4);
//! .... //! myArray->AddEdge (1);
//! myArray->AddVertex(x4,y4,z4) //! myArray->AddEdge (2);
//! myArray->AddEdge(1) //! myArray->AddEdge (3);
//! myArray->AddEdge(2) //! myArray->AddEdge (2);
//! myArray->AddEdge(3) //! myArray->AddEdge (3);
//! myArray->AddEdge(2) //! myArray->AddEdge (4);
//! myArray->AddEdge(3) //! @endcode
//! myArray->AddEdge(4) //! @param theMaxVertexs defines the maximum allowed vertex number in the array
//! //! @param theMaxEdges defines the maximum allowed edge number in the array
//! <maxVertexs> defined the maximun allowed vertex number in the array. //! @param theHasVNormals when TRUE, AddVertex(Point,Normal), AddVertex(Point,Normal,Color) or AddVertex(Point,Normal,Texel) should be used to specify vertex normal;
//! <maxEdges> defined the maximun allowed edge number in the array. //! vertex normals should be specified coherent to triangle orientation (defined by order of vertexes within triangle) for proper rendering
//! Warning: //! @param theHasVColors when TRUE, AddVertex(Point,Color) or AddVertex(Point,Normal,Color) should be used to specify vertex color
//! When <hasVNormals> is TRUE , you must use one of //! @param theHasVTexels when TRUE, AddVertex(Point,Texel) or AddVertex(Point,Normal,Texel) should be used to specify vertex UV coordinates
//! AddVertex(Point,Normal) Graphic3d_ArrayOfTriangles (const Standard_Integer theMaxVertexs,
//! or AddVertex(Point,Normal,Color) const Standard_Integer theMaxEdges = 0,
//! or AddVertex(Point,Normal,Texel) methods. const Standard_Boolean theHasVNormals = Standard_False,
//! When <hasVColors> is TRUE , you must use one of const Standard_Boolean theHasVColors = Standard_False,
//! AddVertex(Point,Color) const Standard_Boolean theHasVTexels = Standard_False)
//! or AddVertex(Point,Normal,Color) methods. : Graphic3d_ArrayOfPrimitives (Graphic3d_TOPA_TRIANGLES, theMaxVertexs, 0, theMaxEdges, theHasVNormals, theHasVColors, Standard_False, theHasVTexels) {}
//! When <hasTexels> is TRUE , you must use one of
//! AddVertex(Point,Texel)
//! or AddVertex(Point,Normal,Texel) methods.
//! Warning:
//! the user is responsible about the orientation of the triangle
//! depending of the order of the created vertex or edges and this
//! orientation must be coherent with the vertex normal optionnaly
//! given at each vertex (See the Orientate() methods).
Standard_EXPORT Graphic3d_ArrayOfTriangles(const Standard_Integer maxVertexs, const Standard_Integer maxEdges = 0, const Standard_Boolean hasVNormals = Standard_False, const Standard_Boolean hasVColors = Standard_False, const Standard_Boolean hasTexels = Standard_False);
DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfTriangles,Graphic3d_ArrayOfPrimitives)
protected:
private:
}; };
DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfTriangles, Graphic3d_ArrayOfPrimitives)
#endif // _Graphic3d_ArrayOfTriangles_HeaderFile #endif // _Graphic3d_ArrayOfTriangles_HeaderFile

33
src/Graphic3d/Graphic3d_TypeOfPrimitiveArray.hxx
View File

@ -20,16 +20,29 @@
//! The type of primitive array in a group in a structure. //! The type of primitive array in a group in a structure.
enum Graphic3d_TypeOfPrimitiveArray enum Graphic3d_TypeOfPrimitiveArray
{ {
Graphic3d_TOPA_UNDEFINED, Graphic3d_TOPA_UNDEFINED, //!< undefined primitive type
Graphic3d_TOPA_POINTS, // main rendering types
Graphic3d_TOPA_POLYLINES, Graphic3d_TOPA_POINTS, //!< individual points
Graphic3d_TOPA_SEGMENTS, Graphic3d_TOPA_SEGMENTS, //!< segments array - each 2 vertexes define 1 segment
Graphic3d_TOPA_POLYGONS, Graphic3d_TOPA_POLYLINES, //!< line strip - each new vertex in array defines segment with previous one
Graphic3d_TOPA_TRIANGLES, Graphic3d_TOPA_TRIANGLES, //!< triangle array - each 3 vertexes define 1 triangle
Graphic3d_TOPA_QUADRANGLES, Graphic3d_TOPA_TRIANGLESTRIPS, //!< triangle strip - each new vertex in array defines triangle with 2 previous vertexes
Graphic3d_TOPA_TRIANGLESTRIPS, Graphic3d_TOPA_TRIANGLEFANS, //!< triangle fan - each new vertex in array define triangle with the previous vertex and the very first vertex (fan center)
Graphic3d_TOPA_QUADRANGLESTRIPS, // rendering type with auxiliary adjacent info (can be accessed only within Geometry shader)
Graphic3d_TOPA_TRIANGLEFANS Graphic3d_TOPA_LINES_ADJACENCY, //!< ADVANCED - same as Graphic3d_TOPA_SEGMENTS, but each pair of vertexes defining 1 segment
//! is preceded by 1 extra vertex and followed by 1 extra vertex which are not actually rendered
Graphic3d_TOPA_LINE_STRIP_ADJACENCY, //!< ADVANCED - same as Graphic3d_TOPA_POLYLINES, but each sequence of vertexes defining 1 polyline
//! is preceded by 1 extra vertex and followed by 1 extra vertex which are not actually rendered
Graphic3d_TOPA_TRIANGLES_ADJACENCY, //!< ADVANCED - same as Graphic3d_TOPA_TRIANGLES, but each vertex defining of triangle
//! is followed by 1 extra adjacent vertex which is not actually rendered
Graphic3d_TOPA_TRIANGLE_STRIP_ADJACENCY, //!< ADVANCED - same as Graphic3d_TOPA_TRIANGLESTRIPS, but with extra adjacent vertexes
// deprecated types, unsupported by mobile hardware
Graphic3d_TOPA_QUADRANGLES, //!< DEPRECATED - triangle array should be used instead;
//! array of quads - each 4 vertexes define single quad
Graphic3d_TOPA_QUADRANGLESTRIPS, //!< DEPRECATED - triangle array should be used instead;
//! quad strip - each 2 new vertexes define a quad shared 2 more vertexes of previous quad
Graphic3d_TOPA_POLYGONS //!< DEPRECATED - triangle array should be used instead;
//! array defines a polygon
}; };
#endif // _Graphic3d_TypeOfPrimitiveArray_HeaderFile #endif // _Graphic3d_TypeOfPrimitiveArray_HeaderFile

12
src/Graphic3d/Graphic3d_TypeOfShaderObject.hxx
View File

@ -16,11 +16,17 @@
#ifndef _Graphic3d_TypeOfShaderObject_HeaderFile #ifndef _Graphic3d_TypeOfShaderObject_HeaderFile
#define _Graphic3d_TypeOfShaderObject_HeaderFile #define _Graphic3d_TypeOfShaderObject_HeaderFile
//! Type of the shader object (may be extended). //! Type of the shader object.
enum Graphic3d_TypeOfShaderObject enum Graphic3d_TypeOfShaderObject
{ {
Graphic3d_TOS_VERTEX, // rendering shaders
Graphic3d_TOS_FRAGMENT Graphic3d_TOS_VERTEX = 0x01, //!< vertex shader object, mandatory
Graphic3d_TOS_TESS_CONTROL = 0x02, //!< tessellation control shader object, optional
Graphic3d_TOS_TESS_EVALUATION = 0x04, //!< tessellation evaluation shader object, optional
Graphic3d_TOS_GEOMETRY = 0x08, //!< geometry shader object, optional
Graphic3d_TOS_FRAGMENT = 0x10, //!< fragment shader object, mandatory
// general-purpose compute shader
Graphic3d_TOS_COMPUTE = 0x20 //!< compute shader object, should be used as alternative to shader object types for rendering
}; };
#endif #endif

3
src/OpenGl/OpenGl_CappingAlgo.cxx
View File

@ -230,6 +230,5 @@ Standard_Boolean OpenGl_CappingAlgoFilter::ShouldRender (const Handle(OpenGl_Wor
const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement); const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
return aPArray != NULL return aPArray != NULL
&& aPArray->DrawMode() >= OpenGl_PrimitiveArray::THE_FILLPRIM_FROM && aPArray->IsFillDrawMode();
&& aPArray->DrawMode() <= OpenGl_PrimitiveArray::THE_FILLPRIM_TO;
} }

13
src/OpenGl/OpenGl_GlFunctions.hxx
View File

@ -198,6 +198,19 @@
// OpenGL ES 3.0+ or OES_texture_half_float // OpenGL ES 3.0+ or OES_texture_half_float
#define GL_HALF_FLOAT 0x140B #define GL_HALF_FLOAT 0x140B
#define GL_HALF_FLOAT_OES 0x8D61 #define GL_HALF_FLOAT_OES 0x8D61
// OpenGL ES 3.1+
#define GL_COMPUTE_SHADER 0x91B9
// OpenGL ES 3.2+
#define GL_GEOMETRY_SHADER 0x8DD9
#define GL_TESS_CONTROL_SHADER 0x8E88
#define GL_TESS_EVALUATION_SHADER 0x8E87
#define GL_LINES_ADJACENCY 0x000A
#define GL_LINE_STRIP_ADJACENCY 0x000B
#define GL_TRIANGLES_ADJACENCY 0x000C
#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D
#define GL_PATCHES 0x000E
#endif #endif
#if !defined(HAVE_EGL) && (defined(__ANDROID__) || defined(__QNX__) || defined(HAVE_GLES2) || defined(OCCT_UWP)) #if !defined(HAVE_EGL) && (defined(__ANDROID__) || defined(__QNX__) || defined(HAVE_GLES2) || defined(OCCT_UWP))

6
src/OpenGl/OpenGl_LayerList.cxx
View File

@ -665,8 +665,7 @@ Standard_Boolean OpenGl_LayerList::OpenGl_OpaqueFilter::ShouldRender (const Hand
const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement); const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
if (aPArray == NULL if (aPArray == NULL
|| aPArray->DrawMode() < OpenGl_PrimitiveArray::THE_FILLPRIM_FROM || !aPArray->IsFillDrawMode())
|| aPArray->DrawMode() > OpenGl_PrimitiveArray::THE_FILLPRIM_TO)
{ {
return Standard_True; return Standard_True;
} }
@ -697,8 +696,7 @@ Standard_Boolean OpenGl_LayerList::OpenGl_TransparentFilter::ShouldRender (const
const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement); const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
if (aPArray == NULL if (aPArray == NULL
|| aPArray->DrawMode() < OpenGl_PrimitiveArray::THE_FILLPRIM_FROM || !aPArray->IsFillDrawMode())
|| aPArray->DrawMode() > OpenGl_PrimitiveArray::THE_FILLPRIM_TO)
{ {
return dynamic_cast<const OpenGl_AspectFace*> (theGlElement) != NULL; return dynamic_cast<const OpenGl_AspectFace*> (theGlElement) != NULL;
} }

101
src/OpenGl/OpenGl_PrimitiveArray.cxx
View File

@ -373,8 +373,12 @@ void OpenGl_PrimitiveArray::drawArray (const Handle(OpenGl_Workspace)& theWorksp
return; return;
} }
const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext(); const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
const bool toHilight = theWorkspace->ToHighlight(); const bool toHilight = theWorkspace->ToHighlight();
const GLenum aDrawMode = !aGlContext->ActiveProgram().IsNull()
&& aGlContext->ActiveProgram()->HasTessellationStage()
? GL_PATCHES
: myDrawMode;
myVboAttribs->BindAllAttributes (aGlContext); myVboAttribs->BindAllAttributes (aGlContext);
if (theHasVertColor && toHilight) if (theHasVertColor && toHilight)
{ {
@ -393,14 +397,14 @@ void OpenGl_PrimitiveArray::drawArray (const Handle(OpenGl_Workspace)& theWorksp
{ {
const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter]; const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
if (theFaceColors != NULL) aGlContext->SetColor4fv (theFaceColors[aGroupIter]); if (theFaceColors != NULL) aGlContext->SetColor4fv (theFaceColors[aGroupIter]);
glDrawElements (myDrawMode, aNbElemsInGroup, myVboIndices->GetDataType(), anOffset); glDrawElements (aDrawMode, aNbElemsInGroup, myVboIndices->GetDataType(), anOffset);
anOffset += aStride * aNbElemsInGroup; anOffset += aStride * aNbElemsInGroup;
} }
} }
else else
{ {
// draw one (or sequential) primitive by the indices // draw one (or sequential) primitive by the indices
glDrawElements (myDrawMode, myVboIndices->GetElemsNb(), myVboIndices->GetDataType(), anOffset); glDrawElements (aDrawMode, myVboIndices->GetElemsNb(), myVboIndices->GetDataType(), anOffset);
} }
myVboIndices->Unbind (aGlContext); myVboIndices->Unbind (aGlContext);
} }
@ -411,7 +415,7 @@ void OpenGl_PrimitiveArray::drawArray (const Handle(OpenGl_Workspace)& theWorksp
{ {
const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter]; const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
if (theFaceColors != NULL) aGlContext->SetColor4fv (theFaceColors[aGroupIter]); if (theFaceColors != NULL) aGlContext->SetColor4fv (theFaceColors[aGroupIter]);
glDrawArrays (myDrawMode, aFirstElem, aNbElemsInGroup); glDrawArrays (aDrawMode, aFirstElem, aNbElemsInGroup);
aFirstElem += aNbElemsInGroup; aFirstElem += aNbElemsInGroup;
} }
} }
@ -423,7 +427,7 @@ void OpenGl_PrimitiveArray::drawArray (const Handle(OpenGl_Workspace)& theWorksp
} }
else else
{ {
glDrawArrays (myDrawMode, 0, myVboAttribs->GetElemsNb()); glDrawArrays (aDrawMode, 0, myVboAttribs->GetElemsNb());
} }
} }
@ -466,6 +470,10 @@ void OpenGl_PrimitiveArray::drawEdges (const OpenGl_Vec4& theEdgeCo
Standard_False, Standard_False,
anAspect->ShaderProgramRes (aGlContext)); anAspect->ShaderProgramRes (aGlContext));
} }
const GLenum aDrawMode = !aGlContext->ActiveProgram().IsNull()
&& aGlContext->ActiveProgram()->HasTessellationStage()
? GL_PATCHES
: myDrawMode;
/// OCC22236 NOTE: draw edges for all situations: /// OCC22236 NOTE: draw edges for all situations:
/// 1) draw elements with GL_LINE style as edges from myPArray->bufferVBO[VBOEdges] indices array /// 1) draw elements with GL_LINE style as edges from myPArray->bufferVBO[VBOEdges] indices array
@ -489,14 +497,14 @@ void OpenGl_PrimitiveArray::drawEdges (const OpenGl_Vec4& theEdgeCo
for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter) for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
{ {
const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter]; const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
glDrawElements (myDrawMode, aNbElemsInGroup, myVboIndices->GetDataType(), anOffset); glDrawElements (aDrawMode, aNbElemsInGroup, myVboIndices->GetDataType(), anOffset);
anOffset += aStride * aNbElemsInGroup; anOffset += aStride * aNbElemsInGroup;
} }
} }
// draw one (or sequential) primitive by the indices // draw one (or sequential) primitive by the indices
else else
{ {
glDrawElements (myDrawMode, myVboIndices->GetElemsNb(), myVboIndices->GetDataType(), anOffset); glDrawElements (aDrawMode, myVboIndices->GetElemsNb(), myVboIndices->GetDataType(), anOffset);
} }
myVboIndices->Unbind (aGlContext); myVboIndices->Unbind (aGlContext);
} }
@ -506,13 +514,13 @@ void OpenGl_PrimitiveArray::drawEdges (const OpenGl_Vec4& theEdgeCo
for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter) for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
{ {
const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter]; const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
glDrawArrays (myDrawMode, aFirstElem, aNbElemsInGroup); glDrawArrays (aDrawMode, aFirstElem, aNbElemsInGroup);
aFirstElem += aNbElemsInGroup; aFirstElem += aNbElemsInGroup;
} }
} }
else else
{ {
glDrawArrays (myDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements); glDrawArrays (aDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
} }
// unbind buffers // unbind buffers
@ -528,8 +536,13 @@ void OpenGl_PrimitiveArray::drawEdges (const OpenGl_Vec4& theEdgeCo
// ======================================================================= // =======================================================================
void OpenGl_PrimitiveArray::drawMarkers (const Handle(OpenGl_Workspace)& theWorkspace) const void OpenGl_PrimitiveArray::drawMarkers (const Handle(OpenGl_Workspace)& theWorkspace) const
{ {
const OpenGl_AspectMarker* anAspectMarker = theWorkspace->ApplyAspectMarker(); const OpenGl_AspectMarker* anAspectMarker = theWorkspace->ApplyAspectMarker();
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext(); const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
const GLenum aDrawMode = !aCtx->ActiveProgram().IsNull()
&& aCtx->ActiveProgram()->HasTessellationStage()
? GL_PATCHES
: myDrawMode;
const Handle(OpenGl_TextureSet)& aSpriteNormRes = anAspectMarker->SpriteRes (aCtx); const Handle(OpenGl_TextureSet)& aSpriteNormRes = anAspectMarker->SpriteRes (aCtx);
const OpenGl_PointSprite* aSpriteNorm = !aSpriteNormRes.IsNull() ? dynamic_cast<const OpenGl_PointSprite*> (aSpriteNormRes->First().get()) : NULL; const OpenGl_PointSprite* aSpriteNorm = !aSpriteNormRes.IsNull() ? dynamic_cast<const OpenGl_PointSprite*> (aSpriteNormRes->First().get()) : NULL;
if (aSpriteNorm != NULL if (aSpriteNorm != NULL
@ -549,7 +562,7 @@ void OpenGl_PrimitiveArray::drawMarkers (const Handle(OpenGl_Workspace)& theWork
aCtx->core11fwd->glEnable (GL_BLEND); aCtx->core11fwd->glEnable (GL_BLEND);
aCtx->core11fwd->glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); aCtx->core11fwd->glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
aCtx->core11fwd->glDrawArrays (myDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements); aCtx->core11fwd->glDrawArrays (aDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
aCtx->core11fwd->glDisable (GL_BLEND); aCtx->core11fwd->glDisable (GL_BLEND);
#if !defined(GL_ES_VERSION_2_0) #if !defined(GL_ES_VERSION_2_0)
@ -564,7 +577,7 @@ void OpenGl_PrimitiveArray::drawMarkers (const Handle(OpenGl_Workspace)& theWork
else if (anAspectMarker->Aspect()->Type() == Aspect_TOM_POINT) else if (anAspectMarker->Aspect()->Type() == Aspect_TOM_POINT)
{ {
aCtx->SetPointSize (anAspectMarker->MarkerSize()); aCtx->SetPointSize (anAspectMarker->MarkerSize());
aCtx->core11fwd->glDrawArrays (myDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements); aCtx->core11fwd->glDrawArrays (aDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
aCtx->SetPointSize (1.0f); aCtx->SetPointSize (1.0f);
} }
#if !defined(GL_ES_VERSION_2_0) #if !defined(GL_ES_VERSION_2_0)
@ -600,6 +613,7 @@ void OpenGl_PrimitiveArray::drawMarkers (const Handle(OpenGl_Workspace)& theWork
OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (const OpenGl_GraphicDriver* theDriver) OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (const OpenGl_GraphicDriver* theDriver)
: myDrawMode (DRAW_MODE_NONE), : myDrawMode (DRAW_MODE_NONE),
myIsFillType(Standard_False),
myIsVboInit (Standard_False) myIsVboInit (Standard_False)
{ {
if (theDriver != NULL) if (theDriver != NULL)
@ -622,6 +636,7 @@ OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (const OpenGl_GraphicDriver*
myAttribs (theAttribs), myAttribs (theAttribs),
myBounds (theBounds), myBounds (theBounds),
myDrawMode (DRAW_MODE_NONE), myDrawMode (DRAW_MODE_NONE),
myIsFillType(Standard_False),
myIsVboInit (Standard_False) myIsVboInit (Standard_False)
{ {
if (!myIndices.IsNull() if (!myIndices.IsNull()
@ -876,45 +891,75 @@ void OpenGl_PrimitiveArray::setDrawMode (const Graphic3d_TypeOfPrimitiveArray th
if (myAttribs.IsNull()) if (myAttribs.IsNull())
{ {
myDrawMode = DRAW_MODE_NONE; myDrawMode = DRAW_MODE_NONE;
myIsFillType = false;
return; return;
} }
switch (theType) switch (theType)
{ {
case Graphic3d_TOPA_POINTS: case Graphic3d_TOPA_POINTS:
myDrawMode = GL_POINTS; myDrawMode = GL_POINTS;
break; myIsFillType = false;
case Graphic3d_TOPA_POLYLINES:
myDrawMode = GL_LINE_STRIP;
break; break;
case Graphic3d_TOPA_SEGMENTS: case Graphic3d_TOPA_SEGMENTS:
myDrawMode = GL_LINES; myDrawMode = GL_LINES;
myIsFillType = false;
break;
case Graphic3d_TOPA_POLYLINES:
myDrawMode = GL_LINE_STRIP;
myIsFillType = false;
break; break;
case Graphic3d_TOPA_TRIANGLES: case Graphic3d_TOPA_TRIANGLES:
myDrawMode = GL_TRIANGLES; myDrawMode = GL_TRIANGLES;
myIsFillType = true;
break; break;
case Graphic3d_TOPA_TRIANGLESTRIPS: case Graphic3d_TOPA_TRIANGLESTRIPS:
myDrawMode = GL_TRIANGLE_STRIP; myDrawMode = GL_TRIANGLE_STRIP;
myIsFillType = true;
break; break;
case Graphic3d_TOPA_TRIANGLEFANS: case Graphic3d_TOPA_TRIANGLEFANS:
myDrawMode = GL_TRIANGLE_FAN; myDrawMode = GL_TRIANGLE_FAN;
myIsFillType = true;
break; break;
//
case Graphic3d_TOPA_LINES_ADJACENCY:
myDrawMode = GL_LINES_ADJACENCY;
myIsFillType = false;
break;
case Graphic3d_TOPA_LINE_STRIP_ADJACENCY:
myDrawMode = GL_LINE_STRIP_ADJACENCY;
myIsFillType = false;
break;
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) #if !defined(GL_ES_VERSION_2_0)
case Graphic3d_TOPA_POLYGONS:
myDrawMode = GL_POLYGON;
break;
case Graphic3d_TOPA_QUADRANGLES: case Graphic3d_TOPA_QUADRANGLES:
myDrawMode = GL_QUADS; myDrawMode = GL_QUADS;
myIsFillType = true;
break; break;
case Graphic3d_TOPA_QUADRANGLESTRIPS: case Graphic3d_TOPA_QUADRANGLESTRIPS:
myDrawMode = GL_QUAD_STRIP; myDrawMode = GL_QUAD_STRIP;
myIsFillType = true;
break;
case Graphic3d_TOPA_POLYGONS:
myDrawMode = GL_POLYGON;
myIsFillType = true;
break; break;
#else #else
case Graphic3d_TOPA_POLYGONS:
case Graphic3d_TOPA_QUADRANGLES: case Graphic3d_TOPA_QUADRANGLES:
case Graphic3d_TOPA_QUADRANGLESTRIPS: case Graphic3d_TOPA_QUADRANGLESTRIPS:
case Graphic3d_TOPA_POLYGONS:
#endif #endif
case Graphic3d_TOPA_UNDEFINED: case Graphic3d_TOPA_UNDEFINED:
myDrawMode = DRAW_MODE_NONE;
myIsFillType = false;
break; break;
} }
} }

19
src/OpenGl/OpenGl_PrimitiveArray.hxx
View File

@ -32,22 +32,13 @@ class OpenGl_GraphicDriver;
class OpenGl_PrimitiveArray : public OpenGl_Element class OpenGl_PrimitiveArray : public OpenGl_Element
{ {
public: public:
// OpenGL does not provide a constant for "none" draw mode. //! OpenGL does not provide a constant for "none" draw mode.
// So we define our own one that does not conflict with GL constants //! So we define our own one that does not conflict with GL constants and utilizes common GL invalid value.
// and utilizes common GL invalid value
enum enum
{ {
DRAW_MODE_NONE = -1 DRAW_MODE_NONE = -1
}; };
#if !defined(GL_ES_VERSION_2_0)
static const GLint THE_FILLPRIM_FROM = GL_TRIANGLES;
static const GLint THE_FILLPRIM_TO = GL_POLYGON;
#else
static const GLint THE_FILLPRIM_FROM = GL_TRIANGLES;
static const GLint THE_FILLPRIM_TO = GL_TRIANGLE_FAN;
#endif
//! Empty constructor //! Empty constructor
Standard_EXPORT OpenGl_PrimitiveArray (const OpenGl_GraphicDriver* theDriver); Standard_EXPORT OpenGl_PrimitiveArray (const OpenGl_GraphicDriver* theDriver);
@ -78,6 +69,9 @@ public:
//! @return primitive type (GL_LINES, GL_TRIANGLES and others) //! @return primitive type (GL_LINES, GL_TRIANGLES and others)
GLint DrawMode() const { return myDrawMode; } GLint DrawMode() const { return myDrawMode; }
//! Return TRUE if primitive type generates shaded triangulation.
Standard_Boolean IsFillDrawMode() const { return myIsFillType; }
//! @return indices array //! @return indices array
const Handle(Graphic3d_IndexBuffer)& Indices() const { return myIndices; } const Handle(Graphic3d_IndexBuffer)& Indices() const { return myIndices; }
@ -139,7 +133,8 @@ protected:
mutable Handle(Graphic3d_IndexBuffer) myIndices; mutable Handle(Graphic3d_IndexBuffer) myIndices;
mutable Handle(Graphic3d_Buffer) myAttribs; mutable Handle(Graphic3d_Buffer) myAttribs;
mutable Handle(Graphic3d_BoundBuffer) myBounds; mutable Handle(Graphic3d_BoundBuffer) myBounds;
GLint myDrawMode; GLshort myDrawMode;
mutable Standard_Boolean myIsFillType;
mutable Standard_Boolean myIsVboInit; mutable Standard_Boolean myIsVboInit;
Standard_Size myUID; //!< Unique ID of primitive array. Standard_Size myUID; //!< Unique ID of primitive array.

188
src/OpenGl/OpenGl_ShaderProgram.cxx
View File

@ -76,6 +76,24 @@ Standard_CString OpenGl_ShaderProgram::PredefinedKeywords[] =
"occPointSize" // OpenGl_OCCT_POINT_SIZE "occPointSize" // OpenGl_OCCT_POINT_SIZE
}; };
namespace
{
//! Convert Graphic3d_TypeOfShaderObject enumeration into OpenGL enumeration.
static GLenum shaderTypeToGl (Graphic3d_TypeOfShaderObject theType)
{
switch (theType)
{
case Graphic3d_TOS_VERTEX: return GL_VERTEX_SHADER;
case Graphic3d_TOS_FRAGMENT: return GL_FRAGMENT_SHADER;
case Graphic3d_TOS_GEOMETRY: return GL_GEOMETRY_SHADER;
case Graphic3d_TOS_TESS_CONTROL: return GL_TESS_CONTROL_SHADER;
case Graphic3d_TOS_TESS_EVALUATION: return GL_TESS_EVALUATION_SHADER;
case Graphic3d_TOS_COMPUTE: return GL_COMPUTE_SHADER;
}
return 0;
}
}
// ======================================================================= // =======================================================================
// function : OpenGl_VariableSetterSelector // function : OpenGl_VariableSetterSelector
// purpose : Creates new variable setter selector // purpose : Creates new variable setter selector
@ -130,7 +148,8 @@ OpenGl_ShaderProgram::OpenGl_ShaderProgram (const Handle(Graphic3d_ShaderProgram
: OpenGl_NamedResource (!theProxy.IsNull() ? theProxy->GetId() : ""), : OpenGl_NamedResource (!theProxy.IsNull() ? theProxy->GetId() : ""),
myProgramID (NO_PROGRAM), myProgramID (NO_PROGRAM),
myProxy (theProxy), myProxy (theProxy),
myShareCount(1) myShareCount(1),
myHasTessShader (false)
{ {
memset (myCurrentState, 0, sizeof (myCurrentState)); memset (myCurrentState, 0, sizeof (myCurrentState));
for (GLint aVar = 0; aVar < OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES; ++aVar) for (GLint aVar = 0; aVar < OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES; ++aVar)
@ -146,66 +165,113 @@ OpenGl_ShaderProgram::OpenGl_ShaderProgram (const Handle(Graphic3d_ShaderProgram
Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)& theCtx, Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)& theCtx,
const Graphic3d_ShaderObjectList& theShaders) const Graphic3d_ShaderObjectList& theShaders)
{ {
myHasTessShader = false;
if (theCtx.IsNull() || !Create (theCtx)) if (theCtx.IsNull() || !Create (theCtx))
{ {
return Standard_False; return Standard_False;
} }
TCollection_AsciiString aHeader = !myProxy.IsNull() && !myProxy->Header().IsEmpty() TCollection_AsciiString aHeaderVer = !myProxy.IsNull() ? myProxy->Header() : TCollection_AsciiString();
? (myProxy->Header() + "\n") int aShaderMask = 0;
: TCollection_AsciiString(); for (Graphic3d_ShaderObjectList::Iterator anIter (theShaders); anIter.More(); anIter.Next())
{
aShaderMask |= anIter.Value()->Type();
}
myHasTessShader = (aShaderMask & (Graphic3d_TOS_TESS_CONTROL | Graphic3d_TOS_TESS_EVALUATION)) != 0;
TCollection_AsciiString aDeclarations = Shaders_Declarations_glsl; // detect the minimum GLSL version required for defined Shader Objects
TCollection_AsciiString aDeclImpl = Shaders_DeclarationsImpl_glsl; #if defined(GL_ES_VERSION_2_0)
if (myHasTessShader
|| (aShaderMask & Graphic3d_TOS_GEOMETRY) != 0)
{
if (!theCtx->IsGlGreaterEqual (3, 2))
{
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
"Error! Geometry and Tessellation shaders require OpenGL ES 3.2+");
return false;
}
else if (aHeaderVer.IsEmpty())
{
aHeaderVer = "#version 320 es";
}
}
else if ((aShaderMask & Graphic3d_TOS_COMPUTE) != 0)
{
if (!theCtx->IsGlGreaterEqual (3, 1))
{
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
"Error! Compute shaders require OpenGL ES 3.1+");
return false;
}
else if (aHeaderVer.IsEmpty())
{
aHeaderVer = "#version 310 es";
}
}
#else
if ((aShaderMask & Graphic3d_TOS_COMPUTE) != 0)
{
if (!theCtx->IsGlGreaterEqual (4, 3))
{
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
"Error! Compute shaders require OpenGL 4.3+");
return 0;
}
else if (aHeaderVer.IsEmpty())
{
aHeaderVer = "#version 430";
}
}
else if (myHasTessShader)
{
if (!theCtx->IsGlGreaterEqual (4, 0))
{
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
"Error! Tessellation shaders require OpenGL 4.0+");
return 0;
}
else if (aHeaderVer.IsEmpty())
{
aHeaderVer = "#version 400";
}
}
else if ((aShaderMask & Graphic3d_TOS_GEOMETRY) != 0)
{
if (!theCtx->IsGlGreaterEqual (3, 2))
{
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
"Error! Geometry shaders require OpenGL 3.2+");
return 0;
}
else if (aHeaderVer.IsEmpty())
{
aHeaderVer = "#version 150";
}
}
#endif
aDeclarations += aDeclImpl; for (Graphic3d_ShaderObjectList::Iterator anIter (theShaders); anIter.More(); anIter.Next())
for (Graphic3d_ShaderObjectList::Iterator anIter (theShaders);
anIter.More(); anIter.Next())
{ {
if (!anIter.Value()->IsDone()) if (!anIter.Value()->IsDone())
{ {
const TCollection_ExtendedString aMsg = "Error! Failed to get shader source"; const TCollection_ExtendedString aMsg = "Error! Failed to get shader source";
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aMsg);
GL_DEBUG_TYPE_ERROR,
0,
GL_DEBUG_SEVERITY_HIGH,
aMsg);
return Standard_False; return Standard_False;
} }
Handle(OpenGl_ShaderObject) aShader; const GLenum aShaderType = shaderTypeToGl (anIter.Value()->Type());
if (aShaderType == 0)
// Note: Add support of other shader types here
switch (anIter.Value()->Type())
{ {
case Graphic3d_TOS_VERTEX:
aShader = new OpenGl_ShaderObject (GL_VERTEX_SHADER);
break;
case Graphic3d_TOS_FRAGMENT:
aShader = new OpenGl_ShaderObject (GL_FRAGMENT_SHADER);
break;
}
// Is unsupported shader type?
if (aShader.IsNull())
{
TCollection_ExtendedString aMsg = "Error! Unsupported shader type";
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
GL_DEBUG_TYPE_ERROR,
0,
GL_DEBUG_SEVERITY_HIGH,
aMsg);
return Standard_False; return Standard_False;
} }
Handle(OpenGl_ShaderObject) aShader = new OpenGl_ShaderObject (aShaderType);
if (!aShader->Create (theCtx)) if (!aShader->Create (theCtx))
{ {
aShader->Release (theCtx.operator->()); aShader->Release (theCtx.operator->());
return Standard_False; return Standard_False;
} }
TCollection_AsciiString aSource = aDeclarations + anIter.Value()->Source();
TCollection_AsciiString anExtensions = "// Enable extensions used in OCCT GLSL programs\n"; TCollection_AsciiString anExtensions = "// Enable extensions used in OCCT GLSL programs\n";
if (theCtx->hasDrawBuffers) if (theCtx->hasDrawBuffers)
{ {
@ -238,29 +304,37 @@ Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)&
#endif #endif
} }
switch (anIter.Value()->Type()) TCollection_AsciiString aPrecisionHeader;
if (anIter.Value()->Type() == Graphic3d_TOS_FRAGMENT)
{ {
case Graphic3d_TOS_VERTEX: #if defined(GL_ES_VERSION_2_0)
{ aPrecisionHeader = theCtx->hasHighp
aSource = aHeader + TCollection_AsciiString ("#define VERTEX_SHADER\n") + anExtensions + aSource; ? "precision highp float;\n"
break; "precision highp int;\n"
} : "precision mediump float;\n"
case Graphic3d_TOS_FRAGMENT: "precision mediump int;\n";
{ #endif
#if defined(GL_ES_VERSION_2_0)
TCollection_AsciiString aPrefix (theCtx->hasHighp
? "precision highp float;\n"
"precision highp int;\n"
: "precision mediump float;\n"
"precision mediump int;\n");
aSource = aHeader + anExtensions + aPrefix + aSource;
#else
aSource = aHeader + anExtensions + aSource;
#endif
break;
}
} }
TCollection_AsciiString aHeaderType;
switch (anIter.Value()->Type())
{
case Graphic3d_TOS_COMPUTE: { aHeaderType = "#define COMPUTE_SHADER\n"; break; }
case Graphic3d_TOS_VERTEX: { aHeaderType = "#define VERTEX_SHADER\n"; break; }
case Graphic3d_TOS_TESS_CONTROL: { aHeaderType = "#define TESS_CONTROL_SHADER\n"; break; }
case Graphic3d_TOS_TESS_EVALUATION: { aHeaderType = "#define TESS_EVALUATION_SHADER\n"; break; }
case Graphic3d_TOS_GEOMETRY: { aHeaderType = "#define GEOMETRY_SHADER\n"; break; }
case Graphic3d_TOS_FRAGMENT: { aHeaderType = "#define FRAGMENT_SHADER\n"; break; }
}
const TCollection_AsciiString aSource = aHeaderVer // #version - header defining GLSL version, should be first
+ (!aHeaderVer.IsEmpty() ? "\n" : "")
+ anExtensions // #extension - list of enabled extensions, should be second
+ aPrecisionHeader // precision - default precision qualifiers, should be before any code
+ aHeaderType // auxiliary macros defining a shader stage (type)
+ Shaders_Declarations_glsl // common declarations (global constants and Vertex Shader inputs)
+ Shaders_DeclarationsImpl_glsl
+ anIter.Value()->Source(); // the source code itself (defining main() function)
if (!aShader->LoadSource (theCtx, aSource)) if (!aShader->LoadSource (theCtx, aSource))
{ {
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aSource); theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aSource);

4
src/OpenGl/OpenGl_ShaderProgram.hxx
View File

@ -210,6 +210,9 @@ public:
return myProgramID; return myProgramID;
} }
//! Return TRUE if program defines tessellation stage.
Standard_Boolean HasTessellationStage() const { return myHasTessShader; }
private: private:
//! Returns index of last modification of variables of specified state type. //! Returns index of last modification of variables of specified state type.
@ -551,6 +554,7 @@ protected:
OpenGl_ShaderList myShaderObjects; //!< List of attached shader objects OpenGl_ShaderList myShaderObjects; //!< List of attached shader objects
Handle(Graphic3d_ShaderProgram) myProxy; //!< Proxy shader program (from application layer) Handle(Graphic3d_ShaderProgram) myProxy; //!< Proxy shader program (from application layer)
Standard_Integer myShareCount; //!< program users count, initialized with 1 (already shared by one user) Standard_Integer myShareCount; //!< program users count, initialized with 1 (already shared by one user)
Standard_Boolean myHasTessShader; //!< flag indicating that program defines tessellation stage
protected: protected:

29
src/Prs3d/Prs3d_Drawer.cxx
View File

@ -1089,10 +1089,11 @@ inline void setAspectProgram (const Handle(Graphic3d_ShaderProgram)& theProgram,
// function : SetShaderProgram // function : SetShaderProgram
// purpose : // purpose :
// ======================================================================= // =======================================================================
void Prs3d_Drawer::SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProgram, bool Prs3d_Drawer::SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProgram,
const Graphic3d_GroupAspect theAspect, const Graphic3d_GroupAspect theAspect,
const bool theToOverrideDefaults) const bool theToOverrideDefaults)
{ {
bool isUpdateNeeded = false;
switch (theAspect) switch (theAspect)
{ {
case Graphic3d_ASPECT_LINE: case Graphic3d_ASPECT_LINE:
@ -1101,6 +1102,7 @@ void Prs3d_Drawer::SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theP
{ {
if (!myHasOwnUIsoAspect) if (!myHasOwnUIsoAspect)
{ {
isUpdateNeeded = true;
Handle(Prs3d_IsoAspect) anAspect = UIsoAspect(); Handle(Prs3d_IsoAspect) anAspect = UIsoAspect();
if (!myLink.IsNull()) if (!myLink.IsNull())
{ {
@ -1112,6 +1114,7 @@ void Prs3d_Drawer::SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theP
} }
if (!myHasOwnVIsoAspect) if (!myHasOwnVIsoAspect)
{ {
isUpdateNeeded = true;
Handle(Prs3d_IsoAspect) anAspect = VIsoAspect(); Handle(Prs3d_IsoAspect) anAspect = VIsoAspect();
if (!myLink.IsNull()) if (!myLink.IsNull())
{ {
@ -1123,62 +1126,74 @@ void Prs3d_Drawer::SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theP
} }
if (!myHasOwnWireAspect) if (!myHasOwnWireAspect)
{ {
isUpdateNeeded = true;
copyLineAspect (myLink, myWireAspect, WireAspect()); copyLineAspect (myLink, myWireAspect, WireAspect());
myHasOwnWireAspect = true; myHasOwnWireAspect = true;
} }
if (!myHasOwnLineAspect) if (!myHasOwnLineAspect)
{ {
isUpdateNeeded = true;
copyLineAspect (myLink, myLineAspect, LineAspect()); copyLineAspect (myLink, myLineAspect, LineAspect());
myHasOwnLineAspect = true; myHasOwnLineAspect = true;
} }
if (!myHasOwnSeenLineAspect) if (!myHasOwnSeenLineAspect)
{ {
isUpdateNeeded = true;
copyLineAspect (myLink, mySeenLineAspect, SeenLineAspect()); copyLineAspect (myLink, mySeenLineAspect, SeenLineAspect());
myHasOwnSeenLineAspect = true; myHasOwnSeenLineAspect = true;
} }
if (!myHasOwnHiddenLineAspect) if (!myHasOwnHiddenLineAspect)
{ {
isUpdateNeeded = true;
copyLineAspect (myLink, myHiddenLineAspect, HiddenLineAspect()); copyLineAspect (myLink, myHiddenLineAspect, HiddenLineAspect());
myHasOwnHiddenLineAspect = true; myHasOwnHiddenLineAspect = true;
} }
if (!myHasOwnVectorAspect) if (!myHasOwnVectorAspect)
{ {
isUpdateNeeded = true;
copyLineAspect (myLink, myVectorAspect, VectorAspect()); copyLineAspect (myLink, myVectorAspect, VectorAspect());
myHasOwnVectorAspect = true; myHasOwnVectorAspect = true;
} }
if (!myHasOwnSectionAspect) if (!myHasOwnSectionAspect)
{ {
isUpdateNeeded = true;
copyLineAspect (myLink, mySectionAspect, SectionAspect()); copyLineAspect (myLink, mySectionAspect, SectionAspect());
myHasOwnSectionAspect = true; myHasOwnSectionAspect = true;
} }
if (!myHasOwnFreeBoundaryAspect) if (!myHasOwnFreeBoundaryAspect)
{ {
isUpdateNeeded = true;
copyLineAspect (myLink, myFreeBoundaryAspect, FreeBoundaryAspect()); copyLineAspect (myLink, myFreeBoundaryAspect, FreeBoundaryAspect());
myHasOwnFreeBoundaryAspect = true; myHasOwnFreeBoundaryAspect = true;
} }
if (!myHasOwnUnFreeBoundaryAspect) if (!myHasOwnUnFreeBoundaryAspect)
{ {
isUpdateNeeded = true;
copyLineAspect (myLink, myUnFreeBoundaryAspect, UnFreeBoundaryAspect()); copyLineAspect (myLink, myUnFreeBoundaryAspect, UnFreeBoundaryAspect());
myHasOwnUnFreeBoundaryAspect = true; myHasOwnUnFreeBoundaryAspect = true;
} }
if (!myHasOwnFaceBoundaryAspect) if (!myHasOwnFaceBoundaryAspect)
{ {
isUpdateNeeded = true;
copyLineAspect (myLink, myFaceBoundaryAspect, FaceBoundaryAspect()); copyLineAspect (myLink, myFaceBoundaryAspect, FaceBoundaryAspect());
myHasOwnFaceBoundaryAspect = true; myHasOwnFaceBoundaryAspect = true;
} }
if (!myHasOwnPlaneAspect) if (!myHasOwnPlaneAspect)
{ {
isUpdateNeeded = true;
myPlaneAspect = new Prs3d_PlaneAspect(); myPlaneAspect = new Prs3d_PlaneAspect();
myHasOwnPlaneAspect = true; myHasOwnPlaneAspect = true;
} }
if (!myHasOwnArrowAspect) if (!myHasOwnArrowAspect)
{ {
isUpdateNeeded = true;
myArrowAspect = new Prs3d_ArrowAspect(); myArrowAspect = new Prs3d_ArrowAspect();
myHasOwnArrowAspect = true; myHasOwnArrowAspect = true;
} }
if (!myHasOwnDatumAspect) if (!myHasOwnDatumAspect)
{ {
isUpdateNeeded = true;
myDatumAspect = new Prs3d_DatumAspect(); myDatumAspect = new Prs3d_DatumAspect();
myHasOwnDatumAspect = true; myHasOwnDatumAspect = true;
} }
@ -1208,13 +1223,14 @@ void Prs3d_Drawer::SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theP
setAspectProgram (theProgram, true, myDatumAspect->LineAspect(Prs3d_DP_ZAxis)); setAspectProgram (theProgram, true, myDatumAspect->LineAspect(Prs3d_DP_ZAxis));
} }
setAspectProgram (theProgram, myHasOwnArrowAspect, myArrowAspect); setAspectProgram (theProgram, myHasOwnArrowAspect, myArrowAspect);
return; return isUpdateNeeded;
} }
case Graphic3d_ASPECT_TEXT: case Graphic3d_ASPECT_TEXT:
{ {
if (theToOverrideDefaults if (theToOverrideDefaults
&& !myHasOwnTextAspect) && !myHasOwnTextAspect)
{ {
isUpdateNeeded = true;
myTextAspect = new Prs3d_TextAspect(); myTextAspect = new Prs3d_TextAspect();
myHasOwnTextAspect = true; myHasOwnTextAspect = true;
if (!myLink.IsNull()) if (!myLink.IsNull())
@ -1224,13 +1240,14 @@ void Prs3d_Drawer::SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theP
} }
setAspectProgram (theProgram, myHasOwnTextAspect, myTextAspect); setAspectProgram (theProgram, myHasOwnTextAspect, myTextAspect);
return; return isUpdateNeeded;
} }
case Graphic3d_ASPECT_MARKER: case Graphic3d_ASPECT_MARKER:
{ {
if (theToOverrideDefaults if (theToOverrideDefaults
&& !myHasOwnPointAspect) && !myHasOwnPointAspect)
{ {
isUpdateNeeded = true;
myPointAspect = new Prs3d_PointAspect (Aspect_TOM_PLUS, Quantity_NOC_YELLOW, 1.0); myPointAspect = new Prs3d_PointAspect (Aspect_TOM_PLUS, Quantity_NOC_YELLOW, 1.0);
myHasOwnPointAspect = true; myHasOwnPointAspect = true;
if (!myLink.IsNull()) if (!myLink.IsNull())
@ -1240,13 +1257,14 @@ void Prs3d_Drawer::SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theP
} }
setAspectProgram (theProgram, myHasOwnPointAspect, myPointAspect); setAspectProgram (theProgram, myHasOwnPointAspect, myPointAspect);
return; return isUpdateNeeded;
} }
case Graphic3d_ASPECT_FILL_AREA: case Graphic3d_ASPECT_FILL_AREA:
{ {
if (theToOverrideDefaults if (theToOverrideDefaults
&& !myHasOwnShadingAspect) && !myHasOwnShadingAspect)
{ {
isUpdateNeeded = true;
myShadingAspect = new Prs3d_ShadingAspect(); myShadingAspect = new Prs3d_ShadingAspect();
myHasOwnShadingAspect = true; myHasOwnShadingAspect = true;
if (!myLink.IsNull()) if (!myLink.IsNull())
@ -1255,7 +1273,8 @@ void Prs3d_Drawer::SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theP
} }
} }
setAspectProgram (theProgram, myHasOwnShadingAspect, myShadingAspect); setAspectProgram (theProgram, myHasOwnShadingAspect, myShadingAspect);
return; return isUpdateNeeded;
} }
} }
return false;
} }

3
src/Prs3d/Prs3d_Drawer.hxx
View File

@ -842,7 +842,8 @@ public:
//! @param theAspect the type of primitives //! @param theAspect the type of primitives
//! @param theToOverrideDefaults if true then non-overridden attributes using defaults will be allocated and copied from the Link; //! @param theToOverrideDefaults if true then non-overridden attributes using defaults will be allocated and copied from the Link;
//! otherwise, only already customized attributes will be changed //! otherwise, only already customized attributes will be changed
Standard_EXPORT void SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProgram, //! @return TRUE if presentation should be recomputed after creating aspects not previously customized (if theToOverrideDefaults is also TRUE)
Standard_EXPORT bool SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProgram,
const Graphic3d_GroupAspect theAspect, const Graphic3d_GroupAspect theAspect,
const bool theToOverrideDefaults = false); const bool theToOverrideDefaults = false);

28
src/Shaders/Declarations.glsl
View File

@ -49,20 +49,22 @@
THE_ATTRIBUTE vec3 occNormal; THE_ATTRIBUTE vec3 occNormal;
THE_ATTRIBUTE vec4 occTexCoord; THE_ATTRIBUTE vec4 occTexCoord;
THE_ATTRIBUTE vec4 occVertColor; THE_ATTRIBUTE vec4 occVertColor;
#elif (__VERSION__ >= 130) #elif defined(FRAGMENT_SHADER)
#ifdef OCC_ENABLE_draw_buffers #if (__VERSION__ >= 130)
out vec4 occFragColorArray[2]; #ifdef OCC_ENABLE_draw_buffers
#define occFragColor occFragColorArray[0] out vec4 occFragColorArray[2];
#define occFragCoverage occFragColorArray[1] #define occFragColor occFragColorArray[0]
#define occFragCoverage occFragColorArray[1]
#else
out vec4 occFragColor;
#endif
#else #else
out vec4 occFragColor; #ifdef OCC_ENABLE_draw_buffers
#endif #define occFragColor gl_FragData[0]
#else #define occFragCoverage gl_FragData[1]
#ifdef OCC_ENABLE_draw_buffers #else
#define occFragColor gl_FragData[0] #define occFragColor gl_FragColor
#define occFragCoverage gl_FragData[1] #endif
#else
#define occFragColor gl_FragColor
#endif #endif
#endif #endif

28
src/Shaders/Shaders_Declarations_glsl.pxx
View File

@ -52,20 +52,22 @@ static const char Shaders_Declarations_glsl[] =
" THE_ATTRIBUTE vec3 occNormal;\n" " THE_ATTRIBUTE vec3 occNormal;\n"
" THE_ATTRIBUTE vec4 occTexCoord;\n" " THE_ATTRIBUTE vec4 occTexCoord;\n"
" THE_ATTRIBUTE vec4 occVertColor;\n" " THE_ATTRIBUTE vec4 occVertColor;\n"
"#elif (__VERSION__ >= 130)\n" "#elif defined(FRAGMENT_SHADER)\n"
" #ifdef OCC_ENABLE_draw_buffers\n" " #if (__VERSION__ >= 130)\n"
" out vec4 occFragColorArray[2];\n" " #ifdef OCC_ENABLE_draw_buffers\n"
" #define occFragColor occFragColorArray[0]\n" " out vec4 occFragColorArray[2];\n"
" #define occFragCoverage occFragColorArray[1]\n" " #define occFragColor occFragColorArray[0]\n"
" #define occFragCoverage occFragColorArray[1]\n"
" #else\n"
" out vec4 occFragColor;\n"
" #endif\n"
" #else\n" " #else\n"
" out vec4 occFragColor;\n" " #ifdef OCC_ENABLE_draw_buffers\n"
" #endif\n" " #define occFragColor gl_FragData[0]\n"
"#else\n" " #define occFragCoverage gl_FragData[1]\n"
" #ifdef OCC_ENABLE_draw_buffers\n" " #else\n"
" #define occFragColor gl_FragData[0]\n" " #define occFragColor gl_FragColor\n"
" #define occFragCoverage gl_FragData[1]\n" " #endif\n"
" #else\n"
" #define occFragColor gl_FragColor\n"
" #endif\n" " #endif\n"
"#endif\n" "#endif\n"
"\n" "\n"

337
src/ViewerTest/ViewerTest_OpenGlCommands.cxx
View File

@ -532,6 +532,50 @@ static int VGlInfo (Draw_Interpretor& theDI,
return 0; return 0;
} }
//! Parse shader type argument.
static bool parseShaderTypeArg (Graphic3d_TypeOfShaderObject& theType,
const TCollection_AsciiString& theArg)
{
if (theArg == "-vertex"
|| theArg == "-vert")
{
theType = Graphic3d_TOS_VERTEX;
}
else if (theArg == "-tessevaluation"
|| theArg == "-tesseval"
|| theArg == "-evaluation"
|| theArg == "-eval")
{
theType = Graphic3d_TOS_TESS_EVALUATION;
}
else if (theArg == "-tesscontrol"
|| theArg == "-tessctrl"
|| theArg == "-control"
|| theArg == "-ctrl")
{
theType = Graphic3d_TOS_TESS_CONTROL;
}
else if (theArg == "-geometry"
|| theArg == "-geom")
{
theType = Graphic3d_TOS_GEOMETRY;
}
else if (theArg == "-fragment"
|| theArg == "-frag")
{
theType = Graphic3d_TOS_FRAGMENT;
}
else if (theArg == "-compute"
|| theArg == "-comp")
{
theType = Graphic3d_TOS_COMPUTE;
}
else
{
return false;
}
return true;
}
//============================================================================== //==============================================================================
//function : VShaderProg //function : VShaderProg
@ -544,150 +588,219 @@ static Standard_Integer VShaderProg (Draw_Interpretor& /*theDI*/,
Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext(); Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
if (aCtx.IsNull()) if (aCtx.IsNull())
{ {
std::cerr << "Use 'vinit' command before " << theArgVec[0] << "\n"; std::cout << "Error: no active view.\n";
return 1; return 1;
} }
else if (theArgNb < 2) else if (theArgNb < 2)
{ {
std::cerr << theArgVec[0] << " syntax error: lack of arguments\n"; std::cout << "Syntax error: lack of arguments\n";
return 1; return 1;
} }
TCollection_AsciiString aLastArg (theArgVec[theArgNb - 1]); bool isExplicitShaderType = false;
aLastArg.LowerCase(); Handle(Graphic3d_ShaderProgram) aProgram = new Graphic3d_ShaderProgram();
const Standard_Boolean toTurnOff = aLastArg == "off"; NCollection_Sequence<Handle(AIS_InteractiveObject)> aPrsList;
Standard_Integer anArgsNb = theArgNb - 1; Graphic3d_GroupAspect aGroupAspect = Graphic3d_ASPECT_FILL_AREA;
Handle(Graphic3d_ShaderProgram) aProgram; bool isSetGroupAspect = false;
if (!toTurnOff for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
&& aLastArg == "phong")
{ {
const TCollection_AsciiString& aShadersRoot = Graphic3d_ShaderProgram::ShadersFolder(); TCollection_AsciiString anArg (theArgVec[anArgIter]);
if (aShadersRoot.IsEmpty()) anArg.LowerCase();
Graphic3d_TypeOfShaderObject aShaderTypeArg = Graphic3d_TypeOfShaderObject(-1);
if (!aProgram.IsNull()
&& aProgram->ShaderObjects().IsEmpty()
&& (anArg == "-off"
|| anArg == "off"))
{ {
std::cerr << "Both environment variables CSF_ShadersDirectory and CASROOT are undefined!\n" aProgram.Nullify();
<< "At least one should be defined to load Phong program.\n";
return 1;
} }
else if (!aProgram.IsNull()
&& aProgram->ShaderObjects().IsEmpty()
&& (anArg == "-phong"
|| anArg == "phong"))
{
const TCollection_AsciiString& aShadersRoot = Graphic3d_ShaderProgram::ShadersFolder();
if (aShadersRoot.IsEmpty())
{
std::cout << "Error: both environment variables CSF_ShadersDirectory and CASROOT are undefined!\n"
"At least one should be defined to load Phong program.\n";
return 1;
}
const TCollection_AsciiString aSrcVert = aShadersRoot + "/PhongShading.vs"; const TCollection_AsciiString aSrcVert = aShadersRoot + "/PhongShading.vs";
const TCollection_AsciiString aSrcFrag = aShadersRoot + "/PhongShading.fs"; const TCollection_AsciiString aSrcFrag = aShadersRoot + "/PhongShading.fs";
if (!aSrcVert.IsEmpty()
&& !OSD_File (aSrcVert).Exists())
{
std::cout << "Error: PhongShading.vs is not found\n";
return 1;
}
if (!aSrcFrag.IsEmpty()
&& !OSD_File (aSrcFrag).Exists())
{
std::cout << "Error: PhongShading.fs is not found\n";
return 1;
}
if (!aSrcVert.IsEmpty() aProgram->AttachShader (Graphic3d_ShaderObject::CreateFromFile (Graphic3d_TOS_VERTEX, aSrcVert));
&& !OSD_File (aSrcVert).Exists()) aProgram->AttachShader (Graphic3d_ShaderObject::CreateFromFile (Graphic3d_TOS_FRAGMENT, aSrcFrag));
{
std::cerr << "Error: PhongShading.vs is not found\n";
return 1;
} }
if (!aSrcFrag.IsEmpty() else if (aPrsList.IsEmpty()
&& !OSD_File (aSrcFrag).Exists()) && anArg == "*")
{ {
std::cerr << "Error: PhongShading.fs is not found\n"; //
return 1;
} }
else if (!isSetGroupAspect
&& anArgIter + 1 < theArgNb
&& (anArg == "-primtype"
|| anArg == "-primitivetype"
|| anArg == "-groupaspect"
|| anArg == "-aspecttype"
|| anArg == "-aspect"))
{
isSetGroupAspect = true;
TCollection_AsciiString aPrimTypeStr (theArgVec[++anArgIter]);
aPrimTypeStr.LowerCase();
if (aPrimTypeStr == "line")
{
aGroupAspect = Graphic3d_ASPECT_LINE;
}
else if (aPrimTypeStr == "tris"
|| aPrimTypeStr == "triangles"
|| aPrimTypeStr == "fill"
|| aPrimTypeStr == "fillarea"
|| aPrimTypeStr == "shading"
|| aPrimTypeStr == "shade")
{
aGroupAspect = Graphic3d_ASPECT_FILL_AREA;
}
else if (aPrimTypeStr == "text")
{
aGroupAspect = Graphic3d_ASPECT_TEXT;
}
else if (aPrimTypeStr == "marker"
|| aPrimTypeStr == "point"
|| aPrimTypeStr == "pnt")
{
aGroupAspect = Graphic3d_ASPECT_MARKER;
}
else
{
std::cerr << "Syntax error at '" << aPrimTypeStr << "'\n";
return 1;
}
}
else if (anArgIter + 1 < theArgNb
&& !aProgram.IsNull()
&& aProgram->Header().IsEmpty()
&& (anArg == "-version"
|| anArg == "-glslversion"
|| anArg == "-header"
|| anArg == "-glslheader"))
{
TCollection_AsciiString aHeader (theArgVec[++anArgIter]);
if (aHeader.IsIntegerValue())
{
aHeader = TCollection_AsciiString ("#version ") + aHeader;
}
aProgram->SetHeader (aHeader);
}
else if (!anArg.StartsWith ("-")
&& GetMapOfAIS().IsBound2 (theArgVec[anArgIter]))
{
Handle(AIS_InteractiveObject) anIO = Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (theArgVec[anArgIter]));
if (anIO.IsNull())
{
std::cerr << "Syntax error: " << theArgVec[anArgIter] << " is not an AIS object\n";
return 1;
}
aPrsList.Append (anIO);
}
else if (!aProgram.IsNull()
&& ((anArgIter + 1 < theArgNb && parseShaderTypeArg (aShaderTypeArg, anArg))
|| (!isExplicitShaderType && aProgram->ShaderObjects().Size() < 2)))
{
TCollection_AsciiString aShaderPath (theArgVec[anArgIter]);
if (aShaderTypeArg != Graphic3d_TypeOfShaderObject(-1))
{
aShaderPath = (theArgVec[++anArgIter]);
isExplicitShaderType = true;
}
aProgram = new Graphic3d_ShaderProgram(); const bool isSrcFile = OSD_File (aShaderPath).Exists();
aProgram->AttachShader (Graphic3d_ShaderObject::CreateFromFile (Graphic3d_TOS_VERTEX, aSrcVert)); Handle(Graphic3d_ShaderObject) aShader = isSrcFile
aProgram->AttachShader (Graphic3d_ShaderObject::CreateFromFile (Graphic3d_TOS_FRAGMENT, aSrcFrag)); ? Graphic3d_ShaderObject::CreateFromFile (Graphic3d_TOS_VERTEX, aShaderPath)
} : Graphic3d_ShaderObject::CreateFromSource(Graphic3d_TOS_VERTEX, aShaderPath);
if (!toTurnOff const TCollection_AsciiString& aShaderSrc = aShader->Source();
&& aProgram.IsNull())
{
if (theArgNb < 3)
{
std::cout << "Syntax error: lack of arguments\n";
return 1;
}
const TCollection_AsciiString aSrcVert = theArgVec[theArgNb - 2]; const bool hasVertPos = aShaderSrc.Search ("gl_Position") != -1;
const TCollection_AsciiString aSrcFrag = theArgVec[theArgNb - 1]; const bool hasFragColor = aShaderSrc.Search ("occFragColor") != -1
if (aSrcVert.IsEmpty() || aSrcFrag.IsEmpty()) || aShaderSrc.Search ("gl_FragColor") != -1
{ || aShaderSrc.Search ("gl_FragData") != -1;
std::cout << "Syntax error: lack of arguments\n"; Graphic3d_TypeOfShaderObject aShaderType = aShaderTypeArg;
return 1; if (aShaderType == Graphic3d_TypeOfShaderObject(-1))
} {
if (hasVertPos
&& !hasFragColor)
{
aShaderType = Graphic3d_TOS_VERTEX;
}
if (hasFragColor
&& !hasVertPos)
{
aShaderType = Graphic3d_TOS_FRAGMENT;
}
}
if (aShaderType == Graphic3d_TypeOfShaderObject(-1))
{
std::cerr << "Error: non-existing or invalid shader source\n";
return 1;
}
const bool isVertFile = OSD_File (aSrcVert).Exists(); aProgram->AttachShader (Graphic3d_ShaderObject::CreateFromSource (aShaderType, aShaderSrc));
const bool isFragFile = OSD_File (aSrcFrag).Exists(); }
if (!isVertFile else
&& aSrcVert.Search ("gl_Position") == -1)
{ {
std::cerr << "Error: non-existing or invalid vertex shader source\n"; std::cerr << "Syntax error at '" << anArg << "'\n";
return 1; return 1;
} }
if (!isFragFile
&& aSrcFrag.Search ("occFragColor") == -1)
{
std::cerr << "Error: non-existing or invalid fragment shader source\n";
return 1;
}
aProgram = new Graphic3d_ShaderProgram();
aProgram->AttachShader (isVertFile
? Graphic3d_ShaderObject::CreateFromFile (Graphic3d_TOS_VERTEX, aSrcVert)
: Graphic3d_ShaderObject::CreateFromSource(Graphic3d_TOS_VERTEX, aSrcVert));
aProgram->AttachShader (isFragFile
? Graphic3d_ShaderObject::CreateFromFile (Graphic3d_TOS_FRAGMENT, aSrcFrag)
: Graphic3d_ShaderObject::CreateFromSource(Graphic3d_TOS_FRAGMENT, aSrcFrag));
anArgsNb = theArgNb - 2;
} }
Handle(AIS_InteractiveObject) anIO; ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName aGlobalPrsIter (GetMapOfAIS());
if (anArgsNb <= 1 NCollection_Sequence<Handle(AIS_InteractiveObject)>::Iterator aPrsIter (aPrsList);
|| *theArgVec[1] == '*') const bool isGlobalList = aPrsList.IsEmpty();
for (;;)
{ {
for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (GetMapOfAIS()); Handle(AIS_InteractiveObject) anIO;
anIter.More(); anIter.Next()) if (isGlobalList)
{ {
anIO = Handle(AIS_InteractiveObject)::DownCast (anIter.Key1()); if (!aGlobalPrsIter.More())
{
break;
}
anIO = Handle(AIS_InteractiveObject)::DownCast (aGlobalPrsIter.Key1());
aGlobalPrsIter.Next();
if (anIO.IsNull()) if (anIO.IsNull())
{ {
continue; continue;
} }
}
if (!anIO->Attributes()->HasOwnShadingAspect()) else
{
if (!aPrsIter.More())
{ {
Handle(Prs3d_ShadingAspect) aNewAspect = new Prs3d_ShadingAspect(); break;
*aNewAspect->Aspect() = *anIO->Attributes()->ShadingAspect()->Aspect();
aNewAspect->Aspect()->SetShaderProgram (aProgram);
anIO->Attributes()->SetShadingAspect (aNewAspect);
aCtx->Redisplay (anIO, Standard_False);
} }
else anIO = aPrsIter.Value();
{ aPrsIter.Next();
anIO->Attributes()->SetShaderProgram (aProgram, Graphic3d_ASPECT_FILL_AREA);
anIO->SynchronizeAspects();
}
}
aCtx->UpdateCurrentViewer();
return 0;
}
for (Standard_Integer anArgIter = 1; anArgIter < anArgsNb; ++anArgIter)
{
const TCollection_AsciiString aName (theArgVec[anArgIter]);
if (!GetMapOfAIS().IsBound2 (aName))
{
std::cerr << "Warning: " << aName.ToCString() << " is not displayed\n";
continue;
}
anIO = Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (aName));
if (anIO.IsNull())
{
std::cerr << "Warning: " << aName.ToCString() << " is not an AIS object\n";
continue;
} }
if (!anIO->Attributes()->HasOwnShadingAspect()) if (anIO->Attributes()->SetShaderProgram (aProgram, aGroupAspect, true))
{ {
Handle(Prs3d_ShadingAspect) aNewAspect = new Prs3d_ShadingAspect();
*aNewAspect->Aspect() = *anIO->Attributes()->ShadingAspect()->Aspect();
aNewAspect->Aspect()->SetShaderProgram (aProgram);
anIO->Attributes()->SetShadingAspect (aNewAspect);
aCtx->Redisplay (anIO, Standard_False); aCtx->Redisplay (anIO, Standard_False);
} }
else else
{ {
anIO->Attributes()->SetShaderProgram (aProgram, Graphic3d_ASPECT_FILL_AREA);
anIO->SynchronizeAspects(); anIO->SynchronizeAspects();
} }
} }
@ -720,10 +833,12 @@ void ViewerTest::OpenGlCommands(Draw_Interpretor& theCommands)
"\n\t\t: [GL_SHADING_LANGUAGE_VERSION] [GL_EXTENSIONS]" "\n\t\t: [GL_SHADING_LANGUAGE_VERSION] [GL_EXTENSIONS]"
"\n\t\t: print OpenGL info", "\n\t\t: print OpenGL info",
__FILE__, VGlInfo, aGroup); __FILE__, VGlInfo, aGroup);
theCommands.Add("vshaderprog", theCommands.Add("vshader",
" 'vshaderprog [name] pathToVertexShader pathToFragmentShader'" "vshader name -vert VertexShader -frag FragmentShader [-geom GeometryShader]"
"\n\t\t: or 'vshaderprog [name] off' to disable GLSL program" "\n\t\t: [-off] [-phong] [-aspect {shading|line|point|text}=shading]"
"\n\t\t: or 'vshaderprog [name] phong' to enable per-pixel lighting calculations" "\n\t\t: [-header VersionHeader]"
"\n\t\t: * might be used to specify all displayed objects", "\n\t\t: [-tessControl TessControlShader -tesseval TessEvaluationShader]"
"\n\t\t: Assign custom GLSL program to presentation aspects.",
__FILE__, VShaderProg, aGroup); __FILE__, VShaderProg, aGroup);
theCommands.Add("vshaderprog", "Alias for vshader", __FILE__, VShaderProg, aGroup);
} }

3
tests/v3d/glsl/begin
View File

@ -1,3 +0,0 @@
vclear
vclose ALL
vinit View1

55
tests/v3d/glsl/geom1 Normal file
View File

@ -0,0 +1,55 @@
puts "========"
puts "0029074: Visualization, TKOpenGl - support Geometry Shader definition"
puts "========"
pload MODELING VISUALIZATION
set aShaderVert "
out vec4 VertColor;
void main() {
VertColor = occColor;
gl_Position = occVertex;
}"
# define a Geometry shader drawing shrinked triangles
set aShaderGeom "
layout(triangles) in;
layout(triangle_strip, max_vertices=3) out;
in vec4 VertColor\[3\];
out vec4 Color;
void main() {
mat4 aMat = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix;
vec3 aCenter = vec3 (0.0, 0.0, 0.0);
for (int aTriVertIter = 0; aTriVertIter < 3; ++aTriVertIter) {
aCenter += gl_in\[aTriVertIter\].gl_Position.xyz;
}
aCenter /= 3.0;
for (int aTriVertIter = 0; aTriVertIter < 3; ++aTriVertIter) {
vec3 aVec = gl_in\[aTriVertIter\].gl_Position.xyz - aCenter;
vec3 aVertRes = aCenter + normalize (aVec) * length (aVec) * 0.75;
gl_Position = aMat * vec4 (aVertRes, 1.0);
Color = VertColor\[aTriVertIter\] * 2.0;
EmitVertex();
}
EndPrimitive();
}"
set aShaderFrag "
in vec4 Color;
void main() {
occFragColor = Color;
}"
# draw a box
box b 1 2 3
vcaps -core
vclear
vinit View1
vaxo
vdisplay -dispMode 1 -mutable b
vfit
vrotate 0.2 0.0 0.0
vdump $::imagedir/${::casename}_normal.png
vshaderprog b -vert $aShaderVert -geom $aShaderGeom -frag $aShaderFrag
vdump $::imagedir/${::casename}_geom.png

3
tests/v3d/glsl/gouraud_dir1
View File

@ -4,6 +4,9 @@ puts "Visual comparison with the reference snapshot should be performed for this
puts "========" puts "========"
# setup viewer # setup viewer
vclear
vclose ALL
vinit View1
vcaps -ffp 0 vcaps -ffp 0
vrenderparams -shadingModel vert vrenderparams -shadingModel vert

5
tests/v3d/glsl/gouraud_dir2
View File

@ -3,7 +3,10 @@ puts "Per-vertex lighting using built-in GLSL program, two directional light sou
puts "Visual comparison with the reference snapshot should be performed for this test case." puts "Visual comparison with the reference snapshot should be performed for this test case."
puts "========" puts "========"
# setup viewer # setup viewervclear
vclear
vclose ALL
vinit View1
vcaps -ffp 0 vcaps -ffp 0
vrenderparams -shadingModel vert vrenderparams -shadingModel vert
vlight delete 0 vlight delete 0

4
tests/v3d/glsl/gouraud_pos1
View File

@ -3,6 +3,10 @@ puts "Per-vertex lighting using built-in GLSL program, one positional light sour
puts "Visual comparison with the reference snapshot should be performed for this test case." puts "Visual comparison with the reference snapshot should be performed for this test case."
puts "========" puts "========"
vclear
vclose ALL
vinit View1
# create objects # create objects
set anX 0.001 set anX 0.001
circle c 0 0 0 0.001 circle c 0 0 0 0.001

4
tests/v3d/glsl/gouraud_spot1
View File

@ -3,6 +3,10 @@ puts "Per-vertex lighting using built-in GLSL program, one spot light source."
puts "Visual comparison with the reference snapshot should be performed for this test case." puts "Visual comparison with the reference snapshot should be performed for this test case."
puts "========" puts "========"
vclear
vclose ALL
vinit View1
# create objects # create objects
set anX 0.001 set anX 0.001
circle c 0 0 0 0.001 circle c 0 0 0 0.001

3
tests/v3d/glsl/light_off
View File

@ -6,8 +6,9 @@ puts "========"
box b 1 2 3 box b 1 2 3
# draw box # draw box
vinit View1
vclear vclear
vclose ALL
vinit View1
vsetdispmode 1 vsetdispmode 1
vdisplay b vdisplay b
vfit vfit

3
tests/v3d/glsl/phong_box
View File

@ -6,8 +6,9 @@ puts "========"
box b 1 2 3 box b 1 2 3
# draw box # draw box
vinit View1
vclear vclear
vclose ALL
vinit View1
vsetdispmode 1 vsetdispmode 1
vaxo vaxo
vdisplay b vdisplay b

3
tests/v3d/glsl/phong_couple
View File

@ -8,8 +8,9 @@ tclean f
box b 2 0 0 1 0.5 0.25 box b 2 0 0 1 0.5 0.25
# draw box # draw box
vinit View1
vclear vclear
vclose ALL
vinit View1
vdefaults -absDefl 0.5 vdefaults -absDefl 0.5
vsetdispmode 1 vsetdispmode 1
vaxo vaxo

3
tests/v3d/glsl/phong_dir1
View File

@ -4,6 +4,9 @@ puts "Visual comparison with the reference snapshot should be performed for this
puts "========" puts "========"
# setup viewer # setup viewer
vclear
vclose ALL
vinit View1
vcaps -ffp 0 vcaps -ffp 0
vrenderparams -shadingModel phong vrenderparams -shadingModel phong

3
tests/v3d/glsl/phong_dir2
View File

@ -4,6 +4,9 @@ puts "Visual comparison with the reference snapshot should be performed for this
puts "========" puts "========"
# setup viewer # setup viewer
vclear
vclose ALL
vinit View1
vcaps -ffp 0 vcaps -ffp 0
vrenderparams -shadingModel phong vrenderparams -shadingModel phong
vlight delete 0 vlight delete 0

3
tests/v3d/glsl/phong_fuse
View File

@ -7,8 +7,9 @@ restore [locate_data_file occ/fuse.brep] f
tclean f tclean f
# draw box # draw box
vinit View1
vclear vclear
vclose ALL
vinit View1
vdefaults -absDefl 0.5 vdefaults -absDefl 0.5
vsetdispmode 1 vsetdispmode 1
vaxo vaxo

3
tests/v3d/glsl/phong_fuse2
View File

@ -7,8 +7,9 @@ restore [locate_data_file occ/fuse.brep] f
tclean f tclean f
# draw box # draw box
vinit View1
vclear vclear
vclose ALL
vinit View1
vdefaults -absDefl 0.5 vdefaults -absDefl 0.5
vsetdispmode 1 vsetdispmode 1
vaxo vaxo

3
tests/v3d/glsl/phong_plastic
View File

@ -6,8 +6,9 @@ puts "========"
box b 1 2 3 box b 1 2 3
# draw box # draw box
vinit View1
vclear vclear
vclose ALL
vinit View1
vsetdispmode 1 vsetdispmode 1
vaxo vaxo
vdisplay b vdisplay b

4
tests/v3d/glsl/phong_pos1
View File

@ -3,6 +3,10 @@ puts "Per-fragment lighting using built-in GLSL program, one positional light so
puts "Visual comparison with the reference snapshot should be performed for this test case." puts "Visual comparison with the reference snapshot should be performed for this test case."
puts "========" puts "========"
vclear
vclose ALL
vinit View1
# create objects # create objects
set anX 0.001 set anX 0.001
circle c 0 0 0 0.001 circle c 0 0 0 0.001

3
tests/v3d/glsl/phong_sides
View File

@ -7,8 +7,9 @@ box b 1 2 3
explode b F explode b F
# draw box # draw box
vinit View1
vclear vclear
vclose ALL
vinit View1
vsetdispmode 1 vsetdispmode 1
vaxo vaxo
vdisplay b_1 b_2 vdisplay b_1 b_2

4
tests/v3d/glsl/phong_spot1
View File

@ -3,6 +3,10 @@ puts "Per-fragment lighting using built-in GLSL program, one spot light source."
puts "Visual comparison with the reference snapshot should be performed for this test case." puts "Visual comparison with the reference snapshot should be performed for this test case."
puts "========" puts "========"
vclear
vclose ALL
vinit View1
# create objects # create objects
set anX 0.001 set anX 0.001
circle c 0 0 0 0.001 circle c 0 0 0 0.001

3
tests/v3d/glsl/phong_views
View File

@ -6,8 +6,9 @@ puts "========"
box b 1 2 3 box b 1 2 3
# draw box # draw box
vinit View1
vclear vclear
vclose ALL
vinit View1
vsetdispmode 1 vsetdispmode 1
vaxo vaxo
vdisplay b vdisplay b

1
tests/v3d/glsl/rendscale
View File

@ -15,6 +15,7 @@ if { "$aFontFile" != "" } {
box b 1 2 3 box b 1 2 3
vclear vclear
vclose ALL
vinit View1 vinit View1
vdisplay b vdisplay b
vfit vfit

3
tests/v3d/glsl/stereo
View File

@ -3,8 +3,9 @@ puts "Stereo output modes"
puts "========" puts "========"
restore [locate_data_file occ/fuse.brep] f restore [locate_data_file occ/fuse.brep] f
vinit View1
vclear vclear
vclose ALL
vinit View1
vsetdispmode 1 vsetdispmode 1
vaxo vaxo
vdisplay f vdisplay f

2
tests/v3d/glsl/stipple_line
View File

@ -1,6 +1,8 @@
restore [locate_data_file occ/fuse.brep] f restore [locate_data_file occ/fuse.brep] f
vcaps -ffp 1 vcaps -ffp 1
vclear
vclose ALL
vinit View1 vinit View1
vclear vclear
vsetdispmode 0 vsetdispmode 0

75
tests/v3d/glsl/tess1 Normal file
View File

@ -0,0 +1,75 @@
puts "========"
puts "0029074: Visualization, TKOpenGl - support of Tessellation Shaders"
puts "========"
pload MODELING VISUALIZATION
set aShaderVert "
out vec4 VertColor;
void main() {
VertColor = occColor;
gl_Position = occVertex;
}"
set aShaderTessCtrl "
layout(vertices = 3) out;
void main() {
if (gl_InvocationID == 0) {
gl_TessLevelInner\[0\] = 7.0;
gl_TessLevelOuter\[0\] = 2.0;
gl_TessLevelOuter\[1\] = 3.0;
gl_TessLevelOuter\[2\] = 7.0;
}
gl_out\[gl_InvocationID\].gl_Position = gl_in\[gl_InvocationID\].gl_Position;
}"
set aShaderTessEval "
layout(triangles, equal_spacing, ccw) in;
void main() {
vec3 aPnt0 = gl_TessCoord.x * gl_in\[0\].gl_Position.xyz;
vec3 aPnt1 = gl_TessCoord.y * gl_in\[1\].gl_Position.xyz;
vec3 aPnt2 = gl_TessCoord.z * gl_in\[2\].gl_Position.xyz;
gl_Position = vec4 (aPnt0 + aPnt1 + aPnt2, 1.0);
}"
set aShaderGeom "
layout(triangles) in;
layout(triangle_strip, max_vertices=3) out;
void main() {
mat4 aMat = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix;
vec3 aCenter = vec3 (0.0, 0.0, 0.0);
for (int aTriVertIter = 0; aTriVertIter < 3; ++aTriVertIter) {
aCenter += gl_in\[aTriVertIter\].gl_Position.xyz;
}
aCenter /= 3.0;
for (int aTriVertIter = 0; aTriVertIter < 3; ++aTriVertIter) {
vec3 aVec = gl_in\[aTriVertIter\].gl_Position.xyz - aCenter;
vec3 aVertRes = aCenter + normalize (aVec) * length (aVec) * 0.75;
gl_Position = aMat * vec4 (aVertRes, 1.0);
EmitVertex();
}
EndPrimitive();
}"
set aShaderFrag "
void main() {
occFragColor = vec4(1.0, 0.0, 0.0, 1.0);
}"
# draw a box
box b 1 2 3
explode b F
vcaps -core
vclear
vinit View1
vaxo
vdisplay -dispMode 1 -mutable b_1
vfit
vrotate 0.2 0.0 0.0
# take snapshot with built-in shader
vdump $::imagedir/${::casename}_normal.png
vshaderprog b_1 -vert $aShaderVert -tessCtrl $aShaderTessCtrl -tessEval $aShaderTessEval -geom $aShaderGeom -frag $aShaderFrag
vdump $::imagedir/${::casename}_tess.png

4
tests/v3d/glsl/texture_multi1
View File

@ -26,6 +26,7 @@ void main() {
# draw a box # draw a box
box b 1 2 3 box b 1 2 3
vclear vclear
vclose ALL
vinit View1 vinit View1
vaxo vaxo
vdisplay -dispMode 1 b vdisplay -dispMode 1 b
@ -36,5 +37,6 @@ vrotate 0.2 0.0 0.0
vtexture b -tex0 3 -tex1 4 -tex2 5 -tex3 6 vtexture b -tex0 3 -tex1 4 -tex2 5 -tex3 6
vdump $::imagedir/${::casename}_normal.png vdump $::imagedir/${::casename}_normal.png
vshaderprog b $aShaderVert $aShaderFrag #vshaderprog b $aShaderVert $aShaderFrag
vshaderprog b -vert $aShaderVert -frag $aShaderFrag
vdump $::imagedir/${::casename}_multi.png vdump $::imagedir/${::casename}_multi.png

4
tests/v3d/glsl/texture_trsf
View File

@ -2,6 +2,10 @@ puts "========"
puts "Texture 2D transformation (UV coordinates generation)" puts "Texture 2D transformation (UV coordinates generation)"
puts "========" puts "========"
vclear
vclose ALL
vinit View1
set aTexture [locate_data_file bug26122_texture_trsf_ref.png] set aTexture [locate_data_file bug26122_texture_trsf_ref.png]
pload MODELING VISUALIZATION pload MODELING VISUALIZATION
box b 1 1 1 box b 1 1 1

1
tests/v3d/glsl/tiles
View File

@ -16,6 +16,7 @@ if { "$aFontFile" != "" } {
} }
vclear vclear
vclose ALL
vinit View1 vinit View1
vraytrace 0 vraytrace 0
vsetgradientbg 180 200 255 180 180 180 2 vsetgradientbg 180 200 255 180 180 180 2