Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity

Adjust landscape vertex program to use new interface

Browse source 
--HG--
branch : multipass-stereo
This commit is contained in:
kaetemi 2013-09-10 15:42:42 +02:00
parent 5ad617efb6
commit abafc9b1ef
12 changed files with 199 additions and 256 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -1202,6 +1202,8 @@ public:
virtual bool setUniformDriver(TProgram program) = 0; // set all driver-specific features params (based on program->features->DriverFlags) (called automatically when rendering with cmaterial and using a user program) virtual bool setUniformDriver(TProgram program) = 0; // set all driver-specific features params (based on program->features->DriverFlags) (called automatically when rendering with cmaterial and using a user program)
virtual bool setUniformMaterial(TProgram program, CMaterial &material) = 0; // set all material-specific feature params (based on program->features->MaterialFlags) (called automatically when rendering with cmaterial and using a user program) virtual bool setUniformMaterial(TProgram program, CMaterial &material) = 0; // set all material-specific feature params (based on program->features->MaterialFlags) (called automatically when rendering with cmaterial and using a user program)
virtual void setUniformParams(TProgram program, CGPUProgramParams &params) = 0; // set all user-provided params from the storage virtual void setUniformParams(TProgram program, CGPUProgramParams &params) = 0; // set all user-provided params from the storage
// Return true if uniforms are kept as program state and switched together with programs, false if uniforms are driver state and stay accross program switches.
virtual bool isUniformProgramState() = 0;
// @} // @}

98
code/nel/include/nel/3d/gpu_program.h
View file

@ -60,12 +60,13 @@ public:
virtual uint getUniformIndex(const char *name) const = 0; virtual uint getUniformIndex(const char *name) const = 0;
}; };
#define NL_GPU_PROGRAM_LIGHTS 8 // Features exposed by a program. Used to set builtin parameters on user provided shaders.
// This is only used for user provided shaders, not for builtin shaders,
/// Features exposed by a program. Used to set builtin parameters on user provided shaders // as it is a slow method which has to go through all of the options every time.
// Builtin shaders should set all flags to 0.
struct CGPUProgramFeatures struct CGPUProgramFeatures
{ {
CGPUProgramFeatures() : DriverFlags(0), MaterialFlags(0) /*, NumLights(0) */ { } CGPUProgramFeatures() : DriverFlags(0), MaterialFlags(0) { }
// Driver builtin parameters // Driver builtin parameters
enum TDriverFlags enum TDriverFlags
@ -73,11 +74,11 @@ struct CGPUProgramFeatures
// Matrices // Matrices
ModelView = 0x00000001, ModelView = 0x00000001,
ModelViewInverse = 0x00000002, ModelViewInverse = 0x00000002,
ModelViewTranspose = 0x00000004, ModelViewTranspose = 0x00000004,
ModelViewInverseTranspose = 0x00000008, ModelViewInverseTranspose = 0x00000008,
Projection = 0x00000010, Projection = 0x00000010,
ProjectionInverse = 0x00000020, ProjectionInverse = 0x00000020,
ProjectionTranspose = 0x00000040, ProjectionTranspose = 0x00000040,
ProjectionInverseTranspose = 0x00000080, ProjectionInverseTranspose = 0x00000080,
@ -88,84 +89,54 @@ struct CGPUProgramFeatures
// Fog // Fog
Fog = 0x00001000, Fog = 0x00001000,
//
// Rough example, modify as necessary.
//
// Lighting (todo)
/// Driver ambient, must be ignored when material ambient is flagged
//DriverAmbient = 0x00001000,
/// Lights, does not set diffuses if material lights is flagged
//DriverLights = 0x00002000,
// etcetera
// Fog (todo)
// Fog = ...,
}; };
uint32 DriverFlags; uint32 DriverFlags;
// uint NumLights; // number of lights supported by the program (not used yet, modify as necessary) // uint NumLights;
enum TMaterialFlags enum TMaterialFlags
{ {
/// Use the CMaterial texture stages as the textures for a Pixel Program /// Use the CMaterial texture stages as the textures for a Pixel Program
TextureStages = 0x00000001, // <- don't remove this one, it's already used, if you want to split them up into the different stages, then it's ok to change it TextureStages = 0x00000001,
TextureMatrices = 0x00000002, TextureMatrices = 0x00000002,
//
// Rough example, modify as necessary.
//
// Lighting (todo)
/// Material ambient premultiplied with driver ambient
//MaterialAmbient = 0x00000002,
/// Premultiply lights diffuse with material diffuse, requires driver lights to be flagged
//MaterialLights = 0x00000004,
// etcetera
// Add all necessary feature sets used with builtin materials here
}; };
// Material builtin parameters // Material builtin parameters
uint32 MaterialFlags; uint32 MaterialFlags;
}; };
/// Stucture used to cache the indices of builtin parameters // Stucture used to cache the indices of builtin parameters which are used by the drivers
struct CGPUProgramIndices // Not used for parameters of specific nl3d programs
struct CGPUProgramIndex
{ {
uint ModelView; enum TName
uint ModelViewInverse; {
uint ModelViewTranspose; ModelView,
uint ModelViewInverseTranspose; ModelViewInverse,
ModelViewTranspose,
ModelViewInverseTranspose,
uint Projection; Projection,
uint ProjectionInverse; ProjectionInverse,
uint ProjectionTranspose; ProjectionTranspose,
uint ProjectionInverseTranspose; ProjectionInverseTranspose,
uint ModelViewProjection; ModelViewProjection,
uint ModelViewProjectionInverse; ModelViewProjectionInverse,
uint ModelViewProjectionTranspose; ModelViewProjectionTranspose,
uint ModelViewProjectionInverseTranspose; ModelViewProjectionInverseTranspose,
uint Fog; Fog,
// NUM_UNIFORMS
// Rough example, modify as necessary. };
// static const char *Names[NUM_UNIFORMS];
//uint Ambient; uint Indices[NUM_UNIFORMS];
//uint LightType[NL_GPU_PROGRAM_LIGHTS];
//uint LightAmbient[NL_GPU_PROGRAM_LIGHTS];
//uint LightDiffuse[NL_GPU_PROGRAM_LIGHTS];
//uint LightPosition[NL_GPU_PROGRAM_LIGHTS];
//uint LightDirection[NL_GPU_PROGRAM_LIGHTS];
}; };
/** /**
* \brief IGPUProgram * \brief IGPUProgram
* \date 2013-09-07 15:00GMT * \date 2013-09-07 15:00GMT
* \author Jan Boon (Kaetemi) * \author Jan Boon (Kaetemi)
* A compiled GPU program * A generic GPU program
*/ */
class IGPUProgram : public NLMISC::CRefCount class IGPUProgram : public NLMISC::CRefCount
{ {
@ -234,6 +205,7 @@ public:
const char *SourcePtr; const char *SourcePtr;
size_t SourceLen; size_t SourceLen;
/// Copy the source code string /// Copy the source code string
inline void setSource(const std::string &source) { SourceCopy = source; SourcePtr = &SourceCopy[0]; SourceLen = SourceCopy.size(); }
inline void setSource(const char *source) { SourceCopy = source; SourcePtr = &SourceCopy[0]; SourceLen = SourceCopy.size(); } inline void setSource(const char *source) { SourceCopy = source; SourcePtr = &SourceCopy[0]; SourceLen = SourceCopy.size(); }
/// Set pointer to source code string without copying the string /// Set pointer to source code string without copying the string
inline void setSourcePtr(const char *sourcePtr, size_t sourceLen) { SourceCopy.clear(); SourcePtr = sourcePtr; SourceLen = sourceLen; } inline void setSourcePtr(const char *sourcePtr, size_t sourceLen) { SourceCopy.clear(); SourcePtr = sourcePtr; SourceLen = sourceLen; }
@ -262,11 +234,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(CGPUProgramIndex::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 CGPUProgramFeatures &features() const { return m_Source->Features; };
inline const CGPUProgramIndices &indices() const { return m_Indices; };
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
@ -281,7 +253,7 @@ protected:
/// The source used for compilation /// The source used for compilation
NLMISC::CSmartPtr<CSource> m_Source; NLMISC::CSmartPtr<CSource> m_Source;
CGPUProgramIndices m_Indices; CGPUProgramIndex m_Index;
public: public:
/// The driver information. For the driver implementation only. /// The driver information. For the driver implementation only.

26
code/nel/include/nel/3d/landscapevb_allocator.h
View file

@ -21,6 +21,7 @@
#include "nel/misc/smart_ptr.h" #include "nel/misc/smart_ptr.h"
#include "nel/3d/tessellation.h" #include "nel/3d/tessellation.h"
#include "nel/3d/vertex_buffer.h" #include "nel/3d/vertex_buffer.h"
#include "nel/3d/vertex_program.h"
namespace NL3D namespace NL3D
@ -41,6 +42,7 @@ class CVertexProgram;
#define NL3D_LANDSCAPE_VPPOS_DELTAPOS (CVertexBuffer::TexCoord3) #define NL3D_LANDSCAPE_VPPOS_DELTAPOS (CVertexBuffer::TexCoord3)
#define NL3D_LANDSCAPE_VPPOS_ALPHAINFO (CVertexBuffer::TexCoord4) #define NL3D_LANDSCAPE_VPPOS_ALPHAINFO (CVertexBuffer::TexCoord4)
class CVertexProgramLandscape;
// *************************************************************************** // ***************************************************************************
/** /**
@ -107,6 +109,8 @@ public:
* Give a vertexProgram Id to activate. Always 0, but 1 For tile Lightmap Pass. * Give a vertexProgram Id to activate. Always 0, but 1 For tile Lightmap Pass.
*/ */
void activate(uint vpId); void activate(uint vpId);
void activateVP(uint vpId);
inline CVertexProgramLandscape *getVP(uint vpId) const { return _VertexProgram[vpId]; }
// @} // @}
@ -151,15 +155,35 @@ private:
/// \name Vertex Program mgt . /// \name Vertex Program mgt .
// @{ // @{
public:
enum {MaxVertexProgram= 2,}; enum {MaxVertexProgram= 2,};
// Vertex Program , NULL if not enabled. // Vertex Program , NULL if not enabled.
CVertexProgram *_VertexProgram[MaxVertexProgram]; private:
NLMISC::CSmartPtr<CVertexProgramLandscape> _VertexProgram[MaxVertexProgram];
void deleteVertexProgram(); void deleteVertexProgram();
void setupVBFormatAndVertexProgram(bool withVertexProgram); void setupVBFormatAndVertexProgram(bool withVertexProgram);
// @} // @}
}; };
class CVertexProgramLandscape : public CVertexProgram
{
public:
struct CIdx
{
uint ProgramConstants0;
uint RefineCenter;
uint TileDist;
uint PZBModelPosition;
};
CVertexProgramLandscape(CLandscapeVBAllocator::TType type, bool lightMap = false);
virtual ~CVertexProgramLandscape() { }
virtual void buildInfo();
public:
const CIdx &idx() const { return m_Idx; }
CIdx m_Idx;
};
} // NL3D } // NL3D

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

@ -1211,6 +1211,7 @@ public:
virtual bool setUniformDriver(TProgram program); // set all driver-specific features params (based on program->features->DriverFlags) virtual bool setUniformDriver(TProgram program); // set all driver-specific features params (based on program->features->DriverFlags)
virtual bool setUniformMaterial(TProgram program, CMaterial &material); // set all material-specific feature params (based on program->features->MaterialFlags) virtual bool setUniformMaterial(TProgram program, CMaterial &material); // set all material-specific feature params (based on program->features->MaterialFlags)
virtual void setUniformParams(TProgram program, CGPUProgramParams &params); // set all user-provided params from the storage virtual void setUniformParams(TProgram program, CGPUProgramParams &params); // set all user-provided params from the storage
virtual bool isUniformProgramState() { return false; }
// @} // @}

2
code/nel/src/3d/driver/direct3d/driver_direct3d_uniform.cpp
View file

@ -222,7 +222,7 @@ bool CDriverD3D::setUniformDriver(TProgram program)
return true; return true;
} }
bool CDriverD3D::setUniformMaterial(TProgram program, const CMaterial &material) bool CDriverD3D::setUniformMaterial(TProgram program, CMaterial &material)
{ {
// todo // todo

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

@ -1418,6 +1418,7 @@ private:
virtual bool setUniformMaterial(TProgram program, CMaterial &material); // set all material-specific feature params (based on program->features->MaterialFlags) virtual bool setUniformMaterial(TProgram program, CMaterial &material); // set all material-specific feature params (based on program->features->MaterialFlags)
bool setUniformMaterialInternal(TProgram program, CMaterial &material); // set all material-specific feature params (based on program->features->MaterialFlags) bool setUniformMaterialInternal(TProgram program, CMaterial &material); // set all material-specific feature params (based on program->features->MaterialFlags)
virtual void setUniformParams(TProgram program, CGPUProgramParams &params); // set all user-provided params from the storage virtual void setUniformParams(TProgram program, CGPUProgramParams &params); // set all user-provided params from the storage
virtual bool isUniformProgramState() { return false; }
// @} // @}

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

@ -311,55 +311,55 @@ bool CDriverGL::setUniformDriver(TProgram program)
{ {
if (features.DriverFlags & CGPUProgramFeatures::ModelView) if (features.DriverFlags & CGPUProgramFeatures::ModelView)
{ {
setUniformMatrix(program, prog->indices().ModelView, ModelView, Identity); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelView), ModelView, Identity);
} }
if (features.DriverFlags & CGPUProgramFeatures::ModelViewInverse) if (features.DriverFlags & CGPUProgramFeatures::ModelViewInverse)
{ {
setUniformMatrix(program, prog->indices().ModelViewInverse, ModelView, Inverse); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewInverse), ModelView, Inverse);
} }
if (features.DriverFlags & CGPUProgramFeatures::ModelViewTranspose) if (features.DriverFlags & CGPUProgramFeatures::ModelViewTranspose)
{ {
setUniformMatrix(program, prog->indices().ModelViewTranspose, ModelView, Transpose); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewTranspose), ModelView, Transpose);
} }
if (features.DriverFlags & CGPUProgramFeatures::ModelViewInverseTranspose) if (features.DriverFlags & CGPUProgramFeatures::ModelViewInverseTranspose)
{ {
setUniformMatrix(program, prog->indices().ModelViewInverseTranspose, ModelView, InverseTranspose); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewInverseTranspose), ModelView, InverseTranspose);
} }
if (features.DriverFlags & CGPUProgramFeatures::Projection) if (features.DriverFlags & CGPUProgramFeatures::Projection)
{ {
setUniformMatrix(program, prog->indices().Projection, Projection, Identity); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::Projection), Projection, Identity);
} }
if (features.DriverFlags & CGPUProgramFeatures::ProjectionInverse) if (features.DriverFlags & CGPUProgramFeatures::ProjectionInverse)
{ {
setUniformMatrix(program, prog->indices().ProjectionInverse, Projection, Inverse); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ProjectionInverse), Projection, Inverse);
} }
if (features.DriverFlags & CGPUProgramFeatures::ProjectionTranspose) if (features.DriverFlags & CGPUProgramFeatures::ProjectionTranspose)
{ {
setUniformMatrix(program, prog->indices().ProjectionTranspose, Projection, Transpose); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ProjectionTranspose), Projection, Transpose);
} }
if (features.DriverFlags & CGPUProgramFeatures::ProjectionInverseTranspose) if (features.DriverFlags & CGPUProgramFeatures::ProjectionInverseTranspose)
{ {
setUniformMatrix(program, prog->indices().ProjectionInverseTranspose, Projection, InverseTranspose); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ProjectionInverseTranspose), Projection, InverseTranspose);
} }
if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjection) if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjection)
{ {
setUniformMatrix(program, prog->indices().ModelViewProjection, ModelViewProjection, Identity); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewProjection), ModelViewProjection, Identity);
} }
if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjectionInverse) if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjectionInverse)
{ {
setUniformMatrix(program, prog->indices().ModelViewProjectionInverse, ModelViewProjection, Inverse); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewProjectionInverse), ModelViewProjection, Inverse);
} }
if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjectionTranspose) if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjectionTranspose)
{ {
setUniformMatrix(program, prog->indices().ModelViewProjectionTranspose, ModelViewProjection, Transpose); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewProjectionTranspose), ModelViewProjection, Transpose);
} }
if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjectionInverseTranspose) if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjectionInverseTranspose)
{ {
setUniformMatrix(program, prog->indices().ModelViewProjectionInverseTranspose, ModelViewProjection, InverseTranspose); setUniformMatrix(program, prog->getUniformIndex(CGPUProgramIndex::ModelViewProjectionInverseTranspose), ModelViewProjection, InverseTranspose);
} }
if (features.DriverFlags & CGPUProgramFeatures::Fog) if (features.DriverFlags & CGPUProgramFeatures::Fog)
{ {
setUniformFog(program, prog->indices().Fog); setUniformFog(program, prog->getUniformIndex(CGPUProgramIndex::Fog));
} }
} }
@ -432,7 +432,7 @@ bool CDriverGL::setUniformMaterialInternal(TProgram program, CMaterial &material
if (features.MaterialFlags & ~(CGPUProgramFeatures::TextureStages | CGPUProgramFeatures::TextureMatrices)) if (features.MaterialFlags & ~(CGPUProgramFeatures::TextureStages | CGPUProgramFeatures::TextureMatrices))
{ {
// todo // none
} }
return true; return true;

154
code/nel/src/3d/gpu_program.cpp
View file

@ -72,6 +72,26 @@ IGPUProgram::~IGPUProgram()
m_DrvInfo.kill(); m_DrvInfo.kill();
} }
const char *CGPUProgramIndex::Names[NUM_UNIFORMS] =
{
"modelView",
"modelViewInverse",
"modelViewTranspose",
"modelViewInverseTranspose",
"projection",
"projectionInverse",
"projectionTranspose",
"projectionInverseTranspose",
"modelViewProjection",
"modelViewProjectionInverse",
"modelViewProjectionTranspose",
"modelViewProjectionInverseTranspose",
"fog",
};
void IGPUProgram::buildInfo(CSource *source) void IGPUProgram::buildInfo(CSource *source)
{ {
nlassert(!m_Source); nlassert(!m_Source);
@ -79,140 +99,10 @@ void IGPUProgram::buildInfo(CSource *source)
m_Source = source; m_Source = source;
// Fill index cache // Fill index cache
CGPUProgramFeatures &features = m_Source->Features; for (int i = 0; i < CGPUProgramIndex::NUM_UNIFORMS; ++i)
TProfile profile = m_Source->Profile; // for special cases
if (features.DriverFlags & CGPUProgramFeatures::ModelView)
{ {
m_Indices.ModelView = getUniformIndex("modelView"); m_Index.Indices[i] = getUniformIndex(m_Index.Names[i]);
if (m_Indices.ModelView == ~0)
{
nlwarning("Missing 'modelView' in gpu program '%s', ModelView disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ModelView;
}
} }
if (features.DriverFlags & CGPUProgramFeatures::ModelViewInverse)
{
m_Indices.ModelViewInverse = getUniformIndex("modelViewInverse");
if (m_Indices.ModelViewInverse == ~0)
{
nlwarning("Missing 'modelViewInverse' in gpu program '%s', ModelViewInverse disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ModelViewInverse;
}
}
if (features.DriverFlags & CGPUProgramFeatures::ModelViewTranspose)
{
m_Indices.ModelViewTranspose = getUniformIndex("modelViewTranspose");
if (m_Indices.ModelViewTranspose == ~0)
{
nlwarning("Missing 'modelViewTranspose' in gpu program '%s', ModelViewTranspose disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ModelViewTranspose;
}
}
if (features.DriverFlags & CGPUProgramFeatures::ModelViewInverseTranspose)
{
m_Indices.ModelViewInverseTranspose = getUniformIndex("modelViewInverseTranspose");
if (m_Indices.ModelViewInverseTranspose == ~0)
{
nlwarning("Missing 'modelViewInverseTranspose' in gpu program '%s', ModelViewInverseTranspose disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ModelViewInverseTranspose;
}
}
if (features.DriverFlags & CGPUProgramFeatures::Projection)
{
m_Indices.Projection = getUniformIndex("projection");
if (m_Indices.Projection == ~0)
{
nlwarning("Missing 'projection' in gpu program '%s', Projection disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::Projection;
}
}
if (features.DriverFlags & CGPUProgramFeatures::ProjectionInverse)
{
m_Indices.ProjectionInverse = getUniformIndex("projectionInverse");
if (m_Indices.ProjectionInverse == ~0)
{
nlwarning("Missing 'projectionInverse' in gpu program '%s', ProjectionInverse disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ProjectionInverse;
}
}
if (features.DriverFlags & CGPUProgramFeatures::ProjectionTranspose)
{
m_Indices.ProjectionTranspose = getUniformIndex("projectionTranspose");
if (m_Indices.ProjectionTranspose == ~0)
{
nlwarning("Missing 'projectionTranspose' in gpu program '%s', ProjectionTranspose disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ProjectionTranspose;
}
}
if (features.DriverFlags & CGPUProgramFeatures::ProjectionInverseTranspose)
{
m_Indices.ProjectionInverseTranspose = getUniformIndex("projectionInverseTranspose");
if (m_Indices.ProjectionInverseTranspose == ~0)
{
nlwarning("Missing 'projectionInverseTranspose' in gpu program '%s', ProjectionInverseTranspose disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ProjectionInverseTranspose;
}
}
if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjection)
{
m_Indices.ModelViewProjection = getUniformIndex("modelViewProjection");
if (m_Indices.ModelViewProjection == ~0)
{
nlwarning("Missing 'modelViewProjection' in gpu program '%s', ModelViewProjection disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ModelViewProjection;
}
}
if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjectionInverse)
{
m_Indices.ModelViewProjectionInverse = getUniformIndex("modelViewProjectionInverse");
if (m_Indices.ModelViewProjectionInverse == ~0)
{
nlwarning("Missing 'modelViewProjectionInverse' in gpu program '%s', ModelViewProjectionInverse disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ModelViewProjectionInverse;
}
}
if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjectionTranspose)
{
m_Indices.ModelViewProjectionTranspose = getUniformIndex("modelViewProjectionTranspose");
if (m_Indices.ModelViewProjectionTranspose == ~0)
{
nlwarning("Missing 'modelViewProjectionTranspose' in gpu program '%s', ModelViewProjectionTranspose disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ModelViewProjectionTranspose;
}
}
if (features.DriverFlags & CGPUProgramFeatures::ModelViewProjectionInverseTranspose)
{
m_Indices.ModelViewProjectionInverseTranspose = getUniformIndex("modelViewProjectionInverseTranspose");
if (m_Indices.ModelViewProjectionInverseTranspose == ~0)
{
nlwarning("Missing 'modelViewProjectionInverseTranspose' in gpu program '%s', ModelViewProjectionInverseTranspose disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::ModelViewProjectionInverseTranspose;
}
}
if (features.DriverFlags & CGPUProgramFeatures::Fog)
{
m_Indices.Fog = getUniformIndex("fog");
if (m_Indices.Fog == ~0)
{
nlwarning("Missing 'fog' in gpu program '%s', Fog disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::Fog;
}
}
//
// Rough example, modify as necessary.
//
/*if (features.DriverFlags & CGPUProgramFeatures::DriverAmbient || features.MaterialFlags & CGPUProgramFeatures::MaterialAmbient)
{
m_Indices.Ambient = getUniformIndex("nlAmbient");
if (m_Indices.Ambient == ~0)
{
nlwarning("Missing 'nlAmbient' in gpu program '%s', Ambient disabled", source->DisplayName.c_str());
features.DriverFlags &= ~CGPUProgramFeatures::DriverAmbient;
features.MaterialFlags &= ~CGPUProgramFeatures::MaterialAmbient;
}
}*/
buildInfo(); buildInfo();
} }

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

@ -1193,20 +1193,29 @@ void CLandscape::render(const CVector &refineCenter, const CVector &frontVecto
// If VertexShader enabled, setup VertexProgram Constants. // If VertexShader enabled, setup VertexProgram Constants.
if(_VertexShaderOk) if (_VertexShaderOk)
{ {
// c[0..3] take the ModelViewProjection Matrix. bool uprogstate = driver->isUniformProgramState();
driver->setConstantMatrix(0, IDriver::ModelViewProjection, IDriver::Identity); uint nbvp = uprogstate ? CLandscapeVBAllocator::MaxVertexProgram : 1;
// c[4] take useful constants. for (uint i = 0; i < nbvp; ++i)
driver->setConstant(4, 0, 1, 0.5f, 0); {
// c[5] take RefineCenter // activate the program to set the uniforms in the program state for all programs
driver->setConstant(5, refineCenter); // note: when uniforms are driver state, the indices must be the same across programs
// c[6] take info for Geomorph trnasition to TileNear. if (uprogstate) _TileVB.activateVP(i);
driver->setConstant(6, CLandscapeGlobals::TileDistFarSqr, CLandscapeGlobals::OOTileDistDeltaSqr, 0, 0); CVertexProgramLandscape *program = _TileVB.getVP(i);
// c[10] take the fog vector. // c[0..3] take the ModelViewProjection Matrix.
driver->setConstantFog(10); driver->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity);
// c[12] take the current landscape Center / delta Pos to apply // c[4] take useful constants.
driver->setConstant(12, _PZBModelPosition); driver->setUniform4f(IDriver::VertexProgram, program->idx().ProgramConstants0, 0, 1, 0.5f, 0);
// c[5] take RefineCenter
driver->setuniform3f(IDriver::VertexProgram, program->idx().RefineCenter, refineCenter);
// c[6] take info for Geomorph trnasition to TileNear.
driver->setUniform2f(IDriver::VertexProgram, program->idx().TileDist, CLandscapeGlobals::TileDistFarSqr, CLandscapeGlobals::OOTileDistDeltaSqr);
// c[10] take the fog vector.
driver->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::Fog));
// c[12] take the current landscape Center / delta Pos to apply
driver->setUniform3f(IDriver::VertexProgram, program->idx().PZBModelPosition, _PZBModelPosition);
}
} }

96
code/nel/src/3d/landscapevb_allocator.cpp
View file

@ -247,14 +247,23 @@ void CLandscapeVBAllocator::activate(uint vpId)
nlassert(_Driver); nlassert(_Driver);
nlassert(!_BufferLocked); nlassert(!_BufferLocked);
activateVP(vpId);
_Driver->activeVertexBuffer(_VB);
}
// ***************************************************************************
void CLandscapeVBAllocator::activateVP(uint vpId)
{
nlassert(_Driver);
// If enabled, activate Vertex program first. // If enabled, activate Vertex program first.
if(_VertexProgram[vpId]) if (_VertexProgram[vpId])
{ {
//nlinfo("\nSTARTVP\n%s\nENDVP\n", _VertexProgram[vpId]->getProgram().c_str()); //nlinfo("\nSTARTVP\n%s\nENDVP\n", _VertexProgram[vpId]->getProgram().c_str());
nlverify(_Driver->activeVertexProgram(_VertexProgram[vpId])); nlverify(_Driver->activeVertexProgram(_VertexProgram[vpId]));
} }
_Driver->activeVertexBuffer(_VB);
} }
@ -516,12 +525,11 @@ const char* NL3D_LandscapeTileLightMapEndProgram=
// *************************************************************************** // ***************************************************************************
void CLandscapeVBAllocator::deleteVertexProgram() void CLandscapeVBAllocator::deleteVertexProgram()
{ {
for(uint i=0;i<MaxVertexProgram;i++) for (uint i = 0; i < MaxVertexProgram; ++i)
{ {
if(_VertexProgram[i]) if (_VertexProgram[i])
{ {
delete _VertexProgram[i]; _VertexProgram[i] = NULL; // smartptr
_VertexProgram[i]= NULL;
} }
} }
} }
@ -560,10 +568,7 @@ void CLandscapeVBAllocator::setupVBFormatAndVertexProgram(bool withVertexProgr
_VB.initEx(); _VB.initEx();
// Init the Vertex Program. // Init the Vertex Program.
string vpgram= string(NL3D_LandscapeCommonStartProgram) + _VertexProgram[0]= new CVertexProgramLandscape(Far0);
string(NL3D_LandscapeFar0EndProgram);
_VertexProgram[0]= new CVertexProgram(vpgram.c_str());
// TODO_VP_GLSL
} }
else if(_Type==Far1) else if(_Type==Far1)
{ {
@ -578,10 +583,7 @@ void CLandscapeVBAllocator::setupVBFormatAndVertexProgram(bool withVertexProgr
_VB.initEx(); _VB.initEx();
// Init the Vertex Program. // Init the Vertex Program.
string vpgram= string(NL3D_LandscapeCommonStartProgram) + _VertexProgram[0] = new CVertexProgramLandscape(Far1);
string(NL3D_LandscapeFar1EndProgram);
_VertexProgram[0]= new CVertexProgram(vpgram.c_str());
// TODO_VP_GLSL
} }
else else
{ {
@ -596,22 +598,70 @@ void CLandscapeVBAllocator::setupVBFormatAndVertexProgram(bool withVertexProgr
_VB.initEx(); _VB.initEx();
// Init the Vertex Program. // Init the Vertex Program.
string vpgram= string(NL3D_LandscapeCommonStartProgram) + _VertexProgram[0] = new CVertexProgramLandscape(Tile, false);
string(NL3D_LandscapeTileEndProgram);
_VertexProgram[0]= new CVertexProgram(vpgram.c_str());
// TODO_VP_GLSL
// Init the Vertex Program for lightmap pass // Init the Vertex Program for lightmap pass
vpgram= string(NL3D_LandscapeCommonStartProgram) + _VertexProgram[1] = new CVertexProgramLandscape(Tile, true);
string(NL3D_LandscapeTileLightMapEndProgram);
_VertexProgram[1]= new CVertexProgram(vpgram.c_str());
// TODO_VP_GLSL
} }
} }
} }
CVertexProgramLandscape::CVertexProgramLandscape(CLandscapeVBAllocator::TType type, bool lightMap)
{
// nelvp
{
CSource *source = new CSource();
source->Profile = nelvp;
source->DisplayName = "Landscape/nelvp";
switch (type)
{
case CLandscapeVBAllocator::Far0:
source->DisplayName += "/far0";
source->setSource(std::string(NL3D_LandscapeCommonStartProgram)
+ std::string(NL3D_LandscapeFar0EndProgram));
break;
case CLandscapeVBAllocator::Far1:
source->DisplayName += "/far1";
source->setSource(std::string(NL3D_LandscapeCommonStartProgram)
+ std::string(NL3D_LandscapeFar1EndProgram));
break;
case CLandscapeVBAllocator::Tile:
source->DisplayName += "/tile";
if (lightMap)
{
source->DisplayName += "/lightmap";
source->setSource(std::string(NL3D_LandscapeCommonStartProgram)
+ std::string(NL3D_LandscapeTileLightMapEndProgram));
}
else
{
source->setSource(std::string(NL3D_LandscapeCommonStartProgram)
+ std::string(NL3D_LandscapeTileEndProgram));
}
break;
}
source->ParamIndices["modelViewProjection"] = 0;
source->ParamIndices["programConstants0"] = 4;
source->ParamIndices["refineCenter"] = 5;
source->ParamIndices["tileDist"] = 6;
source->ParamIndices["fog"] = 10;
source->ParamIndices["pzbModelPosition"] = 12;
addSource(source);
}
// TODO_VP_GLSL
{
// ....
}
}
void CVertexProgramLandscape::buildInfo()
{
m_Idx.ProgramConstants0 = getUniformIndex("programConstants0");
m_Idx.RefineCenter = getUniformIndex("refineCenter");
m_Idx.TileDist = getUniformIndex("tileDist");
m_Idx.PZBModelPosition = getUniformIndex("pzbModelPosition");
}
} // NL3D } // NL3D

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

@ -957,9 +957,9 @@ void CWaterModel::setupMaterialNVertexShader(IDriver *drv, CWaterShape *shape, c
drv->setUniform4f(IDriver::VertexProgram, program->idx().DiffuseMapVector0, _ColorMapMatColumn0.x, _ColorMapMatColumn1.x, 0, _ColorMapMatColumn0.x * obsPos.x + _ColorMapMatColumn1.x * obsPos.y + _ColorMapMatPos.x); drv->setUniform4f(IDriver::VertexProgram, program->idx().DiffuseMapVector0, _ColorMapMatColumn0.x, _ColorMapMatColumn1.x, 0, _ColorMapMatColumn0.x * obsPos.x + _ColorMapMatColumn1.x * obsPos.y + _ColorMapMatPos.x);
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);
} }
/// temp // set builtins
// drv->setUniformMatrix(IDriver::VertexProgram, program->indices().ModelViewProjection, IDriver::ModelViewProjection, IDriver::Identity); // now set by setUniformDriver in setupMaterial drv->setUniformMatrix(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::ModelViewProjection), IDriver::ModelViewProjection, IDriver::Identity);
// drv->setUniformFog(IDriver::VertexProgram, program->indices().Fog); // now set by setUniformDriver in setupMaterial drv->setUniformFog(IDriver::VertexProgram, program->getUniformIndex(CGPUProgramIndex::Fog));
// retrieve current time // retrieve current time
double date = scene->getCurrentTime(); double date = scene->getCurrentTime();
// set bumpmaps pos // set bumpmaps pos

6
code/nel/src/3d/water_shape.cpp
View file

@ -89,9 +89,6 @@ CVertexProgramWaterVPNoWave::CVertexProgramWaterVPNoWave(bool diffuse)
CSource *source = new CSource(); CSource *source = new CSource();
source->Profile = nelvp; source->Profile = nelvp;
source->DisplayName = "WaterVPNoWave/nelvp"; source->DisplayName = "WaterVPNoWave/nelvp";
source->Features.DriverFlags =
CGPUProgramFeatures::ModelViewProjection
| CGPUProgramFeatures::Fog;
source->ParamIndices["modelViewProjection"] = 0; source->ParamIndices["modelViewProjection"] = 0;
source->ParamIndices["fog"] = 4; source->ParamIndices["fog"] = 4;
source->ParamIndices["bumpMap0Scale"] = 5; source->ParamIndices["bumpMap0Scale"] = 5;
@ -120,9 +117,6 @@ CVertexProgramWaterVPNoWave::CVertexProgramWaterVPNoWave(bool diffuse)
// source->Profile = glsl330v; // source->Profile = glsl330v;
// source->DisplayName = "WaterVPNoWave/glsl330v"; // source->DisplayName = "WaterVPNoWave/glsl330v";
// if (diffuse) source->DisplayName += "/diffuse"; // if (diffuse) source->DisplayName += "/diffuse";
// source->Features.DriverFlags =
// CGPUProgramFeatures::ModelViewProjection
// | CGPUProgramFeatures::Fog;
// source->setSource... // source->setSource...
// addSource(source); // addSource(source);
} }