OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-10 18:51:21 +03:00
Code

0024310: TKOpenGl - GLSL compatibility issues

Browse Source 
Lights defintion clean up:
- remove duplicated enumeration TLightType (equals to Visual3d_TypeOfLightSource)
- remove unused fields from Graphic3d_CLight
- OpenGl_Light, reuse Graphic3d_CLight definition

Phong GLSL program:
- move out cumulative ambient light intencity from limited list of lights
- compatibility issues, replace array of structures (light sources, materials, clipping planes) with arrays of primitive types

New Draw Harness command vlight to alter light sources definition.

OpenGl_ShaderProgram::Initialize() - add missing Linker log
This commit is contained in:
kgv 2013-11-04 04:42:44 +04:00 committed by abv
parent e91d202a72
commit 1238134135
29 changed files with 1453 additions and 1757 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
src/Graphic3d/Graphic3d_CLight.hxx
View File

@ -15,26 +15,66 @@
// purpose or non-infringement. Please see the License for the specific terms // purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License. // and conditions governing the rights and limitations under the License.
/*============================================================================*/
/*==== Titre: Graphic3d_CLight.hxx */
/*==== Role : The header file of primitive type "CLight" from Graphic3d */
/*==== */
/*==== Implementation: This is a primitive type implemented with typedef */
/*============================================================================*/
#ifndef _Graphic3d_CLight_HeaderFile #ifndef _Graphic3d_CLight_HeaderFile
#define _Graphic3d_CLight_HeaderFile #define _Graphic3d_CLight_HeaderFile
#include <InterfaceGraphic_Graphic3d.hxx> #include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic_Visual3d.hxx> #include <InterfaceGraphic_Visual3d.hxx>
typedef CALL_DEF_LIGHT Graphic3d_CLight; #include <Graphic3d_Vec.hxx>
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Type.hxx> #include <Standard_Type.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CLight);
/*============================================================================*/
#endif //! Light definition
#endif /*Graphic3d_CLight_HeaderFile*/ struct Graphic3d_CLight
{
public:
Graphic3d_Vec4 Color; //!< light color
Graphic3d_Vec4 Position; //!< light position
Graphic3d_Vec4 Direction; //!< direction of directional/spot light
Graphic3d_Vec4 Params; //!< packed light parameters
Standard_Integer Type; //!< Visual3d_TypeOfLightSource enumeration
Standard_Boolean IsHeadlight; //!< flag to mark head light
//! Const attenuation factor of positional light source
Standard_ShortReal ConstAttenuation() const { return Params.x(); }
//! Linear attenuation factor of positional light source
Standard_ShortReal LinearAttenuation() const { return Params.y(); }
//! Const, Linear attenuation factors of positional light source
Graphic3d_Vec2 Attenuation() const { return Params.xy(); }
//! Angle in radians of the cone created by the spot
Standard_ShortReal Angle() const { return Params.z(); }
//! Intensity distribution of the spot light, with 0..1 range.
Standard_ShortReal Concentration() const { return Params.w(); }
Standard_ShortReal& ChangeConstAttenuation() { return Params.x(); }
Standard_ShortReal& ChangeLinearAttenuation() { return Params.y(); }
Graphic3d_Vec2& ChangeAttenuation() { return Params.xy(); }
Standard_ShortReal& ChangeAngle() { return Params.z(); }
Standard_ShortReal& ChangeConcentration() { return Params.w(); }
public:
//! Empty constructor
Graphic3d_CLight()
: Color (1.0f, 1.0f, 1.0f, 1.0f),
Position (0.0f, 0.0f, 0.0f, 1.0f),
Direction (0.0f, 0.0f, 0.0f, 0.0f),
Params (0.0f, 0.0f, 0.0f, 0.0f),
Type (0),
IsHeadlight (Standard_False)
{
//
}
public:
DEFINE_STANDARD_ALLOC
};
#endif // Graphic3d_CLight_HeaderFile

4
src/Graphic3d/Graphic3d_CView.hxx
View File

@ -21,7 +21,7 @@
#include <InterfaceGraphic_Graphic3d.hxx> #include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic_Visual3d.hxx> #include <InterfaceGraphic_Visual3d.hxx>
#include <Handle_Graphic3d_TextureEnv.hxx> #include <Handle_Graphic3d_TextureEnv.hxx>
#include <Standard_Type.hxx> #include <Graphic3d_CLight.hxx>
#include <Graphic3d_SetOfHClipPlane.hxx> #include <Graphic3d_SetOfHClipPlane.hxx>
class CALL_DEF_VIEWCONTEXT class CALL_DEF_VIEWCONTEXT
@ -69,7 +69,7 @@ public:
int Visualization; int Visualization;
int NbActiveLight; int NbActiveLight;
CALL_DEF_LIGHT* ActiveLight; Graphic3d_CLight* ActiveLight;
Handle(Graphic3d_TextureEnv) TextureEnv; Handle(Graphic3d_TextureEnv) TextureEnv;
int SurfaceDetail; int SurfaceDetail;

10
src/Graphic3d/Graphic3d_GraphicDriver.cdl
View File

@ -941,16 +941,6 @@ is
---Purpose: Get Z layer ID of structure. If the structure doesn't ---Purpose: Get Z layer ID of structure. If the structure doesn't
-- exists in graphic driver, the method returns -1. -- exists in graphic driver, the method returns -1.
--------------------------
-- Category: Class methods
--------------------------
Light ( myclass;
ACLight : CLight from Graphic3d;
Update : Boolean from Standard )
returns Integer from Standard;
---Purpose: call_togl_light
----------------------------- -----------------------------
-- Category: Internal methods -- Category: Internal methods
----------------------------- -----------------------------

25
src/Graphic3d/Graphic3d_GraphicDriver.cxx
View File

@ -55,18 +55,6 @@ Graphic3d_GraphicDriver::Graphic3d_GraphicDriver (const Standard_CString AShrNam
} }
//-Methods, in order
Standard_Integer Graphic3d_GraphicDriver::Light (const Graphic3d_CLight& ACLight, const Standard_Boolean Update) {
static Standard_Integer NbLights = 1;
Standard_Boolean Result;
Result = Update ? ACLight.LightId : NbLights++;
return Result;
}
//-Internal methods, in order //-Internal methods, in order
void Graphic3d_GraphicDriver::PrintBoolean (const Standard_CString AComment, const Standard_Boolean AValue) const { void Graphic3d_GraphicDriver::PrintBoolean (const Standard_CString AComment, const Standard_Boolean AValue) const {
@ -87,12 +75,12 @@ void Graphic3d_GraphicDriver::PrintCGroup (const Graphic3d_CGroup& ACGroup, cons
} }
void Graphic3d_GraphicDriver::PrintCLight (const Graphic3d_CLight& ACLight, const Standard_Integer AField) const { void Graphic3d_GraphicDriver::PrintCLight (const Graphic3d_CLight& theCLight,
const Standard_Integer theField) const
if (AField) { {
cout << "\tws id " << ACLight.WsId << ", " if (theField)
<< "view id " << ACLight.ViewId << "\n"; {
switch (ACLight.LightType) { switch (theCLight.Type) {
case 0 : case 0 :
cout << "\tlight type : ambient\n"; cout << "\tlight type : ambient\n";
break; break;
@ -111,7 +99,6 @@ void Graphic3d_GraphicDriver::PrintCLight (const Graphic3d_CLight& ACLight, cons
} }
cout << flush; cout << flush;
} }
} }
void Graphic3d_GraphicDriver::PrintCPick (const Graphic3d_CPick& ACPick, const Standard_Integer AField) const { void Graphic3d_GraphicDriver::PrintCPick (const Graphic3d_CPick& ACPick, const Standard_Integer AField) const {

31
src/InterfaceGraphic/InterfaceGraphic_Visual3d.hxx
View File

@ -35,37 +35,6 @@ typedef struct {
} CALL_DEF_VERTEX; } CALL_DEF_VERTEX;
/* SOURCE LUMINEUSE */
typedef struct {
int WsId;
int ViewId;
int LightId;
int Active;
int LightType;
int Headlight;
CALL_DEF_COLOR Color;
CALL_DEF_VERTEX Position;
CALL_DEF_VERTEX Direction;
float Concentration;
float Attenuation[2];
float Angle;
} CALL_DEF_LIGHT;
/* ORIENTATION */ /* ORIENTATION */
typedef struct { typedef struct {

8
src/InterfaceGraphic/InterfaceGraphic_telem.hxx
View File

@ -48,14 +48,6 @@ struct TEL_COLOUR
}; };
typedef TEL_COLOUR* tel_colour; typedef TEL_COLOUR* tel_colour;
typedef enum
{
TLightAmbient,
TLightDirectional,
TLightPositional,
TLightSpot
} TLightType;
typedef enum typedef enum
{ {
TelCullNone, TelCullNone,

6
src/NCollection/NCollection_Vec4.hxx
View File

@ -215,6 +215,12 @@ public:
return aSumm += theRight; return aSumm += theRight;
} }
//! Unary -.
NCollection_Vec4 operator-() const
{
return NCollection_Vec4 (-x(), -y(), -z(), -w());
}
//! Compute per-component subtraction. //! Compute per-component subtraction.
NCollection_Vec4& operator-= (const NCollection_Vec4& theDec) NCollection_Vec4& operator-= (const NCollection_Vec4& theDec)
{ {

23
src/OpenGl/OpenGl_Light.hxx
View File

@ -17,29 +17,16 @@
// purpose or non-infringement. Please see the License for the specific terms // purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License. // and conditions governing the rights and limitations under the License.
#ifndef OpenGl_Light_Header #ifndef OpenGl_Light_Header
#define OpenGl_Light_Header #define OpenGl_Light_Header
#include <Graphic3d_CLight.hxx>
#include <Visual3d_TypeOfLightSource.hxx>
#include <NCollection_List.hxx> #include <NCollection_List.hxx>
#include <InterfaceGraphic_telem.hxx> #define OpenGLMaxLights 8
#define OpenGLMaxLights 8
struct OpenGl_Light
{
TLightType type;
int HeadLight;
TEL_COLOUR col;
Tfloat pos[3];
Tfloat dir[3];
Tfloat shine;
Tfloat atten[2];
Tfloat angle;
DEFINE_STANDARD_ALLOC
};
typedef Graphic3d_CLight OpenGl_Light;
typedef NCollection_List<OpenGl_Light> OpenGl_ListOfLight; typedef NCollection_List<OpenGl_Light> OpenGl_ListOfLight;
#endif //OpenGl_Light_Header #endif // OpenGl_Light_Header

346
src/OpenGl/OpenGl_ShaderManager.cxx
View File

@ -255,89 +255,75 @@ const OpenGl_WorldViewState& OpenGl_ShaderManager::WorldViewState() const
// ======================================================================= // =======================================================================
void OpenGl_ShaderManager::PushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const void OpenGl_ShaderManager::PushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const
{ {
if (myLightSourceState.Index() == theProgram->ActiveState (OpenGl_LIGHT_SOURCES_STATE)) if (myLightSourceState.Index() == theProgram->ActiveState (OpenGl_LIGHT_SOURCES_STATE)
|| !theProgram->IsValid())
{ {
return; return;
} }
theProgram->SetUniform (myContext, theProgram->GetStateLocation (
OpenGl_OCC_LIGHT_SOURCE_COUNT), myLightSourceState.LightSources()->Size());
OpenGl_ListOfLight::Iterator anIter (*myLightSourceState.LightSources()); const GLint aTypesLoc = theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES);
for (unsigned int anIndex = 0; anIter.More(); anIter.Next()) const GLint aParamsLoc = theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_PARAMS);
const Standard_Integer aLightsDefNb = Min (myLightSourceState.LightSources()->Size(), OpenGLMaxLights);
if (aLightsDefNb < 1)
{ {
if (anIndex >= OpenGLMaxLights)
{
break;
}
const OpenGl_Light& aLight = anIter.Value();
if (aLight.type == TLightAmbient)
{
OpenGl_Vec3 anAmbient (aLight.col.rgb[0],
aLight.col.rgb[1],
aLight.col.rgb[2]);
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_AMBIENT + anIndex), anAmbient);
anIter.Next();
if (!anIter.More())
{
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_TYPE + anIndex), int (aLight.type));
break;
}
}
OpenGl_Vec3 aDiffuse (aLight.col.rgb[0],
aLight.col.rgb[1],
aLight.col.rgb[2]);
OpenGl_Vec3 aPosition (aLight.type == TLightDirectional ? -aLight.dir[0] : aLight.pos[0],
aLight.type == TLightDirectional ? -aLight.dir[1] : aLight.pos[1],
aLight.type == TLightDirectional ? -aLight.dir[2] : aLight.pos[2]);
theProgram->SetUniform (myContext, theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_TYPE + anIndex), int (aLight.type)); theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
0);
theProgram->SetUniform (myContext, theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_HEAD + anIndex), aLight.HeadLight); theProgram->GetStateLocation (OpenGl_OCC_LIGHT_AMBIENT),
OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f));
theProgram->SetUniform (myContext, theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index());
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_DIFFUSE + anIndex), aDiffuse); return;
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_SPECULAR + anIndex), aDiffuse);
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_POSITION + anIndex), aPosition);
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_CONST_ATTENUATION + anIndex), aLight.atten[0]);
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_LINEAR_ATTENUATION + anIndex), aLight.atten[1]);
if (aLight.type == TLightSpot)
{
OpenGl_Vec3 aDirection (aLight.dir[0],
aLight.dir[1],
aLight.dir[2]);
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_SPOT_CUTOFF + anIndex), aLight.angle);
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_SPOT_EXPONENT + anIndex), aLight.shine);
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_SPOT_DIRECTION + anIndex), aDirection);
}
++anIndex;
} }
OpenGl_Vec2i* aTypesArray = new OpenGl_Vec2i[aLightsDefNb];
OpenGl_Vec4* aParamsArray = new OpenGl_Vec4 [aLightsDefNb * 4];
OpenGl_Vec4 anAmbient (0.0f, 0.0f, 0.0f, 0.0f);
Standard_Integer aLightsNb = 0;
for (OpenGl_ListOfLight::Iterator anIter (*myLightSourceState.LightSources()); anIter.More(); anIter.Next())
{
const OpenGl_Light& aLight = anIter.Value();
if (aLight.Type == Visual3d_TOLS_AMBIENT)
{
anAmbient += aLight.Color;
continue;
}
else if (aLightsNb >= OpenGLMaxLights)
{
continue;
}
aTypesArray[aLightsNb].x() = aLight.Type;
aTypesArray[aLightsNb].y() = aLight.IsHeadlight;
aParamsArray[aLightsNb * 4 + 0] = aLight.Color;
aParamsArray[aLightsNb * 4 + 1] = aLight.Type == Visual3d_TOLS_DIRECTIONAL
? -aLight.Direction
: aLight.Position;
if (aLight.Type == Visual3d_TOLS_SPOT)
{
aParamsArray[aLightsNb * 4 + 2] = aLight.Direction;
}
aParamsArray[aLightsNb * 4 + 3] = aLight.Params;
++aLightsNb;
}
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
aLightsNb);
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_LIGHT_AMBIENT),
anAmbient);
if (aLightsNb > 0)
{
myContext->core20->glUniform2iv (aTypesLoc, aLightsNb, aTypesArray [0].GetData());
myContext->core20->glUniform4fv (aParamsLoc, aLightsNb * 4, aParamsArray[0].GetData());
}
delete[] aTypesArray;
delete[] aParamsArray;
theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index()); theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index());
} }
@ -472,8 +458,18 @@ void OpenGl_ShaderManager::PushClippingState (const Handle(OpenGl_ShaderProgram)
return; return;
} }
Graphic3d_SetOfHClipPlane::Iterator anIter (myContext->Clipping().Planes()); theProgram->UpdateState (OpenGl_CLIP_PLANES_STATE, myClippingState.Index());
for (GLuint anIndex = 0; anIter.More(); anIter.Next()) const GLint aLocEquations = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_EQUATIONS);
const GLint aLocSpaces = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_SPACES);
if (aLocEquations == OpenGl_ShaderProgram::INVALID_LOCATION
&& aLocSpaces == OpenGl_ShaderProgram::INVALID_LOCATION)
{
return;
}
GLuint aPlanesNb = 0;
for (Graphic3d_SetOfHClipPlane::Iterator anIter (myContext->Clipping().Planes());
anIter.More(); anIter.Next())
{ {
const Handle(Graphic3d_ClipPlane)& aPlane = anIter.Value(); const Handle(Graphic3d_ClipPlane)& aPlane = anIter.Value();
if (!myContext->Clipping().IsEnabled (aPlane)) if (!myContext->Clipping().IsEnabled (aPlane))
@ -481,23 +477,37 @@ void OpenGl_ShaderManager::PushClippingState (const Handle(OpenGl_ShaderProgram)
continue; continue;
} }
GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_0_EQUATION + anIndex); ++aPlanesNb;
if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION) }
{ if (aPlanesNb < 1)
const Graphic3d_ClipPlane::Equation& anEquation = aPlane->GetEquation(); {
theProgram->SetUniform (myContext, aLocation, OpenGl_Vec4 ((float) anEquation.x(), return;
(float) anEquation.y(),
(float) anEquation.z(),
(float) anEquation.w()));
}
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_0_SPACE + anIndex),
myContext->Clipping().GetEquationSpace (aPlane));
++anIndex;
} }
theProgram->UpdateState (OpenGl_CLIP_PLANES_STATE, myClippingState.Index()); OpenGl_Vec4* anEquations = new OpenGl_Vec4[aPlanesNb];
GLint* aSpaces = new GLint [aPlanesNb];
GLuint aPlaneId = 0;
for (Graphic3d_SetOfHClipPlane::Iterator anIter (myContext->Clipping().Planes());
anIter.More(); anIter.Next())
{
const Handle(Graphic3d_ClipPlane)& aPlane = anIter.Value();
if (!myContext->Clipping().IsEnabled (aPlane))
{
continue;
}
const Graphic3d_ClipPlane::Equation& anEquation = aPlane->GetEquation();
anEquations[aPlaneId] = OpenGl_Vec4 ((float) anEquation.x(),
(float) anEquation.y(),
(float) anEquation.z(),
(float) anEquation.w());
aSpaces[aPlaneId] = myContext->Clipping().GetEquationSpace (aPlane);
++aPlaneId;
}
myContext->core20->glUniform4fv (aLocEquations, aPlanesNb, anEquations[0].GetData());
myContext->core20->glUniform1iv (aLocSpaces, aPlanesNb, aSpaces);
delete[] anEquations;
delete[] aSpaces;
} }
// ======================================================================= // =======================================================================
@ -559,65 +569,48 @@ static void PushAspectFace (const Handle(OpenGl_Context)& theCtx,
theProgram->SetUniform (theCtx, theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE), theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),
theAspect->DoTextureMap()); theAspect->DoTextureMap());
theProgram->SetUniform (theCtx, theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER), theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER),
0 /* GL_TEXTURE0 */); 0 /* GL_TEXTURE0 */);
theProgram->SetUniform (theCtx, theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE), theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
theAspect->DistinguishingMode()); theAspect->DistinguishingMode());
for (int anIndex = 0; anIndex < 2; ++anIndex) OpenGl_Vec4 aParams[5];
for (Standard_Integer anIndex = 0; anIndex < 2; ++anIndex)
{ {
const OPENGL_SURF_PROP& aProperties = (anIndex == 0) ? theAspect->IntFront() : theAspect->IntBack(); const GLint aLoc = theProgram->GetStateLocation (anIndex == 0
GLint aLocation = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_AMBIENT + anIndex); ? OpenGl_OCCT_FRONT_MATERIAL
if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION) : OpenGl_OCCT_BACK_MATERIAL);
if (aLoc == OpenGl_ShaderProgram::INVALID_LOCATION)
{ {
OpenGl_Vec4 anAmbient (aProperties.ambcol.rgb[0] * aProperties.amb, continue;
aProperties.ambcol.rgb[1] * aProperties.amb,
aProperties.ambcol.rgb[2] * aProperties.amb,
aProperties.ambcol.rgb[3] * aProperties.amb);
theProgram->SetUniform (theCtx, aLocation, anAmbient);
} }
aLocation = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_DIFFUSE + anIndex); const OPENGL_SURF_PROP& aProps = (anIndex == 0) ? theAspect->IntFront() : theAspect->IntBack();
if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION) const OpenGl_Vec4 anEmission (aProps.emscol.rgb[0] * aProps.emsv,
{ aProps.emscol.rgb[1] * aProps.emsv,
OpenGl_Vec4 aDiffuse (aProperties.difcol.rgb[0] * aProperties.diff, aProps.emscol.rgb[2] * aProps.emsv,
aProperties.difcol.rgb[1] * aProperties.diff, aProps.emscol.rgb[3] * aProps.emsv);
aProperties.difcol.rgb[2] * aProperties.diff, const OpenGl_Vec4 anAmbient (aProps.ambcol.rgb[0] * aProps.amb,
aProperties.difcol.rgb[3] * aProperties.diff); aProps.ambcol.rgb[1] * aProps.amb,
theProgram->SetUniform (theCtx, aLocation, aDiffuse); aProps.ambcol.rgb[2] * aProps.amb,
} aProps.ambcol.rgb[3] * aProps.amb);
const OpenGl_Vec4 aDiffuse (aProps.difcol.rgb[0] * aProps.diff,
aLocation = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_SPECULAR + anIndex); aProps.difcol.rgb[1] * aProps.diff,
if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION) aProps.difcol.rgb[2] * aProps.diff,
{ aProps.difcol.rgb[3] * aProps.diff);
OpenGl_Vec4 aSpecular (aProperties.speccol.rgb[0] * aProperties.spec, const OpenGl_Vec4 aSpecular (aProps.speccol.rgb[0] * aProps.spec,
aProperties.speccol.rgb[1] * aProperties.spec, aProps.speccol.rgb[1] * aProps.spec,
aProperties.speccol.rgb[2] * aProperties.spec, aProps.speccol.rgb[2] * aProps.spec,
aProperties.speccol.rgb[3] * aProperties.spec); aProps.speccol.rgb[3] * aProps.spec);
theProgram->SetUniform (theCtx, aLocation, aSpecular); aParams[0] = anEmission;
} aParams[1] = anAmbient;
aParams[2] = aDiffuse;
aLocation = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_EMISSION + anIndex); aParams[3] = aSpecular;
if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION) aParams[4].x() = aProps.shine;
{ aParams[4].y() = aProps.trans;
OpenGl_Vec4 anEmission (aProperties.emscol.rgb[0] * aProperties.emsv, theCtx->core20->glUniform4fv (aLoc, 5, aParams[0].GetData());
aProperties.emscol.rgb[1] * aProperties.emsv,
aProperties.emscol.rgb[2] * aProperties.emsv,
aProperties.emscol.rgb[3] * aProperties.emsv);
theProgram->SetUniform (theCtx, aLocation, anEmission);
}
theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_SHININESS + anIndex),
aProperties.shine);
theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_TRANSPARENCY + anIndex),
aProperties.trans);
} }
} }
@ -636,21 +629,15 @@ static void PushAspectLine (const Handle(OpenGl_Context)& theCtx,
theAspect->Color().rgb[1], theAspect->Color().rgb[1],
theAspect->Color().rgb[2], theAspect->Color().rgb[2],
theAspect->Color().rgb[3]); theAspect->Color().rgb[3]);
theProgram->SetUniform (theCtx, OpenGl_Vec4 aParams[5];
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_AMBIENT), aParams[0] = THE_COLOR_BLACK_VEC4;
THE_COLOR_BLACK_VEC4); aParams[1] = THE_COLOR_BLACK_VEC4;
theProgram->SetUniform (theCtx, aParams[2] = aDiffuse;
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_DIFFUSE), aParams[3] = THE_COLOR_BLACK_VEC4;
aDiffuse); aParams[4].x() = 0.0f; // shininess
theProgram->SetUniform (theCtx, aParams[4].y() = 0.0f; // transparency
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_SPECULAR), theCtx->core20->glUniform4fv (theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL),
THE_COLOR_BLACK_VEC4); 5, aParams[0].GetData());
theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_EMISSION),
THE_COLOR_BLACK_VEC4);
theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_TRANSPARENCY),
0.0f);
} }
// ======================================================================= // =======================================================================
@ -678,21 +665,15 @@ static void PushAspectText (const Handle(OpenGl_Context)& theCtx,
theAspect->SubtitleColor().rgb[3]); theAspect->SubtitleColor().rgb[3]);
} }
theProgram->SetUniform (theCtx, OpenGl_Vec4 aParams[5];
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_AMBIENT), aParams[0] = THE_COLOR_BLACK_VEC4;
THE_COLOR_BLACK_VEC4); aParams[1] = THE_COLOR_BLACK_VEC4;
theProgram->SetUniform (theCtx, aParams[2] = aDiffuse;
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_DIFFUSE), aParams[3] = THE_COLOR_BLACK_VEC4;
aDiffuse); aParams[4].x() = 0.0f; // shininess
theProgram->SetUniform (theCtx, aParams[4].y() = 0.0f; // transparency
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_SPECULAR), theCtx->core20->glUniform4fv (theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL),
THE_COLOR_BLACK_VEC4); 5, aParams[0].GetData());
theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_EMISSION),
THE_COLOR_BLACK_VEC4);
theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_TRANSPARENCY),
0.0f);
} }
// ======================================================================= // =======================================================================
@ -711,22 +692,15 @@ static void PushAspectMarker (const Handle(OpenGl_Context)& theCtx,
theAspect->Color().rgb[1], theAspect->Color().rgb[1],
theAspect->Color().rgb[2], theAspect->Color().rgb[2],
theAspect->Color().rgb[3]); theAspect->Color().rgb[3]);
OpenGl_Vec4 aParams[5];
theProgram->SetUniform (theCtx, aParams[0] = THE_COLOR_BLACK_VEC4;
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_AMBIENT), aParams[1] = THE_COLOR_BLACK_VEC4;
THE_COLOR_BLACK_VEC4); aParams[2] = aDiffuse;
theProgram->SetUniform (theCtx, aParams[3] = THE_COLOR_BLACK_VEC4;
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_DIFFUSE), aParams[4].x() = 0.0f; // shininess
aDiffuse); aParams[4].y() = 0.0f; // transparency
theProgram->SetUniform (theCtx, theCtx->core20->glUniform4fv (theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL),
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_SPECULAR), 5, aParams[0].GetData());
THE_COLOR_BLACK_VEC4);
theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_EMISSION),
THE_COLOR_BLACK_VEC4);
theProgram->SetUniform (theCtx,
theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_TRANSPARENCY),
0.0f);
} }
}; // nameless namespace }; // nameless namespace
@ -780,4 +754,4 @@ void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& thePro
PushModelWorldState (theProgram); PushModelWorldState (theProgram);
PushProjectionState (theProgram); PushProjectionState (theProgram);
PushLightSourceState (theProgram); PushLightSourceState (theProgram);
} }

182
src/OpenGl/OpenGl_ShaderProgram.cxx
View File

@ -36,153 +36,32 @@ OpenGl_VariableSetterSelector OpenGl_ShaderProgram::mySetterSelector = OpenGl_Va
// Declare OCCT-specific OpenGL/GLSL shader variables // Declare OCCT-specific OpenGL/GLSL shader variables
Standard_CString OpenGl_ShaderProgram::PredefinedKeywords[] = Standard_CString OpenGl_ShaderProgram::PredefinedKeywords[] =
{ {
/* OpenGl_OCC_MODEL_WORLD_MATRIX */ "occModelWorldMatrix", "occModelWorldMatrix", // OpenGl_OCC_MODEL_WORLD_MATRIX
/* OpenGl_OCC_WORLD_VIEW_MATRIX */ "occWorldViewMatrix", "occWorldViewMatrix", // OpenGl_OCC_WORLD_VIEW_MATRIX
/* OpenGl_OCC_PROJECTION_MATRIX */ "occProjectionMatrix", "occProjectionMatrix", // OpenGl_OCC_PROJECTION_MATRIX
/* OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE */ "occModelWorldMatrixInverse", "occModelWorldMatrixInverse", // OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE
/* OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE */ "occWorldViewMatrixInverse", "occWorldViewMatrixInverse", // OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE
/* OpenGl_OCC_PROJECTION_MATRIX_INVERSE */ "occProjectionMatrixInverse", "occProjectionMatrixInverse", // OpenGl_OCC_PROJECTION_MATRIX_INVERSE
/* OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE */ "occModelWorldMatrixTranspose", "occModelWorldMatrixTranspose", // OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE
/* OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE */ "occWorldViewMatrixTranspose", "occWorldViewMatrixTranspose", // OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE
/* OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE */ "occProjectionMatrixTranspose", "occProjectionMatrixTranspose", // OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE
/* OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE */ "occModelWorldMatrixInverseTranspose", "occModelWorldMatrixInverseTranspose", // OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE
/* OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE */ "occWorldViewMatrixInverseTranspose", "occWorldViewMatrixInverseTranspose", // OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE
/* OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE */ "occProjectionMatrixInverseTranspose", "occProjectionMatrixInverseTranspose", // OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE
/* OpenGl_OCC_CLIP_PLANE_0_EQUATION */ "occClipPlanes[0].Equation", "occClipPlaneEquations", // OpenGl_OCC_CLIP_PLANE_EQUATIONS
/* OpenGl_OCC_CLIP_PLANE_1_EQUATION */ "occClipPlanes[1].Equation", "occClipPlaneSpaces", // OpenGl_OCC_CLIP_PLANE_SPACES
/* OpenGl_OCC_CLIP_PLANE_2_EQUATION */ "occClipPlanes[2].Equation",
/* OpenGl_OCC_CLIP_PLANE_3_EQUATION */ "occClipPlanes[3].Equation",
/* OpenGl_OCC_CLIP_PLANE_4_EQUATION */ "occClipPlanes[4].Equation",
/* OpenGl_OCC_CLIP_PLANE_5_EQUATION */ "occClipPlanes[5].Equation",
/* OpenGl_OCC_CLIP_PLANE_6_EQUATION */ "occClipPlanes[6].Equation",
/* OpenGl_OCC_CLIP_PLANE_7_EQUATION */ "occClipPlanes[7].Equation",
/* OpenGl_OCC_CLIP_PLANE_0_SPACE */ "occClipPlanes[0].Space", "occLightSourcesCount", // OpenGl_OCC_LIGHT_SOURCE_COUNT
/* OpenGl_OCC_CLIP_PLANE_1_SPACE */ "occClipPlanes[1].Space", "occLightSourcesTypes", // OpenGl_OCC_LIGHT_SOURCE_TYPES
/* OpenGl_OCC_CLIP_PLANE_2_SPACE */ "occClipPlanes[2].Space", "occLightSources", // OpenGl_OCC_LIGHT_SOURCE_PARAMS
/* OpenGl_OCC_CLIP_PLANE_3_SPACE */ "occClipPlanes[3].Space", "occLightAmbient", // OpenGl_OCC_LIGHT_AMBIENT
/* OpenGl_OCC_CLIP_PLANE_4_SPACE */ "occClipPlanes[4].Space",
/* OpenGl_OCC_CLIP_PLANE_5_SPACE */ "occClipPlanes[5].Space",
/* OpenGl_OCC_CLIP_PLANE_6_SPACE */ "occClipPlanes[6].Space",
/* OpenGl_OCC_CLIP_PLANE_7_SPACE */ "occClipPlanes[7].Space",
/* OpenGl_OCC_LIGHT_SOURCE_COUNT */ "occLightSourcesCount", "occActiveSampler", // OpenGl_OCCT_ACTIVE_SAMPLER
"occTextureEnable", // OpenGl_OCCT_TEXTURE_ENABLE
/* OpenGl_OCC_LIGHT_SOURCE_0_TYPE */ "occLightSources[0].Type", "occDistinguishingMode", // OpenGl_OCCT_DISTINGUISH_MODE
/* OpenGl_OCC_LIGHT_SOURCE_1_TYPE */ "occLightSources[1].Type", "occFrontMaterial", // OpenGl_OCCT_FRONT_MATERIAL
/* OpenGl_OCC_LIGHT_SOURCE_2_TYPE */ "occLightSources[2].Type", "occBackMaterial" // OpenGl_OCCT_BACK_MATERIAL
/* OpenGl_OCC_LIGHT_SOURCE_3_TYPE */ "occLightSources[3].Type",
/* OpenGl_OCC_LIGHT_SOURCE_4_TYPE */ "occLightSources[4].Type",
/* OpenGl_OCC_LIGHT_SOURCE_5_TYPE */ "occLightSources[5].Type",
/* OpenGl_OCC_LIGHT_SOURCE_6_TYPE */ "occLightSources[6].Type",
/* OpenGl_OCC_LIGHT_SOURCE_7_TYPE */ "occLightSources[7].Type",
/* OpenGl_OCC_LIGHT_SOURCE_0_HEAD */ "occLightSources[0].Head",
/* OpenGl_OCC_LIGHT_SOURCE_1_HEAD */ "occLightSources[1].Head",
/* OpenGl_OCC_LIGHT_SOURCE_2_HEAD */ "occLightSources[2].Head",
/* OpenGl_OCC_LIGHT_SOURCE_3_HEAD */ "occLightSources[3].Head",
/* OpenGl_OCC_LIGHT_SOURCE_4_HEAD */ "occLightSources[4].Head",
/* OpenGl_OCC_LIGHT_SOURCE_5_HEAD */ "occLightSources[5].Head",
/* OpenGl_OCC_LIGHT_SOURCE_6_HEAD */ "occLightSources[6].Head",
/* OpenGl_OCC_LIGHT_SOURCE_7_HEAD */ "occLightSources[7].Head",
/* OpenGl_OCC_LIGHT_SOURCE_0_AMBIENT */ "occLightSources[0].Ambient",
/* OpenGl_OCC_LIGHT_SOURCE_1_AMBIENT */ "occLightSources[1].Ambient",
/* OpenGl_OCC_LIGHT_SOURCE_2_AMBIENT */ "occLightSources[2].Ambient",
/* OpenGl_OCC_LIGHT_SOURCE_3_AMBIENT */ "occLightSources[3].Ambient",
/* OpenGl_OCC_LIGHT_SOURCE_4_AMBIENT */ "occLightSources[4].Ambient",
/* OpenGl_OCC_LIGHT_SOURCE_5_AMBIENT */ "occLightSources[5].Ambient",
/* OpenGl_OCC_LIGHT_SOURCE_6_AMBIENT */ "occLightSources[6].Ambient",
/* OpenGl_OCC_LIGHT_SOURCE_7_AMBIENT */ "occLightSources[7].Ambient",
/* OpenGl_OCC_LIGHT_SOURCE_0_DIFFUSE */ "occLightSources[0].Diffuse",
/* OpenGl_OCC_LIGHT_SOURCE_1_DIFFUSE */ "occLightSources[1].Diffuse",
/* OpenGl_OCC_LIGHT_SOURCE_2_DIFFUSE */ "occLightSources[2].Diffuse",
/* OpenGl_OCC_LIGHT_SOURCE_3_DIFFUSE */ "occLightSources[3].Diffuse",
/* OpenGl_OCC_LIGHT_SOURCE_4_DIFFUSE */ "occLightSources[4].Diffuse",
/* OpenGl_OCC_LIGHT_SOURCE_5_DIFFUSE */ "occLightSources[5].Diffuse",
/* OpenGl_OCC_LIGHT_SOURCE_6_DIFFUSE */ "occLightSources[6].Diffuse",
/* OpenGl_OCC_LIGHT_SOURCE_7_DIFFUSE */ "occLightSources[7].Diffuse",
/* OpenGl_OCC_LIGHT_SOURCE_0_SPECULAR */ "occLightSources[0].Specular",
/* OpenGl_OCC_LIGHT_SOURCE_1_SPECULAR */ "occLightSources[1].Specular",
/* OpenGl_OCC_LIGHT_SOURCE_2_SPECULAR */ "occLightSources[2].Specular",
/* OpenGl_OCC_LIGHT_SOURCE_3_SPECULAR */ "occLightSources[3].Specular",
/* OpenGl_OCC_LIGHT_SOURCE_4_SPECULAR */ "occLightSources[4].Specular",
/* OpenGl_OCC_LIGHT_SOURCE_5_SPECULAR */ "occLightSources[5].Specular",
/* OpenGl_OCC_LIGHT_SOURCE_6_SPECULAR */ "occLightSources[6].Specular",
/* OpenGl_OCC_LIGHT_SOURCE_7_SPECULAR */ "occLightSources[7].Specular",
/* OpenGl_OCC_LIGHT_SOURCE_0_POSITION */ "occLightSources[0].Position",
/* OpenGl_OCC_LIGHT_SOURCE_1_POSITION */ "occLightSources[1].Position",
/* OpenGl_OCC_LIGHT_SOURCE_2_POSITION */ "occLightSources[2].Position",
/* OpenGl_OCC_LIGHT_SOURCE_3_POSITION */ "occLightSources[3].Position",
/* OpenGl_OCC_LIGHT_SOURCE_4_POSITION */ "occLightSources[4].Position",
/* OpenGl_OCC_LIGHT_SOURCE_5_POSITION */ "occLightSources[5].Position",
/* OpenGl_OCC_LIGHT_SOURCE_6_POSITION */ "occLightSources[6].Position",
/* OpenGl_OCC_LIGHT_SOURCE_7_POSITION */ "occLightSources[7].Position",
/* OpenGl_OCC_LIGHT_SOURCE_0_SPOT_CUTOFF */ "occLightSources[0].SpotCutoff",
/* OpenGl_OCC_LIGHT_SOURCE_1_SPOT_CUTOFF */ "occLightSources[1].SpotCutoff",
/* OpenGl_OCC_LIGHT_SOURCE_2_SPOT_CUTOFF */ "occLightSources[2].SpotCutoff",
/* OpenGl_OCC_LIGHT_SOURCE_3_SPOT_CUTOFF */ "occLightSources[3].SpotCutoff",
/* OpenGl_OCC_LIGHT_SOURCE_4_SPOT_CUTOFF */ "occLightSources[4].SpotCutoff",
/* OpenGl_OCC_LIGHT_SOURCE_5_SPOT_CUTOFF */ "occLightSources[5].SpotCutoff",
/* OpenGl_OCC_LIGHT_SOURCE_6_SPOT_CUTOFF */ "occLightSources[6].SpotCutoff",
/* OpenGl_OCC_LIGHT_SOURCE_7_SPOT_CUTOFF */ "occLightSources[7].SpotCutoff",
/* OpenGl_OCC_LIGHT_SOURCE_0_SPOT_EXPONENT */ "occLightSources[0].SpotExponent",
/* OpenGl_OCC_LIGHT_SOURCE_1_SPOT_EXPONENT */ "occLightSources[1].SpotExponent",
/* OpenGl_OCC_LIGHT_SOURCE_2_SPOT_EXPONENT */ "occLightSources[2].SpotExponent",
/* OpenGl_OCC_LIGHT_SOURCE_3_SPOT_EXPONENT */ "occLightSources[3].SpotExponent",
/* OpenGl_OCC_LIGHT_SOURCE_4_SPOT_EXPONENT */ "occLightSources[4].SpotExponent",
/* OpenGl_OCC_LIGHT_SOURCE_5_SPOT_EXPONENT */ "occLightSources[5].SpotExponent",
/* OpenGl_OCC_LIGHT_SOURCE_6_SPOT_EXPONENT */ "occLightSources[6].SpotExponent",
/* OpenGl_OCC_LIGHT_SOURCE_7_SPOT_EXPONENT */ "occLightSources[7].SpotExponent",
/* OpenGl_OCC_LIGHT_SOURCE_0_SPOT_DIRECTION */ "occLightSources[0].SpotDirection",
/* OpenGl_OCC_LIGHT_SOURCE_1_SPOT_DIRECTION */ "occLightSources[1].SpotDirection",
/* OpenGl_OCC_LIGHT_SOURCE_2_SPOT_DIRECTION */ "occLightSources[2].SpotDirection",
/* OpenGl_OCC_LIGHT_SOURCE_3_SPOT_DIRECTION */ "occLightSources[3].SpotDirection",
/* OpenGl_OCC_LIGHT_SOURCE_4_SPOT_DIRECTION */ "occLightSources[4].SpotDirection",
/* OpenGl_OCC_LIGHT_SOURCE_5_SPOT_DIRECTION */ "occLightSources[5].SpotDirection",
/* OpenGl_OCC_LIGHT_SOURCE_6_SPOT_DIRECTION */ "occLightSources[6].SpotDirection",
/* OpenGl_OCC_LIGHT_SOURCE_7_SPOT_DIRECTION */ "occLightSources[7].SpotDirection",
/* OpenGl_OCC_LIGHT_SOURCE_0_CONST_ATTENUATION */ "occLightSources[0].ConstAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_1_CONST_ATTENUATION */ "occLightSources[1].ConstAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_2_CONST_ATTENUATION */ "occLightSources[2].ConstAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_3_CONST_ATTENUATION */ "occLightSources[3].ConstAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_4_CONST_ATTENUATION */ "occLightSources[4].ConstAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_5_CONST_ATTENUATION */ "occLightSources[5].ConstAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_6_CONST_ATTENUATION */ "occLightSources[6].ConstAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_7_CONST_ATTENUATION */ "occLightSources[7].ConstAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_0_LINEAR_ATTENUATION */ "occLightSources[0].LinearAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_1_LINEAR_ATTENUATION */ "occLightSources[1].LinearAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_2_LINEAR_ATTENUATION */ "occLightSources[2].LinearAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_3_LINEAR_ATTENUATION */ "occLightSources[3].LinearAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_4_LINEAR_ATTENUATION */ "occLightSources[4].LinearAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_5_LINEAR_ATTENUATION */ "occLightSources[5].LinearAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_6_LINEAR_ATTENUATION */ "occLightSources[6].LinearAttenuation",
/* OpenGl_OCC_LIGHT_SOURCE_7_LINEAR_ATTENUATION */ "occLightSources[7].LinearAttenuation",
/* OpenGl_OCCT_ACTIVE_SAMPLER */ "occActiveSampler",
/* OpenGl_OCCT_TEXTURE_ENABLE */ "occTextureEnable",
/* OpenGl_OCCT_DISTINGUISH_MODE */ "occDistinguishingMode",
/* OpenGl_OCCT_FRONT_MATERIAL_AMBIENT */ "occFrontMaterial.Ambient",
/* OpenGl_OCCT_BACK_MATERIAL_AMBIENT */ "occBackMaterial.Ambient",
/* OpenGl_OCCT_FRONT_MATERIAL_DIFFUSE */ "occFrontMaterial.Diffuse",
/* OpenGl_OCCT_BACK_MATERIAL_DIFFUSE */ "occBackMaterial.Diffuse",
/* OpenGl_OCCT_FRONT_MATERIAL_SPECULAR */ "occFrontMaterial.Specular",
/* OpenGl_OCCT_BACK_MATERIAL_SPECULAR */ "occBackMaterial.Specular",
/* OpenGl_OCCT_FRONT_MATERIAL_EMISSION */ "occFrontMaterial.Emission",
/* OpenGl_OCCT_BACK_MATERIAL_EMISSION */ "occBackMaterial.Emission",
/* OpenGl_OCCT_FRONT_MATERIAL_SHININESS */ "occFrontMaterial.Shininess",
/* OpenGl_OCCT_BACK_MATERIAL_SHININESS */ "occBackMaterial.Shininess",
/* OpenGl_OCCT_FRONT_MATERIAL_TRANSPARENCY */ "occFrontMaterial.Transparency",
/* OpenGl_OCCT_BACK_MATERIAL_TRANSPARENCY */ "occBackMaterial.Transparency"
}; };
@ -260,8 +139,10 @@ Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)&
return Standard_False; return Standard_False;
} }
OSD_File aDeclFile (Graphic3d_ShaderProgram::ShadersFolder() + "/Declarations.glsl"); OSD_File aDeclFile (Graphic3d_ShaderProgram::ShadersFolder() + "/Declarations.glsl");
if (!aDeclFile.Exists()) OSD_File aDeclImplFile (Graphic3d_ShaderProgram::ShadersFolder() + "/DeclarationsImpl.glsl");
if (!aDeclFile.Exists()
|| !aDeclImplFile.Exists())
{ {
const TCollection_ExtendedString aMsg = "Error! Failed to load OCCT shader declarations file"; const TCollection_ExtendedString aMsg = "Error! Failed to load OCCT shader declarations file";
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB, theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
@ -273,11 +154,16 @@ Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)&
} }
TCollection_AsciiString aDeclarations; TCollection_AsciiString aDeclarations;
aDeclFile.Open (OSD_ReadOnly, OSD_Protection()); aDeclFile.Open (OSD_ReadOnly, OSD_Protection());
aDeclFile.Read (aDeclarations, (int)aDeclFile.Size()); aDeclFile.Read (aDeclarations, (int)aDeclFile.Size());
aDeclFile.Close(); aDeclFile.Close();
TCollection_AsciiString aDeclImpl;
aDeclImplFile.Open (OSD_ReadOnly, OSD_Protection());
aDeclImplFile.Read (aDeclImpl, (int)aDeclImplFile.Size());
aDeclImplFile.Close();
aDeclarations += aDeclImpl;
for (Graphic3d_ShaderObjectList::Iterator anIter (theShaders); for (Graphic3d_ShaderObjectList::Iterator anIter (theShaders);
anIter.More(); anIter.Next()) anIter.More(); anIter.Next())
{ {
@ -391,7 +277,7 @@ Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)&
GL_DEBUG_TYPE_ERROR_ARB, GL_DEBUG_TYPE_ERROR_ARB,
0, 0,
GL_DEBUG_SEVERITY_HIGH_ARB, GL_DEBUG_SEVERITY_HIGH_ARB,
TCollection_ExtendedString ("Failed to link program object! Linker log:\n")); TCollection_ExtendedString ("Failed to link program object! Linker log:\n") + aLog);
return Standard_False; return Standard_False;
} }
else if (theCtx->caps->glslWarnings) else if (theCtx->caps->glslWarnings)

132
src/OpenGl/OpenGl_ShaderProgram.hxx
View File

@ -52,131 +52,21 @@ enum OpenGl_StateVariable
OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE, OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE,
// OpenGL clip planes state // OpenGL clip planes state
OpenGl_OCC_CLIP_PLANE_0_EQUATION, OpenGl_OCC_CLIP_PLANE_EQUATIONS,
OpenGl_OCC_CLIP_PLANE_1_EQUATION, OpenGl_OCC_CLIP_PLANE_SPACES,
OpenGl_OCC_CLIP_PLANE_2_EQUATION,
OpenGl_OCC_CLIP_PLANE_3_EQUATION,
OpenGl_OCC_CLIP_PLANE_4_EQUATION,
OpenGl_OCC_CLIP_PLANE_5_EQUATION,
OpenGl_OCC_CLIP_PLANE_6_EQUATION,
OpenGl_OCC_CLIP_PLANE_7_EQUATION,
OpenGl_OCC_CLIP_PLANE_0_SPACE,
OpenGl_OCC_CLIP_PLANE_1_SPACE,
OpenGl_OCC_CLIP_PLANE_2_SPACE,
OpenGl_OCC_CLIP_PLANE_3_SPACE,
OpenGl_OCC_CLIP_PLANE_4_SPACE,
OpenGl_OCC_CLIP_PLANE_5_SPACE,
OpenGl_OCC_CLIP_PLANE_6_SPACE,
OpenGl_OCC_CLIP_PLANE_7_SPACE,
OpenGl_OCC_LIGHT_SOURCE_COUNT,
// OpenGL light state // OpenGL light state
OpenGl_OCC_LIGHT_SOURCE_0_TYPE, OpenGl_OCC_LIGHT_SOURCE_COUNT,
OpenGl_OCC_LIGHT_SOURCE_1_TYPE, OpenGl_OCC_LIGHT_SOURCE_TYPES,
OpenGl_OCC_LIGHT_SOURCE_2_TYPE, OpenGl_OCC_LIGHT_SOURCE_PARAMS,
OpenGl_OCC_LIGHT_SOURCE_3_TYPE, OpenGl_OCC_LIGHT_AMBIENT,
OpenGl_OCC_LIGHT_SOURCE_4_TYPE,
OpenGl_OCC_LIGHT_SOURCE_5_TYPE,
OpenGl_OCC_LIGHT_SOURCE_6_TYPE,
OpenGl_OCC_LIGHT_SOURCE_7_TYPE,
OpenGl_OCC_LIGHT_SOURCE_0_HEAD,
OpenGl_OCC_LIGHT_SOURCE_1_HEAD,
OpenGl_OCC_LIGHT_SOURCE_2_HEAD,
OpenGl_OCC_LIGHT_SOURCE_3_HEAD,
OpenGl_OCC_LIGHT_SOURCE_4_HEAD,
OpenGl_OCC_LIGHT_SOURCE_5_HEAD,
OpenGl_OCC_LIGHT_SOURCE_6_HEAD,
OpenGl_OCC_LIGHT_SOURCE_7_HEAD,
OpenGl_OCC_LIGHT_SOURCE_0_AMBIENT,
OpenGl_OCC_LIGHT_SOURCE_1_AMBIENT,
OpenGl_OCC_LIGHT_SOURCE_2_AMBIENT,
OpenGl_OCC_LIGHT_SOURCE_3_AMBIENT,
OpenGl_OCC_LIGHT_SOURCE_4_AMBIENT,
OpenGl_OCC_LIGHT_SOURCE_5_AMBIENT,
OpenGl_OCC_LIGHT_SOURCE_6_AMBIENT,
OpenGl_OCC_LIGHT_SOURCE_7_AMBIENT,
OpenGl_OCC_LIGHT_SOURCE_0_DIFFUSE,
OpenGl_OCC_LIGHT_SOURCE_1_DIFFUSE,
OpenGl_OCC_LIGHT_SOURCE_2_DIFFUSE,
OpenGl_OCC_LIGHT_SOURCE_3_DIFFUSE,
OpenGl_OCC_LIGHT_SOURCE_4_DIFFUSE,
OpenGl_OCC_LIGHT_SOURCE_5_DIFFUSE,
OpenGl_OCC_LIGHT_SOURCE_6_DIFFUSE,
OpenGl_OCC_LIGHT_SOURCE_7_DIFFUSE,
OpenGl_OCC_LIGHT_SOURCE_0_SPECULAR,
OpenGl_OCC_LIGHT_SOURCE_1_SPECULAR,
OpenGl_OCC_LIGHT_SOURCE_2_SPECULAR,
OpenGl_OCC_LIGHT_SOURCE_3_SPECULAR,
OpenGl_OCC_LIGHT_SOURCE_4_SPECULAR,
OpenGl_OCC_LIGHT_SOURCE_5_SPECULAR,
OpenGl_OCC_LIGHT_SOURCE_6_SPECULAR,
OpenGl_OCC_LIGHT_SOURCE_7_SPECULAR,
OpenGl_OCC_LIGHT_SOURCE_0_POSITION,
OpenGl_OCC_LIGHT_SOURCE_1_POSITION,
OpenGl_OCC_LIGHT_SOURCE_2_POSITION,
OpenGl_OCC_LIGHT_SOURCE_3_POSITION,
OpenGl_OCC_LIGHT_SOURCE_4_POSITION,
OpenGl_OCC_LIGHT_SOURCE_5_POSITION,
OpenGl_OCC_LIGHT_SOURCE_6_POSITION,
OpenGl_OCC_LIGHT_SOURCE_7_POSITION,
OpenGl_OCC_LIGHT_SOURCE_0_SPOT_CUTOFF,
OpenGl_OCC_LIGHT_SOURCE_1_SPOT_CUTOFF,
OpenGl_OCC_LIGHT_SOURCE_2_SPOT_CUTOFF,
OpenGl_OCC_LIGHT_SOURCE_3_SPOT_CUTOFF,
OpenGl_OCC_LIGHT_SOURCE_4_SPOT_CUTOFF,
OpenGl_OCC_LIGHT_SOURCE_5_SPOT_CUTOFF,
OpenGl_OCC_LIGHT_SOURCE_6_SPOT_CUTOFF,
OpenGl_OCC_LIGHT_SOURCE_7_SPOT_CUTOFF,
OpenGl_OCC_LIGHT_SOURCE_0_SPOT_EXPONENT,
OpenGl_OCC_LIGHT_SOURCE_1_SPOT_EXPONENT,
OpenGl_OCC_LIGHT_SOURCE_2_SPOT_EXPONENT,
OpenGl_OCC_LIGHT_SOURCE_3_SPOT_EXPONENT,
OpenGl_OCC_LIGHT_SOURCE_4_SPOT_EXPONENT,
OpenGl_OCC_LIGHT_SOURCE_5_SPOT_EXPONENT,
OpenGl_OCC_LIGHT_SOURCE_6_SPOT_EXPONENT,
OpenGl_OCC_LIGHT_SOURCE_7_SPOT_EXPONENT,
OpenGl_OCC_LIGHT_SOURCE_0_SPOT_DIRECTION,
OpenGl_OCC_LIGHT_SOURCE_1_SPOT_DIRECTION,
OpenGl_OCC_LIGHT_SOURCE_2_SPOT_DIRECTION,
OpenGl_OCC_LIGHT_SOURCE_3_SPOT_DIRECTION,
OpenGl_OCC_LIGHT_SOURCE_4_SPOT_DIRECTION,
OpenGl_OCC_LIGHT_SOURCE_5_SPOT_DIRECTION,
OpenGl_OCC_LIGHT_SOURCE_6_SPOT_DIRECTION,
OpenGl_OCC_LIGHT_SOURCE_7_SPOT_DIRECTION,
OpenGl_OCC_LIGHT_SOURCE_0_CONST_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_1_CONST_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_2_CONST_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_3_CONST_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_4_CONST_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_5_CONST_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_6_CONST_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_7_CONST_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_0_LINEAR_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_1_LINEAR_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_2_LINEAR_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_3_LINEAR_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_4_LINEAR_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_5_LINEAR_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_6_LINEAR_ATTENUATION,
OpenGl_OCC_LIGHT_SOURCE_7_LINEAR_ATTENUATION,
// Material state // Material state
OpenGl_OCCT_ACTIVE_SAMPLER, OpenGl_OCCT_ACTIVE_SAMPLER,
OpenGl_OCCT_TEXTURE_ENABLE, OpenGl_OCCT_TEXTURE_ENABLE,
OpenGl_OCCT_DISTINGUISH_MODE, OpenGl_OCCT_DISTINGUISH_MODE,
OpenGl_OCCT_FRONT_MATERIAL_AMBIENT, OpenGl_OCCT_FRONT_MATERIAL,
OpenGl_OCCT_BACK_MATERIAL_AMBIENT, OpenGl_OCCT_BACK_MATERIAL,
OpenGl_OCCT_FRONT_MATERIAL_DIFFUSE,
OpenGl_OCCT_BACK_MATERIAL_DIFFUSE,
OpenGl_OCCT_FRONT_MATERIAL_SPECULAR,
OpenGl_OCCT_BACK_MATERIAL_SPECULAR,
OpenGl_OCCT_FRONT_MATERIAL_EMISSION,
OpenGl_OCCT_BACK_MATERIAL_EMISSION,
OpenGl_OCCT_FRONT_MATERIAL_SHININESS,
OpenGl_OCCT_BACK_MATERIAL_SHININESS,
OpenGl_OCCT_FRONT_MATERIAL_TRANSPARENCY,
OpenGl_OCCT_BACK_MATERIAL_TRANSPARENCY,
// DON'T MODIFY THIS ITEM (insert new items before it) // DON'T MODIFY THIS ITEM (insert new items before it)
OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES
@ -302,6 +192,12 @@ public:
//! Reverts to fixed-function graphics pipeline (FFP). //! Reverts to fixed-function graphics pipeline (FFP).
Standard_EXPORT static void Unbind (const Handle(OpenGl_Context)& theCtx); Standard_EXPORT static void Unbind (const Handle(OpenGl_Context)& theCtx);
//! @return true if current object was initialized
inline bool IsValid() const
{
return myProgramID != NO_PROGRAM;
}
private: private:
//! Returns index of last modification of variables of specified state type. //! Returns index of last modification of variables of specified state type.

79
src/OpenGl/OpenGl_View.cxx
View File

@ -197,83 +197,26 @@ void OpenGl_View::SetSurfaceDetail (const Visual3d_TypeOfSurfaceDetail theMode)
#endif #endif
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : SetBackfacing
// purpose :
// =======================================================================
void OpenGl_View::SetBackfacing (const Standard_Integer theMode) void OpenGl_View::SetBackfacing (const Standard_Integer theMode)
{ {
myBackfacing = theMode; myBackfacing = theMode;
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : SetLights
//call_togl_setlight // purpose :
void OpenGl_View::SetLights (const CALL_DEF_VIEWCONTEXT &AContext) // =======================================================================
void OpenGl_View::SetLights (const CALL_DEF_VIEWCONTEXT& theViewCtx)
{ {
myLights.Clear(); myLights.Clear();
for (Standard_Integer aLightIt = 0; aLightIt < theViewCtx.NbActiveLight; ++aLightIt)
const int nb_lights = AContext.NbActiveLight;
int i = 0;
const CALL_DEF_LIGHT *alight = &(AContext.ActiveLight[0]);
for ( ; i < nb_lights; i++, alight++ )
{ {
OpenGl_Light rep; myLights.Append (theViewCtx.ActiveLight[aLightIt]);
memset(&rep,0,sizeof(rep));
switch( alight->LightType )
{
case 0 : /* TOLS_AMBIENT */
rep.type = TLightAmbient;
rep.col.rgb[0] = alight->Color.r;
rep.col.rgb[1] = alight->Color.g;
rep.col.rgb[2] = alight->Color.b;
break;
case 1 : /* TOLS_DIRECTIONAL */
rep.type = TLightDirectional;
rep.col.rgb[0] = alight->Color.r;
rep.col.rgb[1] = alight->Color.g;
rep.col.rgb[2] = alight->Color.b;
rep.dir[0] = alight->Direction.x;
rep.dir[1] = alight->Direction.y;
rep.dir[2] = alight->Direction.z;
break;
case 2 : /* TOLS_POSITIONAL */
rep.type = TLightPositional;
rep.col.rgb[0] = alight->Color.r;
rep.col.rgb[1] = alight->Color.g;
rep.col.rgb[2] = alight->Color.b;
rep.pos[0] = alight->Position.x;
rep.pos[1] = alight->Position.y;
rep.pos[2] = alight->Position.z;
rep.atten[0] = alight->Attenuation[0];
rep.atten[1] = alight->Attenuation[1];
break;
case 3 : /* TOLS_SPOT */
rep.type = TLightSpot;
rep.col.rgb[0] = alight->Color.r;
rep.col.rgb[1] = alight->Color.g;
rep.col.rgb[2] = alight->Color.b;
rep.pos[0] = alight->Position.x;
rep.pos[1] = alight->Position.y;
rep.pos[2] = alight->Position.z;
rep.dir[0] = alight->Direction.x;
rep.dir[1] = alight->Direction.y;
rep.dir[2] = alight->Direction.z;
rep.shine = alight->Concentration;
rep.atten[0] = alight->Attenuation[0];
rep.atten[1] = alight->Attenuation[1];
rep.angle = alight->Angle;
break;
}
rep.HeadLight = alight->Headlight;
myLights.Append(rep);
} }
myCurrLightSourceState = myStateCounter->Increment(); myCurrLightSourceState = myStateCounter->Increment();
} }

263
src/OpenGl/OpenGl_View_2.cxx
View File

@ -43,10 +43,15 @@
#define EPSI 0.0001 #define EPSI 0.0001
static const GLfloat default_amb[4] = { 0.F, 0.F, 0.F, 1.F }; namespace
static const GLfloat default_sptdir[3] = { 0.F, 0.F, -1.F }; {
static const GLfloat default_sptexpo = 0.F;
static const GLfloat default_sptcutoff = 180.F; static const GLfloat THE_DEFAULT_AMBIENT[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
static const GLfloat THE_DEFAULT_SPOT_DIR[3] = { 0.0f, 0.0f, -1.0f };
static const GLfloat THE_DEFAULT_SPOT_EXPONENT = 0.0f;
static const GLfloat THE_DEFAULT_SPOT_CUTOFF = 180.0f;
};
extern void InitLayerProp (const int theListId); //szvgl: defined in OpenGl_GraphicDriver_Layer.cxx extern void InitLayerProp (const int theListId); //szvgl: defined in OpenGl_GraphicDriver_Layer.cxx
@ -68,171 +73,89 @@ struct OPENGL_CLIP_PLANE
/* /*
* Set des lumieres * Set des lumieres
*/ */
static void bind_light(const OpenGl_Light *lptr, int *gl_lid) static void bind_light (const OpenGl_Light& theLight,
GLenum& theLightGlId)
{ {
// Only 8 lights in OpenGL... // Only 8 lights in OpenGL...
if (*gl_lid > GL_LIGHT7) return; if (theLightGlId > GL_LIGHT7)
// the light is a headlight ?
GLint cur_matrix = 0;
if (lptr->HeadLight)
{ {
glGetIntegerv(GL_MATRIX_MODE, &cur_matrix); return;
glMatrixMode(GL_MODELVIEW); }
if (theLight.Type == Visual3d_TOLS_AMBIENT)
{
// setup RGBA intensity of the ambient light
glLightModelfv (GL_LIGHT_MODEL_AMBIENT, theLight.Color.GetData());
return;
}
// the light is a headlight?
GLint aMatrixModeOld = 0;
if (theLight.IsHeadlight)
{
glGetIntegerv (GL_MATRIX_MODE, &aMatrixModeOld);
glMatrixMode (GL_MODELVIEW);
glPushMatrix(); glPushMatrix();
glLoadIdentity(); glLoadIdentity();
} }
GLfloat data_amb[4]; // setup light type
GLfloat data_diffu[4]; switch (theLight.Type)
GLfloat data_pos[4];
GLfloat data_sptdir[3];
GLfloat data_sptexpo;
GLfloat data_sptcutoff;
GLfloat data_constantattenuation;
GLfloat data_linearattenuation;
/* set la light en fonction de son type */
switch (lptr->type)
{ {
case TLightAmbient: case Visual3d_TOLS_DIRECTIONAL:
data_amb[0] = lptr->col.rgb[0]; {
data_amb[1] = lptr->col.rgb[1]; // if the last parameter of GL_POSITION, is zero, the corresponding light source is a Directional one
data_amb[2] = lptr->col.rgb[2]; const OpenGl_Vec4 anInfDir = -theLight.Direction;
data_amb[3] = 1.0;
/*------------------------- Ambient ---------------------------*/ // to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE.
/* glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
* The GL_AMBIENT parameter refers to RGBA intensity of the ambient glLightfv (theLightGlId, GL_DIFFUSE, theLight.Color.GetData());
* light. glLightfv (theLightGlId, GL_SPECULAR, theLight.Color.GetData());
*/ glLightfv (theLightGlId, GL_POSITION, anInfDir.GetData());
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, data_amb); glLightfv (theLightGlId, GL_SPOT_DIRECTION, THE_DEFAULT_SPOT_DIR);
break; glLightf (theLightGlId, GL_SPOT_EXPONENT, THE_DEFAULT_SPOT_EXPONENT);
glLightf (theLightGlId, GL_SPOT_CUTOFF, THE_DEFAULT_SPOT_CUTOFF);
break;
case TLightDirectional: }
data_diffu[0] = lptr->col.rgb[0]; case Visual3d_TOLS_POSITIONAL:
data_diffu[1] = lptr->col.rgb[1]; {
data_diffu[2] = lptr->col.rgb[2]; // to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE
data_diffu[3] = 1.0; glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
glLightfv (theLightGlId, GL_DIFFUSE, theLight.Color.GetData());
/*------------------------- Direction ---------------------------*/ glLightfv (theLightGlId, GL_SPECULAR, theLight.Color.GetData());
/* From Open GL Programming Rev 1 Guide Chapt 6 : glLightfv (theLightGlId, GL_POSITION, theLight.Position.GetData());
Lighting The Mathematics of Lighting ( p 168 ) glLightfv (theLightGlId, GL_SPOT_DIRECTION, THE_DEFAULT_SPOT_DIR);
glLightf (theLightGlId, GL_SPOT_EXPONENT, THE_DEFAULT_SPOT_EXPONENT);
Directional Light Source ( Infinite ) : glLightf (theLightGlId, GL_SPOT_CUTOFF, THE_DEFAULT_SPOT_CUTOFF);
if the last parameter of GL_POSITION , w , is zero, the glLightf (theLightGlId, GL_CONSTANT_ATTENUATION, theLight.ConstAttenuation());
corresponding light source is a Directional one. glLightf (theLightGlId, GL_LINEAR_ATTENUATION, theLight.LinearAttenuation());
glLightf (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0);
GL_SPOT_CUTOFF a 180 signifie que ce n'est pas un spot. break;
To create a realistic effect, set the GL_SPECULAR parameter }
to the same value as the GL_DIFFUSE. case Visual3d_TOLS_SPOT:
*/ {
glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
data_pos[0] = -lptr->dir[0]; glLightfv (theLightGlId, GL_DIFFUSE, theLight.Color.GetData());
data_pos[1] = -lptr->dir[1]; glLightfv (theLightGlId, GL_SPECULAR, theLight.Color.GetData());
data_pos[2] = -lptr->dir[2]; glLightfv (theLightGlId, GL_POSITION, theLight.Position.GetData());
data_pos[3] = 0.0; glLightfv (theLightGlId, GL_SPOT_DIRECTION, theLight.Direction.GetData());
glLightf (theLightGlId, GL_SPOT_EXPONENT, theLight.Concentration() * 128.0f);
glLightfv(*gl_lid, GL_AMBIENT, default_amb); glLightf (theLightGlId, GL_SPOT_CUTOFF, (theLight.Angle() * 180.0f) / GLfloat(M_PI));
glLightfv(*gl_lid, GL_DIFFUSE, data_diffu); glLightf (theLightGlId, GL_CONSTANT_ATTENUATION, theLight.ConstAttenuation());
glLightfv(*gl_lid, GL_SPECULAR, data_diffu); glLightf (theLightGlId, GL_LINEAR_ATTENUATION, theLight.LinearAttenuation());
glLightf (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0f);
glLightfv(*gl_lid, GL_POSITION, data_pos); break;
glLightfv(*gl_lid, GL_SPOT_DIRECTION, default_sptdir); }
glLightf(*gl_lid, GL_SPOT_EXPONENT, default_sptexpo);
glLightf(*gl_lid, GL_SPOT_CUTOFF, default_sptcutoff);
break;
case TLightPositional:
data_diffu[0] = lptr->col.rgb[0];
data_diffu[1] = lptr->col.rgb[1];
data_diffu[2] = lptr->col.rgb[2];
data_diffu[3] = 1.0;
/*------------------------- Position -----------------------------*/
/* From Open GL Programming Rev 1 Guide Chapt 6 :
Lighting The Mathematics of Lighting ( p 168 )
Positional Light Source :
if the last parameter of GL_POSITION , w , is nonzero,
the corresponding light source is a Positional one.
GL_SPOT_CUTOFF a 180 signifie que ce n'est pas un spot.
To create a realistic effect, set the GL_SPECULAR parameter
to the same value as the GL_DIFFUSE.
*/
data_pos[0] = lptr->pos[0];
data_pos[1] = lptr->pos[1];
data_pos[2] = lptr->pos[2];
data_pos[3] = 1.0;
data_constantattenuation = lptr->atten[0];
data_linearattenuation = lptr->atten[1];
glLightfv(*gl_lid, GL_AMBIENT, default_amb);
glLightfv(*gl_lid, GL_DIFFUSE, data_diffu);
glLightfv(*gl_lid, GL_SPECULAR, data_diffu);
glLightfv(*gl_lid, GL_POSITION, data_pos);
glLightfv(*gl_lid, GL_SPOT_DIRECTION, default_sptdir);
glLightf(*gl_lid, GL_SPOT_EXPONENT, default_sptexpo);
glLightf(*gl_lid, GL_SPOT_CUTOFF, default_sptcutoff);
glLightf(*gl_lid, GL_CONSTANT_ATTENUATION, data_constantattenuation);
glLightf(*gl_lid, GL_LINEAR_ATTENUATION, data_linearattenuation);
glLightf(*gl_lid, GL_QUADRATIC_ATTENUATION, 0.0);
break;
case TLightSpot:
data_diffu[0] = lptr->col.rgb[0];
data_diffu[1] = lptr->col.rgb[1];
data_diffu[2] = lptr->col.rgb[2];
data_diffu[3] = 1.0;
data_pos[0] = lptr->pos[0];
data_pos[1] = lptr->pos[1];
data_pos[2] = lptr->pos[2];
data_pos[3] = 1.0;
data_sptdir[0] = lptr->dir[0];
data_sptdir[1] = lptr->dir[1];
data_sptdir[2] = lptr->dir[2];
data_sptexpo = ( float )lptr->shine * 128.0F;
data_sptcutoff = ( float )(lptr->angle * 180.0F)/( float )M_PI;
data_constantattenuation = lptr->atten[0];
data_linearattenuation = lptr->atten[1];
glLightfv(*gl_lid, GL_AMBIENT, default_amb);
glLightfv(*gl_lid, GL_DIFFUSE, data_diffu);
glLightfv(*gl_lid, GL_SPECULAR, data_diffu);
glLightfv(*gl_lid, GL_POSITION, data_pos);
glLightfv(*gl_lid, GL_SPOT_DIRECTION, data_sptdir);
glLightf(*gl_lid, GL_SPOT_EXPONENT, data_sptexpo);
glLightf(*gl_lid, GL_SPOT_CUTOFF, data_sptcutoff);
glLightf(*gl_lid, GL_CONSTANT_ATTENUATION, data_constantattenuation);
glLightf(*gl_lid, GL_LINEAR_ATTENUATION, data_linearattenuation);
glLightf(*gl_lid, GL_QUADRATIC_ATTENUATION, 0.0);
break;
} }
if (lptr->type != TLightAmbient) // restore matrix in case of headlight
{ if (theLight.IsHeadlight)
glEnable(*gl_lid);
(*gl_lid)++;
}
/* si la light etait une headlight alors restaure la matrice precedente */
if (lptr->HeadLight)
{ {
glPopMatrix(); glPopMatrix();
glMatrixMode(cur_matrix); glMatrixMode (aMatrixModeOld);
} }
glEnable (theLightGlId++);
} }
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
@ -1009,23 +932,23 @@ D = -[Px,Py,Pz] dot |Nx|
// Apply Lights // Apply Lights
{ {
int i; // setup lights
glLightModelfv (GL_LIGHT_MODEL_AMBIENT, THE_DEFAULT_AMBIENT);
// Switch off all lights GLenum aLightGlId = GL_LIGHT0;
for (i = GL_LIGHT0; i <= GL_LIGHT7; i++) for (OpenGl_ListOfLight::Iterator aLightIt (myLights);
glDisable(i); aLightIt.More(); aLightIt.Next())
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, default_amb);
/* set les lights */
int gl_lid = GL_LIGHT0;
OpenGl_ListOfLight::Iterator itl(myLights);
for (; itl.More(); itl.Next())
{ {
const OpenGl_Light &alight = itl.Value(); bind_light (aLightIt.Value(), aLightGlId);
bind_light(&alight, &gl_lid); }
if (aLightGlId != GL_LIGHT0)
{
glEnable (GL_LIGHTING);
}
// switch off unused lights
for (; aLightGlId <= GL_LIGHT7; ++aLightGlId)
{
glDisable (aLightGlId);
} }
if (gl_lid != GL_LIGHT0) glEnable(GL_LIGHTING);
} }
// Apply InteriorShadingMethod // Apply InteriorShadingMethod

44
src/OpenGl/OpenGl_Workspace_Raytrace.cxx
View File

@ -917,42 +917,24 @@ Standard_Boolean OpenGl_Workspace::UpdateRaytraceLightSources (const GLdouble th
{ {
myRaytraceSceneData.LightSources.clear(); myRaytraceSceneData.LightSources.clear();
OpenGl_ListOfLight::Iterator anItl (myView->LightList()); OpenGl_RTVec4f anAmbient (0.0f, 0.0f, 0.0f, 0.0f);
for (OpenGl_ListOfLight::Iterator anItl (myView->LightList());
OpenGl_RTVec4f aAmbient (0.f, 0.f, 0.f, 0.f); anItl.More(); anItl.Next())
for (; anItl.More(); anItl.Next())
{ {
const OpenGl_Light &aLight = anItl.Value(); const OpenGl_Light& aLight = anItl.Value();
if (aLight.Type == Visual3d_TOLS_AMBIENT)
if (aLight.type == TLightAmbient)
{ {
aAmbient += OpenGl_RTVec4f (aLight.col.rgb[0], anAmbient += OpenGl_RTVec4f (aLight.Color.r(), aLight.Color.g(), aLight.Color.b(), 0.0f);
aLight.col.rgb[1],
aLight.col.rgb[2],
0.f);
continue; continue;
} }
OpenGl_RTVec4f aDiffuse (aLight.col.rgb[0], OpenGl_RTVec4f aDiffuse (aLight.Color.r(), aLight.Color.g(), aLight.Color.b(), 1.0f);
aLight.col.rgb[1], OpenGl_RTVec4f aPosition (-aLight.Direction.x(), -aLight.Direction.y(), -aLight.Direction.z(), 0.0f);
aLight.col.rgb[2], if (aLight.Type != Visual3d_TOLS_DIRECTIONAL)
1.f);
OpenGl_RTVec4f aPosition (-aLight.dir[0],
-aLight.dir[1],
-aLight.dir[2],
0.f);
if (aLight.type != TLightDirectional)
{ {
aPosition = OpenGl_RTVec4f (aLight.pos[0], aPosition = OpenGl_RTVec4f (aLight.Position.x(), aLight.Position.y(), aLight.Position.z(), 1.0f);
aLight.pos[1],
aLight.pos[2],
1.f);
} }
if (aLight.IsHeadlight)
if (aLight.HeadLight)
{ {
aPosition = MatVecMult (theInvModelView, aPosition); aPosition = MatVecMult (theInvModelView, aPosition);
} }
@ -962,11 +944,11 @@ Standard_Boolean OpenGl_Workspace::UpdateRaytraceLightSources (const GLdouble th
if (myRaytraceSceneData.LightSources.size() > 0) if (myRaytraceSceneData.LightSources.size() > 0)
{ {
myRaytraceSceneData.LightSources.front().Ambient += aAmbient; myRaytraceSceneData.LightSources.front().Ambient += anAmbient;
} }
else else
{ {
myRaytraceSceneData.LightSources.push_back (OpenGl_RaytraceLight (OpenGl_RTVec4f (aAmbient.xyz(), -1.0f))); myRaytraceSceneData.LightSources.push_back (OpenGl_RaytraceLight (OpenGl_RTVec4f (anAmbient.rgb(), -1.0f)));
} }
cl_int anError = CL_SUCCESS; cl_int anError = CL_SUCCESS;

237
src/Shaders/Declarations.glsl
View File

@ -1,192 +1,79 @@
#define _OCC_MAX_LIGHTS_ 8 // This files includes definition of common uniform variables in OCCT GLSL programs
#define _OCC_MAX_CLIP_PLANES_ 8 #define THE_MAX_LIGHTS 8
#define THE_MAX_CLIP_PLANES 8
//! OCCT ambient light source.
const int occAmbientLight = 0;
//! OCCT directional light source.
const int occDirectLight = 1;
//! OCCT isotropic point light source.
const int occPointLight = 2;
//! OCCT spot light source.
const int occSpotLight = 3;
//! Parameters of OCCT light source.
struct occLightSource
{
//! Type of light source.
int Type;
//! Is light a headlight?
int Head;
//! Ambient intensity.
vec3 Ambient;
//! Diffuse intensity.
vec3 Diffuse;
//! Specular intensity.
vec3 Specular;
//! Position of light source.
vec3 Position;
//! Direction of the spot light.
vec3 SpotDirection;
//! Maximum spread angle of the spot light (in radians).
float SpotCutoff;
//! Attenuation of the spot light intensity (from 0 to 1).
float SpotExponent;
//! Const attenuation factor of positional light source.
float ConstAttenuation;
//! Linear attenuation factor of positional light source.
float LinearAttenuation;
};
//! Parameters of OCCT material.
struct occMaterialParams
{
//! Emission color.
vec4 Emission;
//! Ambient reflection.
vec4 Ambient;
//! Diffuse reflection.
vec4 Diffuse;
//! Specular reflection.
vec4 Specular;
//! Specular exponent.
float Shininess;
//! Transparency coefficient.
float Transparency;
};
//! OCCT view-space clipping plane.
const int occEquationCoordsView = 0;
//! OCCT world-space clipping plane.
const int occEquationCoordsWorld = 1;
//! Parameters of OCCT clipping plane.
struct occClipPlane
{
//! Plane equation.
vec4 Equation;
//! Equation space.
int Space;
};
#ifdef VERTEX_SHADER
/////////////////////////////////////////////////////////////////////
// OCCT vertex attributes
// Vertex attributes
// Note: At the moment, we just 'rename' the default OpenGL // Note: At the moment, we just 'rename' the default OpenGL
// vertex attributes from compatibility profile. In the next // vertex attributes from compatibility profile. In the next
// release old functionality will be removed from shader API. // release old functionality will be removed from shader API.
#ifdef VERTEX_SHADER
//! Vertex color. #define occColor gl_Color //!< Vertex color
#define occColor gl_Color #define occNormal gl_Normal //!< Normal coordinates
#define occVertex gl_Vertex //!< Vertex coordinates
//! Normal coordinates. #define occTexCoord gl_MultiTexCoord0 //!< Texture coordinates
#define occNormal gl_Normal
//! Vertex coordinates.
#define occVertex gl_Vertex
//! Texture coordinates.
#define occTexCoord gl_MultiTexCoord0
#endif #endif
///////////////////////////////////////////////////////////////////// // Matrix state
// OCCT matrix state uniform mat4 occWorldViewMatrix; //!< World-view matrix
uniform mat4 occProjectionMatrix; //!< Projection matrix
uniform mat4 occModelWorldMatrix; //!< Model-world matrix
//! World-view matrix. uniform mat4 occWorldViewMatrixInverse; //!< Inverse of the world-view matrix
uniform mat4 occWorldViewMatrix; uniform mat4 occProjectionMatrixInverse; //!< Inverse of the projection matrix
uniform mat4 occModelWorldMatrixInverse; //!< Inverse of the model-world matrix
//! Projection matrix. uniform mat4 occWorldViewMatrixTranspose; //!< Transpose of the world-view matrix
uniform mat4 occProjectionMatrix; uniform mat4 occProjectionMatrixTranspose; //!< Transpose of the projection matrix
uniform mat4 occModelWorldMatrixTranspose; //!< Transpose of the model-world matrix
//! Model-world matrix. uniform mat4 occWorldViewMatrixInverseTranspose; //!< Transpose of the inverse of the world-view matrix
uniform mat4 occModelWorldMatrix; uniform mat4 occProjectionMatrixInverseTranspose; //!< Transpose of the inverse of the projection matrix
uniform mat4 occModelWorldMatrixInverseTranspose; //!< Transpose of the inverse of the model-world matrix
//------------------------------------------------------- // light type enumeration
const int OccLightType_Direct = 1; //!< directional light source
const int OccLightType_Point = 2; //!< isotropic point light source
const int OccLightType_Spot = 3; //!< spot light source
//! Inverse of the world-view matrix. // Light sources
uniform mat4 occWorldViewMatrixInverse; uniform vec4 occLightAmbient; //!< Cumulative ambient color
uniform int occLightSourcesCount; //!< Total number of light sources
int occLight_Type (in int theId); //!< Type of light source
int occLight_IsHeadlight (in int theId); //!< Is light a headlight?
vec4 occLight_Diffuse (in int theId); //!< Diffuse intensity for specified light source
vec4 occLight_Specular (in int theId); //!< Specular intensity (currently - equals to diffuse intencity)
vec4 occLight_Position (in int theId); //!< Position of specified light source
vec4 occLight_SpotDirection (in int theId); //!< Direction of specified spot light source
float occLight_ConstAttenuation (in int theId); //!< Const attenuation factor of positional light source
float occLight_LinearAttenuation (in int theId); //!< Linear attenuation factor of positional light source
float occLight_SpotCutOff (in int theId); //!< Maximum spread angle of the spot light (in radians)
float occLight_SpotExponent (in int theId); //!< Attenuation of the spot light intensity (from 0 to 1)
//! Inverse of the projection matrix. // Front material properties accessors
uniform mat4 occProjectionMatrixInverse; vec4 occFrontMaterial_Emission(void); //!< Emission color
vec4 occFrontMaterial_Ambient(void); //!< Ambient reflection
vec4 occFrontMaterial_Diffuse(void); //!< Diffuse reflection
vec4 occFrontMaterial_Specular(void); //!< Specular reflection
float occFrontMaterial_Shininess(void); //!< Specular exponent
float occFrontMaterial_Transparency(void); //!< Transparency coefficient
//! Inverse of the model-world matrix. // Front material properties accessors
uniform mat4 occModelWorldMatrixInverse; vec4 occBackMaterial_Emission(void); //!< Emission color
vec4 occBackMaterial_Ambient(void); //!< Ambient reflection
vec4 occBackMaterial_Diffuse(void); //!< Diffuse reflection
vec4 occBackMaterial_Specular(void); //!< Specular reflection
float occBackMaterial_Shininess(void); //!< Specular exponent
float occBackMaterial_Transparency(void); //!< Transparency coefficient
//------------------------------------------------------- uniform int occDistinguishingMode; //!< Are front and back faces distinguished?
uniform int occTextureEnable; //!< Is texture enabled?
uniform sampler2D occActiveSampler; //!< Current active sampler
//! Transpose of the world-view matrix. // clipping planes state
uniform mat4 occWorldViewMatrixTranspose; const int OccEquationCoords_View = 0; //!< view-space clipping plane
const int OccEquationCoords_World = 1; //!< world-space clipping plane
//! Transpose of the projection matrix. //! Parameters of clipping planes
uniform mat4 occProjectionMatrixTranspose; uniform vec4 occClipPlaneEquations[THE_MAX_CLIP_PLANES];
uniform int occClipPlaneSpaces [THE_MAX_CLIP_PLANES];
//! Transpose of the model-world matrix.
uniform mat4 occModelWorldMatrixTranspose;
//-------------------------------------------------------
//! Transpose of the inverse of the world-view matrix.
uniform mat4 occWorldViewMatrixInverseTranspose;
//! Transpose of the inverse of the projection matrix.
uniform mat4 occProjectionMatrixInverseTranspose;
//! Transpose of the inverse of the model-world matrix.
uniform mat4 occModelWorldMatrixInverseTranspose;
/////////////////////////////////////////////////////////////////////
// OCCT light source state
//! Array of OCCT light sources.
uniform occLightSource occLightSources[_OCC_MAX_LIGHTS_];
//! Total number of OCCT light sources.
uniform int occLightSourcesCount;
/////////////////////////////////////////////////////////////////////
// OCCT material state
//! Parameters of OCCT back material.
uniform occMaterialParams occBackMaterial;
//! Parameters of OCCT front material.
uniform occMaterialParams occFrontMaterial;
//! Are front and back faces distinguished?
uniform int occDistinguishingMode;
//! Is texture enabled?
uniform int occTextureEnable;
//! Current active sampler.
uniform sampler2D occActiveSampler;
/////////////////////////////////////////////////////////////////////
// OCCT clipping planes state
uniform occClipPlane occClipPlanes[_OCC_MAX_CLIP_PLANES_];

37
src/Shaders/DeclarationsImpl.glsl Normal file
View File

@ -0,0 +1,37 @@
// This file includes implementation of common functions and properties accessors
// arrays of light sources
uniform ivec2 occLightSourcesTypes[THE_MAX_LIGHTS]; //!< packed light sources types
uniform vec4 occLightSources[THE_MAX_LIGHTS * 4]; //!< packed light sources parameters
// light source properties accessors
int occLight_Type (in int theId) { return occLightSourcesTypes[theId].x; }
int occLight_IsHeadlight (in int theId) { return occLightSourcesTypes[theId].y; }
vec4 occLight_Diffuse (in int theId) { return occLightSources[theId * 4 + 0]; }
vec4 occLight_Specular (in int theId) { return occLightSources[theId * 4 + 0]; }
vec4 occLight_Position (in int theId) { return occLightSources[theId * 4 + 1]; }
vec4 occLight_SpotDirection (in int theId) { return occLightSources[theId * 4 + 2]; }
float occLight_ConstAttenuation (in int theId) { return occLightSources[theId * 4 + 3].x; }
float occLight_LinearAttenuation (in int theId) { return occLightSources[theId * 4 + 3].y; }
float occLight_SpotCutOff (in int theId) { return occLightSources[theId * 4 + 3].z; }
float occLight_SpotExponent (in int theId) { return occLightSources[theId * 4 + 3].w; }
// material state
uniform vec4 occFrontMaterial[5];
uniform vec4 occBackMaterial[5];
// front material properties accessors
vec4 occFrontMaterial_Emission(void) { return occFrontMaterial[0]; }
vec4 occFrontMaterial_Ambient(void) { return occFrontMaterial[1]; }
vec4 occFrontMaterial_Diffuse(void) { return occFrontMaterial[2]; }
vec4 occFrontMaterial_Specular(void) { return occFrontMaterial[3]; }
float occFrontMaterial_Shininess(void) { return occFrontMaterial[4].x; }
float occFrontMaterial_Transparency(void) { return occFrontMaterial[4].y; }
// back material properties accessors
vec4 occBackMaterial_Emission(void) { return occBackMaterial[0]; }
vec4 occBackMaterial_Ambient(void) { return occBackMaterial[1]; }
vec4 occBackMaterial_Diffuse(void) { return occBackMaterial[2]; }
vec4 occBackMaterial_Specular(void) { return occBackMaterial[3]; }
float occBackMaterial_Shininess(void) { return occBackMaterial[4].x; }
float occBackMaterial_Transparency(void) { return occBackMaterial[4].y; }

139
src/Shaders/PhongShading.fs
View File

@ -17,46 +17,22 @@
// purpose or non-infringement. Please see the License for the specific terms // purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License. // and conditions governing the rights and limitations under the License.
//! Direction to the viewer. varying vec3 View; //!< Direction to the viewer
varying vec3 View; varying vec3 Normal; //!< Vertex normal in view space
varying vec4 Position; //!< Vertex position in view space.
//! Vertex normal in view space. vec3 Ambient; //!< Ambient contribution of light sources
varying vec3 Normal; vec3 Diffuse; //!< Diffuse contribution of light sources
vec3 Specular; //!< Specular contribution of light sources
//! Vertex position in view space. //! Computes contribution of isotropic point light source
varying vec4 Position; void pointLight (in int theId,
//! Ambient contribution of light sources.
vec3 Ambient;
//! Diffuse contribution of light sources.
vec3 Diffuse;
//! Specular contribution of light sources.
vec3 Specular;
// =======================================================================
// function : AmbientLight
// purpose : Computes contribution of OCCT pure ambient light source
// =======================================================================
void AmbientLight (in int theIndex)
{
Ambient += occLightSources[theIndex].Ambient;
}
// =======================================================================
// function : PointLight
// purpose : Computes contribution of OCCT isotropic point light source
// =======================================================================
void PointLight (in int theIndex,
in vec3 theNormal, in vec3 theNormal,
in vec3 theView, in vec3 theView,
in vec3 thePoint) in vec3 thePoint)
{ {
vec3 aLight = occLightSources[theIndex].Position; vec3 aLight = occLight_Position (theId).xyz;
if (occLightSources[theIndex].Head == 0) if (occLight_IsHeadlight (theId) == 0)
{ {
aLight = vec3 (occWorldViewMatrix * occModelWorldMatrix * vec4 (aLight, 1.0)); aLight = vec3 (occWorldViewMatrix * occModelWorldMatrix * vec4 (aLight, 1.0));
} }
@ -64,107 +40,86 @@ void PointLight (in int theIndex,
float aDist = length (aLight); float aDist = length (aLight);
aLight = aLight * (1.0 / aDist); aLight = aLight * (1.0 / aDist);
float anAttenuation = 1.0 / (occLightSources[theIndex].ConstAttenuation + float anAtten = 1.0 / (occLight_ConstAttenuation (theId)
occLightSources[theIndex].LinearAttenuation * aDist); + occLight_LinearAttenuation (theId) * aDist);
vec3 aHalf = normalize (aLight + theView); vec3 aHalf = normalize (aLight + theView);
float aNdotL = max (0.0, dot (theNormal, aLight)); float aNdotL = max (0.0, dot (theNormal, aLight));
float aNdotH = max (0.0, dot (theNormal, aHalf)); float aNdotH = max (0.0, dot (theNormal, aHalf ));
float aSpecl = 0.0; float aSpecl = 0.0;
if (aNdotL > 0.0) if (aNdotL > 0.0)
{ {
aSpecl = pow (aNdotH, occFrontMaterial.Shininess); aSpecl = pow (aNdotH, occFrontMaterial_Shininess());
} }
Ambient += occLightSources[theIndex].Ambient * anAttenuation; Diffuse += occLight_Diffuse (theId).rgb * aNdotL * anAtten;
Diffuse += occLightSources[theIndex].Diffuse * aNdotL * anAttenuation; Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;
Specular += occLightSources[theIndex].Specular * aSpecl * anAttenuation;
} }
// ======================================================================= //! Computes contribution of directional light source
// function : DirectionalLight void directionalLight (in int theId,
// purpose : Computes contribution of OCCT directional light source
// =======================================================================
void DirectionalLight (in int theIndex,
in vec3 theNormal, in vec3 theNormal,
in vec3 theView) in vec3 theView)
{ {
vec3 aLight = normalize (occLightSources[theIndex].Position); vec3 aLight = normalize (occLight_Position (theId).xyz);
if (occLight_IsHeadlight (theId) == 0)
if (occLightSources[theIndex].Head == 0)
{ {
aLight = vec3 (occWorldViewMatrix * occModelWorldMatrix * vec4 (aLight, 0.0)); aLight = vec3 (occWorldViewMatrix * occModelWorldMatrix * vec4 (aLight, 0.0));
} }
vec3 aHalf = normalize (aLight + theView); vec3 aHalf = normalize (aLight + theView);
float aNdotL = max (0.0, dot (theNormal, aLight)); float aNdotL = max (0.0, dot (theNormal, aLight));
float aNdotH = max (0.0, dot (theNormal, aHalf)); float aNdotH = max (0.0, dot (theNormal, aHalf ));
float aSpecl = 0.0; float aSpecl = 0.0;
if (aNdotL > 0.0) if (aNdotL > 0.0)
{ {
aSpecl = pow (aNdotH, occFrontMaterial.Shininess); aSpecl = pow (aNdotH, occFrontMaterial_Shininess());
} }
Ambient += occLightSources[theIndex].Ambient; Diffuse += occLight_Diffuse (theId).rgb * aNdotL;
Diffuse += occLightSources[theIndex].Diffuse * aNdotL; Specular += occLight_Specular (theId).rgb * aSpecl;
Specular += occLightSources[theIndex].Specular * aSpecl;
} }
// ======================================================================= //! Computes illumination from light sources
// function : ComputeLighting vec4 computeLighting (in vec3 theNormal,
// purpose : Computes illumination from OCCT light sources
// =======================================================================
vec4 ComputeLighting (in vec3 theNormal,
in vec3 theView, in vec3 theView,
in vec4 thePoint) in vec4 thePoint)
{ {
// Clear the light intensity accumulators // Clear the light intensity accumulators
Ambient = vec3 (0.0); Ambient = occLightAmbient.rgb;
Diffuse = vec3 (0.0); Diffuse = vec3 (0.0);
Specular = vec3 (0.0); Specular = vec3 (0.0);
vec3 aPoint = thePoint.xyz / thePoint.w; vec3 aPoint = thePoint.xyz / thePoint.w;
for (int anIndex = 0; anIndex < occLightSourcesCount; ++anIndex) for (int anIndex = 0; anIndex < occLightSourcesCount; ++anIndex)
{ {
occLightSource light = occLightSources[anIndex]; int aType = occLight_Type (anIndex);
if (aType == OccLightType_Direct)
if (light.Type == occAmbientLight)
{ {
AmbientLight (anIndex); directionalLight (anIndex, theNormal, theView);
}
else if (aType == OccLightType_Point)
{
pointLight (anIndex, theNormal, theView, aPoint);
}
else if (aType == OccLightType_Spot)
{
// Not implemented
} }
else if (light.Type == occDirectLight)
{
DirectionalLight (anIndex, theNormal, theView);
}
else if (light.Type == occPointLight)
{
PointLight (anIndex, theNormal, theView, aPoint);
}
else if (light.Type == occSpotLight)
{
/* Not implemented */
}
} }
return vec4 (Ambient, 1.0) * occFrontMaterial.Ambient + return vec4 (Ambient, 1.0) * occFrontMaterial_Ambient()
vec4 (Diffuse, 1.0) * occFrontMaterial.Diffuse + + vec4 (Diffuse, 1.0) * occFrontMaterial_Diffuse()
vec4 (Specular, 1.0) * occFrontMaterial.Specular; + vec4 (Specular, 1.0) * occFrontMaterial_Specular();
} }
// ======================================================================= //! Entry point to the Fragment Shader
// function : main
// purpose : Entry point to the fragment shader
// =======================================================================
void main() void main()
{ {
gl_FragColor = ComputeLighting (normalize (Normal), gl_FragColor = computeLighting (normalize (Normal),
normalize (View), normalize (View),
Position); Position);
} }

41
src/Shaders/PhongShading.vs
View File

@ -17,42 +17,27 @@
// purpose or non-infringement. Please see the License for the specific terms // purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License. // and conditions governing the rights and limitations under the License.
//! Direction to the viewer. varying vec3 View; //!< Direction to the viewer
varying vec3 View; varying vec3 Normal; //!< Vertex normal in view space
varying vec4 Position; //!< Vertex position in view space
//! Vertex normal in view space. //! Computes the normal in view space
varying vec3 Normal;
//! Vertex position in view space.
varying vec4 Position;
// =======================================================================
// function : TransformNormal
// purpose : Computes the normal in view space
// =======================================================================
vec3 TransformNormal (in vec3 theNormal) vec3 TransformNormal (in vec3 theNormal)
{ {
vec4 aResult = occWorldViewMatrixInverseTranspose * vec4 aResult = occWorldViewMatrixInverseTranspose
occModelWorldMatrixInverseTranspose * vec4 (theNormal, 0.0); * occModelWorldMatrixInverseTranspose
* vec4 (theNormal, 0.0);
return normalize (aResult.xyz); return normalize (aResult.xyz);
} }
// ======================================================================= //! Entry point to the Vertex Shader
// function : main
// purpose : Entry point to the vertex shader
// =======================================================================
void main() void main()
{ {
// Compute vertex position in the view space Position = occWorldViewMatrix * occModelWorldMatrix * occVertex; // position in the view space
Position = occWorldViewMatrix * occModelWorldMatrix * occVertex; Normal = TransformNormal (occNormal); // normal in the view space
// Compute vertex normal in the view space // Note: The specified view vector is absolutely correct only for the orthogonal projection.
Normal = TransformNormal (occNormal); // For perspective projection it will be approximate, but it is in good agreement with the OpenGL calculations.
// Note: The specified view vector is absolutely correct only for the orthogonal
// projection. For perspective projection it will be approximate, but it is in
// good agreement with the OpenGL calculations
View = vec3 (0.0, 0.0, 1.0); View = vec3 (0.0, 0.0, 1.0);
// Do fixed functionality vertex transform // Do fixed functionality vertex transform

4
src/V3d/V3d_Light.cdl
View File

@ -106,6 +106,10 @@ is
---Level: Public ---Level: Public
---Purpose: returns true if the light is a headlight ---Purpose: returns true if the light is a headlight
SetHeadlight( me : mutable; theValue : Boolean from Standard ) is static;
---Level: Public
---Purpose: Setup headlight flag.
IsDisplayed( me ) returns Boolean from Standard; IsDisplayed( me ) returns Boolean from Standard;
---Level: Public ---Level: Public
---Purpose: Returns TRUE when a light representation is displayed ---Purpose: Returns TRUE when a light representation is displayed

5
src/V3d/V3d_Light.cxx
View File

@ -114,6 +114,11 @@ Standard_Boolean V3d_Light::Headlight() const {
return MyLight->Headlight(); return MyLight->Headlight();
} }
void V3d_Light::SetHeadlight (const Standard_Boolean theValue)
{
MyLight->SetHeadlight (theValue);
}
void V3d_Light::SymetricPointOnSphere (const Handle(V3d_View)& aView, const Graphic3d_Vertex &Center, const Graphic3d_Vertex &aPoint, const Standard_Real Rayon, Standard_Real& X, Standard_Real& Y, Standard_Real& Z, Standard_Real& VX, Standard_Real& VY, Standard_Real& VZ ) { void V3d_Light::SymetricPointOnSphere (const Handle(V3d_View)& aView, const Graphic3d_Vertex &Center, const Graphic3d_Vertex &aPoint, const Standard_Real Rayon, Standard_Real& X, Standard_Real& Y, Standard_Real& Z, Standard_Real& VX, Standard_Real& VY, Standard_Real& VZ ) {
Standard_Real X0,Y0,Z0,XP,YP,ZP; Standard_Real X0,Y0,Z0,XP,YP,ZP;

457
src/ViewerTest/ViewerTest_ViewerCommands.cxx
View File

@ -42,7 +42,12 @@
#include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx> #include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
#include <Visual3d_View.hxx> #include <Visual3d_View.hxx>
#include <Visual3d_ViewManager.hxx> #include <Visual3d_ViewManager.hxx>
#include <V3d_AmbientLight.hxx>
#include <V3d_DirectionalLight.hxx>
#include <V3d_LayerMgr.hxx> #include <V3d_LayerMgr.hxx>
#include <V3d_LayerMgrPointer.hxx>
#include <V3d_PositionalLight.hxx>
#include <V3d_SpotLight.hxx>
#include <NCollection_DoubleMap.hxx> #include <NCollection_DoubleMap.hxx>
#include <NCollection_List.hxx> #include <NCollection_List.hxx>
#include <NCollection_Vector.hxx> #include <NCollection_Vector.hxx>
@ -61,8 +66,6 @@
#include <TColStd_HSequenceOfReal.hxx> #include <TColStd_HSequenceOfReal.hxx>
#include <TColgp_Array1OfPnt2d.hxx> #include <TColgp_Array1OfPnt2d.hxx>
#include <Visual3d_LayerItem.hxx> #include <Visual3d_LayerItem.hxx>
#include <V3d_LayerMgr.hxx>
#include <V3d_LayerMgrPointer.hxx>
#include <Aspect_TypeOfLine.hxx> #include <Aspect_TypeOfLine.hxx>
#include <Image_Diff.hxx> #include <Image_Diff.hxx>
#include <Aspect_DisplayConnection.hxx> #include <Aspect_DisplayConnection.hxx>
@ -5352,6 +5355,449 @@ static int VDefaults (Draw_Interpretor& theDi,
return 0; return 0;
} }
//! Auxiliary method
inline void addLight (const Handle(V3d_Light)& theLightNew,
const Standard_Boolean theIsGlobal)
{
if (theLightNew.IsNull())
{
return;
}
if (theIsGlobal)
{
ViewerTest::GetViewerFromContext()->SetLightOn (theLightNew);
}
else
{
ViewerTest::CurrentView()->SetLightOn (theLightNew);
}
}
//! Auxiliary method
inline Standard_Integer getLightId (const TCollection_AsciiString& theArgNext)
{
TCollection_AsciiString anArgNextCase (theArgNext);
anArgNextCase.UpperCase();
if (anArgNextCase.Length() > 5
&& anArgNextCase.SubString (1, 5).IsEqual ("LIGHT"))
{
return theArgNext.SubString (6, theArgNext.Length()).IntegerValue();
}
else
{
return theArgNext.IntegerValue();
}
}
//===============================================================================================
//function : VLight
//purpose :
//===============================================================================================
static int VLight (Draw_Interpretor& theDi,
Standard_Integer theArgsNb,
const char** theArgVec)
{
Handle(V3d_View) aView = ViewerTest::CurrentView();
Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
if (aView.IsNull()
|| aViewer.IsNull())
{
std::cerr << "No active viewer!\n";
return 1;
}
Standard_Real anXYZ[3];
Quantity_Coefficient anAtten[2];
if (theArgsNb < 2)
{
// print lights info
Standard_Integer aLightId = 0;
for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightId)
{
Handle(V3d_Light) aLight = aView->ActiveLight();
const Quantity_Color aColor = aLight->Color();
theDi << "Light" << aLightId << "\n";
switch (aLight->Type())
{
case V3d_AMBIENT:
{
theDi << " Type: Ambient\n";
break;
}
case V3d_DIRECTIONAL:
{
Handle(V3d_DirectionalLight) aLightDir = Handle(V3d_DirectionalLight)::DownCast (aLight);
theDi << " Type: Directional\n";
theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
if (!aLightDir.IsNull())
{
aLightDir->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
aLightDir->Direction (anXYZ[0], anXYZ[1], anXYZ[2]);
theDi << " Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
}
break;
}
case V3d_POSITIONAL:
{
Handle(V3d_PositionalLight) aLightPos = Handle(V3d_PositionalLight)::DownCast (aLight);
theDi << " Type: Positional\n";
theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
if (!aLightPos.IsNull())
{
aLightPos->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
aLightPos->Attenuation (anAtten[0], anAtten[1]);
theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
}
break;
}
case V3d_SPOT:
{
Handle(V3d_SpotLight) aLightSpot = Handle(V3d_SpotLight)::DownCast (aLight);
theDi << " Type: Spot\n";
theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
if (!aLightSpot.IsNull())
{
aLightSpot->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
aLightSpot->Direction (anXYZ[0], anXYZ[1], anXYZ[2]);
theDi << " Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
aLightSpot->Attenuation (anAtten[0], anAtten[1]);
theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
theDi << " Angle: " << (aLightSpot->Angle() * 180.0 / M_PI) << "\n";
theDi << " Exponent: " << aLightSpot->Concentration() << "\n";
}
break;
}
default:
{
theDi << " Type: UNKNOWN\n";
break;
}
}
theDi << " Color: " << aColor.Red() << ", " << aColor.Green() << ", " << aColor.Blue() << "\n";
}
}
Handle(V3d_Light) aLightNew;
Handle(V3d_Light) aLightOld;
Standard_Boolean isGlobal = Standard_True;
Standard_Boolean toCreate = Standard_False;
for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
{
Handle(V3d_Light) aLightCurr = aLightNew.IsNull() ? aLightOld : aLightNew;
Handle(V3d_AmbientLight) aLightAmb = Handle(V3d_AmbientLight) ::DownCast (aLightCurr);
Handle(V3d_DirectionalLight) aLightDir = Handle(V3d_DirectionalLight)::DownCast (aLightCurr);
Handle(V3d_PositionalLight) aLightPos = Handle(V3d_PositionalLight) ::DownCast (aLightCurr);
Handle(V3d_SpotLight) aLightSpot = Handle(V3d_SpotLight) ::DownCast (aLightCurr);
TCollection_AsciiString aName, aValue;
const TCollection_AsciiString anArg (theArgVec[anArgIt]);
TCollection_AsciiString anArgCase (anArg);
anArgCase.UpperCase();
if (anArgCase.IsEqual ("NEW")
|| anArgCase.IsEqual ("ADD")
|| anArgCase.IsEqual ("CREATE"))
{
toCreate = Standard_True;
}
else if (anArgCase.IsEqual ("GLOB")
|| anArgCase.IsEqual ("GLOBAL"))
{
isGlobal = Standard_True;
}
else if (anArgCase.IsEqual ("LOC")
|| anArgCase.IsEqual ("LOCAL"))
{
isGlobal = Standard_False;
}
else if (anArgCase.IsEqual ("AMB")
|| anArgCase.IsEqual ("AMBIENT")
|| anArgCase.IsEqual ("AMBLIGHT"))
{
addLight (aLightNew, isGlobal);
if (!toCreate)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
toCreate = Standard_False;
aLightNew = new V3d_AmbientLight (aViewer);
}
else if (anArgCase.IsEqual ("DIRECTIONAL")
|| anArgCase.IsEqual ("DIRLIGHT"))
{
addLight (aLightNew, isGlobal);
if (!toCreate)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
toCreate = Standard_False;
aLightNew = new V3d_DirectionalLight (aViewer);
}
else if (anArgCase.IsEqual ("SPOT")
|| anArgCase.IsEqual ("SPOTLIGHT"))
{
addLight (aLightNew, isGlobal);
if (!toCreate)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
toCreate = Standard_False;
aLightNew = new V3d_SpotLight (aViewer, 0.0, 0.0, 0.0);
}
else if (anArgCase.IsEqual ("POSLIGHT")
|| anArgCase.IsEqual ("POSITIONAL"))
{
addLight (aLightNew, isGlobal);
if (!toCreate)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
toCreate = Standard_False;
aLightNew = new V3d_PositionalLight (aViewer, 0.0, 0.0, 0.0);
}
else if (anArgCase.IsEqual ("CHANGE"))
{
addLight (aLightNew, isGlobal);
aLightNew.Nullify();
if (++anArgIt >= theArgsNb)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
const Standard_Integer aLightId = getLightId (theArgVec[anArgIt]);
Standard_Integer aLightIt = 0;
for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightIt)
{
if (aLightIt == aLightId)
{
aLightOld = aView->ActiveLight();
break;
}
}
if (aLightOld.IsNull())
{
std::cerr << "Light " << theArgVec[anArgIt] << " is undefined!\n";
return 1;
}
}
else if (anArgCase.IsEqual ("DEL")
|| anArgCase.IsEqual ("DELETE"))
{
Handle(V3d_Light) aLightDel;
if (++anArgIt >= theArgsNb)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
const TCollection_AsciiString anArgNext (theArgVec[anArgIt]);
const Standard_Integer aLightDelId = getLightId (theArgVec[anArgIt]);
Standard_Integer aLightIt = 0;
for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightIt)
{
aLightDel = aView->ActiveLight();
if (aLightIt == aLightDelId)
{
break;
}
}
if (!aLightDel.IsNull())
{
aViewer->DelLight (aLightDel);
}
}
else if (anArgCase.IsEqual ("COLOR")
|| anArgCase.IsEqual ("COLOUR"))
{
if (++anArgIt >= theArgsNb)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
TCollection_AsciiString anArgNext (theArgVec[anArgIt]);
anArgNext.UpperCase();
const Quantity_Color aColor = ViewerTest::GetColorFromName (anArgNext.ToCString());
if (!aLightCurr.IsNull())
{
aLightCurr->SetColor (aColor);
}
}
else if (anArgCase.IsEqual ("POS")
|| anArgCase.IsEqual ("POSITION"))
{
if ((anArgIt + 3) >= theArgsNb)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
anXYZ[0] = Atof (theArgVec[++anArgIt]);
anXYZ[1] = Atof (theArgVec[++anArgIt]);
anXYZ[2] = Atof (theArgVec[++anArgIt]);
if (!aLightDir.IsNull())
{
aLightDir->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
}
else if (!aLightPos.IsNull())
{
aLightPos->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
}
else if (!aLightSpot.IsNull())
{
aLightSpot->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
}
else
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
}
else if (anArgCase.IsEqual ("DIR")
|| anArgCase.IsEqual ("DIRECTION"))
{
if ((anArgIt + 3) >= theArgsNb)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
anXYZ[0] = Atof (theArgVec[++anArgIt]);
anXYZ[1] = Atof (theArgVec[++anArgIt]);
anXYZ[2] = Atof (theArgVec[++anArgIt]);
if (!aLightDir.IsNull())
{
aLightDir->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
}
else if (!aLightSpot.IsNull())
{
aLightSpot->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
}
else
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
}
else if (anArgCase.IsEqual ("CONSTATTEN")
|| anArgCase.IsEqual ("CONSTATTENUATION"))
{
if (++anArgIt >= theArgsNb)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
if (!aLightPos.IsNull())
{
aLightPos->Attenuation (anAtten[0], anAtten[1]);
anAtten[0] = Atof (theArgVec[anArgIt]);
aLightPos->SetAttenuation (anAtten[0], anAtten[1]);
}
else if (!aLightSpot.IsNull())
{
aLightSpot->Attenuation (anAtten[0], anAtten[1]);
anAtten[0] = Atof (theArgVec[anArgIt]);
aLightSpot->SetAttenuation (anAtten[0], anAtten[1]);
}
else
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
}
else if (anArgCase.IsEqual ("LINATTEN")
|| anArgCase.IsEqual ("LINEARATTEN")
|| anArgCase.IsEqual ("LINEARATTENUATION"))
{
if (++anArgIt >= theArgsNb)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
if (!aLightPos.IsNull())
{
aLightPos->Attenuation (anAtten[0], anAtten[1]);
anAtten[1] = Atof (theArgVec[anArgIt]);
aLightPos->SetAttenuation (anAtten[0], anAtten[1]);
}
else if (!aLightSpot.IsNull())
{
aLightSpot->Attenuation (anAtten[0], anAtten[1]);
anAtten[1] = Atof (theArgVec[anArgIt]);
aLightSpot->SetAttenuation (anAtten[0], anAtten[1]);
}
else
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
}
else if (anArgCase.IsEqual ("EXP")
|| anArgCase.IsEqual ("EXPONENT")
|| anArgCase.IsEqual ("SPOTEXP")
|| anArgCase.IsEqual ("SPOTEXPONENT"))
{
if (++anArgIt >= theArgsNb)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
if (!aLightSpot.IsNull())
{
aLightSpot->SetConcentration (Atof (theArgVec[anArgIt]));
}
else
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
}
else if (anArgCase.IsEqual ("HEAD")
|| anArgCase.IsEqual ("HEADLIGHT"))
{
if (++anArgIt >= theArgsNb)
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
if (aLightAmb.IsNull()
&& !aLightCurr.IsNull())
{
aLightCurr->SetHeadlight (Draw::Atoi (theArgVec[anArgIt]) != 0);
}
else
{
std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
}
else
{
std::cerr << "Warning: unknown argument '" << anArg << "'\n";
}
}
addLight (aLightNew, isGlobal);
aViewer->UpdateLights();
return 0;
}
//============================================================================== //==============================================================================
//function : VClInfo //function : VClInfo
//purpose : Prints info about active OpenCL device //purpose : Prints info about active OpenCL device
@ -5749,6 +6195,13 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
theCommands.Add("vdefaults", theCommands.Add("vdefaults",
"vdefaults [absDefl=value] [devCoeff=value] [angDefl=value]", "vdefaults [absDefl=value] [devCoeff=value] [angDefl=value]",
__FILE__, VDefaults, group); __FILE__, VDefaults, group);
theCommands.Add("vlight",
"vlight [add|new {amb}ient|directional|{spot}light|positional]"
"\n\t\t: [{del}ete|change lightId] [local|global]"
"\n\t\t: [{pos}ition X Y Z] [color colorName] [{head}light 0|1]"
"\n\t\t: [{constAtten}uation value] [{linearAtten}uation value]"
"\n\t\t: [angle angleDeg] [{spotexp}onent value]",
__FILE__, VLight, group);
theCommands.Add("vraytrace", theCommands.Add("vraytrace",
"vraytrace 0|1", "vraytrace 0|1",
__FILE__,VRaytrace,group); __FILE__,VRaytrace,group);

65
src/Visual3d/Visual3d_Light.cdl
View File

@ -17,7 +17,6 @@
-- purpose or non-infringement. Please see the License for the specific terms -- purpose or non-infringement. Please see the License for the specific terms
-- and conditions governing the rights and limitations under the License. -- and conditions governing the rights and limitations under the License.
class Light from Visual3d inherits TShared class Light from Visual3d inherits TShared
---Version: ---Version:
@ -43,17 +42,15 @@ class Light from Visual3d inherits TShared
uses uses
Color from Quantity, Color from Quantity,
CLight from Graphic3d,
CLight from Graphic3d, Vector from Graphic3d,
Vector from Graphic3d, Vertex from Graphic3d,
Vertex from Graphic3d, TypeOfLightSource from Visual3d
TypeOfLightSource from Visual3d
raises raises
LightDefinitionError from Visual3d LightDefinitionError from Visual3d
is is
@ -207,12 +204,16 @@ is
-- Category: Inquire methods -- Category: Inquire methods
---------------------------- ----------------------------
Headlight ( me ) Headlight ( me )
returns Boolean from Standard is static; returns Boolean from Standard is static;
---Level: Public ---Level: Public
---Purpose: Returns the headlight state of the light <me> ---Purpose: Returns the headlight state of the light <me>
---Category: Inquire methods ---Category: Inquire methods
SetHeadlight( me : mutable; theValue : Boolean from Standard ) is static;
---Level: Public
---Purpose: Setup headlight flag.
Color ( me ) Color ( me )
returns Color from Quantity is static; returns Color from Quantity is static;
---Level: Public ---Level: Public
@ -279,6 +280,14 @@ is
-- if the type of the light is not TOLS_SPOT. -- if the type of the light is not TOLS_SPOT.
raises LightDefinitionError is static; raises LightDefinitionError is static;
CLight ( me )
returns CLight from Graphic3d
is static;
---C++: return const &
---Level: Public
---Purpose: Returns the light defintion.
---Category: Inquire methods
-------------------------- --------------------------
-- Category: Class methods -- Category: Class methods
-------------------------- --------------------------
@ -309,32 +318,12 @@ is
-- spot light spread angle. -- spot light spread angle.
---Category: Private methods ---Category: Private methods
-- --
fields fields
-- -- the associated C structure
-- Class : Visual3d_Light myCLight : CLight from Graphic3d;
--
-- Purpose : Declaration of variables specific to light sources
--
-- Reminder : A light source is defined by:
-- - its type
-- - its colour
-- - the attenuation factor ( positional and spot only)
-- - its angle ( spot only )
-- - its concentration ( spot only )
-- - its direction ( directional and spot only )
-- - its position ( positional and spot only )
--
-- It is actived in a context of view.
--
-- the type
MyType : TypeOfLightSource from Visual3d;
-- the associated C structure
MyCLight : CLight from Graphic3d;
friends friends

779
src/Visual3d/Visual3d_Light.cxx
View File

@ -16,509 +16,378 @@
// purpose or non-infringement. Please see the License for the specific terms // purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License. // and conditions governing the rights and limitations under the License.
/***********************************************************************
FUNCTION :
----------
File Visual3d_Light :
Declaration of variables specific to light sources
NOTES:
----------
A light source is defined by :
- type
- color
- reduction factors ( for positional and spot only )
- its angle ( for spot only )
- its concentration ( for spot only )
- its direction ( directional and spot only )
- its position ( positional and spot only )
It is active in a view, in the associated context.
ATTENTION:
----------
- AngleCone is given in radian [Pex] while OpenGl works in
degreees. The limits for Pex are [0,PI] while for OpenGl this is [0,90].
- Two reduction factors are used with Pex while OpenGl uses three.
- The ereduction factors have range [0.0,1.0] for Pex and
for OpenGl the range is [0.0,n]
- The concentration varies from [0.,1.0] for Pex to [0,128] for OpenGl.
************************************************************************/
/*----------------------------------------------------------------------*/
/*
* Includes
*/
#include <Visual3d_Light.ixx> #include <Visual3d_Light.ixx>
#include <Graphic3d_GraphicDriver.hxx> #include <Graphic3d_GraphicDriver.hxx>
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Visual3d_Light
Visual3d_Light::Visual3d_Light (): // purpose :
MyType (Visual3d_TOLS_AMBIENT) { // =======================================================================
Visual3d_Light::Visual3d_Light()
MyCLight.WsId = -1; {
MyCLight.ViewId = 0; /* not used */ myCLight.Type = Visual3d_TOLS_AMBIENT;
MyCLight.LightType = int (MyType);
MyCLight.Headlight = 0;
Quantity_Color White (Quantity_NOC_WHITE);
MyCLight.Color.r = float (White.Red ());
MyCLight.Color.g = float (White.Green ());
MyCLight.Color.b = float (White.Blue ());
MyCLight.LightId =
Graphic3d_GraphicDriver::Light (MyCLight, Standard_False);
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Visual3d_Light
Visual3d_Light::Visual3d_Light (const Quantity_Color& Color): // purpose :
MyType (Visual3d_TOLS_AMBIENT) { // =======================================================================
Visual3d_Light::Visual3d_Light (const Quantity_Color& theColor)
MyCLight.WsId = -1; {
MyCLight.ViewId = 0; /* not used */ myCLight.Type = Visual3d_TOLS_AMBIENT;
MyCLight.LightType = int (MyType); myCLight.Color.r() = Standard_ShortReal (theColor.Red());
MyCLight.Headlight = 0; myCLight.Color.g() = Standard_ShortReal (theColor.Green());
myCLight.Color.b() = Standard_ShortReal (theColor.Blue());
MyCLight.Color.r = float (Color.Red ());
MyCLight.Color.g = float (Color.Green ());
MyCLight.Color.b = float (Color.Blue ());
MyCLight.LightId =
Graphic3d_GraphicDriver::Light (MyCLight, Standard_False);
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Visual3d_Light
Visual3d_Light::Visual3d_Light(const Quantity_Color& Color,const Graphic3d_Vector& Direction,const Standard_Boolean Headlight): MyType (Visual3d_TOLS_DIRECTIONAL) { // purpose :
// =======================================================================
if (Direction.LengthZero ()) Visual3d_Light::Visual3d_Light (const Quantity_Color& theColor,
Visual3d_LightDefinitionError::Raise const Graphic3d_Vector& theDir,
("Bad value for LightDirection"); const Standard_Boolean theIsHeadlight)
{
MyCLight.WsId = -1; Visual3d_LightDefinitionError_Raise_if (theDir.LengthZero(),
MyCLight.ViewId = 0; /* not used */ "Bad value for LightDirection");
MyCLight.LightType = int (MyType); myCLight.Type = Visual3d_TOLS_DIRECTIONAL;
MyCLight.Headlight = Headlight? 1:0; myCLight.IsHeadlight = theIsHeadlight;
myCLight.Color.r() = Standard_ShortReal (theColor.Red());
Standard_Real Norme, X, Y, Z; myCLight.Color.g() = Standard_ShortReal (theColor.Green());
myCLight.Color.b() = Standard_ShortReal (theColor.Blue());
Color.Values (X, Y, Z, Quantity_TOC_RGB);
MyCLight.Color.r = float (X);
MyCLight.Color.g = float (Y);
MyCLight.Color.b = float (Z);
Direction.Coord (X, Y, Z);
Norme = Sqrt (X*X+Y*Y+Z*Z);
// Direction.LengthZero () == Standard_False
MyCLight.Direction.x = float (X/Norme);
MyCLight.Direction.y = float (Y/Norme);
MyCLight.Direction.z = float (Z/Norme);
MyCLight.LightId =
Graphic3d_GraphicDriver::Light (MyCLight, Standard_False);
Standard_Real X, Y, Z;
theDir.Coord (X, Y, Z);
const Standard_Real aNorm = Sqrt (X * X + Y * Y + Z * Z);
myCLight.Direction.x() = Standard_ShortReal (X / aNorm);
myCLight.Direction.y() = Standard_ShortReal (Y / aNorm);
myCLight.Direction.z() = Standard_ShortReal (Z / aNorm);
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Visual3d_Light
Visual3d_Light::Visual3d_Light (const Quantity_Color& Color, const Graphic3d_Vertex& Position, const Standard_Real Fact1, const Standard_Real Fact2): // purpose :
MyType (Visual3d_TOLS_POSITIONAL) { // =======================================================================
Visual3d_Light::Visual3d_Light (const Quantity_Color& theColor,
if ( (Fact1 == 0.0) && (Fact2 == 0.0) ) const Graphic3d_Vertex& thePos,
Visual3d_LightDefinitionError::Raise const Standard_Real theFact1,
("Bad value for LightAttenuation"); const Standard_Real theFact2)
{
if ( (Fact1 < 0.0) || (Fact1 > 1.0) ) Visual3d_LightDefinitionError_Raise_if ((theFact1 == 0.0 && theFact2 == 0.0)
Visual3d_LightDefinitionError::Raise || (theFact1 < 0.0 || theFact1 > 1.0)
("Bad value for LightAttenuation"); || (theFact2 < 0.0 || theFact2 > 1.0),
"Bad value for LightAttenuation");
if ( (Fact2 < 0.0) || (Fact2 > 1.0) ) myCLight.Type = Visual3d_TOLS_POSITIONAL;
Visual3d_LightDefinitionError::Raise myCLight.IsHeadlight = Standard_False;
("Bad value for LightAttenuation"); myCLight.Color.r() = Standard_ShortReal (theColor.Red());
myCLight.Color.g() = Standard_ShortReal (theColor.Green());
MyCLight.WsId = -1; myCLight.Color.b() = Standard_ShortReal (theColor.Blue());
MyCLight.ViewId = 0; /* not used */ myCLight.Position.x() = Standard_ShortReal (thePos.X());
MyCLight.LightType = int (MyType); myCLight.Position.y() = Standard_ShortReal (thePos.Y());
MyCLight.Headlight = 0; myCLight.Position.z() = Standard_ShortReal (thePos.Z());
myCLight.ChangeConstAttenuation() = Standard_ShortReal (theFact1);
MyCLight.Color.r = float (Color.Red ()); myCLight.ChangeLinearAttenuation() = Standard_ShortReal (theFact2);
MyCLight.Color.g = float (Color.Green ());
MyCLight.Color.b = float (Color.Blue ());
MyCLight.Position.x = float (Position.X ());
MyCLight.Position.y = float (Position.Y ());
MyCLight.Position.z = float (Position.Z ());
MyCLight.Attenuation[0] = float (Fact1);
MyCLight.Attenuation[1] = float (Fact2);
MyCLight.LightId =
Graphic3d_GraphicDriver::Light (MyCLight, Standard_False);
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Visual3d_Light
// purpose :
// =======================================================================
Visual3d_Light::Visual3d_Light (const Quantity_Color& theColor,
const Graphic3d_Vertex& thePos,
const Graphic3d_Vector& theDir,
const Standard_Real theConcentration,
const Standard_Real theFact1,
const Standard_Real theFact2,
const Standard_Real theAngleCone)
{
Visual3d_LightDefinitionError_Raise_if (theDir.LengthZero(),
"Bad value for LightDirection");
Visual3d_LightDefinitionError_Raise_if (theConcentration < 0.0 || theConcentration > 1.0,
"Bad value for LightConcentration");
Visual3d_LightDefinitionError_Raise_if ((theFact1 == 0.0 && theFact2 == 0.0)
|| (theFact1 < 0.0 || theFact1 > 1.0)
|| (theFact2 < 0.0 || theFact2 > 1.0),
"Bad value for LightAttenuation");
Visual3d_LightDefinitionError_Raise_if (!Visual3d_Light::IsValid (theAngleCone),
"Bad value for LightAngle");
myCLight.Type = Visual3d_TOLS_SPOT;
myCLight.IsHeadlight = Standard_False;
myCLight.Color.r() = Standard_ShortReal (theColor.Red());
myCLight.Color.g() = Standard_ShortReal (theColor.Green());
myCLight.Color.b() = Standard_ShortReal (theColor.Blue());
myCLight.Position.x() = Standard_ShortReal (thePos.X());
myCLight.Position.y() = Standard_ShortReal (thePos.Y());
myCLight.Position.z() = Standard_ShortReal (thePos.Z());
Visual3d_Light::Visual3d_Light (const Quantity_Color& Color, const Graphic3d_Vertex& Position, const Graphic3d_Vector& Direction, const Standard_Real Concentration, const Standard_Real Fact1, const Standard_Real Fact2, const Standard_Real AngleCone): Standard_Real X, Y, Z;
MyType (Visual3d_TOLS_SPOT) { theDir.Coord (X, Y, Z);
myCLight.Direction.x() = Standard_ShortReal (X);
if (Direction.LengthZero ()) myCLight.Direction.y() = Standard_ShortReal (Y);
Visual3d_LightDefinitionError::Raise myCLight.Direction.z() = Standard_ShortReal (Z);
("Bad value for LightDirection");
if ( (Concentration < 0.0) || (Concentration > 1.0) )
Visual3d_LightDefinitionError::Raise
("Bad value for LightConcentration");
if ( (Fact1 == 0.0) && (Fact2 == 0.0) )
Visual3d_LightDefinitionError::Raise
("Bad value for LightAttenuation");
if ( (Fact1 < 0.0) || (Fact1 > 1.0) )
Visual3d_LightDefinitionError::Raise
("Bad value for LightAttenuation");
if ( (Fact2 < 0.0) || (Fact2 > 1.0) )
Visual3d_LightDefinitionError::Raise
("Bad value for LightAttenuation");
if (Visual3d_Light::IsValid (AngleCone)) {
MyCLight.WsId = -1;
MyCLight.ViewId = 0; /* not used */
MyCLight.LightType = int (MyType);
MyCLight.Headlight = 0;
Standard_Real X, Y, Z;
Color.Values (X, Y, Z, Quantity_TOC_RGB);
MyCLight.Color.r = float (X);
MyCLight.Color.g = float (Y);
MyCLight.Color.b = float (Z);
Position.Coord (X, Y, Z);
MyCLight.Position.x = float (X);
MyCLight.Position.y = float (Y);
MyCLight.Position.z = float (Z);
Direction.Coord (X, Y, Z);
MyCLight.Direction.x = float (X);
MyCLight.Direction.y = float (Y);
MyCLight.Direction.z = float (Z);
MyCLight.Concentration = float (Concentration);
MyCLight.Attenuation[0] = float (Fact1);
MyCLight.Attenuation[1] = float (Fact2);
MyCLight.Angle = float (AngleCone);
MyCLight.LightId =
Graphic3d_GraphicDriver::Light (MyCLight, Standard_False);
}
else
Visual3d_LightDefinitionError::Raise
("Bad value for LightAngle");
myCLight.ChangeConcentration() = Standard_ShortReal (theConcentration);
myCLight.ChangeConstAttenuation() = Standard_ShortReal (theFact1);
myCLight.ChangeLinearAttenuation() = Standard_ShortReal (theFact2);
myCLight.ChangeAngle() = Standard_ShortReal (theAngleCone);
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Color
Quantity_Color Visual3d_Light::Color () const { // purpose :
// =======================================================================
Quantity_Color AColor (Standard_Real (MyCLight.Color.r), Quantity_Color Visual3d_Light::Color() const
Standard_Real (MyCLight.Color.g), {
Standard_Real (MyCLight.Color.b), return Quantity_Color (Standard_Real (myCLight.Color.r()),
Quantity_TOC_RGB); Standard_Real (myCLight.Color.g()),
Standard_Real (myCLight.Color.b()),
return (AColor); Quantity_TOC_RGB);
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : LightType
Visual3d_TypeOfLightSource Visual3d_Light::LightType () const { // purpose :
// =======================================================================
return (MyType); Visual3d_TypeOfLightSource Visual3d_Light::LightType() const
{
return (Visual3d_TypeOfLightSource )myCLight.Type;
} }
/*----------------------------------------------------------------------*/ // =======================================================================
Standard_Boolean Visual3d_Light::Headlight () const { // function : Headlight
return MyCLight.Headlight==0? Standard_False:Standard_True; // purpose :
// =======================================================================
Standard_Boolean Visual3d_Light::Headlight() const
{
return myCLight.IsHeadlight;
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : SetHeadlight
void Visual3d_Light::Values (Quantity_Color& Color) const { // purpose :
// =======================================================================
Quantity_Color AColor (Standard_Real (MyCLight.Color.r), void Visual3d_Light::SetHeadlight (const Standard_Boolean theValue)
Standard_Real (MyCLight.Color.g), {
Standard_Real (MyCLight.Color.b), myCLight.IsHeadlight = theValue;
Quantity_TOC_RGB);
if (MyType == Visual3d_TOLS_AMBIENT)
Color = AColor;
else Visual3d_LightDefinitionError::Raise
("Light Type != Visual3d_TOLS_AMBIENT");
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Values
void Visual3d_Light::Values (Quantity_Color& Color, Graphic3d_Vector& Direction) const { // purpose :
// =======================================================================
Quantity_Color AColor (Standard_Real (MyCLight.Color.r), void Visual3d_Light::Values (Quantity_Color& theColor) const
Standard_Real (MyCLight.Color.g), {
Standard_Real (MyCLight.Color.b), Visual3d_LightDefinitionError_Raise_if (myCLight.Type != Visual3d_TOLS_AMBIENT,
Quantity_TOC_RGB); "Light Type != Visual3d_TOLS_AMBIENT");
theColor.SetValues (Standard_Real (myCLight.Color.r()),
Graphic3d_Vector ADirection (Standard_Real (MyCLight.Direction.x), Standard_Real (myCLight.Color.g()),
Standard_Real (MyCLight.Direction.y), Standard_Real (myCLight.Color.b()),
Standard_Real (MyCLight.Direction.z)); Quantity_TOC_RGB);
if (MyType == Visual3d_TOLS_DIRECTIONAL) {
Color = AColor;
Direction = ADirection;
}
else Visual3d_LightDefinitionError::Raise
("Light Type != Visual3d_TOLS_DIRECTIONAL");
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Values
void Visual3d_Light::Values (Quantity_Color& Color, Graphic3d_Vertex& Position, Standard_Real& Fact1, Standard_Real& Fact2) const { // purpose :
// =======================================================================
Quantity_Color AColor (Standard_Real (MyCLight.Color.r), void Visual3d_Light::Values (Quantity_Color& theColor,
Standard_Real (MyCLight.Color.g), Graphic3d_Vector& theDir) const
Standard_Real (MyCLight.Color.b), {
Quantity_TOC_RGB); Visual3d_LightDefinitionError_Raise_if (myCLight.Type != Visual3d_TOLS_DIRECTIONAL,
"Light Type != Visual3d_TOLS_DIRECTIONAL");
Graphic3d_Vertex APosition (Standard_Real (MyCLight.Position.x), theColor.SetValues (Standard_Real (myCLight.Color.r()),
Standard_Real (MyCLight.Position.y), Standard_Real (myCLight.Color.g()),
Standard_Real (MyCLight.Position.z)); Standard_Real (myCLight.Color.b()),
Quantity_TOC_RGB);
if (MyType == Visual3d_TOLS_POSITIONAL) { theDir.SetCoord (Standard_Real (myCLight.Direction.x()),
Color = AColor; Standard_Real (myCLight.Direction.y()),
Position = APosition; Standard_Real (myCLight.Direction.z()));
Fact1 = Standard_Real (MyCLight.Attenuation[0]);
Fact2 = Standard_Real (MyCLight.Attenuation[1]);
}
else Visual3d_LightDefinitionError::Raise
("Light Type != Visual3d_TOLS_POSITIONAL");
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Values
void Visual3d_Light::Values (Quantity_Color& Color, Graphic3d_Vertex& Position, Graphic3d_Vector& Direction, Standard_Real& Concentration, Standard_Real& Fact1, Standard_Real& Fact2, Standard_Real& AngleCone) const { // purpose :
// =======================================================================
Quantity_Color AColor (Standard_Real (MyCLight.Color.r), void Visual3d_Light::Values (Quantity_Color& theColor,
Standard_Real (MyCLight.Color.g), Graphic3d_Vertex& thePos,
Standard_Real (MyCLight.Color.b), Standard_Real& theFact1,
Quantity_TOC_RGB); Standard_Real& theFact2) const
{
Graphic3d_Vertex APosition (Standard_Real (MyCLight.Position.x), Visual3d_LightDefinitionError_Raise_if (myCLight.Type != Visual3d_TOLS_POSITIONAL,
Standard_Real (MyCLight.Position.y), "Light Type != Visual3d_TOLS_POSITIONAL");
Standard_Real (MyCLight.Position.z)); theColor.SetValues (Standard_Real (myCLight.Color.r()),
Standard_Real (myCLight.Color.g()),
Graphic3d_Vector ADirection (Standard_Real (MyCLight.Direction.x), Standard_Real (myCLight.Color.b()),
Standard_Real (MyCLight.Direction.y), Quantity_TOC_RGB);
Standard_Real (MyCLight.Direction.z)); thePos.SetCoord (Standard_Real (myCLight.Position.x()),
Standard_Real (myCLight.Position.y()),
if (MyType == Visual3d_TOLS_SPOT) { Standard_Real (myCLight.Position.z()));
Color = AColor; theFact1 = Standard_Real (myCLight.ConstAttenuation());
Position = APosition; theFact2 = Standard_Real (myCLight.LinearAttenuation());
Direction = ADirection;
Concentration = Standard_Real (MyCLight.Concentration);
Fact1 = Standard_Real (MyCLight.Attenuation[0]);
Fact2 = Standard_Real (MyCLight.Attenuation[1]);
AngleCone = Standard_Real (MyCLight.Angle);
}
else Visual3d_LightDefinitionError::Raise
("Light Type != Visual3d_TOLS_SPOT");
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Values
void Visual3d_Light::SetAngle (const Standard_Real AngleCone) { // purpose :
// =======================================================================
if (! Visual3d_Light::IsValid (AngleCone)) void Visual3d_Light::Values (Quantity_Color& theColor,
Visual3d_LightDefinitionError::Raise Graphic3d_Vertex& thePos,
("Bad value for LightAngle"); Graphic3d_Vector& theDir,
Standard_Real& theConcentration,
if (MyType == Visual3d_TOLS_SPOT) { Standard_Real& theFact1,
MyCLight.Angle = float (AngleCone); Standard_Real& theFact2,
Standard_Real& theAngleCone) const
MyCLight.LightId = {
Graphic3d_GraphicDriver::Light (MyCLight, Standard_True); Visual3d_LightDefinitionError_Raise_if (myCLight.Type != Visual3d_TOLS_SPOT,
"Light Type != Visual3d_TOLS_SPOT");
} theColor.SetValues (Standard_Real (myCLight.Color.r()),
else Visual3d_LightDefinitionError::Raise Standard_Real (myCLight.Color.g()),
("Light Type != Visual3d_TOLS_SPOT"); Standard_Real (myCLight.Color.b()),
Quantity_TOC_RGB);
thePos.SetCoord (Standard_Real (myCLight.Position.x()),
Standard_Real (myCLight.Position.y()),
Standard_Real (myCLight.Position.z()));
theDir.SetCoord (Standard_Real (myCLight.Direction.x()),
Standard_Real (myCLight.Direction.y()),
Standard_Real (myCLight.Direction.z()));
theConcentration = Standard_Real (myCLight.Concentration());
theFact1 = Standard_Real (myCLight.ConstAttenuation());
theFact2 = Standard_Real (myCLight.LinearAttenuation());
theAngleCone = Standard_Real (myCLight.Angle());
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : SetAngle
void Visual3d_Light::SetAttenuation1 (const Standard_Real Fact1) { // purpose :
// =======================================================================
if ( (Fact1 < 0.0) || (Fact1 > 1.0) ) void Visual3d_Light::SetAngle (const Standard_Real theAngleCone)
Visual3d_LightDefinitionError::Raise {
("Bad value for LightAttenuation"); Visual3d_LightDefinitionError_Raise_if (!Visual3d_Light::IsValid (theAngleCone),
"Bad value for LightAngle");
if ( (MyType == Visual3d_TOLS_POSITIONAL) || Visual3d_LightDefinitionError_Raise_if (myCLight.Type != Visual3d_TOLS_SPOT,
(MyType == Visual3d_TOLS_SPOT) ) { "Light Type != Visual3d_TOLS_SPOT");
MyCLight.Attenuation[0] = float (Fact1); myCLight.ChangeAngle() = Standard_ShortReal (theAngleCone);
MyCLight.LightId =
Graphic3d_GraphicDriver::Light (MyCLight, Standard_True);
}
else Visual3d_LightDefinitionError::Raise
("Light Type != Visual3d_TOLS_POSITIONAL and != Visual3d_TOLS_SPOT");
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : SetAttenuation1
void Visual3d_Light::SetAttenuation2 (const Standard_Real Fact2) { // purpose :
// =======================================================================
if ( (Fact2 < 0.0) || (Fact2 > 1.0) ) void Visual3d_Light::SetAttenuation1 (const Standard_Real theFact1)
Visual3d_LightDefinitionError::Raise {
("Bad value for LightAttenuation"); Visual3d_LightDefinitionError_Raise_if (theFact1 < 0.0 || theFact1 > 1.0,
"Bad value for LightAttenuation");
if ( (MyType == Visual3d_TOLS_POSITIONAL) || Visual3d_LightDefinitionError_Raise_if (myCLight.Type != Visual3d_TOLS_POSITIONAL
(MyType == Visual3d_TOLS_SPOT) ) { && myCLight.Type != Visual3d_TOLS_SPOT,
MyCLight.Attenuation[1] = float (Fact2); "Light Type != Visual3d_TOLS_SPOT and != Visual3d_TOLS_POSITIONAL");
myCLight.ChangeConstAttenuation() = Standard_ShortReal (theFact1);
MyCLight.LightId =
Graphic3d_GraphicDriver::Light (MyCLight, Standard_True);
}
else Visual3d_LightDefinitionError::Raise
("Light Type != Visual3d_TOLS_POSITIONAL and != Visual3d_TOLS_SPOT");
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : SetAttenuation2
void Visual3d_Light::SetColor (const Quantity_Color& Color) { // purpose :
// =======================================================================
MyCLight.Color.r = float (Color.Red ()); void Visual3d_Light::SetAttenuation2 (const Standard_Real theFact2)
MyCLight.Color.g = float (Color.Green ()); {
MyCLight.Color.b = float (Color.Blue ()); Visual3d_LightDefinitionError_Raise_if (theFact2 < 0.0 || theFact2 > 1.0,
"Bad value for LightAttenuation");
MyCLight.LightId = Visual3d_LightDefinitionError_Raise_if (myCLight.Type != Visual3d_TOLS_POSITIONAL
Graphic3d_GraphicDriver::Light (MyCLight, Standard_True); && myCLight.Type != Visual3d_TOLS_SPOT,
"Light Type != Visual3d_TOLS_SPOT and != Visual3d_TOLS_POSITIONAL");
myCLight.ChangeLinearAttenuation() = Standard_ShortReal (theFact2);
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : SetColor
void Visual3d_Light::SetConcentration (const Standard_Real Concentration) { // purpose :
// =======================================================================
if ( (Concentration < 0.0) || (Concentration > 1.0) ) void Visual3d_Light::SetColor (const Quantity_Color& theColor)
Visual3d_LightDefinitionError::Raise {
("Bad value for LightConcentration"); myCLight.Color.r() = float (theColor.Red());
myCLight.Color.g() = float (theColor.Green());
if (MyType == Visual3d_TOLS_SPOT) { myCLight.Color.b() = float (theColor.Blue());
MyCLight.Concentration = float (Concentration);
MyCLight.LightId =
Graphic3d_GraphicDriver::Light (MyCLight, Standard_True);
}
else Visual3d_LightDefinitionError::Raise
("Light Type != Visual3d_TOLS_SPOT");
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : SetConcentration
void Visual3d_Light::SetDirection (const Graphic3d_Vector& Direction) { // purpose :
// =======================================================================
if (Direction.LengthZero ()) void Visual3d_Light::SetConcentration (const Standard_Real theConcentration)
Visual3d_LightDefinitionError::Raise {
("Bad value for LightDirection"); Visual3d_LightDefinitionError_Raise_if (theConcentration < 0.0 || theConcentration > 1.0,
"Bad value for LightConcentration");
if ( (MyType == Visual3d_TOLS_DIRECTIONAL) || Visual3d_LightDefinitionError_Raise_if (myCLight.Type != Visual3d_TOLS_SPOT,
(MyType == Visual3d_TOLS_SPOT) ) { "Light Type != Visual3d_TOLS_SPOT");
myCLight.ChangeConcentration() = Standard_ShortReal (theConcentration);
Standard_Real Norme, X, Y, Z;
Direction.Coord (X, Y, Z);
Norme = Sqrt (X*X+Y*Y+Z*Z);
// Direction.LengthZero () == Standard_False
MyCLight.Direction.x = float (X/Norme);
MyCLight.Direction.y = float (Y/Norme);
MyCLight.Direction.z = float (Z/Norme);
MyCLight.LightId =
Graphic3d_GraphicDriver::Light (MyCLight, Standard_True);
}
else Visual3d_LightDefinitionError::Raise
("Light Type != Visual3d_TOLS_DIRECTIONAL and != Visual3d_TOLS_SPOT");
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : SetDirection
void Visual3d_Light::SetPosition (const Graphic3d_Vertex& Position) { // purpose :
// =======================================================================
if ( (MyType == Visual3d_TOLS_POSITIONAL) || void Visual3d_Light::SetDirection (const Graphic3d_Vector& theDir)
(MyType == Visual3d_TOLS_SPOT) ) { {
Visual3d_LightDefinitionError_Raise_if (theDir.LengthZero(),
MyCLight.Position.x = float (Position.X ()); "Bad value for LightDirection");
MyCLight.Position.y = float (Position.Y ()); Visual3d_LightDefinitionError_Raise_if (myCLight.Type != Visual3d_TOLS_SPOT
MyCLight.Position.z = float (Position.Z ()); && myCLight.Type != Visual3d_TOLS_DIRECTIONAL,
"Light Type != Visual3d_TOLS_DIRECTIONAL and != Visual3d_TOLS_SPOT");
MyCLight.LightId = Standard_Real X, Y, Z;
Graphic3d_GraphicDriver::Light (MyCLight, Standard_True); theDir.Coord (X, Y, Z);
const Standard_Real aNorm = Sqrt (X * X + Y * Y + Z * Z);
} myCLight.Direction.x() = float (X / aNorm);
else Visual3d_LightDefinitionError::Raise myCLight.Direction.y() = float (Y / aNorm);
("Light Type != Visual3d_TOLS_POSITIONAL and != Visual3d_TOLS_SPOT"); myCLight.Direction.z() = float (Z / aNorm);
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : SetPosition
Standard_Integer Visual3d_Light::Limit () { // purpose :
// =======================================================================
// Old method, replaced by GraphicDriver::InquireLightLimit () void Visual3d_Light::SetPosition (const Graphic3d_Vertex& thePos)
return 0; {
Visual3d_LightDefinitionError_Raise_if (myCLight.Type != Visual3d_TOLS_SPOT
&& myCLight.Type != Visual3d_TOLS_POSITIONAL,
"Light Type != Visual3d_TOLS_POSITIONAL and != Visual3d_TOLS_SPOT");
myCLight.Position.x() = float (thePos.X());
myCLight.Position.y() = float (thePos.Y());
myCLight.Position.z() = float (thePos.Z());
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Limit
Standard_Integer Visual3d_Light::Identification () const { // purpose :
// =======================================================================
return (Standard_Integer (MyCLight.LightId)); Standard_Integer Visual3d_Light::Limit()
{
// Old method, replaced by GraphicDriver::InquireLightLimit()
return 0;
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : Identification
Standard_Boolean Visual3d_Light::IsValid (const Standard_Real AAngle) { // purpose :
// =======================================================================
return ( (AAngle < M_PI) && (AAngle >= 0.0) ); Standard_Integer Visual3d_Light::Identification() const
{
return 0;
} }
/*----------------------------------------------------------------------*/ // =======================================================================
// function : IsValid
// purpose :
// =======================================================================
Standard_Boolean Visual3d_Light::IsValid (const Standard_Real theAngle)
{
return (theAngle < M_PI)
&& (theAngle >= 0.0);
}
// =======================================================================
// function : CLight
// purpose :
// =======================================================================
const Graphic3d_CLight& Visual3d_Light::CLight() const
{
return myCLight;
}

178
src/Visual3d/Visual3d_View.cxx
View File

@ -79,9 +79,6 @@
#define BUC60572 //GG_03-08-99 Add protection on Zclipping & Zcueing planes #define BUC60572 //GG_03-08-99 Add protection on Zclipping & Zcueing planes
// positions. // positions.
#define BUC60570 //GG 14-09-99 Don't activates lighting
// when the view shading model is NONE.
#define GER61454 //GG 14-09-99 Activates model clipping planes #define GER61454 //GG 14-09-99 Activates model clipping planes
#define RIC120302 //GG Add a NEW SetWindow method which enable #define RIC120302 //GG Add a NEW SetWindow method which enable
@ -706,148 +703,45 @@ Standard_Real Rap;
} }
void Visual3d_View::UpdateLights () { void Visual3d_View::UpdateLights()
{
Standard_Integer i, j; if (IsDeleted()
CALL_DEF_LIGHT *lights=NULL; || !IsDefined())
{
#ifdef BUC60570 return;
if( MyContext.Model() == Visual3d_TOM_NONE ) {
// Activates only a white ambient light
MyCView.Context.NbActiveLight = 1;
lights = new CALL_DEF_LIGHT [MyCView.Context.NbActiveLight];
MyCView.Context.ActiveLight = lights;
lights[0].WsId = MyCView.ViewId;
lights[0].ViewId = MyCView.ViewId;
lights[0].LightType = int (Visual3d_TOLS_AMBIENT);
lights[0].Active = 1;
lights[0].LightId = 0;
lights[0].Headlight = 0;
lights[0].Color.r = lights[0].Color.g = lights[0].Color.b = 1.;
} else {
#endif
i = MyContext.NumberOfActivatedLights ();
j = MyGraphicDriver->InquireLightLimit ();
MyCView.Context.NbActiveLight = (i > j ? j : i);
if (MyCView.Context.NbActiveLight > 0) {
// Dynamic Allocation
lights = new CALL_DEF_LIGHT [MyCView.Context.NbActiveLight];
MyCView.Context.ActiveLight = lights;
Standard_Real X, Y, Z;
Standard_Real LightConcentration = 0.;
Standard_Real LightAttenuation1 = 0.;
Standard_Real LightAttenuation2 = 0.;
Standard_Real LightAngle = 0.;
Quantity_Color LightColor;
Graphic3d_Vertex LightPosition;
Graphic3d_Vector LightDirection;
Visual3d_TypeOfLightSource LightType=Visual3d_TOLS_AMBIENT;
// Parcing of light sources
for (j=0; j<MyCView.Context.NbActiveLight; j++) {
LightType = (MyContext.ActivatedLight (j+1))->LightType ();
lights[j].WsId = MyCView.ViewId;
lights[j].ViewId = MyCView.ViewId;
lights[j].LightType = int (LightType);
lights[j].Active = 1;
lights[j].LightId =
int ((MyContext.ActivatedLight (j+1))->Identification ());
lights[j].Headlight = (MyContext.ActivatedLight (j+1))->Headlight ()? 1:0;
switch (LightType) {
case Visual3d_TOLS_AMBIENT :
(MyContext.ActivatedLight (j+1))->Values (
LightColor
);
break;
case Visual3d_TOLS_POSITIONAL :
(MyContext.ActivatedLight (j+1))->Values (
LightColor,
LightPosition,
LightAttenuation1,
LightAttenuation2
);
break;
case Visual3d_TOLS_DIRECTIONAL :
(MyContext.ActivatedLight (j+1))->Values (
LightColor,
LightDirection
);
break;
case Visual3d_TOLS_SPOT :
(MyContext.ActivatedLight (j+1))->Values (
LightColor,
LightPosition,
LightDirection,
LightConcentration,
LightAttenuation1,
LightAttenuation2,
LightAngle
);
break;
}
lights[j].Color.r = float (LightColor.Red ());
lights[j].Color.g = float (LightColor.Green ());
lights[j].Color.b = float (LightColor.Blue ());
if ( (LightType == Visual3d_TOLS_POSITIONAL) ||
(LightType == Visual3d_TOLS_SPOT) ) {
LightPosition.Coord (X, Y, Z);
lights[j].Position.x = float (X);
lights[j].Position.y = float (Y);
lights[j].Position.z = float (Z);
}
if ( (LightType == Visual3d_TOLS_DIRECTIONAL) ||
(LightType == Visual3d_TOLS_SPOT) ) {
LightDirection.Coord (X, Y, Z);
lights[j].Direction.x = float (X);
lights[j].Direction.y = float (Y);
lights[j].Direction.z = float (Z);
}
if ( (LightType == Visual3d_TOLS_POSITIONAL) ||
(LightType == Visual3d_TOLS_SPOT) ) {
lights[j].Attenuation[0] =
float (LightAttenuation1);
lights[j].Attenuation[1] =
float (LightAttenuation2);
}
if (LightType == Visual3d_TOLS_SPOT) {
lights[j].Concentration =
float (LightConcentration);
lights[j].Angle =
float (LightAngle);
}
}
}
#ifdef BUC60570
} }
#endif
// management of light sources
if (! IsDeleted ())
if (IsDefined ())
MyGraphicDriver->SetLight (MyCView);
// Dynamic allocation if (MyContext.Model() == Visual3d_TOM_NONE)
if (MyCView.Context.NbActiveLight > 0) delete [] lights; {
// activate only a white ambient light
Graphic3d_CLight aCLight;
aCLight.Type = Visual3d_TOLS_AMBIENT;
aCLight.IsHeadlight = Standard_False;
aCLight.Color.r() = aCLight.Color.g() = aCLight.Color.b() = 1.0f;
MyCView.Context.NbActiveLight = 1;
MyCView.Context.ActiveLight = &aCLight;
MyGraphicDriver->SetLight (MyCView);
MyCView.Context.ActiveLight = NULL;
return;
}
MyCView.Context.NbActiveLight = Min (MyContext.NumberOfActivatedLights(),
MyGraphicDriver->InquireLightLimit());
if (MyCView.Context.NbActiveLight < 1)
{
return;
}
// parcing of light sources
MyCView.Context.ActiveLight = new Graphic3d_CLight[MyCView.Context.NbActiveLight];
for (Standard_Integer aLightIter = 0; aLightIter < MyCView.Context.NbActiveLight; ++aLightIter)
{
MyCView.Context.ActiveLight[aLightIter] = MyContext.ActivatedLight (aLightIter + 1)->CLight();
}
MyGraphicDriver->SetLight (MyCView);
delete[] MyCView.Context.ActiveLight;
MyCView.Context.ActiveLight = NULL;
} }
void Visual3d_View::UpdatePlanes() void Visual3d_View::UpdatePlanes()

1
tests/v3d/glsl/phong_box
View File

@ -9,6 +9,7 @@ box b 1 2 3
vinit View1 vinit View1
vclear vclear
vsetdispmode 1 vsetdispmode 1
vaxo
vdisplay b vdisplay b
vfit vfit
vrotate 0.2 0.0 0.0 vrotate 0.2 0.0 0.0

1
tests/v3d/glsl/phong_couple
View File

@ -12,6 +12,7 @@ vinit View1
vclear vclear
vdefaults absDefl=0.5 vdefaults absDefl=0.5
vsetdispmode 1 vsetdispmode 1
vaxo
vdisplay f vdisplay f
vfit vfit
vrotate -0.5 0.0 0.0 vrotate -0.5 0.0 0.0

1
tests/v3d/glsl/phong_fuse
View File

@ -11,6 +11,7 @@ vinit View1
vclear vclear
vdefaults absDefl=0.5 vdefaults absDefl=0.5
vsetdispmode 1 vsetdispmode 1
vaxo
vdisplay f vdisplay f
vfit vfit
vrotate -0.5 0.0 0.0 vrotate -0.5 0.0 0.0

39
tests/v3d/glsl/phong_fuse2 Normal file
View File

@ -0,0 +1,39 @@
puts "========"
puts "Per-pixel lighting using GLSL program (Phong shading)"
puts "========"
# import model
restore [locate_data_file occ/fuse.brep] f
tclean f
# draw box
vinit View1
vclear
vdefaults absDefl=0.5
vsetdispmode 1
vaxo
vdisplay f
vfit
vrotate -0.5 0.0 0.0
vfit
# setup lights
vlight delete 0
vlight delete 0
vlight delete 0
vlight delete 0
vlight delete 0
vlight add ambient color WHITE
vlight add directional dir 1 0 0 color GREEN headlight 1
vlight add directional dir -1 0 0 color RED1 headlight 1
# take snapshot with fixed pipeline
vdump $::imagedir/${::casename}_OFF.png
vshaderprog f phong
vdump $::imagedir/${::casename}_ph1.png
vclear
vdisplay f
vshaderprog f phong
vdump $::imagedir/${::casename}_ph2.png
vmoveto 250 250

1
tests/v3d/glsl/phong_views
View File

@ -9,6 +9,7 @@ box b 1 2 3
vinit View1 vinit View1
vclear vclear
vsetdispmode 1 vsetdispmode 1
vaxo
vdisplay b vdisplay b
vfit vfit
vrotate 0.2 0.0 0.0 vrotate 0.2 0.0 0.0