aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-11-17 04:51:52 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rename

Browse source 
--HG--
branch : multipass-stereo
This commit is contained in:
kaetemi 2013-09-14 00:46:10 +02:00
parent 973215e1d0
commit 6dfc8d0a00
27 changed files with 143 additions and 143 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
code/nel/include/nel/3d/driver.h
View file

@ -1455,8 +1455,8 @@ protected:
friend class CTextureDrvShare; friend class CTextureDrvShare;
friend class ITextureDrvInfos; friend class ITextureDrvInfos;
friend class IMaterialDrvInfos; friend class IMaterialDrvInfos;
friend class IGPUProgramDrvInfos; friend class IProgramDrvInfos;
friend class IGPUProgramParamsDrvInfos; friend class IProgramParamsDrvInfos;
/// remove ptr from the lists in the driver. /// remove ptr from the lists in the driver.
void removeVBDrvInfoPtr(ItVBDrvInfoPtrList vbDrvInfoIt); void removeVBDrvInfoPtr(ItVBDrvInfoPtrList vbDrvInfoIt);

4
code/nel/include/nel/3d/geometry_program.h
View file

@ -26,13 +26,13 @@
#include <nel/misc/types_nl.h> #include <nel/misc/types_nl.h>
#include <nel/misc/smart_ptr.h> #include <nel/misc/smart_ptr.h>
#include <nel/3d/gpu_program.h> #include <nel/3d/program.h>
#include <list> #include <list>
namespace NL3D { namespace NL3D {
class CGeometryProgram : public IGPUProgram class CGeometryProgram : public IProgram
{ {
public: public:
/// Constructor /// Constructor

4
code/nel/include/nel/3d/pixel_program.h
View file

@ -26,13 +26,13 @@
#include <nel/misc/types_nl.h> #include <nel/misc/types_nl.h>
#include <nel/misc/smart_ptr.h> #include <nel/misc/smart_ptr.h>
#include <nel/3d/gpu_program.h> #include <nel/3d/program.h>
#include <list> #include <list>
namespace NL3D { namespace NL3D {
class CPixelProgram : public IGPUProgram class CPixelProgram : public IProgram
{ {
public: public:
/// Constructor /// Constructor

52
code/nel/include/nel/3d/gpu_program.h → code/nel/include/nel/3d/program.h
View file

@ -1,9 +1,9 @@
/** /**
* \file gpu_program.h * \file program.h
* \brief IGPUProgram * \brief IProgram
* \date 2013-09-07 15:00GMT * \date 2013-09-07 15:00GMT
* \author Jan Boon (Kaetemi) * \author Jan Boon (Kaetemi)
* IGPUProgram * IProgram
*/ */
/* /*
@ -25,8 +25,8 @@
* <http://www.gnu.org/licenses/>. * <http://www.gnu.org/licenses/>.
*/ */
#ifndef NL3D_GPU_PROGRAM_H #ifndef NL3D_PROGRAM_H
#define NL3D_GPU_PROGRAM_H #define NL3D_PROGRAM_H
#include <nel/misc/types_nl.h> #include <nel/misc/types_nl.h>
// STL includes // STL includes
@ -40,22 +40,22 @@ namespace NL3D {
// List typedef. // List typedef.
class IDriver; class IDriver;
class IGPUProgramDrvInfos; class IProgramDrvInfos;
typedef std::list<IGPUProgramDrvInfos*> TGPUPrgDrvInfoPtrList; typedef std::list<IProgramDrvInfos*> TGPUPrgDrvInfoPtrList;
typedef TGPUPrgDrvInfoPtrList::iterator ItGPUPrgDrvInfoPtrList; typedef TGPUPrgDrvInfoPtrList::iterator ItGPUPrgDrvInfoPtrList;
// Class for interaction of vertex program with Driver. // Class for interaction of vertex program with Driver.
// IGPUProgramDrvInfos represent the real data of the GPU program, stored into the driver (eg: just a GLint for opengl). // IProgramDrvInfos represent the real data of the GPU program, stored into the driver (eg: just a GLint for opengl).
class IGPUProgramDrvInfos : public NLMISC::CRefCount class IProgramDrvInfos : public NLMISC::CRefCount
{ {
private: private:
IDriver *_Driver; IDriver *_Driver;
ItGPUPrgDrvInfoPtrList _DriverIterator; ItGPUPrgDrvInfoPtrList _DriverIterator;
public: public:
IGPUProgramDrvInfos (IDriver *drv, ItGPUPrgDrvInfoPtrList it); IProgramDrvInfos (IDriver *drv, ItGPUPrgDrvInfoPtrList it);
// The virtual dtor is important. // The virtual dtor is important.
virtual ~IGPUProgramDrvInfos(void); virtual ~IProgramDrvInfos(void);
virtual uint getUniformIndex(const char *name) const = 0; virtual uint getUniformIndex(const char *name) const = 0;
}; };
@ -73,9 +73,9 @@ public:
// This does not work extremely efficient, but it's the most practical option // This does not work extremely efficient, but it's the most practical option
// for passing builtin parameters onto user provided shaders. // for passing builtin parameters onto user provided shaders.
// Note: May need additional flags related to scene sorting, etcetera. // Note: May need additional flags related to scene sorting, etcetera.
struct CGPUProgramFeatures struct CProgramFeatures
{ {
CGPUProgramFeatures() : DriverFlags(0), MaterialFlags(0) { } CProgramFeatures() : DriverFlags(0), MaterialFlags(0) { }
// Driver builtin parameters // Driver builtin parameters
enum TDriverFlags enum TDriverFlags
@ -100,7 +100,7 @@ struct CGPUProgramFeatures
// Stucture used to cache the indices of builtin parameters which are used by the drivers // Stucture used to cache the indices of builtin parameters which are used by the drivers
// Not used for parameters of specific nl3d programs // Not used for parameters of specific nl3d programs
struct CGPUProgramIndex struct CProgramIndex
{ {
enum TName enum TName
{ {
@ -128,12 +128,12 @@ struct CGPUProgramIndex
}; };
/** /**
* \brief IGPUProgram * \brief IProgram
* \date 2013-09-07 15:00GMT * \date 2013-09-07 15:00GMT
* \author Jan Boon (Kaetemi) * \author Jan Boon (Kaetemi)
* A generic GPU program * A generic GPU program
*/ */
class IGPUProgram : public NLMISC::CRefCount class IProgram : public NLMISC::CRefCount
{ {
public: public:
enum TProfile enum TProfile
@ -195,7 +195,7 @@ public:
std::string DisplayName; std::string DisplayName;
/// Minimal required profile for this GPU program /// Minimal required profile for this GPU program
IGPUProgram::TProfile Profile; IProgram::TProfile Profile;
const char *SourcePtr; const char *SourcePtr;
size_t SourceLen; size_t SourceLen;
@ -207,7 +207,7 @@ public:
inline void setSourcePtr(const char *sourcePtr) { SourceCopy.clear(); SourcePtr = sourcePtr; SourceLen = strlen(sourcePtr); } inline void setSourcePtr(const char *sourcePtr) { SourceCopy.clear(); SourcePtr = sourcePtr; SourceLen = strlen(sourcePtr); }
/// CVertexProgramInfo/CPixelProgramInfo/... NeL features /// CVertexProgramInfo/CPixelProgramInfo/... NeL features
CGPUProgramFeatures Features; CProgramFeatures Features;
/// Map with known parameter indices, used for assembly programs /// Map with known parameter indices, used for assembly programs
std::map<std::string, uint> ParamIndices; std::map<std::string, uint> ParamIndices;
@ -217,8 +217,8 @@ public:
}; };
public: public:
IGPUProgram(); IProgram();
virtual ~IGPUProgram(); virtual ~IProgram();
// Manage the sources, not allowed after compilation. // Manage the sources, not allowed after compilation.
// Add multiple sources using different profiles, the driver will use the first one it supports. // Add multiple sources using different profiles, the driver will use the first one it supports.
@ -230,11 +230,11 @@ public:
// Get the idx of a parameter (ogl: uniform, d3d: constant, etcetera) by name. Invalid name returns ~0 // Get the idx of a parameter (ogl: uniform, d3d: constant, etcetera) by name. Invalid name returns ~0
inline uint getUniformIndex(const char *name) const { return m_DrvInfo->getUniformIndex(name); }; inline uint getUniformIndex(const char *name) const { return m_DrvInfo->getUniformIndex(name); };
inline uint getUniformIndex(const std::string &name) const { return m_DrvInfo->getUniformIndex(name.c_str()); }; inline uint getUniformIndex(const std::string &name) const { return m_DrvInfo->getUniformIndex(name.c_str()); };
inline uint getUniformIndex(CGPUProgramIndex::TName name) const { return m_Index.Indices[name]; } inline uint getUniformIndex(CProgramIndex::TName name) const { return m_Index.Indices[name]; }
// Get feature information of the current program // Get feature information of the current program
inline CSource *source() const { return m_Source; }; inline CSource *source() const { return m_Source; };
inline const CGPUProgramFeatures &features() const { return m_Source->Features; }; inline const CProgramFeatures &features() const { return m_Source->Features; };
inline TProfile profile() const { return m_Source->Profile; } inline TProfile profile() const { return m_Source->Profile; }
// Build feature info, called automatically by the driver after compile succeeds // Build feature info, called automatically by the driver after compile succeeds
@ -249,16 +249,16 @@ protected:
/// The source used for compilation /// The source used for compilation
NLMISC::CSmartPtr<CSource> m_Source; NLMISC::CSmartPtr<CSource> m_Source;
CGPUProgramIndex m_Index; CProgramIndex m_Index;
public: public:
/// The driver information. For the driver implementation only. /// The driver information. For the driver implementation only.
NLMISC::CRefPtr<IGPUProgramDrvInfos> m_DrvInfo; NLMISC::CRefPtr<IProgramDrvInfos> m_DrvInfo;
}; /* class IGPUProgram */ }; /* class IProgram */
} /* namespace NL3D */ } /* namespace NL3D */
#endif /* #ifndef NL3D_GPU_PROGRAM_H */ #endif /* #ifndef NL3D_PROGRAM_H */
/* end of file */ /* end of file */

4
code/nel/include/nel/3d/vertex_program.h
View file

@ -19,13 +19,13 @@
#include "nel/misc/types_nl.h" #include "nel/misc/types_nl.h"
#include "nel/misc/smart_ptr.h" #include "nel/misc/smart_ptr.h"
#include "nel/3d/gpu_program.h" #include "nel/3d/program.h"
#include <list> #include <list>
namespace NL3D { namespace NL3D {
class CVertexProgram : public IGPUProgram class CVertexProgram : public IProgram
{ {
public: public:
/// Constructor /// Constructor

4
code/nel/src/3d/CMakeLists.txt
View file

@ -167,8 +167,8 @@ SOURCE_GROUP(Driver FILES
../../include/nel/3d/pixel_program.h ../../include/nel/3d/pixel_program.h
geometry_program.cpp geometry_program.cpp
../../include/nel/3d/geometry_program.h ../../include/nel/3d/geometry_program.h
gpu_program.cpp program.cpp
../../include/nel/3d/gpu_program.h ../../include/nel/3d/program.h
gpu_program_params.cpp gpu_program_params.cpp
../../include/nel/3d/gpu_program_params.h) ../../include/nel/3d/gpu_program_params.h)

8
code/nel/src/3d/driver/direct3d/driver_direct3d.h
View file

@ -299,7 +299,7 @@ public:
// *************************************************************************** // ***************************************************************************
class CVertexProgamDrvInfosD3D : public IGPUProgramDrvInfos class CVertexProgamDrvInfosD3D : public IProgramDrvInfos
{ {
public: public:
@ -321,7 +321,7 @@ public:
// *************************************************************************** // ***************************************************************************
class CPixelProgramDrvInfosD3D : public IGPUProgramDrvInfos class CPixelProgramDrvInfosD3D : public IProgramDrvInfos
{ {
public: public:
@ -2111,7 +2111,7 @@ public:
{ {
H_AUTO_D3D(CDriverD3D_getPixelProgramD3D); H_AUTO_D3D(CDriverD3D_getPixelProgramD3D);
CPixelProgramDrvInfosD3D* d3dPixelProgram; CPixelProgramDrvInfosD3D* d3dPixelProgram;
d3dPixelProgram = (CPixelProgramDrvInfosD3D*)(IGPUProgramDrvInfos*)(pixelProgram.m_DrvInfo); d3dPixelProgram = (CPixelProgramDrvInfosD3D*)(IProgramDrvInfos*)(pixelProgram.m_DrvInfo);
return d3dPixelProgram; return d3dPixelProgram;
} }
@ -2120,7 +2120,7 @@ public:
{ {
H_AUTO_D3D(CDriverD3D_getVertexProgramD3D); H_AUTO_D3D(CDriverD3D_getVertexProgramD3D);
CVertexProgamDrvInfosD3D* d3dVertexProgram; CVertexProgamDrvInfosD3D* d3dVertexProgram;
d3dVertexProgram = (CVertexProgamDrvInfosD3D*)(IGPUProgramDrvInfos*)(vertexProgram.m_DrvInfo); d3dVertexProgram = (CVertexProgamDrvInfosD3D*)(IProgramDrvInfos*)(vertexProgram.m_DrvInfo);
return d3dVertexProgram; return d3dVertexProgram;
} }

4
code/nel/src/3d/driver/direct3d/driver_direct3d_material.cpp
View file

@ -649,7 +649,7 @@ bool CDriverD3D::setupMaterial(CMaterial &mat)
// because setupTexture() may disable all stage. // because setupTexture() may disable all stage.
if (matShader == CMaterial::Normal if (matShader == CMaterial::Normal
|| ((matShader == CMaterial::Program) && (_PixelProgramUser->features().MaterialFlags & CGPUProgramFeatures::TextureStages)) || ((matShader == CMaterial::Program) && (_PixelProgramUser->features().MaterialFlags & CProgramFeatures::TextureStages))
) )
{ {
uint stage; uint stage;
@ -671,7 +671,7 @@ bool CDriverD3D::setupMaterial(CMaterial &mat)
{ {
H_AUTO_D3D(CDriverD3D_setupMaterial_normalShaderActivateTextures) H_AUTO_D3D(CDriverD3D_setupMaterial_normalShaderActivateTextures)
if (matShader == CMaterial::Normal if (matShader == CMaterial::Normal
|| ((matShader == CMaterial::Program) && (_PixelProgramUser->features().MaterialFlags & CGPUProgramFeatures::TextureStages)) || ((matShader == CMaterial::Program) && (_PixelProgramUser->features().MaterialFlags & CProgramFeatures::TextureStages))
) )
{ {
uint stage; uint stage;

6
code/nel/src/3d/driver/direct3d/driver_direct3d_pixel_program.cpp
View file

@ -37,7 +37,7 @@ namespace NL3D
// *************************************************************************** // ***************************************************************************
CPixelProgramDrvInfosD3D::CPixelProgramDrvInfosD3D(IDriver *drv, ItGPUPrgDrvInfoPtrList it) : IGPUProgramDrvInfos (drv, it) CPixelProgramDrvInfosD3D::CPixelProgramDrvInfosD3D(IDriver *drv, ItGPUPrgDrvInfoPtrList it) : IProgramDrvInfos (drv, it)
{ {
H_AUTO_D3D(CPixelProgramDrvInfosD3D_CPixelProgamDrvInfosD3D) H_AUTO_D3D(CPixelProgramDrvInfosD3D_CPixelProgamDrvInfosD3D)
Shader = NULL; Shader = NULL;
@ -69,7 +69,7 @@ bool CDriverD3D::compilePixelProgram(CPixelProgram *program)
if (program->m_DrvInfo==NULL) if (program->m_DrvInfo==NULL)
{ {
// Find a supported pixel program profile // Find a supported pixel program profile
IGPUProgram::CSource *source = NULL; IProgram::CSource *source = NULL;
for (uint i = 0; i < program->getSourceNb(); ++i) for (uint i = 0; i < program->getSourceNb(); ++i)
{ {
if (supportPixelProgram(program->getSource(i)->Profile)) if (supportPixelProgram(program->getSource(i)->Profile))
@ -128,7 +128,7 @@ bool CDriverD3D::activePixelProgram(CPixelProgram *program)
{ {
if (!CDriverD3D::compilePixelProgram(program)) return false; if (!CDriverD3D::compilePixelProgram(program)) return false;
CPixelProgramDrvInfosD3D *info = static_cast<CPixelProgramDrvInfosD3D *>((IGPUProgramDrvInfos*)program->m_DrvInfo); CPixelProgramDrvInfosD3D *info = static_cast<CPixelProgramDrvInfosD3D *>((IProgramDrvInfos*)program->m_DrvInfo);
_PixelProgramUser = program; _PixelProgramUser = program;
setPixelShader(info->Shader); setPixelShader(info->Shader);
} }

6
code/nel/src/3d/driver/direct3d/driver_direct3d_vertex_program.cpp
View file

@ -26,7 +26,7 @@ namespace NL3D
// *************************************************************************** // ***************************************************************************
CVertexProgamDrvInfosD3D::CVertexProgamDrvInfosD3D(IDriver *drv, ItGPUPrgDrvInfoPtrList it) : IGPUProgramDrvInfos (drv, it) CVertexProgamDrvInfosD3D::CVertexProgamDrvInfosD3D(IDriver *drv, ItGPUPrgDrvInfoPtrList it) : IProgramDrvInfos (drv, it)
{ {
H_AUTO_D3D(CVertexProgamDrvInfosD3D_CVertexProgamDrvInfosD3D) H_AUTO_D3D(CVertexProgamDrvInfosD3D_CVertexProgamDrvInfosD3D)
Shader = NULL; Shader = NULL;
@ -268,7 +268,7 @@ bool CDriverD3D::compileVertexProgram(NL3D::CVertexProgram *program)
if (program->m_DrvInfo == NULL) if (program->m_DrvInfo == NULL)
{ {
// Find nelvp // Find nelvp
IGPUProgram::CSource *source = NULL; IProgram::CSource *source = NULL;
for (uint i = 0; i < program->getSourceNb(); ++i) for (uint i = 0; i < program->getSourceNb(); ++i)
{ {
if (program->getSource(i)->Profile == CVertexProgram::nelvp) if (program->getSource(i)->Profile == CVertexProgram::nelvp)
@ -378,7 +378,7 @@ bool CDriverD3D::activeVertexProgram (CVertexProgram *program)
{ {
if (!CDriverD3D::compileVertexProgram(program)) return false; if (!CDriverD3D::compileVertexProgram(program)) return false;
CVertexProgamDrvInfosD3D *info = NLMISC::safe_cast<CVertexProgamDrvInfosD3D *>((IGPUProgramDrvInfos*)program->m_DrvInfo); CVertexProgamDrvInfosD3D *info = NLMISC::safe_cast<CVertexProgamDrvInfosD3D *>((IProgramDrvInfos*)program->m_DrvInfo);
_VertexProgramUser = program; _VertexProgramUser = program;
setVertexProgram (info->Shader, program); setVertexProgram (info->Shader, program);

4
code/nel/src/3d/driver/opengl/driver_opengl.h
View file

@ -1627,7 +1627,7 @@ private:
}; };
// *************************************************************************** // ***************************************************************************
class CVertexProgamDrvInfosGL : public IGPUProgramDrvInfos class CVertexProgamDrvInfosGL : public IProgramDrvInfos
{ {
public: public:
// The GL Id. // The GL Id.
@ -1661,7 +1661,7 @@ public:
}; };
// *************************************************************************** // ***************************************************************************
class CPixelProgamDrvInfosGL : public IGPUProgramDrvInfos class CPixelProgamDrvInfosGL : public IProgramDrvInfos
{ {
public: public:
// The GL Id. // The GL Id.

6
code/nel/src/3d/driver/opengl/driver_opengl_material.cpp
View file

@ -404,7 +404,7 @@ bool CDriverGL::setupMaterial(CMaterial& mat)
// Must separate texture setup and texture activation in 2 "for"... // Must separate texture setup and texture activation in 2 "for"...
// because setupTexture() may disable all stage. // because setupTexture() may disable all stage.
if (matShader != CMaterial::Water if (matShader != CMaterial::Water
&& ((matShader != CMaterial::Program) || (_LastSetuppedPP->features().MaterialFlags & CGPUProgramFeatures::TextureStages)) && ((matShader != CMaterial::Program) || (_LastSetuppedPP->features().MaterialFlags & CProgramFeatures::TextureStages))
) )
{ {
for (uint stage = 0; stage < inlGetNumTextStages(); ++stage) for (uint stage = 0; stage < inlGetNumTextStages(); ++stage)
@ -441,7 +441,7 @@ bool CDriverGL::setupMaterial(CMaterial& mat)
&& matShader != CMaterial::Cloud && matShader != CMaterial::Cloud
&& matShader != CMaterial::Water && matShader != CMaterial::Water
&& matShader != CMaterial::Specular && matShader != CMaterial::Specular
&& ((matShader != CMaterial::Program) || (_LastSetuppedPP->features().MaterialFlags & CGPUProgramFeatures::TextureStages)) && ((matShader != CMaterial::Program) || (_LastSetuppedPP->features().MaterialFlags & CProgramFeatures::TextureStages))
) )
{ {
for(uint stage=0 ; stage<inlGetNumTextStages() ; stage++) for(uint stage=0 ; stage<inlGetNumTextStages() ; stage++)
@ -573,7 +573,7 @@ bool CDriverGL::setupMaterial(CMaterial& mat)
// Textures user matrix // Textures user matrix
if (matShader == CMaterial::Normal if (matShader == CMaterial::Normal
|| ((matShader == CMaterial::Program) && (_LastSetuppedPP->features().MaterialFlags & CGPUProgramFeatures::TextureMatrices)) || ((matShader == CMaterial::Program) && (_LastSetuppedPP->features().MaterialFlags & CProgramFeatures::TextureMatrices))
) )
{ {
setupUserTextureMatrix(inlGetNumTextStages(), mat); setupUserTextureMatrix(inlGetNumTextStages(), mat);

10
code/nel/src/3d/driver/opengl/driver_opengl_pixel_program.cpp
View file

@ -51,7 +51,7 @@ namespace NLDRIVERGL {
// *************************************************************************** // ***************************************************************************
CPixelProgamDrvInfosGL::CPixelProgamDrvInfosGL (CDriverGL *drv, ItGPUPrgDrvInfoPtrList it) : IGPUProgramDrvInfos (drv, it) CPixelProgamDrvInfosGL::CPixelProgamDrvInfosGL (CDriverGL *drv, ItGPUPrgDrvInfoPtrList it) : IProgramDrvInfos (drv, it)
{ {
H_AUTO_OGL(CPixelProgamDrvInfosGL_CPixelProgamDrvInfosGL) H_AUTO_OGL(CPixelProgamDrvInfosGL_CPixelProgamDrvInfosGL)
// Extension must exist // Extension must exist
@ -103,7 +103,7 @@ bool CDriverGL::compilePixelProgram(NL3D::CPixelProgram *program)
_PixelProgramEnabled = false; _PixelProgramEnabled = false;
// Insert into driver list. (so it is deleted when driver is deleted). // Insert into driver list. (so it is deleted when driver is deleted).
ItGPUPrgDrvInfoPtrList it = _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IGPUProgramDrvInfos*)NULL); ItGPUPrgDrvInfoPtrList it = _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IProgramDrvInfos*)NULL);
// Create a driver info // Create a driver info
CPixelProgamDrvInfosGL *drvInfo; CPixelProgamDrvInfosGL *drvInfo;
@ -136,7 +136,7 @@ bool CDriverGL::activeARBPixelProgram(CPixelProgram *program)
if (!CDriverGL::compilePixelProgram(program)) return false; if (!CDriverGL::compilePixelProgram(program)) return false;
// Cast the driver info pointer // Cast the driver info pointer
CPixelProgamDrvInfosGL *drvInfo = safe_cast<CPixelProgamDrvInfosGL*>((IGPUProgramDrvInfos*)program->m_DrvInfo); CPixelProgamDrvInfosGL *drvInfo = safe_cast<CPixelProgamDrvInfosGL*>((IProgramDrvInfos*)program->m_DrvInfo);
glEnable(GL_FRAGMENT_PROGRAM_ARB); glEnable(GL_FRAGMENT_PROGRAM_ARB);
_PixelProgramEnabled = true; _PixelProgramEnabled = true;
@ -159,10 +159,10 @@ bool CDriverGL::setupPixelProgram(CPixelProgram *program, GLuint id/*, bool &spe
{ {
H_AUTO_OGL(CDriverGL_setupARBPixelProgram) H_AUTO_OGL(CDriverGL_setupARBPixelProgram)
CPixelProgamDrvInfosGL *drvInfo = static_cast<CPixelProgamDrvInfosGL *>((IGPUProgramDrvInfos *)program->m_DrvInfo); CPixelProgamDrvInfosGL *drvInfo = static_cast<CPixelProgamDrvInfosGL *>((IProgramDrvInfos *)program->m_DrvInfo);
// Find a supported pixel program profile // Find a supported pixel program profile
IGPUProgram::CSource *source = NULL; IProgram::CSource *source = NULL;
for (uint i = 0; i < program->getSourceNb(); ++i) for (uint i = 0; i < program->getSourceNb(); ++i)
{ {
if (supportPixelProgram(program->getSource(i)->Profile)) if (supportPixelProgram(program->getSource(i)->Profile))

78
code/nel/src/3d/driver/opengl/driver_opengl_uniform.cpp
View file

@ -310,7 +310,7 @@ void CDriverGL::setUniformFog(NL3D::IDriver::TProgram program, uint index)
bool CDriverGL::setUniformDriver(TProgram program) bool CDriverGL::setUniformDriver(TProgram program)
{ {
IGPUProgram *prog = NULL; IProgram *prog = NULL;
switch (program) switch (program)
{ {
case VertexProgram: case VertexProgram:
@ -322,66 +322,66 @@ bool CDriverGL::setUniformDriver(TProgram program)
} }
if (!prog) return false; if (!prog) return false;
const CGPUProgramFeatures &features = prog->features(); const CProgramFeatures &features = prog->features();
if (features.DriverFlags) if (features.DriverFlags)
{ {
if (features.DriverFlags & CGPUProgramFeatures::Matrices) if (features.DriverFlags & CProgramFeatures::Matrices)
{ {
if (prog->getUniformIndex(CGPUProgramIndex::ModelView) != ~0) if (prog->getUniformIndex(CProgramIndex::ModelView) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelView), ModelView, Identity); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelView), ModelView, Identity);
} }
if (prog->getUniformIndex(CGPUProgramIndex::ModelViewInverse) != ~0) if (prog->getUniformIndex(CProgramIndex::ModelViewInverse) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewInverse), ModelView, Inverse); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewInverse), ModelView, Inverse);
} }
if (prog->getUniformIndex(CGPUProgramIndex::ModelViewTranspose) != ~0) if (prog->getUniformIndex(CProgramIndex::ModelViewTranspose) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewTranspose), ModelView, Transpose); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewTranspose), ModelView, Transpose);
} }
if (prog->getUniformIndex(CGPUProgramIndex::ModelViewInverseTranspose) != ~0) if (prog->getUniformIndex(CProgramIndex::ModelViewInverseTranspose) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewInverseTranspose), ModelView, InverseTranspose); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewInverseTranspose), ModelView, InverseTranspose);
} }
if (prog->getUniformIndex(CGPUProgramIndex::Projection) != ~0) if (prog->getUniformIndex(CProgramIndex::Projection) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::Projection), Projection, Identity); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::Projection), Projection, Identity);
} }
if (prog->getUniformIndex(CGPUProgramIndex::ProjectionInverse) != ~0) if (prog->getUniformIndex(CProgramIndex::ProjectionInverse) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ProjectionInverse), Projection, Inverse); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ProjectionInverse), Projection, Inverse);
} }
if (prog->getUniformIndex(CGPUProgramIndex::ProjectionTranspose) != ~0) if (prog->getUniformIndex(CProgramIndex::ProjectionTranspose) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ProjectionTranspose), Projection, Transpose); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ProjectionTranspose), Projection, Transpose);
} }
if (prog->getUniformIndex(CGPUProgramIndex::ProjectionInverseTranspose) != ~0) if (prog->getUniformIndex(CProgramIndex::ProjectionInverseTranspose) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ProjectionInverseTranspose), Projection, InverseTranspose); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ProjectionInverseTranspose), Projection, InverseTranspose);
} }
if (prog->getUniformIndex(CGPUProgramIndex::ModelViewProjection) != ~0) if (prog->getUniformIndex(CProgramIndex::ModelViewProjection) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewProjection), ModelViewProjection, Identity); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewProjection), ModelViewProjection, Identity);
} }
if (prog->getUniformIndex(CGPUProgramIndex::ModelViewProjectionInverse) != ~0) if (prog->getUniformIndex(CProgramIndex::ModelViewProjectionInverse) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewProjectionInverse), ModelViewProjection, Inverse); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewProjectionInverse), ModelViewProjection, Inverse);
} }
if (prog->getUniformIndex(CGPUProgramIndex::ModelViewProjectionTranspose) != ~0) if (prog->getUniformIndex(CProgramIndex::ModelViewProjectionTranspose) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewProjectionTranspose), ModelViewProjection, Transpose); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewProjectionTranspose), ModelViewProjection, Transpose);
} }
if (prog->getUniformIndex(CGPUProgramIndex::ModelViewProjectionInverseTranspose) != ~0) if (prog->getUniformIndex(CProgramIndex::ModelViewProjectionInverseTranspose) != ~0)
{ {
setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewProjectionInverseTranspose), ModelViewProjection, InverseTranspose); setUniformMatrix(program, prog->getUniformIndex(CProgramIndex::ModelViewProjectionInverseTranspose), ModelViewProjection, InverseTranspose);
} }
} }
if (features.DriverFlags & CGPUProgramFeatures::Fog) if (features.DriverFlags & CProgramFeatures::Fog)
{ {
if (prog->getUniformIndex(CGPUProgramIndex::Fog) != ~0) if (prog->getUniformIndex(CProgramIndex::Fog) != ~0)
{ {
setUniformFog(program, prog->getUniformIndex(CGPUProgramIndex::Fog)); setUniformFog(program, prog->getUniformIndex(CProgramIndex::Fog));
} }
} }
} }
@ -391,7 +391,7 @@ bool CDriverGL::setUniformDriver(TProgram program)
bool CDriverGL::setUniformMaterial(TProgram program, CMaterial &material) bool CDriverGL::setUniformMaterial(TProgram program, CMaterial &material)
{ {
IGPUProgram *prog = NULL; IProgram *prog = NULL;
switch (program) switch (program)
{ {
case VertexProgram: case VertexProgram:
@ -403,12 +403,12 @@ bool CDriverGL::setUniformMaterial(TProgram program, CMaterial &material)
} }
if (!prog) return false; if (!prog) return false;
const CGPUProgramFeatures &features = prog->features(); const CProgramFeatures &features = prog->features();
// These are also already set by setupMaterial, so setupMaterial uses setUniformMaterialInternal instead // These are also already set by setupMaterial, so setupMaterial uses setUniformMaterialInternal instead
if (features.MaterialFlags & (CGPUProgramFeatures::TextureStages | CGPUProgramFeatures::TextureMatrices)) if (features.MaterialFlags & (CProgramFeatures::TextureStages | CProgramFeatures::TextureMatrices))
{ {
if (features.MaterialFlags & CGPUProgramFeatures::TextureStages) if (features.MaterialFlags & CProgramFeatures::TextureStages)
{ {
for (uint stage = 0; stage < inlGetNumTextStages(); ++stage) for (uint stage = 0; stage < inlGetNumTextStages(); ++stage)
{ {
@ -427,7 +427,7 @@ bool CDriverGL::setUniformMaterial(TProgram program, CMaterial &material)
} }
if (features.MaterialFlags & CGPUProgramFeatures::TextureMatrices) if (features.MaterialFlags & CProgramFeatures::TextureMatrices)
{ {
// Textures user matrix // Textures user matrix
setupUserTextureMatrix(inlGetNumTextStages(), material); setupUserTextureMatrix(inlGetNumTextStages(), material);
@ -439,7 +439,7 @@ bool CDriverGL::setUniformMaterial(TProgram program, CMaterial &material)
bool CDriverGL::setUniformMaterialInternal(TProgram program, CMaterial &material) bool CDriverGL::setUniformMaterialInternal(TProgram program, CMaterial &material)
{ {
IGPUProgram *prog = NULL; IProgram *prog = NULL;
switch (program) switch (program)
{ {
case VertexProgram: case VertexProgram:
@ -451,9 +451,9 @@ bool CDriverGL::setUniformMaterialInternal(TProgram program, CMaterial &material
} }
if (!prog) return false; if (!prog) return false;
const CGPUProgramFeatures &features = prog->features(); const CProgramFeatures &features = prog->features();
if (features.MaterialFlags & ~(CGPUProgramFeatures::TextureStages | CGPUProgramFeatures::TextureMatrices)) if (features.MaterialFlags & ~(CProgramFeatures::TextureStages | CProgramFeatures::TextureMatrices))
{ {
// none // none
} }
@ -463,7 +463,7 @@ bool CDriverGL::setUniformMaterialInternal(TProgram program, CMaterial &material
void CDriverGL::setUniformParams(TProgram program, CGPUProgramParams &params) void CDriverGL::setUniformParams(TProgram program, CGPUProgramParams &params)
{ {
IGPUProgram *prog = NULL; IProgram *prog = NULL;
switch (program) switch (program)
{ {
case VertexProgram: case VertexProgram:

4
code/nel/src/3d/driver/opengl/driver_opengl_vertex.cpp
View file

@ -1151,7 +1151,7 @@ void CDriverGL::toggleGlArraysForEXTVertexShader()
CVertexProgram *vp = _LastSetuppedVP; CVertexProgram *vp = _LastSetuppedVP;
if (vp) if (vp)
{ {
CVertexProgamDrvInfosGL *drvInfo = NLMISC::safe_cast<CVertexProgamDrvInfosGL *>((IGPUProgramDrvInfos *) vp->m_DrvInfo); CVertexProgamDrvInfosGL *drvInfo = NLMISC::safe_cast<CVertexProgamDrvInfosGL *>((IProgramDrvInfos *) vp->m_DrvInfo);
if (drvInfo) if (drvInfo)
{ {
// Disable all VertexAttribs. // Disable all VertexAttribs.
@ -1396,7 +1396,7 @@ void CDriverGL::setupGlArraysForEXTVertexShader(CVertexBufferInfo &vb)
CVertexProgram *vp = _LastSetuppedVP; CVertexProgram *vp = _LastSetuppedVP;
if (!vp) return; if (!vp) return;
CVertexProgamDrvInfosGL *drvInfo = NLMISC::safe_cast<CVertexProgamDrvInfosGL *>((IGPUProgramDrvInfos *) vp->m_DrvInfo); CVertexProgamDrvInfosGL *drvInfo = NLMISC::safe_cast<CVertexProgamDrvInfosGL *>((IProgramDrvInfos *) vp->m_DrvInfo);
if (!drvInfo) return; if (!drvInfo) return;
uint32 flags= vb.VertexFormat; uint32 flags= vb.VertexFormat;

20
code/nel/src/3d/driver/opengl/driver_opengl_vertex_program.cpp
View file

@ -41,7 +41,7 @@ namespace NLDRIVERGL {
#endif #endif
// *************************************************************************** // ***************************************************************************
CVertexProgamDrvInfosGL::CVertexProgamDrvInfosGL(CDriverGL *drv, ItGPUPrgDrvInfoPtrList it) : IGPUProgramDrvInfos (drv, it) CVertexProgamDrvInfosGL::CVertexProgamDrvInfosGL(CDriverGL *drv, ItGPUPrgDrvInfoPtrList it) : IProgramDrvInfos (drv, it)
{ {
H_AUTO_OGL(CVertexProgamDrvInfosGL_CVertexProgamDrvInfosGL); H_AUTO_OGL(CVertexProgamDrvInfosGL_CVertexProgamDrvInfosGL);
@ -98,7 +98,7 @@ bool CDriverGL::compileNVVertexProgram(CVertexProgram *program)
_VertexProgramEnabled = false; _VertexProgramEnabled = false;
// Find nelvp // Find nelvp
IGPUProgram::CSource *source = NULL; IProgram::CSource *source = NULL;
for (uint i = 0; i < program->getSourceNb(); ++i) for (uint i = 0; i < program->getSourceNb(); ++i)
{ {
if (program->getSource(i)->Profile == CVertexProgram::nelvp) if (program->getSource(i)->Profile == CVertexProgram::nelvp)
@ -130,7 +130,7 @@ bool CDriverGL::compileNVVertexProgram(CVertexProgram *program)
} }
// Insert into driver list. (so it is deleted when driver is deleted). // Insert into driver list. (so it is deleted when driver is deleted).
ItGPUPrgDrvInfoPtrList it = _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IGPUProgramDrvInfos*)NULL); ItGPUPrgDrvInfoPtrList it = _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IProgramDrvInfos*)NULL);
// Create a driver info // Create a driver info
*it = drvInfo = new CVertexProgamDrvInfosGL(this, it); *it = drvInfo = new CVertexProgamDrvInfosGL(this, it);
@ -208,7 +208,7 @@ bool CDriverGL::activeNVVertexProgram(CVertexProgram *program)
if (program) if (program)
{ {
// Driver info // Driver info
CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IGPUProgramDrvInfos*)program->m_DrvInfo); CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IProgramDrvInfos*)program->m_DrvInfo);
nlassert(drvInfo); nlassert(drvInfo);
// Enable vertex program // Enable vertex program
@ -1529,7 +1529,7 @@ bool CDriverGL::compileARBVertexProgram(NL3D::CVertexProgram *program)
_VertexProgramEnabled = false; _VertexProgramEnabled = false;
// Find nelvp // Find nelvp
IGPUProgram::CSource *source = NULL; IProgram::CSource *source = NULL;
for (uint i = 0; i < program->getSourceNb(); ++i) for (uint i = 0; i < program->getSourceNb(); ++i)
{ {
if (program->getSource(i)->Profile == CVertexProgram::nelvp) if (program->getSource(i)->Profile == CVertexProgram::nelvp)
@ -1557,7 +1557,7 @@ bool CDriverGL::compileARBVertexProgram(NL3D::CVertexProgram *program)
return false; return false;
} }
// Insert into driver list. (so it is deleted when driver is deleted). // Insert into driver list. (so it is deleted when driver is deleted).
ItGPUPrgDrvInfoPtrList it = _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IGPUProgramDrvInfos*)NULL); ItGPUPrgDrvInfoPtrList it = _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IProgramDrvInfos*)NULL);
// Create a driver info // Create a driver info
CVertexProgamDrvInfosGL *drvInfo; CVertexProgamDrvInfosGL *drvInfo;
@ -1600,7 +1600,7 @@ bool CDriverGL::activeARBVertexProgram(CVertexProgram *program)
if (program) if (program)
{ {
// Driver info // Driver info
CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IGPUProgramDrvInfos*)program->m_DrvInfo); CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IProgramDrvInfos*)program->m_DrvInfo);
nlassert(drvInfo); nlassert(drvInfo);
glEnable( GL_VERTEX_PROGRAM_ARB ); glEnable( GL_VERTEX_PROGRAM_ARB );
@ -1644,7 +1644,7 @@ bool CDriverGL::compileEXTVertexShader(CVertexProgram *program)
_VertexProgramEnabled = false; _VertexProgramEnabled = false;
// Find nelvp // Find nelvp
IGPUProgram::CSource *source = NULL; IProgram::CSource *source = NULL;
for (uint i = 0; i < program->getSourceNb(); ++i) for (uint i = 0; i < program->getSourceNb(); ++i)
{ {
if (program->getSource(i)->Profile == CVertexProgram::nelvp) if (program->getSource(i)->Profile == CVertexProgram::nelvp)
@ -1684,7 +1684,7 @@ bool CDriverGL::compileEXTVertexShader(CVertexProgram *program)
*/ */
// Insert into driver list. (so it is deleted when driver is deleted). // Insert into driver list. (so it is deleted when driver is deleted).
ItGPUPrgDrvInfoPtrList it= _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IGPUProgramDrvInfos*)NULL); ItGPUPrgDrvInfoPtrList it= _GPUPrgDrvInfos.insert(_GPUPrgDrvInfos.end(), (NL3D::IProgramDrvInfos*)NULL);
// Create a driver info // Create a driver info
CVertexProgamDrvInfosGL *drvInfo; CVertexProgamDrvInfosGL *drvInfo;
@ -1727,7 +1727,7 @@ bool CDriverGL::activeEXTVertexShader(CVertexProgram *program)
if (program) if (program)
{ {
// Driver info // Driver info
CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IGPUProgramDrvInfos*)program->m_DrvInfo); CVertexProgamDrvInfosGL *drvInfo = safe_cast<CVertexProgamDrvInfosGL*>((IProgramDrvInfos*)program->m_DrvInfo);
nlassert(drvInfo); nlassert(drvInfo);
glEnable(GL_VERTEX_SHADER_EXT); glEnable(GL_VERTEX_SHADER_EXT);

4
code/nel/src/3d/landscape.cpp
View file

@ -1207,7 +1207,7 @@ void CLandscape::render(const CVector &refineCenter, const CVector &frontVecto
_TileVB.activateVP(i); _TileVB.activateVP(i);
// c[0..3] take the ModelViewProjection Matrix. // c[0..3] take the ModelViewProjection Matrix.
driver->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity); driver->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity);
// c[4] take useful constants. // c[4] take useful constants.
driver->setUniform4f(IDriver::VertexProgram, program->idx().ProgramConstants0, 0, 1, 0.5f, 0); driver->setUniform4f(IDriver::VertexProgram, program->idx().ProgramConstants0, 0, 1, 0.5f, 0);
// c[5] take RefineCenter // c[5] take RefineCenter
@ -1215,7 +1215,7 @@ void CLandscape::render(const CVector &refineCenter, const CVector &frontVecto
// c[6] take info for Geomorph trnasition to TileNear. // c[6] take info for Geomorph trnasition to TileNear.
driver->setUniform2f(IDriver::VertexProgram, program->idx().TileDist, CLandscapeGlobals::TileDistFarSqr, CLandscapeGlobals::OOTileDistDeltaSqr); driver->setUniform2f(IDriver::VertexProgram, program->idx().TileDist, CLandscapeGlobals::TileDistFarSqr, CLandscapeGlobals::OOTileDistDeltaSqr);
// c[10] take the fog vector. // c[10] take the fog vector.
driver->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::Fog)); driver->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::Fog));
// c[12] take the current landscape Center / delta Pos to apply // c[12] take the current landscape Center / delta Pos to apply
driver->setUniform3f(IDriver::VertexProgram, program->idx().PZBModelPosition, _PZBModelPosition); driver->setUniform3f(IDriver::VertexProgram, program->idx().PZBModelPosition, _PZBModelPosition);
} }

2
code/nel/src/3d/meshvp_per_pixel_light.cpp
View file

@ -555,7 +555,7 @@ bool CMeshVPPerPixelLight::begin(IDriver *drv,
} }
// c[0..3] take the ModelViewProjection Matrix. After setupModelMatrix(); // c[0..3] take the ModelViewProjection Matrix. After setupModelMatrix();
drv->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity); drv->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity);
return true; return true;
} }

4
code/nel/src/3d/meshvp_wind_tree.cpp
View file

@ -315,10 +315,10 @@ inline void CMeshVPWindTree::setupPerInstanceConstants(IDriver *driver, CScene
setupLighting(scene, mbi, invertedModelMat); setupLighting(scene, mbi, invertedModelMat);
// c[0..3] take the ModelViewProjection Matrix. After setupModelMatrix(); // c[0..3] take the ModelViewProjection Matrix. After setupModelMatrix();
driver->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::ModelViewProjection), driver->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::ModelViewProjection),
IDriver::ModelViewProjection, IDriver::Identity); IDriver::ModelViewProjection, IDriver::Identity);
// c[4..7] take the ModelView Matrix. After setupModelMatrix();00 // c[4..7] take the ModelView Matrix. After setupModelMatrix();00
driver->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::Fog)); driver->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::Fog));
// c[15] take Wind of level 0. // c[15] take Wind of level 0.

24
code/nel/src/3d/gpu_program.cpp → code/nel/src/3d/program.cpp
View file

@ -1,9 +1,9 @@
/** /**
* \file gpu_program.cpp * \file program.cpp
* \brief IGPUProgram * \brief IProgram
* \date 2013-09-07 15:00GMT * \date 2013-09-07 15:00GMT
* \author Jan Boon (Kaetemi) * \author Jan Boon (Kaetemi)
* IGPUProgram * IProgram
*/ */
/* /*
@ -26,7 +26,7 @@
*/ */
#include <nel/misc/types_nl.h> #include <nel/misc/types_nl.h>
#include <nel/3d/gpu_program.h> #include <nel/3d/program.h>
// STL includes // STL includes
@ -44,7 +44,7 @@ namespace NL3D {
// *************************************************************************** // ***************************************************************************
IGPUProgramDrvInfos::IGPUProgramDrvInfos(IDriver *drv, ItGPUPrgDrvInfoPtrList it) IProgramDrvInfos::IProgramDrvInfos(IDriver *drv, ItGPUPrgDrvInfoPtrList it)
{ {
_Driver = drv; _Driver = drv;
_DriverIterator = it; _DriverIterator = it;
@ -52,27 +52,27 @@ IGPUProgramDrvInfos::IGPUProgramDrvInfos(IDriver *drv, ItGPUPrgDrvInfoPtrList it
// *************************************************************************** // ***************************************************************************
IGPUProgramDrvInfos::~IGPUProgramDrvInfos () IProgramDrvInfos::~IProgramDrvInfos ()
{ {
_Driver->removeGPUPrgDrvInfoPtr(_DriverIterator); _Driver->removeGPUPrgDrvInfoPtr(_DriverIterator);
} }
// *************************************************************************** // ***************************************************************************
IGPUProgram::IGPUProgram() IProgram::IProgram()
{ {
} }
// *************************************************************************** // ***************************************************************************
IGPUProgram::~IGPUProgram() IProgram::~IProgram()
{ {
// Must kill the drv mirror of this program. // Must kill the drv mirror of this program.
m_DrvInfo.kill(); m_DrvInfo.kill();
} }
const char *CGPUProgramIndex::Names[NUM_UNIFORMS] = const char *CProgramIndex::Names[NUM_UNIFORMS] =
{ {
"modelView", "modelView",
"modelViewInverse", "modelViewInverse",
@ -92,14 +92,14 @@ const char *CGPUProgramIndex::Names[NUM_UNIFORMS] =
"fog", "fog",
}; };
void IGPUProgram::buildInfo(CSource *source) void IProgram::buildInfo(CSource *source)
{ {
nlassert(!m_Source); nlassert(!m_Source);
m_Source = source; m_Source = source;
// Fill index cache // Fill index cache
for (int i = 0; i < CGPUProgramIndex::NUM_UNIFORMS; ++i) for (int i = 0; i < CProgramIndex::NUM_UNIFORMS; ++i)
{ {
m_Index.Indices[i] = getUniformIndex(m_Index.Names[i]); m_Index.Indices[i] = getUniformIndex(m_Index.Names[i]);
} }
@ -107,7 +107,7 @@ void IGPUProgram::buildInfo(CSource *source)
buildInfo(); buildInfo();
} }
void IGPUProgram::buildInfo() void IProgram::buildInfo()
{ {
} }

12
code/nel/src/3d/stereo_debugger.cpp
View file

@ -163,17 +163,17 @@ void CStereoDebugger::setDriver(NL3D::UDriver *driver)
m_PixelProgram = new CPixelProgram(); m_PixelProgram = new CPixelProgram();
// arbfp1 // arbfp1
{ {
IGPUProgram::CSource *source = new IGPUProgram::CSource(); IProgram::CSource *source = new IProgram::CSource();
source->Features.MaterialFlags = CGPUProgramFeatures::TextureStages; source->Features.MaterialFlags = CProgramFeatures::TextureStages;
source->Profile = IGPUProgram::arbfp1; source->Profile = IProgram::arbfp1;
source->setSourcePtr(a_arbfp1); source->setSourcePtr(a_arbfp1);
m_PixelProgram->addSource(source); m_PixelProgram->addSource(source);
} }
// ps_2_0 // ps_2_0
{ {
IGPUProgram::CSource *source = new IGPUProgram::CSource(); IProgram::CSource *source = new IProgram::CSource();
source->Features.MaterialFlags = CGPUProgramFeatures::TextureStages; source->Features.MaterialFlags = CProgramFeatures::TextureStages;
source->Profile = IGPUProgram::ps_2_0; source->Profile = IProgram::ps_2_0;
source->setSourcePtr(a_ps_2_0); source->setSourcePtr(a_ps_2_0);
m_PixelProgram->addSource(source); m_PixelProgram->addSource(source);
} }

8
code/nel/src/3d/stereo_ovr.cpp
View file

@ -251,14 +251,14 @@ public:
{ {
CSource *source = new CSource(); CSource *source = new CSource();
source->Profile = glsl330f; source->Profile = glsl330f;
source->Features.MaterialFlags = CGPUProgramFeatures::TextureStages; source->Features.MaterialFlags = CProgramFeatures::TextureStages;
source->setSourcePtr(g_StereoOVR_glsl330f); source->setSourcePtr(g_StereoOVR_glsl330f);
addSource(source); addSource(source);
} }
{ {
CSource *source = new CSource(); CSource *source = new CSource();
source->Profile = fp40; source->Profile = fp40;
source->Features.MaterialFlags = CGPUProgramFeatures::TextureStages; source->Features.MaterialFlags = CProgramFeatures::TextureStages;
source->setSourcePtr(g_StereoOVR_fp40); source->setSourcePtr(g_StereoOVR_fp40);
source->ParamIndices["cLensCenter"] = 0; source->ParamIndices["cLensCenter"] = 0;
source->ParamIndices["cScreenCenter"] = 1; source->ParamIndices["cScreenCenter"] = 1;
@ -270,7 +270,7 @@ public:
{ {
CSource *source = new CSource(); CSource *source = new CSource();
source->Profile = arbfp1; source->Profile = arbfp1;
source->Features.MaterialFlags = CGPUProgramFeatures::TextureStages; source->Features.MaterialFlags = CProgramFeatures::TextureStages;
source->setSourcePtr(g_StereoOVR_arbfp1); source->setSourcePtr(g_StereoOVR_arbfp1);
source->ParamIndices["cLensCenter"] = 0; source->ParamIndices["cLensCenter"] = 0;
source->ParamIndices["cScreenCenter"] = 1; source->ParamIndices["cScreenCenter"] = 1;
@ -282,7 +282,7 @@ public:
{ {
CSource *source = new CSource(); CSource *source = new CSource();
source->Profile = ps_2_0; source->Profile = ps_2_0;
source->Features.MaterialFlags = CGPUProgramFeatures::TextureStages; source->Features.MaterialFlags = CProgramFeatures::TextureStages;
source->setSourcePtr(g_StereoOVR_ps_2_0); source->setSourcePtr(g_StereoOVR_ps_2_0);
source->ParamIndices["cLensCenter"] = 0; source->ParamIndices["cLensCenter"] = 0;
source->ParamIndices["cScreenCenter"] = 1; source->ParamIndices["cScreenCenter"] = 1;

4
code/nel/src/3d/vegetable_manager.cpp
View file

@ -1872,11 +1872,11 @@ void CVegetableManager::setupVertexProgramConstants(IDriver *driver, bool fogE
// Standard // Standard
// setup VertexProgram constants. // setup VertexProgram constants.
// c[0..3] take the ModelViewProjection Matrix. After setupModelMatrix(); // c[0..3] take the ModelViewProjection Matrix. After setupModelMatrix();
driver->setUniformMatrix(IDriver::VertexProgram, _ActiveVertexProgram->getUniformIndex(CGPUProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity); driver->setUniformMatrix(IDriver::VertexProgram, _ActiveVertexProgram->getUniformIndex(CProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity);
// c[6] take the Fog vector. After setupModelMatrix(); // c[6] take the Fog vector. After setupModelMatrix();
if (fogEnabled) if (fogEnabled)
{ {
driver->setUniformFog(IDriver::VertexProgram, _ActiveVertexProgram->getUniformIndex(CGPUProgramIndex::Fog)); driver->setUniformFog(IDriver::VertexProgram, _ActiveVertexProgram->getUniformIndex(CProgramIndex::Fog));
} }
// c[8] take useful constants. // c[8] take useful constants.
driver->setUniform4f(IDriver::VertexProgram, _ActiveVertexProgram->idx().ProgramConstants0, 0, 1, 0.5f, 2); driver->setUniform4f(IDriver::VertexProgram, _ActiveVertexProgram->idx().ProgramConstants0, 0, 1, 0.5f, 2);

2
code/nel/src/3d/vertex_program.cpp
View file

@ -36,7 +36,7 @@ CVertexProgram::CVertexProgram()
CVertexProgram::CVertexProgram(const char *nelvp) CVertexProgram::CVertexProgram(const char *nelvp)
{ {
CSource *source = new CSource(); CSource *source = new CSource();
source->Profile = IGPUProgram::nelvp; source->Profile = IProgram::nelvp;
source->setSource(nelvp); source->setSource(nelvp);
addSource(source); addSource(source);
} }

2
code/nel/src/3d/water_env_map.cpp
View file

@ -303,7 +303,7 @@ void CWaterEnvMap::renderTestMesh(IDriver &driver)
driver.activeVertexBuffer(_TestVB); driver.activeVertexBuffer(_TestVB);
driver.activeIndexBuffer(_TestIB); driver.activeIndexBuffer(_TestIB);
_MaterialPassThruZTest.setTexture(0, _EnvCubic); _MaterialPassThruZTest.setTexture(0, _EnvCubic);
driver.setUniformMatrix(IDriver::VertexProgram, testMeshVP->getUniformIndex(CGPUProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity); driver.setUniformMatrix(IDriver::VertexProgram, testMeshVP->getUniformIndex(CProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity);
driver.setUniform2f(IDriver::VertexProgram, testMeshVP->idx().ProgramConstant0, 2.f, 1.f); driver.setUniform2f(IDriver::VertexProgram, testMeshVP->idx().ProgramConstant0, 2.f, 1.f);
//driver.renderTriangles(testMat, 0, TEST_VB_NUM_TRIS); //driver.renderTriangles(testMat, 0, TEST_VB_NUM_TRIS);
driver.renderTriangles(_MaterialPassThruZTest, 0, TEST_VB_NUM_TRIS); driver.renderTriangles(_MaterialPassThruZTest, 0, TEST_VB_NUM_TRIS);

4
code/nel/src/3d/water_model.cpp
View file

@ -958,8 +958,8 @@ void CWaterModel::setupMaterialNVertexShader(IDriver *drv, CWaterShape *shape, c
drv->setUniform4f(IDriver::VertexProgram, program->idx().DiffuseMapVector1, _ColorMapMatColumn0.y, _ColorMapMatColumn1.y, 0, _ColorMapMatColumn0.y * obsPos.x + _ColorMapMatColumn1.y * obsPos.y + _ColorMapMatPos.y); drv->setUniform4f(IDriver::VertexProgram, program->idx().DiffuseMapVector1, _ColorMapMatColumn0.y, _ColorMapMatColumn1.y, 0, _ColorMapMatColumn0.y * obsPos.x + _ColorMapMatColumn1.y * obsPos.y + _ColorMapMatPos.y);
} }
// set builtins // set builtins
drv->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity); drv->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity);
drv->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::Fog)); drv->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::Fog));
// retrieve current time // retrieve current time
double date = scene->getCurrentTime(); double date = scene->getCurrentTime();
// set bumpmaps pos // set bumpmaps pos

2
code/ryzom/client/src/decal.cpp
View file

@ -373,7 +373,7 @@ void CDecal::renderTriCache(NL3D::IDriver &drv, NL3D::CShadowPolyReceiver &/*
memcpy(vba.getVertexCoordPointer(), &_TriCache[0], sizeof(CRGBAVertex) * _TriCache.size()); memcpy(vba.getVertexCoordPointer(), &_TriCache[0], sizeof(CRGBAVertex) * _TriCache.size());
} }
drv.activeVertexBuffer(_VB); drv.activeVertexBuffer(_VB);
drv.setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::ModelViewProjection), NL3D::IDriver::ModelViewProjection, NL3D::IDriver::Identity); drv.setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CProgramIndex::ModelViewProjection), NL3D::IDriver::ModelViewProjection, NL3D::IDriver::Identity);
drv.setUniform4f(IDriver::VertexProgram, program->idx().WorldToUV0, _WorldToUVMatrix[0][0], _WorldToUVMatrix[1][0], _WorldToUVMatrix[2][0], _WorldToUVMatrix[3][0]); drv.setUniform4f(IDriver::VertexProgram, program->idx().WorldToUV0, _WorldToUVMatrix[0][0], _WorldToUVMatrix[1][0], _WorldToUVMatrix[2][0], _WorldToUVMatrix[3][0]);
drv.setUniform4f(IDriver::VertexProgram, program->idx().WorldToUV1, _WorldToUVMatrix[0][1], _WorldToUVMatrix[1][1], _WorldToUVMatrix[2][1], _WorldToUVMatrix[3][1]); drv.setUniform4f(IDriver::VertexProgram, program->idx().WorldToUV1, _WorldToUVMatrix[0][1], _WorldToUVMatrix[1][1], _WorldToUVMatrix[2][1], _WorldToUVMatrix[3][1]);
drv.setUniform4f(IDriver::VertexProgram, program->idx().Diffuse, _Diffuse.R * (1.f / 255.f), _Diffuse.G * (1.f / 255.f), _Diffuse.B * (1.f / 255.f), 1.f); drv.setUniform4f(IDriver::VertexProgram, program->idx().Diffuse, _Diffuse.R * (1.f / 255.f), _Diffuse.G * (1.f / 255.f), _Diffuse.B * (1.f / 255.f), 1.f);