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

0032152: Visualization - move out GLSL program generator from OpenGl_ShaderManager to Graphic3d_ShaderManager

Browse Source
This commit is contained in:
kgv 2021-02-20 23:03:30 +03:00 committed by bugmaster
parent 4464c6b591
commit 4bf072e4eb
12 changed files with 2717 additions and 2370 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/Graphic3d/FILES
View File

@ -127,6 +127,9 @@ Graphic3d_SequenceOfHClipPlane.hxx
Graphic3d_SequenceOfStructure.hxx
Graphic3d_ShaderAttribute.cxx
Graphic3d_ShaderAttribute.hxx
Graphic3d_ShaderFlags.hxx
Graphic3d_ShaderManager.cxx
Graphic3d_ShaderManager.hxx
Graphic3d_ShaderObject.cxx
Graphic3d_ShaderObject.hxx
Graphic3d_ShaderProgram.cxx

45
src/Graphic3d/Graphic3d_ShaderFlags.hxx Normal file
View File

@ -0,0 +1,45 @@
// Created on: 2014-10-08
// Created by: Kirill Gavrilov
// Copyright (c) 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.
#ifndef _Graphic3d_ShaderFlags_HeaderFile
#define _Graphic3d_ShaderFlags_HeaderFile
//! Standard GLSL program combination bits.
enum Graphic3d_ShaderFlags
{
Graphic3d_ShaderFlags_VertColor = 0x0001, //!< per-vertex color
Graphic3d_ShaderFlags_TextureRGB = 0x0002, //!< handle RGB texturing
Graphic3d_ShaderFlags_TextureEnv = 0x0004, //!< handle environment map (obsolete, to be removed)
Graphic3d_ShaderFlags_TextureNormal = Graphic3d_ShaderFlags_TextureRGB|Graphic3d_ShaderFlags_TextureEnv, //!< extended texture set (with normal map)
Graphic3d_ShaderFlags_PointSimple = 0x0008, //!< point marker without sprite
Graphic3d_ShaderFlags_PointSprite = 0x0010, //!< point sprite with RGB image
Graphic3d_ShaderFlags_PointSpriteA = Graphic3d_ShaderFlags_PointSimple|Graphic3d_ShaderFlags_PointSprite, //!< point sprite with Alpha image
Graphic3d_ShaderFlags_StippleLine = 0x0020, //!< stipple line
Graphic3d_ShaderFlags_ClipPlanes1 = 0x0040, //!< handle 1 clipping plane
Graphic3d_ShaderFlags_ClipPlanes2 = 0x0080, //!< handle 2 clipping planes
Graphic3d_ShaderFlags_ClipPlanesN = Graphic3d_ShaderFlags_ClipPlanes1|Graphic3d_ShaderFlags_ClipPlanes2, //!< handle N clipping planes
Graphic3d_ShaderFlags_ClipChains = 0x0100, //!< handle chains of clipping planes
Graphic3d_ShaderFlags_MeshEdges = 0x0200, //!< draw mesh edges (wireframe)
Graphic3d_ShaderFlags_AlphaTest = 0x0400, //!< discard fragment by alpha test (defined by cutoff value)
Graphic3d_ShaderFlags_WriteOit = 0x0800, //!< write coverage buffer for Blended Order-Independent Transparency
Graphic3d_ShaderFlags_OitDepthPeeling = 0x1000, //!< handle Depth Peeling OIT
//
Graphic3d_ShaderFlags_NB = 0x2000, //!< overall number of combinations
Graphic3d_ShaderFlags_IsPoint = Graphic3d_ShaderFlags_PointSimple|Graphic3d_ShaderFlags_PointSprite|Graphic3d_ShaderFlags_PointSpriteA,
Graphic3d_ShaderFlags_HasTextures = Graphic3d_ShaderFlags_TextureRGB|Graphic3d_ShaderFlags_TextureEnv,
Graphic3d_ShaderFlags_NeedsGeomShader = Graphic3d_ShaderFlags_MeshEdges,
};
#endif // _Graphic3d_ShaderFlags_HeaderFile

2114
src/Graphic3d/Graphic3d_ShaderManager.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

223
src/Graphic3d/Graphic3d_ShaderManager.hxx Normal file
View File

@ -0,0 +1,223 @@
// Copyright (c) 2013-2021 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.
#ifndef _Graphic3d_ShaderManager_HeaderFile
#define _Graphic3d_ShaderManager_HeaderFile
#include <Aspect_GraphicsLibrary.hxx>
#include <Graphic3d_ShaderFlags.hxx>
#include <Graphic3d_StereoMode.hxx>
#include <Graphic3d_Vec2.hxx>
#include <Standard_Transient.hxx>
#include <TCollection_AsciiString.hxx>
class Graphic3d_LightSet;
class Graphic3d_ShaderProgram;
//! GLSL syntax extensions.
enum Graphic3d_GlslExtension
{
Graphic3d_GlslExtension_GL_OES_standard_derivatives, //!< OpenGL ES 2.0 extension GL_OES_standard_derivatives
Graphic3d_GlslExtension_GL_EXT_shader_texture_lod, //!< OpenGL ES 2.0 extension GL_EXT_shader_texture_lod
Graphic3d_GlslExtension_GL_EXT_frag_depth, //!< OpenGL ES 2.0 extension GL_EXT_frag_depth
Graphic3d_GlslExtension_GL_EXT_gpu_shader4, //!< OpenGL 2.0 extension GL_EXT_gpu_shader4
};
enum { Graphic3d_GlslExtension_NB = Graphic3d_GlslExtension_GL_EXT_gpu_shader4 + 1 };
//! This class is responsible for generation of shader programs.
class Graphic3d_ShaderManager : public Standard_Transient
{
DEFINE_STANDARD_RTTIEXT(Graphic3d_ShaderManager, Standard_Transient)
public:
//! Creates new empty shader manager.
Standard_EXPORT Graphic3d_ShaderManager (Aspect_GraphicsLibrary theGapi);
//! Releases resources of shader manager.
Standard_EXPORT virtual ~Graphic3d_ShaderManager();
//! @return true if detected GL version is greater or equal to requested one.
bool IsGapiGreaterEqual (Standard_Integer theVerMajor,
Standard_Integer theVerMinor) const
{
return (myGapiVersion[0] > theVerMajor)
|| (myGapiVersion[0] == theVerMajor && myGapiVersion[1] >= theVerMinor);
}
//! Return GAPI version major number.
Standard_Integer GapiVersionMajor() const { return myGapiVersion[0]; }
//! Return GAPI version minor number.
Standard_Integer GapiVersionMinor() const { return myGapiVersion[1]; }
//! Return GAPI version major number.
void SetGapiVersion (Standard_Integer theVerMajor,
Standard_Integer theVerMinor)
{
myGapiVersion.SetValues (theVerMajor, theVerMinor);
}
//! Return TRUE if RED channel should be used instead of ALPHA for single-channel textures
//! (e.g. GAPI supports only GL_RED textures and not GL_ALPHA).
bool UseRedAlpha() const { return myUseRedAlpha; }
//! Set if RED channel should be used instead of ALPHA for single-channel textures.
void SetUseRedAlpha (bool theUseRedAlpha) { myUseRedAlpha = theUseRedAlpha; }
//! Return flag indicating flat shading usage; TRUE by default.
bool HasFlatShading() const { return myHasFlatShading; }
//! Return flag indicating flat shading should reverse normal flag; FALSE by default.
bool ToReverseDFdxSign() const { return myToReverseDFdxSign; }
//! Set flag indicating flat shading usage.
void SetFlatShading (bool theToUse,
bool theToReverseSign)
{
myHasFlatShading = theToUse;
myToReverseDFdxSign = theToReverseSign;
}
//! Return TRUE if depth clamping should be emulated by GLSL program; TRUE by default.
bool ToEmulateDepthClamp() const { return myToEmulateDepthClamp; }
//! Set if depth clamping should be emulated by GLSL program.
void SetEmulateDepthClamp (bool theToEmulate) { myToEmulateDepthClamp = theToEmulate; }
//! Return TRUE if specified extension is available.
bool HasGlslExtension (Graphic3d_GlslExtension theExt) const { return myGlslExtensions[theExt]; }
//! Set if specified extension is available or not.
void EnableGlslExtension (Graphic3d_GlslExtension theExt,
bool theToEnable = true) { myGlslExtensions[theExt] = theToEnable; }
protected:
//! Generate map key for light sources configuration.
//! @param theLights [in] list of light sources
//! @param theHasShadowMap [in] flag indicating shadow maps usage
Standard_EXPORT TCollection_AsciiString genLightKey (const Handle(Graphic3d_LightSet)& theLights,
const bool theHasShadowMap) const;
//! Prepare standard GLSL program for textured font.
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getStdProgramFont() const;
//! Prepare standard GLSL program without lighting.
//! @param theBits [in] program bits
//! @param theIsOutline [in] draw silhouette
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getStdProgramUnlit (Standard_Integer theBits,
Standard_Boolean theIsOutline = false) const;
//! Prepare standard GLSL program with per-vertex lighting.
//! @param theLights [in] list of light sources
//! @param theBits [in] program bits
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getStdProgramGouraud (const Handle(Graphic3d_LightSet)& theLights,
Standard_Integer theBits) const;
//! Prepare standard GLSL program with per-pixel lighting.
//! @param theLights [in] list of light sources
//! @param theBits [in] program bits
//! @param theIsFlatNormal [in] when TRUE, the Vertex normals will be ignored and Face normal will be computed instead
//! @param theIsPBR [in] when TRUE, the PBR pipeline will be activated
//! @param theNbShadowMaps [in] number of shadow maps
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getStdProgramPhong (const Handle(Graphic3d_LightSet)& theLights,
const Standard_Integer theBits,
const Standard_Boolean theIsFlatNormal,
const Standard_Boolean theIsPBR,
const Standard_Integer theNbShadowMaps) const;
//! Prepare standard GLSL program for bounding box.
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getStdProgramBoundBox() const;
//! Generates shader program to render environment cubemap as background.
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getBgCubeMapProgram() const;
//! Prepare GLSL source for IBL generation used in PBR pipeline.
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getPBREnvBakingProgram (Standard_Integer theIndex) const;
//! Prepare standard GLSL program for FBO blit operation.
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getStdProgramFboBlit (Standard_Integer theNbSamples,
Standard_Boolean theIsFallback_sRGB) const;
//! Prepare standard GLSL program for stereoscopic image.
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getStdProgramStereo (Graphic3d_StereoMode theStereoMode) const;
//! Prepare standard GLSL programs for OIT compositing operation.
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getStdProgramOitCompositing (Standard_Boolean theMsaa) const;
//! Prepare standard GLSL programs for OIT Depth Peeling blend operation.
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getStdProgramOitDepthPeelingBlend (Standard_Boolean theMsaa) const;
//! Prepare standard GLSL programs for OIT Depth Peeling flush operation.
Standard_EXPORT Handle(Graphic3d_ShaderProgram) getStdProgramOitDepthPeelingFlush (Standard_Boolean theMsaa) const;
protected:
//! Return TRUE if bitwise operations can be used in GLSL program.
Standard_EXPORT bool hasGlslBitwiseOps() const;
//! Prepare GLSL version header.
//! @param theProgram [in] [out] program to set version header
//! @param theName [in] program id suffix
//! @param theBits [in] program bits
//! @param theUsesDerivates [in] program uses standard derivatives functions or not
//! @return filtered program bits with unsupported features disabled
Standard_EXPORT Standard_Integer defaultGlslVersion (const Handle(Graphic3d_ShaderProgram)& theProgram,
const TCollection_AsciiString& theName,
Standard_Integer theBits,
bool theUsesDerivates = false) const;
//! Prepare GLSL version header for OIT composition programs.
//! @param theProgram [in] [out] program to set version header
//! @param theName [in] program id suffix
//! @param theMsaa [in] multisampling flag
Standard_EXPORT void defaultOitGlslVersion (const Handle(Graphic3d_ShaderProgram)& theProgram,
const TCollection_AsciiString& theName,
bool theMsaa) const;
//! Prepare standard GLSL program for accessing point sprite alpha.
Standard_EXPORT TCollection_AsciiString pointSpriteAlphaSrc (Standard_Integer theBits) const;
//! Prepare standard GLSL program for computing point sprite shading.
Standard_EXPORT TCollection_AsciiString pointSpriteShadingSrc (const TCollection_AsciiString& theBaseColorSrc,
Standard_Integer theBits) const;
//! Define computeLighting GLSL function depending on current lights configuration
//! @param theNbLights [out] number of defined light sources
//! @param theLights [in] light sources list
//! @param theHasVertColor [in] flag to use getVertColor() instead of Ambient and Diffuse components of active material
//! @param theIsPBR [in] flag to activate PBR pipeline
//! @param theHasEmissive [in] flag to include emissive
//! @param theNbShadowMaps [in] flag to include shadow map
Standard_EXPORT TCollection_AsciiString stdComputeLighting (Standard_Integer& theNbLights,
const Handle(Graphic3d_LightSet)& theLights,
Standard_Boolean theHasVertColor,
Standard_Boolean theIsPBR,
Standard_Boolean theHasEmissive,
Standard_Integer theNbShadowMaps) const;
protected:
Aspect_GraphicsLibrary myGapi; //!< GAPI name
Graphic3d_Vec2i myGapiVersion; //!< GAPI version major/minor number pair
Standard_Boolean myGlslExtensions[Graphic3d_GlslExtension_NB];
Standard_Boolean myHasFlatShading; //!< flag indicating flat shading usage
Standard_Boolean myToReverseDFdxSign; //!< flag to reverse flat shading normal (workaround)
Standard_Boolean mySetPointSize; //!< always set gl_PointSize variable
Standard_Boolean myUseRedAlpha; //!< use RED channel instead of ALPHA (e.g. GAPI supports only GL_RED textures and not GL_ALPHA)
Standard_Boolean myToEmulateDepthClamp; //!< emulate depth clamping in GLSL program
Standard_Boolean mySRgbState; //!< track sRGB state
};
#endif // _Graphic3d_ShaderManager_HeaderFile

143
src/Graphic3d/Graphic3d_ShaderObject.cxx
View File

@ -13,11 +13,12 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_ShaderObject.hxx>
#include <Graphic3d_GraphicDriver.hxx>
#include <OSD_File.hxx>
#include <OSD_Protection.hxx>
#include <Standard_Atomic.hxx>
#include <Graphic3d_ShaderObject.hxx>
#include <Graphic3d_GraphicDriver.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ShaderObject,Standard_Transient)
@ -26,7 +27,6 @@ namespace
static volatile Standard_Integer THE_SHADER_OBJECT_COUNTER = 0;
}
// =======================================================================
// function : Graphic3d_ShaderObject
// purpose : Creates a shader object from specified file
@ -90,3 +90,140 @@ Standard_Boolean Graphic3d_ShaderObject::IsDone() const
{
return !mySource.IsEmpty();
}
// =======================================================================
// function : CreateFromSource
// purpose :
// =======================================================================
Handle(Graphic3d_ShaderObject) Graphic3d_ShaderObject::CreateFromSource (TCollection_AsciiString& theSource,
Graphic3d_TypeOfShaderObject theType,
const ShaderVariableList& theUniforms,
const ShaderVariableList& theStageInOuts,
const TCollection_AsciiString& theInName,
const TCollection_AsciiString& theOutName,
Standard_Integer theNbGeomInputVerts)
{
if (theSource.IsEmpty())
{
return Handle(Graphic3d_ShaderObject)();
}
TCollection_AsciiString aSrcUniforms, aSrcInOuts, aSrcInStructs, aSrcOutStructs;
for (ShaderVariableList::Iterator anUniformIter (theUniforms); anUniformIter.More(); anUniformIter.Next())
{
const ShaderVariable& aVar = anUniformIter.Value();
if ((aVar.Stages & theType) != 0)
{
aSrcUniforms += TCollection_AsciiString("\nuniform ") + aVar.Name + ";";
}
}
for (ShaderVariableList::Iterator aVarListIter (theStageInOuts); aVarListIter.More(); aVarListIter.Next())
{
const ShaderVariable& aVar = aVarListIter.Value();
Standard_Integer aStageLower = IntegerLast(), aStageUpper = IntegerFirst();
Standard_Integer aNbStages = 0;
for (Standard_Integer aStageIter = Graphic3d_TOS_VERTEX; aStageIter <= (Standard_Integer )Graphic3d_TOS_COMPUTE; aStageIter = aStageIter << 1)
{
if ((aVar.Stages & aStageIter) != 0)
{
++aNbStages;
aStageLower = Min (aStageLower, aStageIter);
aStageUpper = Max (aStageUpper, aStageIter);
}
}
if ((Standard_Integer )theType < aStageLower
|| (Standard_Integer )theType > aStageUpper)
{
continue;
}
const Standard_Boolean hasGeomStage = theNbGeomInputVerts > 0
&& aStageLower < Graphic3d_TOS_GEOMETRY
&& aStageUpper >= Graphic3d_TOS_GEOMETRY;
const Standard_Boolean isAllStagesVar = aStageLower == Graphic3d_TOS_VERTEX
&& aStageUpper == Graphic3d_TOS_FRAGMENT;
if (hasGeomStage
|| !theInName.IsEmpty()
|| !theOutName.IsEmpty())
{
if (aSrcInStructs.IsEmpty()
&& aSrcOutStructs.IsEmpty()
&& isAllStagesVar)
{
if (theType == aStageLower)
{
aSrcOutStructs = "\nout VertexData\n{";
}
else if (theType == aStageUpper)
{
aSrcInStructs = "\nin VertexData\n{";
}
else // requires theInName/theOutName
{
aSrcInStructs = "\nin VertexData\n{";
aSrcOutStructs = "\nout VertexData\n{";
}
}
}
if (isAllStagesVar
&& (!aSrcInStructs.IsEmpty()
|| !aSrcOutStructs.IsEmpty()))
{
if (!aSrcInStructs.IsEmpty())
{
aSrcInStructs += TCollection_AsciiString("\n ") + aVar.Name + ";";
}
if (!aSrcOutStructs.IsEmpty())
{
aSrcOutStructs += TCollection_AsciiString("\n ") + aVar.Name + ";";
}
}
else
{
if (theType == aStageLower)
{
aSrcInOuts += TCollection_AsciiString("\nTHE_SHADER_OUT ") + aVar.Name + ";";
}
else if (theType == aStageUpper)
{
aSrcInOuts += TCollection_AsciiString("\nTHE_SHADER_IN ") + aVar.Name + ";";
}
}
}
if (theType == Graphic3d_TOS_GEOMETRY)
{
aSrcUniforms.Prepend (TCollection_AsciiString()
+ "\nlayout (triangles) in;"
"\nlayout (triangle_strip, max_vertices = " + theNbGeomInputVerts + ") out;");
}
if (!aSrcInStructs.IsEmpty()
&& theType == Graphic3d_TOS_GEOMETRY)
{
aSrcInStructs += TCollection_AsciiString ("\n} ") + theInName + "[" + theNbGeomInputVerts + "];";
}
else if (!aSrcInStructs.IsEmpty())
{
aSrcInStructs += "\n}";
if (!theInName.IsEmpty())
{
aSrcInStructs += " ";
aSrcInStructs += theInName;
}
aSrcInStructs += ";";
}
if (!aSrcOutStructs.IsEmpty())
{
aSrcOutStructs += "\n}";
if (!theOutName.IsEmpty())
{
aSrcOutStructs += " ";
aSrcOutStructs += theOutName;
}
aSrcOutStructs += ";";
}
theSource.Prepend (aSrcUniforms + aSrcInStructs + aSrcOutStructs + aSrcInOuts);
return Graphic3d_ShaderObject::CreateFromSource (theType, theSource);
}

61
src/Graphic3d/Graphic3d_ShaderObject.hxx
View File

@ -16,15 +16,64 @@
#ifndef _Graphic3d_ShaderObject_HeaderFile
#define _Graphic3d_ShaderObject_HeaderFile
#include <OSD_Path.hxx>
#include <Graphic3d_TypeOfShaderObject.hxx>
#include <NCollection_Sequence.hxx>
#include <OSD_Path.hxx>
//! Forward declaration
//! This class is responsible for managing shader objects.
class Graphic3d_ShaderObject : public Standard_Transient
{
public:
//! Structure defining shader uniform or in/out variable.
struct ShaderVariable
{
TCollection_AsciiString Name; //!< variable name
Standard_Integer Stages; //!< active stages as Graphic3d_TypeOfShaderObject bits;
//! for in/out variables, intermediate stages will be automatically filled
//! Create new shader variable.
ShaderVariable (const TCollection_AsciiString& theVarName, Standard_Integer theShaderStageBits) : Name (theVarName), Stages (theShaderStageBits) {}
//! Empty constructor.
ShaderVariable() : Stages (0) {}
};
//! List of variable of shader program.
typedef NCollection_Sequence<ShaderVariable> ShaderVariableList;
public:
//! Creates new shader object from specified file.
Standard_EXPORT static Handle(Graphic3d_ShaderObject) CreateFromFile (const Graphic3d_TypeOfShaderObject theType,
const TCollection_AsciiString& thePath);
//! Creates new shader object from specified source.
Standard_EXPORT static Handle(Graphic3d_ShaderObject) CreateFromSource (const Graphic3d_TypeOfShaderObject theType,
const TCollection_AsciiString& theSource);
//! This is a preprocessor for Graphic3d_ShaderObject::CreateFromSource() function.
//! Creates a new shader object from specified source according to list of uniforms and in/out variables.
//! @param theSource shader object source code to modify
//! @param theType shader object type to create
//! @param theUniforms list of uniform variables
//! @param theStageInOuts list of stage in/out variables
//! @param theInName name of input variables block;
//! can be empty for accessing each variable without block prefix
//! (mandatory for stages accessing both inputs and outputs)
//! @param theOutName name of output variables block;
//! can be empty for accessing each variable without block prefix
//! (mandatory for stages accessing both inputs and outputs)
//! @param theNbGeomInputVerts number of geometry shader input vertexes
Standard_EXPORT static Handle(Graphic3d_ShaderObject) CreateFromSource (TCollection_AsciiString& theSource,
Graphic3d_TypeOfShaderObject theType,
const ShaderVariableList& theUniforms,
const ShaderVariableList& theStageInOuts,
const TCollection_AsciiString& theInName = TCollection_AsciiString(),
const TCollection_AsciiString& theOutName = TCollection_AsciiString(),
Standard_Integer theNbGeomInputVerts = 0);
private:
//! Creates new shader object of specified type.
@ -50,14 +99,6 @@ public:
//! Returns unique ID used to manage resource in graphic driver.
const TCollection_AsciiString& GetId() const { return myID; }
//! Creates new shader object from specified file.
Standard_EXPORT static Handle(Graphic3d_ShaderObject) CreateFromFile (const Graphic3d_TypeOfShaderObject theType,
const TCollection_AsciiString& thePath);
//! Creates new shader object from specified source.
Standard_EXPORT static Handle(Graphic3d_ShaderObject) CreateFromSource (const Graphic3d_TypeOfShaderObject theType,
const TCollection_AsciiString& theSource);
public:
DEFINE_STANDARD_RTTIEXT(Graphic3d_ShaderObject,Standard_Transient)

24
src/OpenGl/OpenGl_Context.cxx
View File

@ -1510,6 +1510,30 @@ void OpenGl_Context::init (const Standard_Boolean theIsCoreProfile)
myFuncs->load (*this, isCoreProfile);
// setup shader generator
myShaderManager->SetGapiVersion (myGlVerMajor, myGlVerMinor);
myShaderManager->SetEmulateDepthClamp (!arbDepthClamp);
bool toReverseDFdxSign = false;
#if defined(GL_ES_VERSION_2_0)
// workaround Adreno driver bug computing reversed normal using dFdx/dFdy
toReverseDFdxSign = myVendor.Search("qualcomm") != -1;
#endif
myShaderManager->SetFlatShading (hasFlatShading != OpenGl_FeatureNotAvailable, toReverseDFdxSign);
#if defined(GL_ES_VERSION_2_0)
myShaderManager->SetUseRedAlpha (false);
#else
myShaderManager->SetUseRedAlpha (core11 == NULL);
#endif
#define checkGlslExtensionShort(theName) myShaderManager->EnableGlslExtension (Graphic3d_GlslExtension_ ## theName, CheckExtension (#theName))
#if defined(GL_ES_VERSION_2_0)
checkGlslExtensionShort(GL_OES_standard_derivatives);
checkGlslExtensionShort(GL_EXT_shader_texture_lod);
checkGlslExtensionShort(GL_EXT_frag_depth);
#else
checkGlslExtensionShort(GL_EXT_gpu_shader4);
#endif
// initialize debug context extension
if (arbDbg != NULL
&& caps->contextDebug)

30
src/OpenGl/OpenGl_SetOfShaderPrograms.hxx
View File

@ -16,35 +16,11 @@
#ifndef _OpenGl_SetOfShaderPrograms_HeaderFile
#define _OpenGl_SetOfShaderPrograms_HeaderFile
#include <Graphic3d_ShaderFlags.hxx>
#include <Graphic3d_TypeOfShadingModel.hxx>
#include <NCollection_DataMap.hxx>
#include <OpenGl_ShaderProgram.hxx>
//! Standard GLSL program combination bits.
enum OpenGl_ProgramOptions
{
OpenGl_PO_VertColor = 0x0001, //!< per-vertex color
OpenGl_PO_TextureRGB = 0x0002, //!< handle RGB texturing
OpenGl_PO_TextureEnv = 0x0004, //!< handle environment map (obsolete, to be removed)
OpenGl_PO_TextureNormal = OpenGl_PO_TextureRGB|OpenGl_PO_TextureEnv, //!< extended texture set (with normal map)
OpenGl_PO_PointSimple = 0x0008, //!< point marker without sprite
OpenGl_PO_PointSprite = 0x0010, //!< point sprite with RGB image
OpenGl_PO_PointSpriteA = OpenGl_PO_PointSimple|OpenGl_PO_PointSprite, //!< point sprite with Alpha image
OpenGl_PO_StippleLine = 0x0020, //!< stipple line
OpenGl_PO_ClipPlanes1 = 0x0040, //!< handle 1 clipping plane
OpenGl_PO_ClipPlanes2 = 0x0080, //!< handle 2 clipping planes
OpenGl_PO_ClipPlanesN = OpenGl_PO_ClipPlanes1|OpenGl_PO_ClipPlanes2, //!< handle N clipping planes
OpenGl_PO_ClipChains = 0x0100, //!< handle chains of clipping planes
OpenGl_PO_MeshEdges = 0x0200, //!< draw mesh edges (wireframe)
OpenGl_PO_AlphaTest = 0x0400, //!< discard fragment by alpha test (defined by cutoff value)
OpenGl_PO_WriteOit = 0x0800, //!< write coverage buffer for Blended Order-Independent Transparency
OpenGl_PO_OitDepthPeeling = 0x1000, //!< handle Depth Peeling OIT
//
OpenGl_PO_NB = 0x2000, //!< overall number of combinations
OpenGl_PO_IsPoint = OpenGl_PO_PointSimple|OpenGl_PO_PointSprite|OpenGl_PO_PointSpriteA,
OpenGl_PO_HasTextures = OpenGl_PO_TextureRGB|OpenGl_PO_TextureEnv,
OpenGl_PO_NeedsGeomShader = OpenGl_PO_MeshEdges,
};
class OpenGl_ShaderProgram;
//! Alias to programs array of predefined length
class OpenGl_SetOfPrograms : public Standard_Transient
@ -59,7 +35,7 @@ public:
Handle(OpenGl_ShaderProgram)& ChangeValue (Standard_Integer theProgramBits) { return myPrograms[theProgramBits]; }
protected:
Handle(OpenGl_ShaderProgram) myPrograms[OpenGl_PO_NB]; //!< programs array
Handle(OpenGl_ShaderProgram) myPrograms[Graphic3d_ShaderFlags_NB]; //!< programs array
};
//! Alias to 2D programs array of predefined length

2096
src/OpenGl/OpenGl_ShaderManager.cxx
View File

File diff suppressed because it is too large Load Diff

171
src/OpenGl/OpenGl_ShaderManager.hxx
View File

@ -16,12 +16,8 @@
#ifndef _OpenGl_ShaderManager_HeaderFile
#define _OpenGl_ShaderManager_HeaderFile
#include <Graphic3d_ShaderProgram.hxx>
#include <Graphic3d_StereoMode.hxx>
#include <NCollection_DataMap.hxx>
#include <Graphic3d_ShaderManager.hxx>
#include <NCollection_Sequence.hxx>
#include <OpenGl_PBREnvironment.hxx>
#include <OpenGl_SetOfShaderPrograms.hxx>
#include <OpenGl_ShaderStates.hxx>
@ -36,9 +32,9 @@ class OpenGl_VertexBuffer;
typedef NCollection_Sequence<Handle(OpenGl_ShaderProgram)> OpenGl_ShaderProgramList;
//! This class is responsible for managing shader programs.
class OpenGl_ShaderManager : public Standard_Transient
class OpenGl_ShaderManager : public Graphic3d_ShaderManager
{
DEFINE_STANDARD_RTTIEXT(OpenGl_ShaderManager, Standard_Transient)
DEFINE_STANDARD_RTTIEXT(OpenGl_ShaderManager, Graphic3d_ShaderManager)
friend class OpenGl_ShaderProgram;
public:
@ -90,10 +86,10 @@ public:
Handle(OpenGl_ShaderProgram)& theProgram);
//! Returns list of registered shader programs.
Standard_EXPORT const OpenGl_ShaderProgramList& ShaderPrograms() const;
const OpenGl_ShaderProgramList& ShaderPrograms() const { return myProgramList; }
//! Returns true if no program objects are registered in the manager.
Standard_EXPORT Standard_Boolean IsEmpty() const;
Standard_Boolean IsEmpty() const { return myProgramList.IsEmpty(); }
//! Bind program for filled primitives rendering
Standard_Boolean BindFaceProgram (const Handle(OpenGl_TextureSet)& theTextures,
@ -149,7 +145,7 @@ public:
Standard_Integer aBits = getProgramBits (theTextures, theAlphaMode, Aspect_IS_SOLID, theHasVertColor, false, false);
if (theLineType != Aspect_TOL_SOLID)
{
aBits |= OpenGl_PO_StippleLine;
aBits |= Graphic3d_ShaderFlags_StippleLine;
}
Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theShadingModel, aBits);
@ -164,21 +160,7 @@ public:
const Handle(OpenGl_ShaderProgram)& theCustomProgram);
//! Bind program for rendering alpha-textured font.
Standard_Boolean BindFontProgram (const Handle(OpenGl_ShaderProgram)& theCustomProgram)
{
if (!theCustomProgram.IsNull()
|| myContext->caps->ffpEnable)
{
return bindProgramWithState (theCustomProgram, Graphic3d_TOSM_UNLIT);
}
if (myFontProgram.IsNull())
{
prepareStdProgramFont();
}
return bindProgramWithState (myFontProgram, Graphic3d_TOSM_UNLIT);
}
Standard_Boolean BindFontProgram (const Handle(OpenGl_ShaderProgram)& theCustomProgram);
//! Bind program for outline rendering
Standard_Boolean BindOutlineProgram()
@ -208,60 +190,16 @@ public:
Standard_Boolean theIsFallback_sRGB);
//! Bind program for blended order-independent transparency buffers compositing.
Standard_Boolean BindOitCompositingProgram (const Standard_Boolean theIsMSAAEnabled)
{
const Standard_Integer aProgramIdx = theIsMSAAEnabled ? 1 : 0;
if (myOitCompositingProgram[aProgramIdx].IsNull())
{
prepareStdProgramOitCompositing (theIsMSAAEnabled);
}
const Handle(OpenGl_ShaderProgram)& aProgram = myOitCompositingProgram [aProgramIdx];
return !aProgram.IsNull() && myContext->BindProgram (aProgram);
}
Standard_EXPORT Standard_Boolean BindOitCompositingProgram (Standard_Boolean theIsMSAAEnabled);
//! Bind program for Depth Peeling order-independent transparency back color blending.
Standard_Boolean BindOitDepthPeelingBlendProgram (bool theIsMSAAEnabled)
{
const Standard_Integer aProgramIdx = theIsMSAAEnabled ? 1 : 0;
if (myOitDepthPeelingBlendProgram[aProgramIdx].IsNull())
{
prepareStdProgramOitDepthPeelingBlend (theIsMSAAEnabled);
}
const Handle(OpenGl_ShaderProgram)& aProgram = myOitDepthPeelingBlendProgram [aProgramIdx];
return !aProgram.IsNull() && myContext->BindProgram (aProgram);
}
Standard_EXPORT Standard_Boolean BindOitDepthPeelingBlendProgram (bool theIsMSAAEnabled);
//! Bind program for Depth Peeling order-independent transparency flush.
Standard_Boolean BindOitDepthPeelingFlushProgram (bool theIsMSAAEnabled)
{
const Standard_Integer aProgramIdx = theIsMSAAEnabled ? 1 : 0;
if (myOitDepthPeelingFlushProgram[aProgramIdx].IsNull())
{
prepareStdProgramOitDepthPeelingFlush (theIsMSAAEnabled);
}
const Handle(OpenGl_ShaderProgram)& aProgram = myOitDepthPeelingFlushProgram [aProgramIdx];
return !aProgram.IsNull() && myContext->BindProgram (aProgram);
}
Standard_EXPORT Standard_Boolean BindOitDepthPeelingFlushProgram (bool theIsMSAAEnabled);
//! Bind program for rendering stereoscopic image.
Standard_Boolean BindStereoProgram (const Graphic3d_StereoMode theStereoMode)
{
if (theStereoMode < 0 || theStereoMode >= Graphic3d_StereoMode_NB)
{
return Standard_False;
}
if (myStereoPrograms[theStereoMode].IsNull())
{
prepareStdProgramStereo (myStereoPrograms[theStereoMode], theStereoMode);
}
const Handle(OpenGl_ShaderProgram)& aProgram = myStereoPrograms[theStereoMode];
return !aProgram.IsNull()
&& myContext->BindProgram (aProgram);
}
Standard_EXPORT Standard_Boolean BindStereoProgram (Graphic3d_StereoMode theStereoMode);
//! Bind program for rendering bounding box.
Standard_Boolean BindBoundBoxProgram()
@ -613,20 +551,20 @@ protected:
Standard_Integer aBits = 0;
if (myContext->Clipping().HasClippingChains())
{
aBits |= OpenGl_PO_ClipChains;
aBits |= Graphic3d_ShaderFlags_ClipChains;
}
if (aNbPlanes == 1)
{
aBits |= OpenGl_PO_ClipPlanes1;
aBits |= Graphic3d_ShaderFlags_ClipPlanes1;
}
else if (aNbPlanes == 2)
{
aBits |= OpenGl_PO_ClipPlanes2;
aBits |= Graphic3d_ShaderFlags_ClipPlanes2;
}
else
{
aBits |= OpenGl_PO_ClipPlanesN;
aBits |= Graphic3d_ShaderFlags_ClipPlanesN;
}
return aBits;
}
@ -642,47 +580,47 @@ protected:
Standard_Integer aBits = 0;
if (theAlphaMode == Graphic3d_AlphaMode_Mask)
{
aBits |= OpenGl_PO_AlphaTest;
aBits |= Graphic3d_ShaderFlags_AlphaTest;
}
aBits |= getClipPlaneBits();
if (theEnableMeshEdges
&& myContext->hasGeometryStage != OpenGl_FeatureNotAvailable)
{
aBits |= OpenGl_PO_MeshEdges;
aBits |= Graphic3d_ShaderFlags_MeshEdges;
if (theInteriorStyle == Aspect_IS_HOLLOW)
{
aBits |= OpenGl_PO_AlphaTest;
aBits |= Graphic3d_ShaderFlags_AlphaTest;
}
}
if (theEnableEnvMap)
{
// Environment map overwrites material texture
aBits |= OpenGl_PO_TextureEnv;
aBits |= Graphic3d_ShaderFlags_TextureEnv;
}
else if (!theTextures.IsNull()
&& theTextures->HasNonPointSprite())
{
aBits |= OpenGl_PO_TextureRGB;
aBits |= Graphic3d_ShaderFlags_TextureRGB;
if ((theTextures->TextureSetBits() & Graphic3d_TextureSetBits_Normal) != 0)
{
aBits |= OpenGl_PO_TextureNormal;
aBits |= Graphic3d_ShaderFlags_TextureNormal;
}
}
if (theHasVertColor
&& theInteriorStyle != Aspect_IS_HIDDENLINE)
{
aBits |= OpenGl_PO_VertColor;
aBits |= Graphic3d_ShaderFlags_VertColor;
}
if (myOitState.ActiveMode() == Graphic3d_RTM_BLEND_OIT)
{
aBits |= OpenGl_PO_WriteOit;
aBits |= Graphic3d_ShaderFlags_WriteOit;
}
else if (myOitState.ActiveMode() == Graphic3d_RTM_DEPTH_PEELING_OIT)
{
aBits |= OpenGl_PO_OitDepthPeeling;
aBits |= Graphic3d_ShaderFlags_OitDepthPeeling;
}
return aBits;
}
@ -692,7 +630,7 @@ protected:
Standard_Integer theBits)
{
if (theShadingModel == Graphic3d_TOSM_UNLIT
|| (theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureEnv)
|| (theBits & Graphic3d_ShaderFlags_HasTextures) == Graphic3d_ShaderFlags_TextureEnv)
{
// If environment map is enabled lighting calculations are
// not needed (in accordance with default OCCT behavior)
@ -712,30 +650,6 @@ protected:
return aProgram;
}
//! Prepare standard GLSL program for accessing point sprite alpha.
Standard_EXPORT TCollection_AsciiString pointSpriteAlphaSrc (Standard_Integer theBits);
//! Prepare standard GLSL program for computing point sprite shading.
Standard_EXPORT TCollection_AsciiString pointSpriteShadingSrc (const TCollection_AsciiString& theBaseColorSrc,
Standard_Integer theBits);
//! Prepare standard GLSL program for textured font.
Standard_EXPORT Standard_Boolean prepareStdProgramFont();
//! Prepare standard GLSL program for FBO blit operation.
Standard_EXPORT Standard_Boolean prepareStdProgramFboBlit (Handle(OpenGl_ShaderProgram)& theProgram,
Standard_Integer theNbSamples,
Standard_Boolean theIsFallback_sRGB);
//! Prepare standard GLSL programs for OIT compositing operation.
Standard_EXPORT Standard_Boolean prepareStdProgramOitCompositing (const Standard_Boolean theMsaa);
//! Prepare standard GLSL programs for OIT Depth Peeling blend operation.
Standard_EXPORT Standard_Boolean prepareStdProgramOitDepthPeelingBlend (Standard_Boolean theMsaa);
//! Prepare standard GLSL programs for OIT Depth Peeling flush operation.
Standard_EXPORT Standard_Boolean prepareStdProgramOitDepthPeelingFlush (Standard_Boolean theMsaa);
//! Prepare standard GLSL program without lighting.
Standard_EXPORT Standard_Boolean prepareStdProgramUnlit (Handle(OpenGl_ShaderProgram)& theProgram,
Standard_Integer theBits,
@ -771,18 +685,6 @@ protected:
const Standard_Boolean theIsFlatNormal = false,
const Standard_Boolean theIsPBR = false);
//! Define computeLighting GLSL function depending on current lights configuration
//! @param theNbLights [out] number of defined light sources
//! @param theHasVertColor [in] flag to use getVertColor() instead of Ambient and Diffuse components of active material
//! @param theIsPBR [in] flag to activate PBR pipeline
//! @param theHasEmissive [in] flag to include emissive
//! @param theHasShadowMap [in] flag to include shadow map
Standard_EXPORT TCollection_AsciiString stdComputeLighting (Standard_Integer& theNbLights,
Standard_Boolean theHasVertColor,
Standard_Boolean theIsPBR,
Standard_Boolean theHasEmissive,
Standard_Boolean theHasShadowMap);
//! Bind specified program to current context and apply state.
Standard_EXPORT Standard_Boolean bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram,
Graphic3d_TypeOfShadingModel theShadingModel);
@ -790,29 +692,9 @@ protected:
//! Set pointer myLightPrograms to active lighting programs set from myMapOfLightPrograms
Standard_EXPORT void switchLightPrograms();
//! Prepare standard GLSL program for stereoscopic image.
Standard_EXPORT Standard_Boolean prepareStdProgramStereo (Handle(OpenGl_ShaderProgram)& theProgram,
const Graphic3d_StereoMode theStereoMode);
//! Prepare standard GLSL program for bounding box.
Standard_EXPORT Standard_Boolean prepareStdProgramBoundBox();
//! Prepare GLSL version header.
Standard_EXPORT Standard_Integer defaultGlslVersion (const Handle(Graphic3d_ShaderProgram)& theProgram,
const TCollection_AsciiString& theName,
Standard_Integer theBits,
bool theUsesDerivates = false) const;
//! Prepare GLSL version header for OIT composition programs.
Standard_EXPORT void defaultOitGlslVersion (const Handle(Graphic3d_ShaderProgram)& theProgram,
const TCollection_AsciiString& theName,
bool theMsaa) const;
//! Prepare GLSL source for geometry shader according to parameters.
Standard_EXPORT TCollection_AsciiString prepareGeomMainSrc (OpenGl_ShaderObject::ShaderVariableList& theUnifoms,
OpenGl_ShaderObject::ShaderVariableList& theStageInOuts,
Standard_Integer theBits);
//! Prepare GLSL source for IBL generation used in PBR pipeline.
Standard_EXPORT Standard_Boolean preparePBREnvBakingProgram (Standard_Integer theIndex);
@ -893,7 +775,6 @@ protected:
mutable Handle(OpenGl_PBREnvironment) myPBREnvironment; //!< manager of IBL maps used in PBR pipeline
OpenGl_Context* myContext; //!< OpenGL context
Standard_Boolean mySRgbState; //!< track sRGB state
protected:
@ -917,6 +798,4 @@ protected:
};
DEFINE_STANDARD_HANDLE(OpenGl_ShaderManager, Standard_Transient)
#endif // _OpenGl_ShaderManager_HeaderFile

137
src/OpenGl/OpenGl_ShaderObject.cxx
View File

@ -64,143 +64,6 @@ static TCollection_AsciiString getShaderTypeString (GLenum theType)
return "Shader";
}
// =======================================================================
// function : CreateFromSource
// purpose :
// =======================================================================
Handle(Graphic3d_ShaderObject) OpenGl_ShaderObject::CreateFromSource (TCollection_AsciiString& theSource,
Graphic3d_TypeOfShaderObject theType,
const ShaderVariableList& theUniforms,
const ShaderVariableList& theStageInOuts,
const TCollection_AsciiString& theInName,
const TCollection_AsciiString& theOutName,
Standard_Integer theNbGeomInputVerts)
{
if (theSource.IsEmpty())
{
return Handle(Graphic3d_ShaderObject)();
}
TCollection_AsciiString aSrcUniforms, aSrcInOuts, aSrcInStructs, aSrcOutStructs;
for (ShaderVariableList::Iterator anUniformIter (theUniforms); anUniformIter.More(); anUniformIter.Next())
{
const ShaderVariable& aVar = anUniformIter.Value();
if ((aVar.Stages & theType) != 0)
{
aSrcUniforms += TCollection_AsciiString("\nuniform ") + aVar.Name + ";";
}
}
for (ShaderVariableList::Iterator aVarListIter (theStageInOuts); aVarListIter.More(); aVarListIter.Next())
{
const ShaderVariable& aVar = aVarListIter.Value();
Standard_Integer aStageLower = IntegerLast(), aStageUpper = IntegerFirst();
Standard_Integer aNbStages = 0;
for (Standard_Integer aStageIter = Graphic3d_TOS_VERTEX; aStageIter <= (Standard_Integer )Graphic3d_TOS_COMPUTE; aStageIter = aStageIter << 1)
{
if ((aVar.Stages & aStageIter) != 0)
{
++aNbStages;
aStageLower = Min (aStageLower, aStageIter);
aStageUpper = Max (aStageUpper, aStageIter);
}
}
if ((Standard_Integer )theType < aStageLower
|| (Standard_Integer )theType > aStageUpper)
{
continue;
}
const Standard_Boolean hasGeomStage = theNbGeomInputVerts > 0
&& aStageLower < Graphic3d_TOS_GEOMETRY
&& aStageUpper >= Graphic3d_TOS_GEOMETRY;
const Standard_Boolean isAllStagesVar = aStageLower == Graphic3d_TOS_VERTEX
&& aStageUpper == Graphic3d_TOS_FRAGMENT;
if (hasGeomStage
|| !theInName.IsEmpty()
|| !theOutName.IsEmpty())
{
if (aSrcInStructs.IsEmpty()
&& aSrcOutStructs.IsEmpty()
&& isAllStagesVar)
{
if (theType == aStageLower)
{
aSrcOutStructs = "\nout VertexData\n{";
}
else if (theType == aStageUpper)
{
aSrcInStructs = "\nin VertexData\n{";
}
else // requires theInName/theOutName
{
aSrcInStructs = "\nin VertexData\n{";
aSrcOutStructs = "\nout VertexData\n{";
}
}
}
if (isAllStagesVar
&& (!aSrcInStructs.IsEmpty()
|| !aSrcOutStructs.IsEmpty()))
{
if (!aSrcInStructs.IsEmpty())
{
aSrcInStructs += TCollection_AsciiString("\n ") + aVar.Name + ";";
}
if (!aSrcOutStructs.IsEmpty())
{
aSrcOutStructs += TCollection_AsciiString("\n ") + aVar.Name + ";";
}
}
else
{
if (theType == aStageLower)
{
aSrcInOuts += TCollection_AsciiString("\nTHE_SHADER_OUT ") + aVar.Name + ";";
}
else if (theType == aStageUpper)
{
aSrcInOuts += TCollection_AsciiString("\nTHE_SHADER_IN ") + aVar.Name + ";";
}
}
}
if (theType == Graphic3d_TOS_GEOMETRY)
{
aSrcUniforms.Prepend (TCollection_AsciiString()
+ "\nlayout (triangles) in;"
"\nlayout (triangle_strip, max_vertices = " + theNbGeomInputVerts + ") out;");
}
if (!aSrcInStructs.IsEmpty()
&& theType == Graphic3d_TOS_GEOMETRY)
{
aSrcInStructs += TCollection_AsciiString ("\n} ") + theInName + "[" + theNbGeomInputVerts + "];";
}
else if (!aSrcInStructs.IsEmpty())
{
aSrcInStructs += "\n}";
if (!theInName.IsEmpty())
{
aSrcInStructs += " ";
aSrcInStructs += theInName;
}
aSrcInStructs += ";";
}
if (!aSrcOutStructs.IsEmpty())
{
aSrcOutStructs += "\n}";
if (!theOutName.IsEmpty())
{
aSrcOutStructs += " ";
aSrcOutStructs += theOutName;
}
aSrcOutStructs += ";";
}
theSource.Prepend (aSrcUniforms + aSrcInStructs + aSrcOutStructs + aSrcInOuts);
return Graphic3d_ShaderObject::CreateFromSource (theType, theSource);
}
// =======================================================================
// function : OpenGl_ShaderObject
// purpose : Creates uninitialized shader object

40
src/OpenGl/OpenGl_ShaderObject.hxx
View File

@ -31,46 +31,6 @@ public:
//! Non-valid shader name.
static const GLuint NO_SHADER = 0;
public:
//! Structure defining shader uniform or in/out variable.
struct ShaderVariable
{
TCollection_AsciiString Name; //!< variable name
Standard_Integer Stages; //!< active stages as Graphic3d_TypeOfShaderObject bits;
//! for in/out variables, intermediate stages will be automatically filled
//! Create new shader variable.
ShaderVariable (const TCollection_AsciiString& theVarName, Standard_Integer theShaderStageBits) : Name (theVarName), Stages (theShaderStageBits) {}
//! Empty constructor.
ShaderVariable() : Stages (0) {}
};
//! List of variable of shader program.
typedef NCollection_Sequence<ShaderVariable> ShaderVariableList;
//! This is a preprocessor for Graphic3d_ShaderObject::CreateFromSource() function.
//! Creates a new shader object from specified source according to list of uniforms and in/out variables.
//! @param theSource shader object source code to modify
//! @param theType shader object type to create
//! @param theUniforms list of uniform variables
//! @param theStageInOuts list of stage in/out variables
//! @param theInName name of input variables block;
//! can be empty for accessing each variable without block prefix
//! (mandatory for stages accessing both inputs and outputs)
//! @param theOutName name of output variables block;
//! can be empty for accessing each variable without block prefix
//! (mandatory for stages accessing both inputs and outputs)
//! @param theNbGeomInputVerts number of geometry shader input vertexes
Standard_EXPORT static Handle(Graphic3d_ShaderObject) CreateFromSource (TCollection_AsciiString& theSource,
Graphic3d_TypeOfShaderObject theType,
const ShaderVariableList& theUniforms,
const ShaderVariableList& theStageInOuts,
const TCollection_AsciiString& theInName = TCollection_AsciiString(),
const TCollection_AsciiString& theOutName = TCollection_AsciiString(),
Standard_Integer theNbGeomInputVerts = 0);
public:
//! Creates uninitialized shader object.