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

Rename some functions to follow the same naming convention of others

Browse source
This commit is contained in:
kaetemi 2013-06-19 23:49:39 +02:00
parent 1ed0d46026
commit 1f68025931
19 changed files with 59 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -1004,7 +1004,7 @@ public:
/** /**
* Does the driver supports vertex programs ? * Does the driver supports vertex programs ?
*/ */
virtual bool isVertexProgramSupported () const =0; virtual bool supportVertexProgram () const =0;
/** /**
* Does the driver supports vertex program, but emulated by CPU ? * Does the driver supports vertex program, but emulated by CPU ?
@ -1014,8 +1014,8 @@ public:
/** /**
* Does the driver supports pixel programs ? * Does the driver supports pixel programs ?
*/ */
virtual bool isPixelProgramSupported() const =0; virtual bool supportPixelProgram() const =0;
virtual bool isPixelProgramSupported(CPixelProgram::TProfile profile) const =0; virtual bool supportPixelProgram(CPixelProgram::TProfile profile) const =0;
@ -1122,10 +1122,10 @@ public:
/// test whether the device supports some form of texture shader. (could be limited to DX6 EMBM for example) /// test whether the device supports some form of texture shader. (could be limited to DX6 EMBM for example)
virtual bool supportTextureShaders() const = 0; virtual bool supportTextureShaders() const = 0;
// Is the shader water supported ? If not, the driver caller should implement its own version // Is the shader water supported ? If not, the driver caller should implement its own version
virtual bool isWaterShaderSupported() const = 0; virtual bool supportWaterShader() const = 0;
// //
/// test whether a texture addressing mode is supported /// test whether a texture addressing mode is supported
virtual bool isTextureAddrModeSupported(CMaterial::TTexAddressingMode mode) const = 0; virtual bool supportTextureAddrMode(CMaterial::TTexAddressingMode mode) const = 0;
/** setup the 2D matrix for the OffsetTexture, OffsetTextureScale and OffsetTexture addressing mode /** setup the 2D matrix for the OffsetTexture, OffsetTextureScale and OffsetTexture addressing mode
* It should be stored as the following * It should be stored as the following
* [a0 a1] * [a0 a1]

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

@ -2996,7 +2996,7 @@ bool CDriverD3D::stretchRect(ITexture * srcText, NLMISC::CRect &srcRect, ITextur
bool CDriverD3D::supportBloomEffect() const bool CDriverD3D::supportBloomEffect() const
{ {
return isVertexProgramSupported(); return supportVertexProgram();
} }
// *************************************************************************** // ***************************************************************************
@ -3339,9 +3339,9 @@ uint COcclusionQueryD3D::getVisibleCount()
} }
// *************************************************************************** // ***************************************************************************
bool CDriverD3D::isWaterShaderSupported() const bool CDriverD3D::supportWaterShader() const
{ {
H_AUTO_D3D(CDriverD3D_isWaterShaderSupported); H_AUTO_D3D(CDriverD3D_supportWaterShader);
return _PixelShaderVersion >= D3DPS_VERSION(1, 1); return _PixelShaderVersion >= D3DPS_VERSION(1, 1);
} }
@ -3627,7 +3627,7 @@ void CDriverD3D::CVertexProgramPtrState::apply(CDriverD3D *driver)
void CDriverD3D::CPixelShaderPtrState::apply(CDriverD3D *driver) void CDriverD3D::CPixelShaderPtrState::apply(CDriverD3D *driver)
{ {
H_AUTO_D3D(CDriverD3D_CPixelShaderPtrState); H_AUTO_D3D(CDriverD3D_CPixelShaderPtrState);
if (!driver->isPixelProgramSupported()) return; if (!driver->supportPixelProgram()) return;
driver->_DeviceInterface->SetPixelShader(PixelShader); driver->_DeviceInterface->SetPixelShader(PixelShader);
} }

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

@ -973,9 +973,9 @@ public:
virtual bool supportTextureShaders() const {return false;}; virtual bool supportTextureShaders() const {return false;};
virtual bool supportMADOperator() const; virtual bool supportMADOperator() const;
// todo hulud d3d adressing mode // todo hulud d3d adressing mode
virtual bool isWaterShaderSupported() const; virtual bool supportWaterShader() const;
// todo hulud d3d adressing mode // todo hulud d3d adressing mode
virtual bool isTextureAddrModeSupported(CMaterial::TTexAddressingMode /* mode */) const {return false;}; virtual bool supportTextureAddrMode(CMaterial::TTexAddressingMode /* mode */) const {return false;};
// todo hulud d3d adressing mode // todo hulud d3d adressing mode
virtual void setMatrix2DForTextureOffsetAddrMode(const uint /* stage */, const float /* mat */[4]) {} virtual void setMatrix2DForTextureOffsetAddrMode(const uint /* stage */, const float /* mat */[4]) {}
@ -1006,9 +1006,9 @@ public:
virtual void endMaterialMultiPass(); virtual void endMaterialMultiPass();
// Vertex program // Vertex program
virtual bool isVertexProgramSupported () const; virtual bool supportVertexProgram () const;
virtual bool isPixelProgramSupported () const; virtual bool supportPixelProgram () const;
virtual bool isPixelProgramSupported (CPixelProgram::TProfile profile) const; virtual bool supportPixelProgram (CPixelProgram::TProfile profile) const;
virtual bool isVertexProgramEmulated () const; virtual bool isVertexProgramEmulated () const;
virtual bool activeVertexProgram (CVertexProgram *program); virtual bool activeVertexProgram (CVertexProgram *program);
virtual bool activePixelProgram (CPixelProgram *program); virtual bool activePixelProgram (CPixelProgram *program);

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

@ -54,15 +54,15 @@ CPixelProgramDrvInfosD3D::~CPixelProgramDrvInfosD3D()
// *************************************************************************** // ***************************************************************************
bool CDriverD3D::isPixelProgramSupported () const bool CDriverD3D::supportPixelProgram () const
{ {
H_AUTO_D3D(CDriverD3D_isPixelProgramSupported) H_AUTO_D3D(CDriverD3D_supportPixelProgram)
return _PixelProgram; return _PixelProgram;
} }
bool CDriverD3D::isPixelProgramSupported (CPixelProgram::TProfile profile) const bool CDriverD3D::supportPixelProgram (CPixelProgram::TProfile profile) const
{ {
H_AUTO_D3D(CDriverD3D_isPixelProgramSupported_profile) H_AUTO_D3D(CDriverD3D_supportPixelProgram_profile)
return ((profile & 0xFFFF0000) == 0xD3D00000) return ((profile & 0xFFFF0000) == 0xD3D00000)
&& (_PixelProgramVersion >= (uint16)(profile & 0x0000FFFF)); && (_PixelProgramVersion >= (uint16)(profile & 0x0000FFFF));
} }

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

@ -43,9 +43,9 @@ CVertexProgamDrvInfosD3D::~CVertexProgamDrvInfosD3D()
// *************************************************************************** // ***************************************************************************
bool CDriverD3D::isVertexProgramSupported () const bool CDriverD3D::supportVertexProgram () const
{ {
H_AUTO_D3D(CDriverD3D_isVertexProgramSupported ) H_AUTO_D3D(CDriverD3D_supportVertexProgram )
return _VertexProgram; return _VertexProgram;
} }

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

@ -691,7 +691,7 @@ bool CDriverGL::stretchRect(ITexture * /* srcText */, NLMISC::CRect &/* srcRect
// *************************************************************************** // ***************************************************************************
bool CDriverGL::supportBloomEffect() const bool CDriverGL::supportBloomEffect() const
{ {
return (isVertexProgramSupported() && supportFrameBufferObject() && supportPackedDepthStencil() && supportTextureRectangle()); return (supportVertexProgram() && supportFrameBufferObject() && supportPackedDepthStencil() && supportTextureRectangle());
} }
// *************************************************************************** // ***************************************************************************
@ -1539,9 +1539,9 @@ bool CDriverGL::supportTextureShaders() const
} }
// *************************************************************************** // ***************************************************************************
bool CDriverGL::isWaterShaderSupported() const bool CDriverGL::supportWaterShader() const
{ {
H_AUTO_OGL(CDriverGL_isWaterShaderSupported); H_AUTO_OGL(CDriverGL_supportWaterShader);
if(_Extensions.ARBFragmentProgram && ARBWaterShader[0] != 0) return true; if(_Extensions.ARBFragmentProgram && ARBWaterShader[0] != 0) return true;
@ -1551,9 +1551,9 @@ bool CDriverGL::isWaterShaderSupported() const
} }
// *************************************************************************** // ***************************************************************************
bool CDriverGL::isTextureAddrModeSupported(CMaterial::TTexAddressingMode /* mode */) const bool CDriverGL::supportTextureAddrMode(CMaterial::TTexAddressingMode /* mode */) const
{ {
H_AUTO_OGL(CDriverGL_isTextureAddrModeSupported) H_AUTO_OGL(CDriverGL_supportTextureAddrMode)
if (_Extensions.NVTextureShader) if (_Extensions.NVTextureShader)
{ {

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

@ -601,9 +601,9 @@ public:
// @{ // @{
virtual bool supportTextureShaders() const; virtual bool supportTextureShaders() const;
virtual bool isWaterShaderSupported() const; virtual bool supportWaterShader() const;
virtual bool isTextureAddrModeSupported(CMaterial::TTexAddressingMode mode) const; virtual bool supportTextureAddrMode(CMaterial::TTexAddressingMode mode) const;
virtual void setMatrix2DForTextureOffsetAddrMode(const uint stage, const float mat[4]); virtual void setMatrix2DForTextureOffsetAddrMode(const uint stage, const float mat[4]);
// @} // @}
@ -1303,9 +1303,9 @@ private:
/// \name Vertex program interface /// \name Vertex program interface
// @{ // @{
bool isVertexProgramSupported () const; bool supportVertexProgram () const;
bool isPixelProgramSupported () const; bool supportPixelProgram () const;
bool isPixelProgramSupported (CPixelProgram::TProfile profile) const; bool supportPixelProgram (CPixelProgram::TProfile profile) const;
bool isVertexProgramEmulated () const; bool isVertexProgramEmulated () const;
bool activeVertexProgram (CVertexProgram *program); bool activeVertexProgram (CVertexProgram *program);
bool activePixelProgram (CPixelProgram *program); bool activePixelProgram (CPixelProgram *program);

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

@ -63,14 +63,14 @@ CPixelProgamDrvInfosGL::CPixelProgamDrvInfosGL (CDriverGL *drv, ItPixelPrgDrvInf
} }
// *************************************************************************** // ***************************************************************************
bool CDriverGL::isPixelProgramSupported() const bool CDriverGL::supportPixelProgram() const
{ {
H_AUTO_OGL(CPixelProgamDrvInfosGL_isPixelProgramSupported) H_AUTO_OGL(CPixelProgamDrvInfosGL_supportPixelProgram)
return _Extensions.ARBFragmentProgram; return _Extensions.ARBFragmentProgram;
} }
bool CDriverGL::isPixelProgramSupported(CPixelProgram::TProfile profile) const bool CDriverGL::supportPixelProgram(CPixelProgram::TProfile profile) const
{ {
H_AUTO_OGL(CPixelProgamDrvInfosGL_isPixelProgramSupported_profile) H_AUTO_OGL(CPixelProgamDrvInfosGL_supportPixelProgram_profile)
switch (profile) switch (profile)
{ {
case CPixelProgram::arbfp1: case CPixelProgram::arbfp1:
@ -78,6 +78,7 @@ bool CDriverGL::isPixelProgramSupported(CPixelProgram::TProfile profile) const
case CPixelProgram::fp40: case CPixelProgram::fp40:
return _Extensions.NVFragmentProgram2; return _Extensions.NVFragmentProgram2;
} }
return false;
} }
// *************************************************************************** // ***************************************************************************

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

@ -70,9 +70,9 @@ CVertexProgamDrvInfosGL::CVertexProgamDrvInfosGL (CDriverGL *drv, ItVtxPrgDrvInf
// *************************************************************************** // ***************************************************************************
bool CDriverGL::isVertexProgramSupported () const bool CDriverGL::supportVertexProgram () const
{ {
H_AUTO_OGL(CVertexProgamDrvInfosGL_isVertexProgramSupported) H_AUTO_OGL(CVertexProgamDrvInfosGL_supportVertexProgram)
return _Extensions.NVVertexProgram || _Extensions.EXTVertexShader || _Extensions.ARBVertexProgram; return _Extensions.NVVertexProgram || _Extensions.EXTVertexShader || _Extensions.ARBVertexProgram;
} }

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

@ -574,7 +574,7 @@ void CLandscape::setDriver(IDriver *drv)
// Does the driver support VertexShader??? // Does the driver support VertexShader???
// only if VP supported by GPU. // only if VP supported by GPU.
_VertexShaderOk= (_Driver->isVertexProgramSupported() && !_Driver->isVertexProgramEmulated()); _VertexShaderOk= (_Driver->supportVertexProgram() && !_Driver->isVertexProgramEmulated());
// Does the driver has sufficient requirements for Vegetable??? // Does the driver has sufficient requirements for Vegetable???

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

@ -82,7 +82,7 @@ void CLandscapeVBAllocator::updateDriver(IDriver *driver)
deleteVertexProgram(); deleteVertexProgram();
// Then rebuild VB format, and VertexProgram, if needed. // Then rebuild VB format, and VertexProgram, if needed.
// Do it only if VP supported by GPU. // Do it only if VP supported by GPU.
setupVBFormatAndVertexProgram(_Driver->isVertexProgramSupported() && !_Driver->isVertexProgramEmulated()); setupVBFormatAndVertexProgram(_Driver->supportVertexProgram() && !_Driver->isVertexProgramEmulated());
// must reallocate the VertexBuffer. // must reallocate the VertexBuffer.
if( _NumVerticesAllocated>0 ) if( _NumVerticesAllocated>0 )

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

@ -428,7 +428,7 @@ bool CMeshVPPerPixelLight::begin(IDriver *drv,
{ {
// test if supported by driver // test if supported by driver
if (! if (!
(drv->isVertexProgramSupported() (drv->supportVertexProgram()
&& !drv->isVertexProgramEmulated() && !drv->isVertexProgramEmulated()
&& drv->supportPerPixelLighting(SpecularLighting) && drv->supportPerPixelLighting(SpecularLighting)
) )

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

@ -287,7 +287,7 @@ inline void CMeshVPWindTree::setupPerInstanceConstants(IDriver *driver, CScene
// *************************************************************************** // ***************************************************************************
bool CMeshVPWindTree::begin(IDriver *driver, CScene *scene, CMeshBaseInstance *mbi, const NLMISC::CMatrix &invertedModelMat, const NLMISC::CVector & /*viewerPos*/) bool CMeshVPWindTree::begin(IDriver *driver, CScene *scene, CMeshBaseInstance *mbi, const NLMISC::CMatrix &invertedModelMat, const NLMISC::CVector & /*viewerPos*/)
{ {
if (!(driver->isVertexProgramSupported() && !driver->isVertexProgramEmulated())) return false; if (!(driver->supportVertexProgram() && !driver->isVertexProgramEmulated())) return false;
// precompute mesh // precompute mesh
@ -367,7 +367,7 @@ bool CMeshVPWindTree::supportMeshBlockRendering() const
// *************************************************************************** // ***************************************************************************
bool CMeshVPWindTree::isMBRVpOk(IDriver *driver) const bool CMeshVPWindTree::isMBRVpOk(IDriver *driver) const
{ {
return driver->isVertexProgramSupported() && !driver->isVertexProgramEmulated(); return driver->supportVertexProgram() && !driver->isVertexProgramEmulated();
} }
// *************************************************************************** // ***************************************************************************

10
code/nel/src/3d/ps_particle_basic.cpp
View file

@ -786,7 +786,7 @@ void CPSMultiTexturedParticle::setupMaterial(ITexture *primary, IDriver *driver,
/// if bump is used, the matrix must be setupped each time (not a material field) /// if bump is used, the matrix must be setupped each time (not a material field)
if (!_ForceBasicCaps && isMultiTextureEnabled() && _MainOp == EnvBumpMap) if (!_ForceBasicCaps && isMultiTextureEnabled() && _MainOp == EnvBumpMap)
{ {
if (driver->isTextureAddrModeSupported(CMaterial::OffsetTexture)) if (driver->supportTextureAddrMode(CMaterial::OffsetTexture))
{ {
CTextureBump *tb = dynamic_cast<CTextureBump *>((ITexture *) _Texture2); CTextureBump *tb = dynamic_cast<CTextureBump *>((ITexture *) _Texture2);
if (tb != NULL) if (tb != NULL)
@ -858,7 +858,7 @@ void CPSMultiTexturedParticle::setupMaterial(ITexture *primary, IDriver *driver,
} }
else else
{ {
if (!_ForceBasicCaps && (driver->isTextureAddrModeSupported(CMaterial::OffsetTexture) || driver->supportEMBM())) // envbumpmap supported ? if (!_ForceBasicCaps && (driver->supportTextureAddrMode(CMaterial::OffsetTexture) || driver->supportEMBM())) // envbumpmap supported ?
{ {
CTextureBump *tb = dynamic_cast<CTextureBump *>((ITexture *) _Texture2); CTextureBump *tb = dynamic_cast<CTextureBump *>((ITexture *) _Texture2);
if (tb != NULL) if (tb != NULL)
@ -917,7 +917,7 @@ void CPSMultiTexturedParticle::setupMultiTexEnv(TOperator op, ITexture *tex1, IT
mat.enableTexAddrMode(false); mat.enableTexAddrMode(false);
break; break;
case EnvBumpMap: case EnvBumpMap:
if (drv.isTextureAddrModeSupported(CMaterial::OffsetTexture)) if (drv.supportTextureAddrMode(CMaterial::OffsetTexture))
{ {
mat.setTexture(0, tex2); mat.setTexture(0, tex2);
mat.setTexture(1, tex1); mat.setTexture(1, tex1);
@ -1113,7 +1113,7 @@ void CPSMultiTexturedParticle::enumTexs(std::vector<NLMISC::CSmartPtr<ITexture>
NL_PS_FUNC(CPSMultiTexturedParticle_enumTexs) NL_PS_FUNC(CPSMultiTexturedParticle_enumTexs)
if (_MainOp == EnvBumpMap && !_ForceBasicCaps) if (_MainOp == EnvBumpMap && !_ForceBasicCaps)
{ {
if (drv.isTextureAddrModeSupported(CMaterial::OffsetTexture) || drv.supportEMBM()) if (drv.supportTextureAddrMode(CMaterial::OffsetTexture) || drv.supportEMBM())
{ {
if (_Texture2) dest.push_back(_Texture2); if (_Texture2) dest.push_back(_Texture2);
} }
@ -1132,7 +1132,7 @@ bool CPSMultiTexturedParticle::isAlternateTextureUsed(IDriver &driver) const
NL_PS_FUNC(CPSMultiTexturedParticle_isAlternateTextureUsed) NL_PS_FUNC(CPSMultiTexturedParticle_isAlternateTextureUsed)
if (!isTouched() && areBasicCapsForcedLocal() == areBasicCapsForced()) return (_MultiTexState & AlternateTextureUsed) != 0; if (!isTouched() && areBasicCapsForcedLocal() == areBasicCapsForced()) return (_MultiTexState & AlternateTextureUsed) != 0;
if (_MainOp != EnvBumpMap) return false; if (_MainOp != EnvBumpMap) return false;
return _ForceBasicCaps || (!driver.isTextureAddrModeSupported(CMaterial::OffsetTexture) && !driver.supportEMBM()); return _ForceBasicCaps || (!driver.supportTextureAddrMode(CMaterial::OffsetTexture) && !driver.supportEMBM());
} }
} // NL3D } // NL3D

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

@ -98,7 +98,7 @@ void CVegetableVBAllocator::updateDriver(IDriver *driver)
_VBHardOk= false; _VBHardOk= false;
// Driver must support VP. // Driver must support VP.
nlassert(_Driver->isVertexProgramSupported()); nlassert(_Driver->supportVertexProgram());
// must reallocate the VertexBuffer. // must reallocate the VertexBuffer.
if( _NumVerticesAllocated>0 ) if( _NumVerticesAllocated>0 )

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

@ -61,7 +61,7 @@ void CWaterModel::setupVertexBuffer(CVertexBuffer &vb, uint numWantedVertices, I
vb.setNumVertices(0); vb.setNumVertices(0);
vb.setName("Water"); vb.setName("Water");
vb.setPreferredMemory(CVertexBuffer::AGPPreferred, false); vb.setPreferredMemory(CVertexBuffer::AGPPreferred, false);
if (drv->isWaterShaderSupported()) if (drv->supportWaterShader())
{ {
vb.setVertexFormat(CVertexBuffer::PositionFlag); vb.setVertexFormat(CVertexBuffer::PositionFlag);
} }
@ -377,7 +377,7 @@ void CWaterModel::traverseRender()
#ifndef FORCE_SIMPLE_WATER_RENDER #ifndef FORCE_SIMPLE_WATER_RENDER
if (!drv->isWaterShaderSupported()) if (!drv->supportWaterShader())
#endif #endif
{ {
doSimpleRender(drv); doSimpleRender(drv);
@ -1363,7 +1363,7 @@ uint CWaterModel::getNumWantedVertices()
uint CWaterModel::fillVB(void *datas, uint startTri, IDriver &drv) uint CWaterModel::fillVB(void *datas, uint startTri, IDriver &drv)
{ {
H_AUTO( NL3D_Water_Render ); H_AUTO( NL3D_Water_Render );
if (drv.isWaterShaderSupported()) if (drv.supportWaterShader())
{ {
return fillVBHard(datas, startTri); return fillVBHard(datas, startTri);
} }
@ -1657,7 +1657,7 @@ void CWaterModel::traverseRender()
drv->setupModelMatrix(modelMat); drv->setupModelMatrix(modelMat);
bool isAbove = obsPos.z > getWorldMatrix().getPos().z; bool isAbove = obsPos.z > getWorldMatrix().getPos().z;
CVertexBuffer &vb = renderTrav.Scene->getWaterVB(); CVertexBuffer &vb = renderTrav.Scene->getWaterVB();
if (drv->isWaterShaderSupported()) if (drv->supportWaterShader())
{ {
setupMaterialNVertexShader(drv, shape, obsPos, isAbove, zHeight); setupMaterialNVertexShader(drv, shape, obsPos, isAbove, zHeight);
nlassert(vb.getNumVertices() > 0); nlassert(vb.getNumVertices() > 0);

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

@ -372,7 +372,7 @@ void CWaterShape::flushTextures (IDriver &driver, uint selectedTexture)
/* /*
if ( if (
(driver.supportTextureShaders() && driver.isTextureAddrModeSupported(CMaterial::OffsetTexture)) (driver.supportTextureShaders() && driver.supportTextureAddrMode(CMaterial::OffsetTexture))
|| driver.supportEMBM() || driver.supportEMBM()
) )
{ {

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

@ -560,7 +560,7 @@ void CDecalRenderList::renderAllDecals()
NL3D::IDriver *drvInternal = ((CDriverUser *) Driver)->getDriver(); NL3D::IDriver *drvInternal = ((CDriverUser *) Driver)->getDriver();
// //
static volatile bool forceNoVertexProgram = false; static volatile bool forceNoVertexProgram = false;
if (drvInternal->isVertexProgramSupported() && !forceNoVertexProgram) if (drvInternal->supportVertexProgram() && !forceNoVertexProgram)
{ {
//drvInternal->setConstantMatrix(0, NL3D::IDriver::ModelViewProjection, NL3D::IDriver::Identity); //drvInternal->setConstantMatrix(0, NL3D::IDriver::ModelViewProjection, NL3D::IDriver::Identity);
drvInternal->setConstant(7, _DistScale, _DistBias, 0.f, 1.f); drvInternal->setConstant(7, _DistScale, _DistBias, 0.f, 1.f);

10
code/snowballs2/client/src/commands.cpp
View file

@ -339,28 +339,28 @@ void initCommands()
"mov oC0.xzw, c0.xyyx\n" "mov oC0.xzw, c0.xyyx\n"
"texld oC0.y, v0, s0\n"; "texld oC0.y, v0, s0\n";
NL3D::IDriver *d = dynamic_cast<NL3D::CDriverUser *>(Driver)->getDriver(); NL3D::IDriver *d = dynamic_cast<NL3D::CDriverUser *>(Driver)->getDriver();
if (d->isPixelProgramSupported(CPixelProgram::fp40)) if (d->supportPixelProgram(CPixelProgram::fp40))
{ {
nldebug("fp40"); nldebug("fp40");
a_DevPixelProgram = new CPixelProgram(program_fp40); a_DevPixelProgram = new CPixelProgram(program_fp40);
} }
else if (d->isPixelProgramSupported(CPixelProgram::arbfp1)) else if (d->supportPixelProgram(CPixelProgram::arbfp1))
{ {
nldebug("arbfp1"); nldebug("arbfp1");
a_DevPixelProgram = new CPixelProgram(program_arbfp1); a_DevPixelProgram = new CPixelProgram(program_arbfp1);
} }
/*else if (d->isPixelProgramSupported(CPixelProgram::ps_3_0)) /*else if (d->supportPixelProgram(CPixelProgram::ps_3_0))
{ {
nldebug("ps_3_0"); nldebug("ps_3_0");
a_DevPixelProgram = new CPixelProgram(program_ps_3_0); a_DevPixelProgram = new CPixelProgram(program_ps_3_0);
// Textures do not seem to work with ps_3_0... // Textures do not seem to work with ps_3_0...
}*/ }*/
else if (d->isPixelProgramSupported(CPixelProgram::ps_2_0)) else if (d->supportPixelProgram(CPixelProgram::ps_2_0))
{ {
nldebug("ps_2_0"); nldebug("ps_2_0");
a_DevPixelProgram = new CPixelProgram(program_ps_2_0); a_DevPixelProgram = new CPixelProgram(program_ps_2_0);
} }
else if (d->isPixelProgramSupported(CPixelProgram::ps_1_1)) else if (d->supportPixelProgram(CPixelProgram::ps_1_1))
{ {
nldebug("ps_1_1"); nldebug("ps_1_1");
a_DevPixelProgram = new CPixelProgram(program_ps_1_1); a_DevPixelProgram = new CPixelProgram(program_ps_1_1);