aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-12-17 22:48:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/src/3d/driver/opengl/driver_opengl_material.cpp

2290 lines
73 KiB
C++
Raw Normal View History

initial version
2010-05-06 00:08:41 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdopengl.h"
#include "driver_opengl.h"
#include "nel/3d/cube_map_builder.h"
#include "nel/3d/texture_mem.h"
#include "nel/3d/texture_bump.h"
#include "nel/3d/material.h"
namespace NL3D {
static void convBlend(CMaterial::TBlend blend, GLenum& glenum)
{
H_AUTO_OGL(convBlend)
switch(blend)
{
case CMaterial::one: glenum=GL_ONE; break;
case CMaterial::zero: glenum=GL_ZERO; break;
case CMaterial::srcalpha: glenum=GL_SRC_ALPHA; break;
case CMaterial::invsrcalpha:glenum=GL_ONE_MINUS_SRC_ALPHA; break;
case CMaterial::srccolor: glenum=GL_SRC_COLOR; break;
case CMaterial::invsrccolor:glenum=GL_ONE_MINUS_SRC_COLOR; break;
// Extended Blend modes.
case CMaterial::blendConstantColor: glenum=GL_CONSTANT_COLOR_EXT; break;
case CMaterial::blendConstantInvColor: glenum=GL_ONE_MINUS_CONSTANT_COLOR_EXT; break;
case CMaterial::blendConstantAlpha: glenum=GL_CONSTANT_ALPHA_EXT; break;
case CMaterial::blendConstantInvAlpha: glenum=GL_ONE_MINUS_CONSTANT_ALPHA_EXT; break;
default: nlstop;
}
}
static void convZFunction(CMaterial::ZFunc zfunc, GLenum& glenum)
{
H_AUTO_OGL(convZFunction)
switch(zfunc)
{
case CMaterial::lessequal: glenum=GL_LEQUAL; break;
case CMaterial::less: glenum=GL_LESS; break;
case CMaterial::always: glenum=GL_ALWAYS; break;
case CMaterial::never: glenum=GL_NEVER; break;
case CMaterial::equal: glenum=GL_EQUAL; break;
case CMaterial::notequal: glenum=GL_NOTEQUAL; break;
case CMaterial::greater: glenum=GL_GREATER; break;
case CMaterial::greaterequal: glenum=GL_GEQUAL; break;
default: nlstop;
}
}
static void convColor(CRGBA col, GLfloat glcol[4])
{
H_AUTO_OGL(convColor)
static const float OO255= 1.0f/255;
glcol[0]= col.R*OO255;
glcol[1]= col.G*OO255;
glcol[2]= col.B*OO255;
glcol[3]= col.A*OO255;
}
static inline void convTexAddr(ITexture *tex, CMaterial::TTexAddressingMode mode, GLenum &glenum)
{
H_AUTO_OGL(convTexAddr)
nlassert(mode < CMaterial::TexAddrCount);
static const GLenum glTex2dAddrModesNV[] =
{
GL_NONE, GL_TEXTURE_2D, GL_PASS_THROUGH_NV, GL_CULL_FRAGMENT_NV,
GL_OFFSET_TEXTURE_2D_NV, GL_OFFSET_TEXTURE_2D_SCALE_NV,
GL_DEPENDENT_AR_TEXTURE_2D_NV, GL_DEPENDENT_GB_TEXTURE_2D_NV,
GL_DOT_PRODUCT_NV, GL_DOT_PRODUCT_TEXTURE_2D_NV, GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV,
GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV, GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV,
GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV, GL_DOT_PRODUCT_DEPTH_REPLACE_NV
};
static const GLenum glTexCubeAddrModesNV[] =
{
GL_NONE, GL_TEXTURE_CUBE_MAP_ARB, GL_PASS_THROUGH_NV, GL_CULL_FRAGMENT_NV,
GL_OFFSET_TEXTURE_2D_NV, GL_OFFSET_TEXTURE_2D_SCALE_NV,
GL_DEPENDENT_AR_TEXTURE_2D_NV, GL_DEPENDENT_GB_TEXTURE_2D_NV,
GL_DOT_PRODUCT_NV, GL_DOT_PRODUCT_TEXTURE_2D_NV, GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV,
GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV, GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV,
GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV, GL_DOT_PRODUCT_DEPTH_REPLACE_NV
};
if (!tex || !tex->isTextureCube())
{
glenum = glTex2dAddrModesNV[(uint) mode];
}
else
{
glenum = glTexCubeAddrModesNV[(uint) mode];
}
}
// --------------------------------------------------
void CDriverGL::setTextureEnvFunction(uint stage, CMaterial& mat)
{
H_AUTO_OGL(CDriverGL_setTextureEnvFunction)
ITexture *text= mat.getTexture(uint8(stage));
if(text)
{
CMaterial::CTexEnv &env= mat._TexEnvs[stage];
// Activate the env for this stage.
// NB: Thoses calls use caching.
activateTexEnvMode(stage, env);
activateTexEnvColor(stage, env);
// Activate texture generation mapping
_DriverGLStates.activeTextureARB(stage);
if (mat.getTexCoordGen (stage))
{
// set mode and enable.
CMaterial::TTexCoordGenMode mode= mat.getTexCoordGenMode(stage);
if(mode==CMaterial::TexCoordGenReflect)
{
// Cubic or normal ?
if (text->isTextureCube ())
_DriverGLStates.setTexGenMode (stage, GL_REFLECTION_MAP_ARB);
else
_DriverGLStates.setTexGenMode (stage, GL_SPHERE_MAP);
}
else if(mode==CMaterial::TexCoordGenObjectSpace)
{
_DriverGLStates.setTexGenMode (stage, GL_OBJECT_LINEAR);
}
else if(mode==CMaterial::TexCoordGenEyeSpace)
_DriverGLStates.setTexGenMode (stage, GL_EYE_LINEAR);
}
else
{
// Disable.
_DriverGLStates.setTexGenMode(stage, 0);
}
}
}
//--------------------------------
void CDriverGL::setupUserTextureMatrix(uint numStages, CMaterial& mat)
{
H_AUTO_OGL(CDriverGL_setupUserTextureMatrix)
if (
(_UserTexMatEnabled != 0 && (mat.getFlags() & IDRV_MAT_USER_TEX_MAT_ALL) == 0)
|| (mat.getFlags() & IDRV_MAT_USER_TEX_MAT_ALL) != 0
)
{
glMatrixMode(GL_TEXTURE);
// for each stage, setup the texture matrix if needed
uint newMask = (mat.getFlags() & IDRV_MAT_USER_TEX_MAT_ALL) >> IDRV_MAT_USER_TEX_FIRST_BIT;
uint shiftMask = 1;
for (uint k = 0; k < numStages ; ++k)
{
if (newMask & shiftMask) // user matrix for this stage
{
_DriverGLStates.activeTextureARB(k);
glLoadMatrixf(mat.getUserTexMat(k).get());
_UserTexMatEnabled |= shiftMask;
}
else
{
/// check if matrix disabled
if (
(newMask & shiftMask) != (_UserTexMatEnabled & shiftMask)
)
{
_DriverGLStates.activeTextureARB(k);
glLoadIdentity();
_UserTexMatEnabled &= ~shiftMask;
}
}
shiftMask <<= 1;
}
glMatrixMode(GL_MODELVIEW);
}
}
void CDriverGL::disableUserTextureMatrix()
{
H_AUTO_OGL(CDriverGL_disableUserTextureMatrix)
if (_UserTexMatEnabled != 0)
{
glMatrixMode(GL_TEXTURE);
uint k = 0;
do
{
if (_UserTexMatEnabled & (1 << k)) // user matrix for this stage
{
_DriverGLStates.activeTextureARB(k);
glLoadIdentity();
_UserTexMatEnabled &= ~ (1 << k);
}
++k;
}
while (_UserTexMatEnabled != 0);
glMatrixMode(GL_MODELVIEW);
}
}
// --------------------------------------------------
CMaterial::TShader CDriverGL::getSupportedShader(CMaterial::TShader shader)
{
H_AUTO_OGL(CDriverGL_CDriverGL)
switch (shader)
{
case CMaterial::PerPixelLighting: return _SupportPerPixelShader ? CMaterial::PerPixelLighting : CMaterial::Normal;
case CMaterial::PerPixelLightingNoSpec: return _SupportPerPixelShaderNoSpec ? CMaterial::PerPixelLightingNoSpec : CMaterial::Normal;
// Lightmap and Specular work only if at least 2 text stages.
case CMaterial::LightMap: return (inlGetNumTextStages()>=2) ? CMaterial::LightMap : CMaterial::Normal;
case CMaterial::Specular: return (inlGetNumTextStages()>=2) ? CMaterial::Specular : CMaterial::Normal;
default: return shader;
}
}
// --------------------------------------------------
void CDriverGL::setTextureShaders(const uint8 *addressingModes, const CSmartPtr<ITexture> *textures)
{
H_AUTO_OGL(CDriverGL_setTextureShaders)
GLenum glAddrMode;
for (uint stage = 0; stage < IDRV_MAT_MAXTEXTURES; ++stage)
{
convTexAddr(textures[stage], (CMaterial::TTexAddressingMode) addressingModes[stage], glAddrMode);
if (glAddrMode != _CurrentTexAddrMode[stage]) // addressing mode different from the one in the device?
{
_DriverGLStates.activeTextureARB(stage);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, glAddrMode);
_CurrentTexAddrMode[stage] = glAddrMode;
}
}
}
// --------------------------------------------------
bool CDriverGL::setupMaterial(CMaterial& mat)
{
H_AUTO_OGL(CDriverGL_setupMaterial)
CShaderGL* pShader;
GLenum glenum;
uint32 touched=mat.getTouched();
uint stage;
// profile.
_NbSetupMaterialCall++;
// 0. Retrieve/Create driver shader.
//==================================
if (!mat._MatDrvInfo)
{
// insert into driver list. (so it is deleted when driver is deleted).
ItMatDrvInfoPtrList it= _MatDrvInfos.insert(_MatDrvInfos.end(), NULL);
// create and set iterator, for future deletion.
*it= mat._MatDrvInfo= new CShaderGL(this, it);
// Must create all OpenGL shader states.
touched= IDRV_TOUCHED_ALL;
}
pShader=static_cast<CShaderGL*>((IMaterialDrvInfos*)(mat._MatDrvInfo));
// 1. Setup modified fields of material.
//=====================================
if( touched )
{
/* Exception: if only Textures are modified in the material, no need to "Bind OpenGL States", or even to test
for change, because textures are activated alone, see below.
No problem with delete/new problem (see below), because in this case, IDRV_TOUCHED_ALL is set (see above).
*/
// If any flag is set (but a flag of texture)
if( touched & (~_MaterialAllTextureTouchedFlag) )
{
// Convert Material to driver shader.
if (touched & IDRV_TOUCHED_BLENDFUNC)
{
convBlend( mat.getSrcBlend(),glenum );
pShader->SrcBlend=glenum;
convBlend( mat.getDstBlend(),glenum );
pShader->DstBlend=glenum;
}
if (touched & IDRV_TOUCHED_ZFUNC)
{
convZFunction( mat.getZFunc(),glenum);
pShader->ZComp= glenum;
}
if (touched & IDRV_TOUCHED_LIGHTING)
{
convColor(mat.getEmissive(), pShader->Emissive);
convColor(mat.getAmbient(), pShader->Ambient);
convColor(mat.getDiffuse(), pShader->Diffuse);
convColor(mat.getSpecular(), pShader->Specular);
pShader->PackedEmissive= mat.getEmissive().getPacked();
pShader->PackedAmbient= mat.getAmbient().getPacked();
pShader->PackedDiffuse= mat.getDiffuse().getPacked();
pShader->PackedSpecular= mat.getSpecular().getPacked();
}
if (touched & IDRV_TOUCHED_SHADER)
{
// Get shader. Fallback to other shader if not supported.
pShader->SupportedShader= getSupportedShader(mat.getShader());
}
// Since modified, must rebind all openGL states. And do this also for the delete/new problem.
/* If an old material is deleted, _CurrentMaterial is invalid. But this is grave only if a new
material is created, with the same pointer (bad luck). Since an newly allocated material always
pass here before use, we are sure to avoid any problems.
*/
_CurrentMaterial= NULL;
}
// Optimize: reset all flags at the end.
mat.clearTouched(0xFFFFFFFF);
}
// Now we can get the supported shader from the cache.
CMaterial::TShader matShader = pShader->SupportedShader;
// if the shader has changed since last time
if(matShader != _CurrentMaterialSupportedShader)
{
// if old was lightmap, restore standard lighting
if(_CurrentMaterialSupportedShader==CMaterial::LightMap)
setupLightMapDynamicLighting(false);
// if new is lightmap, setup dynamic lighting
if(matShader==CMaterial::LightMap)
setupLightMapDynamicLighting(true);
}
// setup the global
_CurrentMaterialSupportedShader= matShader;
// 2. Setup / Bind Textures.
//==========================
// Must setup textures each frame. (need to test if touched).
// Must separate texture setup and texture activation in 2 "for"...
// because setupTexture() may disable all stage.
if (matShader != CMaterial::Water)
{
for(stage=0 ; stage<inlGetNumTextStages() ; stage++)
{
ITexture *text= mat.getTexture(uint8(stage));
if (text != NULL && !setupTexture(*text))
return false;
}
}
// Here, for Lightmap materials, setup the lightmaps.
if(matShader == CMaterial::LightMap)
{
for(stage = 0; stage < mat._LightMaps.size(); stage++)
{
ITexture *text = mat._LightMaps[stage].Texture;
if (text != NULL && !setupTexture(*text))
return(false);
}
}
// Here, for caustic shader, setup the lightmaps
/*if (matShader == CMaterial::Caustics)
{
if (mat.getTexture(stage))
}*/
// Activate the textures.
// Do not do it for Lightmap and per pixel lighting , because done in multipass in a very special fashion.
// This avoid the useless multiple change of texture states per lightmapped object.
// Don't do it also for Specular because the EnvFunction and the TexGen may be special.
if(matShader != CMaterial::LightMap
&& matShader != CMaterial::PerPixelLighting
/* && matShader != CMaterial::Caustics */
&& matShader != CMaterial::Cloud
&& matShader != CMaterial::Water
&& matShader != CMaterial::Specular
)
{
for(stage=0 ; stage<inlGetNumTextStages() ; stage++)
{
ITexture *text= mat.getTexture(uint8(stage));
// activate the texture, or disable texturing if NULL.
activateTexture(stage,text);
// If texture not NULL, Change texture env function.
//==================================================
setTextureEnvFunction(stage, mat);
}
}
// 3. Bind OpenGL States.
//=======================
if (_CurrentMaterial!=&mat)
{
// Bind Blend Part.
//=================
bool blend = (mat.getFlags()&IDRV_MAT_BLEND)!=0;
_DriverGLStates.enableBlend(blend);
if(blend)
_DriverGLStates.blendFunc(pShader->SrcBlend, pShader->DstBlend);
// Double Sided Part.
//===================
// NB: inverse state: DoubleSided <=> !CullFace.
uint32 twoSided= mat.getFlags()&IDRV_MAT_DOUBLE_SIDED;
_DriverGLStates.enableCullFace( twoSided==0 );
// Alpha Test Part.
//=================
uint32 alphaTest= mat.getFlags()&IDRV_MAT_ALPHA_TEST;
_DriverGLStates.enableAlphaTest(alphaTest);
if(alphaTest)
{
// setup alphaTest threshold.
_DriverGLStates.alphaFunc(mat.getAlphaTestThreshold());
}
// Bind ZBuffer Part.
//===================
_DriverGLStates.enableZWrite(mat.getFlags()&IDRV_MAT_ZWRITE);
_DriverGLStates.depthFunc(pShader->ZComp);
_DriverGLStates.setZBias (mat.getZBias () * _OODeltaZ);
// Bind Stencil Buffer Part.
//===================
/*
_DriverGLStates.enableStencilTest();
_DriverGLStates.stencilFunc();
_DriverGLStates.stencilOp();
*/
// Color-Lighting Part.
//=====================
// Light Part.
_DriverGLStates.enableLighting(mat.getFlags()&IDRV_MAT_LIGHTING);
if(mat.getFlags()&IDRV_MAT_LIGHTING)
{
_DriverGLStates.setEmissive(pShader->PackedEmissive, pShader->Emissive);
_DriverGLStates.setAmbient(pShader->PackedAmbient, pShader->Ambient);
_DriverGLStates.setDiffuse(pShader->PackedDiffuse, pShader->Diffuse);
_DriverGLStates.setSpecular(pShader->PackedSpecular, pShader->Specular);
_DriverGLStates.setShininess(mat.getShininess());
_DriverGLStates.setVertexColorLighted(mat.isLightedVertexColor ());
}
else
{
// Color unlit part.
CRGBA col= mat.getColor();
glColor4ub(col.R, col.G, col.B, col.A);
_DriverGLStates.setVertexColorLighted(false);
}
// Fog Part.
//=================
// Disable fog if dest blend is ONE
if (blend && (pShader->DstBlend == GL_ONE))
{
_DriverGLStates.enableFog(false);
}
else
{
// Restaure fog state to its current value
_DriverGLStates.enableFog(_FogEnabled);
}
// Texture shader part.
//=====================
if (_Extensions.NVTextureShader)
{
if (matShader == CMaterial::Normal)
{
// Texture addressing modes (support only via NVTextureShader for now)
//===================================================================
if ( mat.getFlags() & IDRV_MAT_TEX_ADDR )
{
enableNVTextureShader(true);
setTextureShaders(&mat._TexAddrMode[0], &mat._Textures[0]);
}
else
{
enableNVTextureShader(false);
}
}
else
{
enableNVTextureShader(false);
}
}
_CurrentMaterial=&mat;
}
// 4. Misc
//=====================================
// If !lightMap and prec material was lihgtmap => vertex setup is dirty!
if( matShader != CMaterial::LightMap && _LastVertexSetupIsLightMap )
resetLightMapVertexSetup();
// Textures user matrix
if (matShader == CMaterial::Normal)
{
setupUserTextureMatrix(inlGetNumTextStages(), mat);
}
else // deactivate texture matrix
{
disableUserTextureMatrix();
}
return true;
}
// ***************************************************************************
sint CDriverGL::beginMultiPass()
{
H_AUTO_OGL(CDriverGL_beginMultiPass)
// Depending on material type and hardware, return number of pass required to draw this material.
switch(_CurrentMaterialSupportedShader)
{
case CMaterial::LightMap:
return beginLightMapMultiPass();
case CMaterial::Specular:
return beginSpecularMultiPass();
case CMaterial::Water:
return beginWaterMultiPass();
case CMaterial::PerPixelLighting:
return beginPPLMultiPass();
case CMaterial::PerPixelLightingNoSpec:
return beginPPLNoSpecMultiPass();
/* case CMaterial::Caustics:
return beginCausticsMultiPass(); */
case CMaterial::Cloud:
return beginCloudMultiPass();
// All others materials require just 1 pass.
default: return 1;
}
}
Changed: #878 Fix typos in comments/code
2010-06-03 12:45:51 +00:00
initial version
2010-05-06 00:08:41 +00:00
// ***************************************************************************
void CDriverGL::setupPass(uint pass)
{
H_AUTO_OGL(CDriverGL_setupPass)
switch(_CurrentMaterialSupportedShader)
{
case CMaterial::LightMap:
setupLightMapPass (pass);
break;
case CMaterial::Specular:
setupSpecularPass (pass);
break;
case CMaterial::Water:
setupWaterPass(pass);
break;
case CMaterial::PerPixelLighting:
setupPPLPass (pass);
break;
case CMaterial::PerPixelLightingNoSpec:
setupPPLNoSpecPass (pass);
break;
/* case CMaterial::Caustics:
case CMaterial::Caustics:
break; */
case CMaterial::Cloud:
setupCloudPass (pass);
break;
// All others materials do not require multi pass.
default: return;
}
}
// ***************************************************************************
void CDriverGL::endMultiPass()
{
H_AUTO_OGL(CDriverGL_endMultiPass)
switch(_CurrentMaterialSupportedShader)
{
case CMaterial::LightMap:
endLightMapMultiPass();
break;
case CMaterial::Specular:
endSpecularMultiPass();
break;
case CMaterial::Water:
endWaterMultiPass();
return;
case CMaterial::PerPixelLighting:
endPPLMultiPass();
break;
case CMaterial::PerPixelLightingNoSpec:
endPPLNoSpecMultiPass();
break;
/* case CMaterial::Caustics:
endCausticsMultiPass();
break; */
case CMaterial::Cloud:
endCloudMultiPass();
break;
// All others materials do not require multi pass.
default: return;
}
}
// ***************************************************************************
void CDriverGL::computeLightMapInfos (const CMaterial &mat)
{
H_AUTO_OGL(CDriverGL_computeLightMapInfos )
static const uint32 RGBMaskPacked = CRGBA(255,255,255,0).getPacked();
// For optimisation consideration, suppose there is not too much lightmap.
nlassert(mat._LightMaps.size()<=NL3D_DRV_MAX_LIGHTMAP);
// Compute number of lightmaps really used (ie factor not NULL), and build the LUT.
_NLightMaps = 0;
// For all lightmaps of the material.
for (uint i = 0; i < mat._LightMaps.size(); ++i)
{
// If the lightmap's factor is not null.
if (mat._LightMaps[i].Factor.getPacked() & RGBMaskPacked)
{
_LightMapLUT[_NLightMaps] = i;
++_NLightMaps;
}
}
// Compute how many pass, according to driver caps.
_NLightMapPerPass = inlGetNumTextStages()-1;
// Can do more than 2 texture stages only if NVTextureEnvCombine4 or ATITextureEnvCombine3
if (!_Extensions.NVTextureEnvCombine4 && !_Extensions.ATITextureEnvCombine3)
{
_NLightMapPerPass = 1;
_LightMapNoMulAddFallBack= true;
}
else
{
_LightMapNoMulAddFallBack= false;
}
// Number of pass.
_NLightMapPass = (_NLightMaps + _NLightMapPerPass-1)/(_NLightMapPerPass);
// NB: _NLightMaps==0 means there is no lightmaps at all.
}
// ***************************************************************************
sint CDriverGL::beginLightMapMultiPass ()
{
H_AUTO_OGL(CDriverGL_beginLightMapMultiPass )
const CMaterial &mat= *_CurrentMaterial;
// compute how many lightmap and pass we must process.
computeLightMapInfos (mat);
// always enable lighting for lightmap (because of dynamic light)
_DriverGLStates.enableLighting(true);
// if the dynamic lightmap light has changed since the last render (should not happen), resetup
// normal way is that setupLightMapDynamicLighting() is called in setupMaterial() if shader different from prec
if(_LightMapDynamicLightDirty)
setupLightMapDynamicLighting(true);
// reset Ambient and specular lighting
static uint32 packedColorBlack= CRGBA(0,0,0,255).getPacked();
static GLfloat glcolBlack[4]= {0,0,0,1};
// lightmap get no specular/ambient. Emissive and Diffuse are setuped in setupLightMapPass()
_DriverGLStates.setAmbient(packedColorBlack, glcolBlack);
_DriverGLStates.setSpecular(packedColorBlack, glcolBlack);
// reset VertexColor array if necessary.
if (_LastVB.VertexFormat & CVertexBuffer::PrimaryColorFlag)
_DriverGLStates.enableColorArray(false);
// Manage too if no lightmaps.
return std::max (_NLightMapPass, (uint)1);
}
Changed: #878 Fix typos in comments/code
2010-06-03 12:45:51 +00:00
initial version
2010-05-06 00:08:41 +00:00
// ***************************************************************************
void CDriverGL::setupLightMapPass(uint pass)
{
H_AUTO_OGL(CDriverGL_setupLightMapPass)
const CMaterial &mat= *_CurrentMaterial;
// common colors
static uint32 packedColorBlack= CRGBA(0,0,0,255).getPacked();
static GLfloat glcolBlack[4]= {0.f,0.f,0.f,1.f};
static uint32 packedColorWhite= CRGBA(255,255,255,255).getPacked();
static GLfloat glcolWhite[4]= {1.f,1.f,1.f,1.f};
static uint32 packedColorGrey= CRGBA(128,128,128,128).getPacked();
static GLfloat glcolGrey[4]= {0.5f,0.5f,0.5f,1.f};
// No lightmap or all blacks??, just setup "black texture" for stage 0.
if(_NLightMaps==0)
{
ITexture *text= mat.getTexture(0);
activateTexture(0,text);
// setup std modulate env
CMaterial::CTexEnv env;
activateTexEnvMode(0, env);
// Since Lighting is disabled, as well as colorArray, must setup alpha.
// setup color to 0 => blackness. in emissive cause texture can still be lighted by dynamic light
_DriverGLStates.setEmissive(packedColorBlack, glcolBlack);
// Setup gen tex off
_DriverGLStates.activeTextureARB(0);
_DriverGLStates.setTexGenMode(0, 0);
// And disable other stages.
for(uint stage = 1; stage < inlGetNumTextStages(); stage++)
{
// disable texturing.
activateTexture(stage, NULL);
}
return;
}
nlassert(pass<_NLightMapPass);
// setup Texture Pass.
//=========================
uint lmapId;
uint nstages;
lmapId= pass * _NLightMapPerPass; // Nb lightmaps already processed
// N lightmaps for this pass, plus the texture.
nstages= std::min(_NLightMapPerPass, _NLightMaps-lmapId) + 1;
// For LMC (lightmap 8Bit compression) compute the total AmbientColor in vertex diffuse
// need only if standard MulADD version
if (!_LightMapNoMulAddFallBack)
{
uint32 r=0;
uint32 g=0;
uint32 b=0;
// sum only the ambient of lightmaps that will be drawn this pass
for(uint sa=0;sa<nstages-1;sa++)
{
uint wla= _LightMapLUT[lmapId+sa];
// must mul them by their respective mapFactor too
CRGBA ambFactor = mat._LightMaps[wla].Factor;
CRGBA lmcAmb= mat._LightMaps[wla].LMCAmbient;
r+= ((uint32)ambFactor.R * ((uint32)lmcAmb.R+(lmcAmb.R>>7))) >>8;
g+= ((uint32)ambFactor.G * ((uint32)lmcAmb.G+(lmcAmb.G>>7))) >>8;
b+= ((uint32)ambFactor.B * ((uint32)lmcAmb.B+(lmcAmb.B>>7))) >>8;
}
r= std::min(r, (uint32)255);
g= std::min(g, (uint32)255);
b= std::min(b, (uint32)255);
// this color will be added to the first lightmap (with help of emissive)
CRGBA col((uint8)r,(uint8)g,(uint8)b,255);
GLfloat glcol[4];
convColor(col, glcol);
_DriverGLStates.setEmissive(col.getPacked(), glcol);
}
// setup all stages.
for(uint stage= 0; stage<inlGetNumTextStages(); stage++)
{
// if must setup a lightmap stage.
if(stage<nstages-1)
{
// setup lightMap.
uint whichLightMap= _LightMapLUT[lmapId];
// get text and factor.
ITexture *text = mat._LightMaps[whichLightMap].Texture;
CRGBA lmapFactor = mat._LightMaps[whichLightMap].Factor;
// Modulate the factor with LightMap compression Diffuse
CRGBA lmcDiff= mat._LightMaps[whichLightMap].LMCDiffuse;
// FallBack if the (very common) extension for MulADD was not found
if(_LightMapNoMulAddFallBack)
{
lmcDiff.addRGBOnly(lmcDiff, mat._LightMaps[whichLightMap].LMCAmbient);
}
lmapFactor.R = (uint8)(((uint32)lmapFactor.R * ((uint32)lmcDiff.R+(lmcDiff.R>>7))) >>8);
lmapFactor.G = (uint8)(((uint32)lmapFactor.G * ((uint32)lmcDiff.G+(lmcDiff.G>>7))) >>8);
lmapFactor.B = (uint8)(((uint32)lmapFactor.B * ((uint32)lmcDiff.B+(lmcDiff.B>>7))) >>8);
lmapFactor.A = 255;
activateTexture(stage,text);
// If texture not NULL, Change texture env fonction.
//==================================================
if(text)
{
static CMaterial::CTexEnv stdEnv;
// fallBack if extension MulAdd not found. just mul factor with (Ambient+Diffuse)
if(_LightMapNoMulAddFallBack)
{
// do not use consant color to blend lightmap, but incoming diffuse color, for stage0 only.
GLfloat glcol[4];
convColor(lmapFactor, glcol);
_DriverGLStates.setEmissive(lmapFactor.getPacked(), glcol);
// Leave stage as default env (Modulate with previous)
activateTexEnvMode(stage, stdEnv);
// Setup gen tex off
_DriverGLStates.activeTextureARB(stage);
_DriverGLStates.setTexGenMode(stage, 0);
}
else
{
// Here, we are sure that texEnvCombine4 or texEnvCombine3 is OK.
nlassert(_Extensions.NVTextureEnvCombine4 || _Extensions.ATITextureEnvCombine3);
// setup constant color with Lightmap factor.
stdEnv.ConstantColor=lmapFactor;
activateTexEnvColor(stage, stdEnv);
// Setup env for texture stage.
_DriverGLStates.activeTextureARB(stage);
_DriverGLStates.setTexGenMode(stage, 0);
// setup TexEnvCombine4 (ignore alpha part).
if(_CurrentTexEnvSpecial[stage] != TexEnvSpecialLightMap)
{
// TexEnv is special.
_CurrentTexEnvSpecial[stage] = TexEnvSpecialLightMap;
if (_Extensions.NVTextureEnvCombine4)
{
// What we want to setup is Texture*Constant + Previous*1.
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
// Operator.
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD );
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_ADD );
// Arg0.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
// Arg1.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_CONSTANT_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
// Arg2.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_PREVIOUS_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
// Arg3.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_RGB_NV, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_RGB_NV, GL_ONE_MINUS_SRC_COLOR);
}
else
{
// ATI EnvCombine3
// What we want to setup is Texture*Constant + Previous.
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
// Operator.
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE_ADD_ATI);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE_ADD_ATI);
// Arg0.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
// Arg1.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_CONSTANT_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
// Arg2.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
}
}
}
// setup UV, with UV1. Only if needed (cached)
if( !_LastVertexSetupIsLightMap || _LightMapUVMap[stage]!=1 )
{
setupUVPtr(stage, _LastVB, 1);
_LightMapUVMap[stage]= 1;
}
}
// Next lightmap.
lmapId++;
}
else if(stage<nstages)
{
// optim: do this only for first pass, and last pass only if stage!=nLMapPerPass
// (meaning not the same stage as preceding passes).
if(pass==0 || (pass==_NLightMapPass-1 && stage!=_NLightMapPerPass))
{
// activate the texture at last stage.
ITexture *text= mat.getTexture(0);
activateTexture(stage,text);
// setup ModulateRGB/ReplaceAlpha env. (this may disable possible COMBINE4_NV setup).
activateTexEnvMode(stage, _LightMapLastStageEnv);
// Setup gen tex off
_DriverGLStates.activeTextureARB(stage);
_DriverGLStates.setTexGenMode(stage, 0);
// setup UV, with UV0. Only if needed (cached)
if( !_LastVertexSetupIsLightMap || _LightMapUVMap[stage]!=0 )
{
setupUVPtr(stage, _LastVB, 0);
_LightMapUVMap[stage]= 0;
}
if (mat._LightMapsMulx2)
{
// Multiply x 2
glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 2);
}
}
}
else
{
// else all other stages are disabled.
activateTexture(stage,NULL);
}
}
// setup blend / lighting.
//=========================
/* If multi-pass, then must setup a black Fog color for 1+ pass (just do it for the pass 1).
This is because Transparency ONE/ONE is used.
*/
if(pass==1 && _FogEnabled)
{
static GLfloat blackFog[4]= {0,0,0,0};
glFogfv(GL_FOG_COLOR, blackFog);
}
// Blend is different if the material is blended or not
if( !mat.getBlend() )
{
// Not blended, std case.
if(pass==0)
{
// no transparency for first pass.
_DriverGLStates.enableBlend(false);
}
else if(pass==1)
{
// setup an Additive transparency (only for pass 1, will be kept for successives pass).
_DriverGLStates.enableBlend(true);
_DriverGLStates.blendFunc(GL_ONE, GL_ONE);
}
}
else
{
/* 1st pass, std alphaBlend. 2nd pass, add to background. Demo:
T: texture.
l0: lightmap (or group of lightmap) of pass 0.
l1: lightmap (or group of lightmap) of pass 1. (same thing with 2,3 etc....)
B: Background.
A: Alpha of texture.
finalResult= T*(l0+l1) * A + B * (1-A).
We get it in two pass:
fint= T*l0 * A + B * (1-A).
finalResult= T*l1 * A + fint = T*l1 * A + T*l0 * A + B * (1-A)=
T* (l0+l1) * A + B * (1-A)
*/
if(pass==0)
{
// no transparency for first pass.
_DriverGLStates.enableBlend(true);
_DriverGLStates.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
else if(pass==1)
{
// setup an Additive transparency (only for pass 1, will be kept for successives pass).
_DriverGLStates.enableBlend(true);
_DriverGLStates.blendFunc(GL_SRC_ALPHA, GL_ONE);
}
}
// Dynamic lighting: The influence of the dynamic light must be added only in the first pass (only one time)
if(pass==0)
{
// If the lightmap is in x2 mode, then must divide effect of the dynamic light too
if (mat._LightMapsMulx2)
_DriverGLStates.setDiffuse(packedColorGrey, glcolGrey);
else
_DriverGLStates.setDiffuse(packedColorWhite, glcolWhite);
}
// no need to reset for pass after 1, since same than prec pass (black)!
else if(pass==1)
_DriverGLStates.setDiffuse(packedColorBlack, glcolBlack);
}
Changed: #878 Fix typos in comments/code
2010-06-03 12:45:51 +00:00
initial version
2010-05-06 00:08:41 +00:00
// ***************************************************************************
void CDriverGL::endLightMapMultiPass()
{
H_AUTO_OGL(CDriverGL_endLightMapMultiPass)
// Flag the fact that VertexSetup is dirty (special lightmap). reseted in activeVertexBuffer(), and setupMaterial()
// NB: if no lightmaps, no setupUVPtr() has been called => don't need to flag
// (important else crash if graphist error while exporting a Lightmap material, with a MeshVertexProgram (WindTree) )
if(_NLightMaps!=0)
_LastVertexSetupIsLightMap= true;
// If multi-pass, then must reset the fog color
if(_NLightMapPass>=2 && _FogEnabled)
{
glFogfv(GL_FOG_COLOR, _CurrentFogColor);
}
// nothing to do with blending/lighting, since always setuped in activeMaterial().
// If material is the same, then it is still a lightmap material (if changed => touched => different!)
// So no need to reset blending/lighting here.
// Clean up all stage for Multiply x 2
if (_CurrentMaterial->_LightMapsMulx2)
{
for (uint32 i = 0; i < (_NLightMapPerPass+1); ++i)
{
_DriverGLStates.activeTextureARB(i);
glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 1);
}
}
}
// ***************************************************************************
void CDriverGL::resetLightMapVertexSetup()
{
H_AUTO_OGL(CDriverGL_resetLightMapVertexSetup)
// special for all stage, std UV behavior.
for(uint i = 0; i < inlGetNumTextStages(); i++)
{
// normal behavior: each texture has its own UV.
setupUVPtr(i, _LastVB, i);
// reset cache
_LightMapUVMap[i]= -1;
}
// pop VertexColor array if necessary.
if (_LastVB.VertexFormat & CVertexBuffer::PrimaryColorFlag)
_DriverGLStates.enableColorArray(true);
// flag
_LastVertexSetupIsLightMap= false;
}
// ***************************************************************************
void CDriverGL::startSpecularBatch()
{
H_AUTO_OGL(CDriverGL_startSpecularBatch)
_SpecularBatchOn= true;
setupSpecularBegin();
}
// ***************************************************************************
void CDriverGL::endSpecularBatch()
{
H_AUTO_OGL(CDriverGL_endSpecularBatch)
_SpecularBatchOn= false;
setupSpecularEnd();
}
// ***************************************************************************
void CDriverGL::setupSpecularBegin()
{
H_AUTO_OGL(CDriverGL_setupSpecularBegin)
// ---- Reset any textures with id>=2
uint stage = 2;
for(; stage < inlGetNumTextStages(); stage++)
{
// disable texturing
activateTexture(stage, NULL);
}
// ---- Stage 0 Common Setup.
// Setup the env for stage 0 only.
// Result RGB : Texture*Diffuse, Alpha : Texture
CMaterial::CTexEnv env;
env.Env.OpAlpha= CMaterial::Replace;
activateTexEnvMode(0, env);
// Disable texGen for stage 0
_DriverGLStates.activeTextureARB(0);
_DriverGLStates.setTexGenMode(0, 0);
// ---- Stage 1 Common Setup.
// NB don't setup the TexEnv here (stage1 setuped in setupSpecularPass() according to extensions)
// For all cases, setup the TexCoord gen for stage1
_DriverGLStates.activeTextureARB(1);
// todo hulud remove
// _DriverGLStates.setTextureMode(CDriverGLStates::TextureCubeMap);
_DriverGLStates.setTexGenMode (1, GL_REFLECTION_MAP_ARB);
// setup the good matrix for stage 1.
glMatrixMode(GL_TEXTURE);
glLoadMatrixf( _SpecularTexMtx.get() );
glMatrixMode(GL_MODELVIEW);
}
// ***************************************************************************
void CDriverGL::setupSpecularEnd()
{
H_AUTO_OGL(CDriverGL_setupSpecularEnd)
// Disable Texture coord generation.
_DriverGLStates.activeTextureARB(1);
_DriverGLStates.setTexGenMode(1, 0);
// Happiness !!! we have already enabled the stage 1
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
}
// ***************************************************************************
sint CDriverGL::beginSpecularMultiPass()
{
H_AUTO_OGL(CDriverGL_beginSpecularMultiPass)
const CMaterial &mat= *_CurrentMaterial;
// activate the 2 textures here
uint stage;
uint numStages= std::min((uint)2, inlGetNumTextStages());
for(stage=0 ; stage<numStages; stage++)
{
ITexture *text= mat.getTexture(uint8(stage));
// activate the texture, or disable texturing if NULL.
activateTexture(stage,text);
}
// End specular , only if not Batching mode.
if(!_SpecularBatchOn)
setupSpecularBegin();
// Manage the rare case when the SpecularMap is not provided (fault of graphist).
if(mat.getTexture(1)==NULL)
return 1;
if(!_Extensions.ARBTextureCubeMap)
return 1;
if( _Extensions.NVTextureEnvCombine4 || _Extensions.ATITextureEnvCombine3) // NVidia or ATI optimization
return 1;
else
return 2;
}
Changed: #878 Fix typos in comments/code
2010-06-03 12:45:51 +00:00
initial version
2010-05-06 00:08:41 +00:00
// ***************************************************************************
void CDriverGL::setupSpecularPass(uint pass)
{
H_AUTO_OGL(CDriverGL_setupSpecularPass)
const CMaterial &mat= *_CurrentMaterial;
// Manage the rare case when the SpecularMap is not provided (error of a graphist).
if(mat.getTexture(1)==NULL)
{
// Just display the texture
// NB: setupMaterial() code has correclty setuped textures.
return;
}
/// Support NVidia combine 4 extension to do specular map in a single pass
if( _Extensions.NVTextureEnvCombine4 )
{ // Ok we can do it in a single pass
// Set Stage 1
// Special: not the same sepcial env if there is or not texture in stage 0.
CTexEnvSpecial newEnvStage1;
if( mat.getTexture(0) == NULL )
newEnvStage1= TexEnvSpecialSpecularStage1NoText;
else
newEnvStage1= TexEnvSpecialSpecularStage1;
// Test if same env as prec.
if(_CurrentTexEnvSpecial[1] != newEnvStage1)
{
// TexEnv is special.
_CurrentTexEnvSpecial[1] = newEnvStage1;
_DriverGLStates.activeTextureARB(1);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
// Operator Add (Arg0*Arg1+Arg2*Arg3)
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD );
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_ADD );
// Arg0.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR );
// Arg1.
if( newEnvStage1 == TexEnvSpecialSpecularStage1NoText )
{
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_ONE_MINUS_SRC_COLOR);
}
else
{
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_ALPHA );
}
// Arg2.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_PREVIOUS_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR );
// Arg3.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_RGB_NV, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_RGB_NV, GL_ONE_MINUS_SRC_COLOR);
// Result : Texture*Previous.Alpha+Previous
// Setup Alpha Diffuse Copy
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PRIMARY_COLOR_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, GL_SRC_ALPHA );
// Arg1.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, GL_ONE_MINUS_SRC_ALPHA);
// Arg2.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT, GL_SRC_ALPHA );
// Arg3.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_ALPHA_NV, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_ALPHA_NV, GL_SRC_ALPHA);
}
}
else if (_Extensions.ATITextureEnvCombine3)
{
// Ok we can do it in a single pass
// Set Stage 1
// Special: not the same sepcial env if there is or not texture in stage 0.
CTexEnvSpecial newEnvStage1;
if( mat.getTexture(0) == NULL )
newEnvStage1= TexEnvSpecialSpecularStage1NoText;
else
newEnvStage1= TexEnvSpecialSpecularStage1;
// Test if same env as prec.
if(_CurrentTexEnvSpecial[1] != newEnvStage1)
{
// TexEnv is special.
_CurrentTexEnvSpecial[1] = newEnvStage1;
_DriverGLStates.activeTextureARB(1);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
// Operator Add (Arg0*Arg2+Arg1)
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE_ADD_ATI );
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE_ADD_ATI );
// Arg0.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR );
// Arg2.
if( newEnvStage1 == TexEnvSpecialSpecularStage1NoText )
{
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_ONE_MINUS_SRC_COLOR);
}
else
{
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_PREVIOUS_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_ALPHA );
}
// Arg1.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR );
// Result : Texture*Previous.Alpha+Previous
// Setup Alpha Diffuse Copy
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PRIMARY_COLOR_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, GL_SRC_ALPHA );
// Arg2.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT, GL_ONE_MINUS_SRC_ALPHA );
// Arg1.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, GL_SRC_ALPHA);
}
}
else
Changed: #878 Fix typos in comments/code
2010-06-03 12:45:51 +00:00
{
// We have to do it in 2 passes
initial version
2010-05-06 00:08:41 +00:00
// For Both Pass, setup correct Env.
if( pass == 0 )
{ // Just display the texture
_DriverGLStates.enableBlend(false);
_DriverGLStates.activeTextureARB(1);
_DriverGLStates.setTextureMode(CDriverGLStates::TextureDisabled);
}
else
{ // Multiply texture1 by alpha_texture0 and display with add
_DriverGLStates.enableBlend(true);
_DriverGLStates.blendFunc(GL_ONE, GL_ONE);
// Set stage 0
_DriverGLStates.activeTextureARB(0);
CMaterial::CTexEnv env;
env.Env.OpRGB = CMaterial::Replace;
env.Env.SrcArg0RGB = CMaterial::Texture;
env.Env.OpArg0RGB = CMaterial::SrcAlpha;
activateTexEnvMode(0, env);
// Set stage 1
if( mat.getTexture(0) == NULL )
{
env.Env.OpRGB = CMaterial::Replace;
env.Env.SrcArg0RGB = CMaterial::Texture;
env.Env.OpArg0RGB = CMaterial::SrcColor;
}
else
{
env.Env.OpRGB = CMaterial::Modulate;
env.Env.SrcArg0RGB = CMaterial::Texture;
env.Env.OpArg0RGB = CMaterial::SrcColor;
env.Env.SrcArg1RGB = CMaterial::Previous;
env.Env.OpArg1RGB = CMaterial::SrcColor;
}
activateTexEnvMode(1, env);
}
}
}
Changed: #878 Fix typos in comments/code
2010-06-03 12:45:51 +00:00
initial version
2010-05-06 00:08:41 +00:00
// ***************************************************************************
void CDriverGL::endSpecularMultiPass()
{
H_AUTO_OGL(CDriverGL_endSpecularMultiPass)
// End specular , only if not Batching mode.
if(!_SpecularBatchOn)
setupSpecularEnd();
}
// a functor that can is used to generate a cube map used for specular / diffuse lighting
struct CSpecCubeMapFunctor : ICubeMapFunctor
{
CSpecCubeMapFunctor(float exp) : Exp(exp) {}
virtual NLMISC::CRGBA operator()(const NLMISC::CVector &v)
{
H_AUTO_OGL(CSpecCubeMapFunctor_operator_parenthesis)
uint8 intensity = (uint8) (255.f * ::powf(std::max(v.normed().z, 0.f), Exp));
return NLMISC::CRGBA(intensity, intensity, intensity, intensity);
//return Exp == 1.f ? CRGBA((uint8)(v.x*127+127), (uint8)(v.y*127+127), (uint8)(v.z*127+127), 0): CRGBA::Black;
}
virtual ~CSpecCubeMapFunctor() {}
float Exp;
};
/* /// parameters for specular cube map generation
const uint MaxSpecularExp = 64;
const uint SpecularExpStep = 8;
const uint SpecularMapSize = 32; */
// ***************************************************************************
CTextureCube *CDriverGL::getSpecularCubeMap(uint exp)
{
H_AUTO_OGL(CDriverGL__getSpecularCubeMap)
const uint DiffuseMapSize = 64;
const uint SpecularMapSize = 32;
const uint SpecularMapSizeHighExponent = 64;
const float HighExponent = 128.f;
const uint MaxExponent = 512;
// this gives the cube map to use given an exponent (from 0 to 128)
static uint16 expToCubeMap[MaxExponent];
// this gives the exponent used by a given cube map (not necessarily ordered)
static float cubeMapExp[] =
{
1.f, 4.f, 8.f, 24.f, 48.f, 128.f, 256.f, 511.f
};
const uint numCubeMap = sizeof(expToCubeMap) / sizeof(float);
static bool tableBuilt = false;
if (!tableBuilt)
{
for (uint k = 0; k < MaxExponent; ++k)
{
uint nearest = 0;
float diff = (float) MaxExponent;
// look for the nearest exponent
for (uint l = 0; l < numCubeMap; ++l)
{
float newDiff = ::fabsf(k - cubeMapExp[l]);
if (newDiff < diff)
{
diff = newDiff;
nearest = l;
}
}
expToCubeMap[k] = uint16(nearest);
}
tableBuilt = true;
}
if (_SpecularTextureCubes.empty())
{
_SpecularTextureCubes.resize(MaxExponent);
}
NLMISC::clamp(exp, 1u, (MaxExponent - 1));
uint cubeMapIndex = expToCubeMap[exp];
nlassert(cubeMapIndex < numCubeMap);
if (_SpecularTextureCubes[cubeMapIndex] != NULL) // has the cube map already been cted ?
{
return _SpecularTextureCubes[cubeMapIndex];
}
else // build the cube map
{
float exponent = cubeMapExp[cubeMapIndex];
CSpecCubeMapFunctor scmf(exponent);
const uint bufSize = 128;
char name[bufSize];
NLMISC::smprintf(name, bufSize, "#SM%d", cubeMapIndex);
CTextureCube *tc;
if (exponent == 1)
{
tc = BuildCubeMap(DiffuseMapSize, scmf, false, name);
}
else
{
tc = BuildCubeMap(exponent >= HighExponent ? SpecularMapSizeHighExponent
: SpecularMapSize,
scmf,
false,
name);
}
static const CTextureCube::TFace numToFace[] =
{ CTextureCube::positive_x,
CTextureCube::negative_x,
CTextureCube::positive_y,
CTextureCube::negative_y,
CTextureCube::positive_z,
CTextureCube::negative_z
};
if (exponent != 1.f)
{
// force 16 bit for specular part, 32 bit if exponent is 1 (diffuse part)
for (uint k = 0; k < 6; ++k)
{
nlassert(tc->getTexture(numToFace[k]));
tc->getTexture(numToFace[k])->setUploadFormat(ITexture::RGB565);
}
}
_SpecularTextureCubes[cubeMapIndex] = tc;
return tc;
}
}
// ***************************************************************************
sint CDriverGL::beginPPLMultiPass()
{
H_AUTO_OGL(CDriverGL_beginPPLMultiPass)
#ifdef NL_DEBUG
nlassert(supportPerPixelLighting(true)); // make sure the hardware can do that
#endif
return 1;
}
// ***************************************************************************
void CDriverGL::setupPPLPass(uint pass)
{
H_AUTO_OGL(CDriverGL_setupPPLPass)
const CMaterial &mat= *_CurrentMaterial;
nlassert(pass == 0);
/* ITexture *tex0 = getSpecularCubeMap(1);
if (tex0) setupTexture(*tex0);
activateTexture(0, tex0);
static CMaterial::CTexEnv env;
env.Env.SrcArg0Alpha = CMaterial::Diffuse;
env.Env.SrcArg1Alpha = CMaterial::Constant;
env.Env.SrcArg0RGB = CMaterial::Diffuse;
env.Env.SrcArg1RGB = CMaterial::Constant;
env.Env.OpRGB = CMaterial::Replace;
env.Env.OpAlpha = CMaterial::Replace;
activateTexEnvMode(0, env);
return;*/
ITexture *tex0 = getSpecularCubeMap(1);
if (tex0) setupTexture(*tex0);
ITexture *tex2 = getSpecularCubeMap((uint) mat.getShininess());
if (tex2) setupTexture(*tex2);
if (mat.getTexture(0)) setupTexture(*mat.getTexture(0));
// tex coord 0 = texture coordinates
// tex coord 1 = normal in tangent space
// tex coord 2 = half angle vector in tangent space
activateTexture(0, tex0);
activateTexture(1, mat.getTexture(0));
activateTexture(2, tex2);
for (uint k = 3; k < inlGetNumTextStages(); ++k)
{
activateTexture(k, NULL);
}
// setup the tex envs
// Stage 0 is rgb = DiffuseCubeMap * LightColor + DiffuseGouraud * 1
if(_CurrentTexEnvSpecial[0] != TexEnvSpecialPPLStage0)
{
// TexEnv is special.
_CurrentTexEnvSpecial[0] = TexEnvSpecialPPLStage0;
_DriverGLStates.activeTextureARB(0);
if (_Extensions.NVTextureEnvCombine4)
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD);
// Arg0 = Diffuse read in cube map
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
// Arg1 = Light color
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_CONSTANT_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
// Arg2 = Primary color (other light diffuse and
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_PRIMARY_COLOR_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
// Arg3 = White (= ~ Black)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_RGB_NV, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_RGB_NV, GL_ONE_MINUS_SRC_COLOR);
}
else // use ATI extension
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE_ADD_ATI);
// Arg0 = Diffuse read in cube map
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
// Arg1 = Light color
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_CONSTANT_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
// Arg2 = Primary color (other light diffuse and
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PRIMARY_COLOR_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
}
}
activateTexEnvColor(0, _PPLightDiffuseColor);
// Stage 1
static CMaterial::CTexEnv env;
env.Env.SrcArg1Alpha = CMaterial::Diffuse;
activateTexEnvMode(1, env);
// Stage 2 is rgb = SpecularCubeMap * SpecularLightColor + Prec * 1
// alpha = prec alpha
if(_CurrentTexEnvSpecial[2] != TexEnvSpecialPPLStage2)
{
// TexEnv is special.
_CurrentTexEnvSpecial[2] = TexEnvSpecialPPLStage2;
_DriverGLStates.activeTextureARB(2);
if (_Extensions.NVTextureEnvCombine4)
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
//== colors ==
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD);
// Arg0 = Specular read in cube map
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
// Arg1 = Light color
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_CONSTANT_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
// Arg2 = Primary color ( + other light diffuse )
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_PREVIOUS_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
// Arg3 = White (= ~ Black)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_RGB_NV, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_RGB_NV, GL_ONE_MINUS_SRC_COLOR);
//== alpha ==
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_ADD);
// Arg0 = PREVIOUS ALPHA
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PREVIOUS_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, GL_SRC_COLOR);
// Arg1 = 1
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, GL_ONE_MINUS_SRC_COLOR);
// Arg2 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT, GL_SRC_COLOR);
// Arg3 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_ALPHA_NV, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_ALPHA_NV, GL_SRC_COLOR);
}
else // ATI EnvCombine3
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
//== colors ==
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE_ADD_ATI);
// Arg0 = Specular read in cube map
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
// Arg2 = Light color
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_CONSTANT_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
// Arg1 = Primary color ( + other light diffuse)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
//== alpha ==
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE_ADD_ATI);
// Arg0 = PREVIOUS ALPHA
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PREVIOUS_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, GL_SRC_COLOR);
// Arg2 = 1
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT, GL_ONE_MINUS_SRC_COLOR);
// Arg1 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, GL_SRC_COLOR);
}
}
activateTexEnvColor(2, _PPLightSpecularColor);
}
// ***************************************************************************
void CDriverGL::endPPLMultiPass()
{
H_AUTO_OGL(CDriverGL_endPPLMultiPass)
// nothing to do there ...
}
// ******PER PIXEL LIGHTING, NO SPECULAR**************************************
sint CDriverGL::beginPPLNoSpecMultiPass()
{
H_AUTO_OGL(CDriverGL_beginPPLNoSpecMultiPass)
#ifdef NL_DEBUG
nlassert(supportPerPixelLighting(false)); // make sure the hardware can do that
#endif
return 1;
}
// ******PER PIXEL LIGHTING, NO SPECULAR**************************************
void CDriverGL::setupPPLNoSpecPass(uint pass)
{
H_AUTO_OGL(CDriverGL_setupPPLNoSpecPass)
const CMaterial &mat= *_CurrentMaterial;
nlassert(pass == 0);
ITexture *tex0 = getSpecularCubeMap(1);
if (tex0) setupTexture(*tex0);
if (mat.getTexture(0)) setupTexture(*mat.getTexture(0));
// tex coord 0 = texture coordinates
// tex coord 1 = normal in tangent space
activateTexture(0, tex0);
activateTexture(1, mat.getTexture(0));
for (uint k = 2; k < inlGetNumTextStages(); ++k)
{
activateTexture(k, NULL);
}
// setup the tex envs
// Stage 0 is rgb = DiffuseCubeMap * LightColor + DiffuseGouraud * 1 (TODO : EnvCombine3)
if(_CurrentTexEnvSpecial[0] != TexEnvSpecialPPLStage0)
{
// TexEnv is special.
_CurrentTexEnvSpecial[0] = TexEnvSpecialPPLStage0;
_DriverGLStates.activeTextureARB(0);
if (_Extensions.NVTextureEnvCombine4)
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD);
// Arg0 = Diffuse read in cube map alpha
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
// Arg1 = Light color
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_CONSTANT_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
// Arg2 = Primary color (other light diffuse and
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_PRIMARY_COLOR_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
// Arg3 = White (= ~ Black)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_RGB_NV, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_RGB_NV, GL_ONE_MINUS_SRC_COLOR);
}
else
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE_ADD_ATI);
// Arg0 = Diffuse read in cube map alpha
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
// Arg2 = Light color
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_CONSTANT_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
// Arg1 = Primary color (other light diffuse and
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PRIMARY_COLOR_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
}
}
activateTexEnvColor(0, _PPLightDiffuseColor);
// Stage 1
static CMaterial::CTexEnv env;
env.Env.SrcArg1Alpha = CMaterial::Diffuse;
activateTexEnvMode(1, env);
}
// ******PER PIXEL LIGHTING, NO SPECULAR**************************************
void CDriverGL::endPPLNoSpecMultiPass()
{
H_AUTO_OGL(CDriverGL_endPPLNoSpecMultiPass)
// nothing to do there ...
}
// ***************************************************************************
/* sint CDriverGL::beginCausticsMultiPass(const CMaterial &mat)
{
nlassert(mat.getShader() == CMaterial::Caustics);
if (!_Extensions.ARBTextureCubeMap) return 1;
switch (inlGetNumTextStages())
{
case 1: return 3;
case 2: return 2;
default:
return 1;
}
}*/
// ***************************************************************************
/*inline void CDriverGL::setupCausticsFirstTex(const CMaterial &mat)
{
/// setup texture 0
activateTexture(0, mat.getTexture(0));
/// texture environment 0
setTextureEnvFunction(0, mat);
/// texture matrix 0
setupUserTextureMatrix(0, mat);
}
// ***************************************************************************
inline void CDriverGL::setupCausticsSecondTex(uint stage)
{
activateTexture(stage, mat.getTexture(0));
_CausticCubeMap
}
// ***************************************************************************
void CDriverGL::setupCausticsPass(const CMaterial &mat, uint pass)
{
nlassert(mat.getShader() == CMaterial::Caustics);
if (inlGetNumTextStages() == 1 || !_Extensions.ARBTextureCubeMap)
{
setupCausticsFirstTex(mat);
}
else
if (inlGetNumTextStages() >= 3) /// do it in one pass
{
nlassert(pass == 0);
setupCausticsFirstTex(mat);
}
else if (inlGetNumTextStages() == 2) /// do in in 2 pass
{
nlassert(pass < 2);
if (pass == 0)
{
setupCausticsFirstTex(mat);
}
else /// caustics setup
{
/// setup additif blending
_DriverGLStates.enableBlend();
_DriverGLStates.blendFunc(pShader->SrcBlend, pShader->DstBlend);
}
}
}
// ***************************************************************************
void CDriverGL::endCausticsMultiPass(const CMaterial &mat)
{
nlassert(mat.getShader() == CMaterial::Caustics);
}
*/
// ***************************************************************************
sint CDriverGL::beginCloudMultiPass ()
{
H_AUTO_OGL(CDriverGL_beginCloudMultiPass )
nlassert(_CurrentMaterial->getShader() == CMaterial::Cloud);
return 1;
}
// ***************************************************************************
void CDriverGL::setupCloudPass (uint /* pass */)
{
H_AUTO_OGL(CDriverGL_setupCloudPass )
nlassert(_CurrentMaterial->getShader() == CMaterial::Cloud);
const CMaterial &mat= *_CurrentMaterial;
activateTexture(0, mat.getTexture(0));
activateTexture(1, mat.getTexture(0));
if (_CurrentTexEnvSpecial[0] != TexEnvSpecialCloudStage0)
{
if (_Extensions.NVTextureEnvCombine4)
{
_CurrentTexEnvSpecial[0] = TexEnvSpecialCloudStage0;
_CurrentTexEnvSpecial[1] = TexEnvSpecialCloudStage1;
// Setup 1st Stage
_DriverGLStates.activeTextureARB(0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
//== colors ==
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD);
// Arg0 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
// Arg1 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
// Arg2 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
// Arg3 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_RGB_NV, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_RGB_NV, GL_SRC_COLOR);
//== alpha ==
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_ADD);
// Arg0 = AT0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE0_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, GL_SRC_ALPHA);
// Arg1 = AWPOS
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_PRIMARY_COLOR_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, GL_SRC_ALPHA);
// Arg2 = AT1
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, GL_TEXTURE1_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT, GL_SRC_ALPHA);
// Arg3 = 1-AWPOS
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_ALPHA_NV, GL_PRIMARY_COLOR_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_ALPHA_NV, GL_ONE_MINUS_SRC_ALPHA);
// Setup 2nd Stage
_DriverGLStates.activeTextureARB(1);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
//== colors ==
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD);
// Arg0 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
// Arg1 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
// Arg2 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
// Arg3 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_RGB_NV, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_RGB_NV, GL_SRC_COLOR);
//== alpha ==
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_ADD);
// Arg0 = AT0*AWPOS+AT1*(1-AWPOS)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PREVIOUS_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, GL_SRC_ALPHA);
// Arg1 = AINT
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_CONSTANT_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, GL_SRC_ALPHA);
// Arg2 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT, GL_SRC_ALPHA);
// Arg3 = 0
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_ALPHA_NV, GL_ZERO);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND3_ALPHA_NV, GL_SRC_ALPHA);
activateTexEnvColor (1, mat.getColor());
}
else
{
// TODO : for now the state is not cached in _CurrentTexEnvSpecial
nglBindFragmentShaderATI(ATICloudShaderHandle);
glEnable(GL_FRAGMENT_SHADER_ATI);
float cst[4] = { 0.f, 0.f, 0.f, mat.getColor().A / 255.f };
nglSetFragmentShaderConstantATI(GL_CON_0_ATI, cst);
/*
_DriverGLStates.activeTextureARB(0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
// Operator.
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_INTERPOLATE_EXT);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_INTERPOLATE_EXT);
// Arg0.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE0_ARB );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, GL_SRC_ALPHA);
// Arg1.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_TEXTURE1_ARB );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, GL_SRC_ALPHA);
// Arg2.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, GL_PRIMARY_COLOR_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT, GL_SRC_ALPHA);
_DriverGLStates.activeTextureARB(1);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
// Operator.
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE);
// Arg0.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PREVIOUS_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, GL_SRC_ALPHA);
// Arg1.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_ZERO );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_CONSTANT_EXT );
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, GL_SRC_ALPHA);
*/
}
}
if (_Extensions.NVTextureEnvCombine4)
activateTexEnvColor (1, mat.getColor());
}
// ***************************************************************************
void CDriverGL::endCloudMultiPass()
{
H_AUTO_OGL(CDriverGL_endCloudMultiPass)
nlassert(_CurrentMaterial->getShader() == CMaterial::Cloud);
if (ATICloudShaderHandle)
{
glDisable(GL_FRAGMENT_SHADER_ATI);
}
}
// ***************************************************************************
sint CDriverGL::beginWaterMultiPass()
{
H_AUTO_OGL(CDriverGL_beginWaterMultiPass)
nlassert(_CurrentMaterial->getShader() == CMaterial::Water);
return 1;
}
// ***************************************************************************
/** water setup for ATI
*/
void CDriverGL::setupWaterPassR200(const CMaterial &mat)
{
H_AUTO_OGL(CDriverGL_setupWaterPassR200)
uint k;
ITexture *tex = mat.getTexture(0);
if (tex)
{
// if (tex->isBumpMap())
// {
// CTextureBump *tb = static_cast<CTextureBump *>(tex);
// }
setupTexture(*tex);
activateTexture(0, tex);
}
tex = mat.getTexture(1);
if (tex)
{
// if (tex->isBumpMap())
// {
// CTextureBump *tb = static_cast<CTextureBump *>(tex);
// }
setupTexture(*tex);
activateTexture(1, tex);
}
tex = mat.getTexture(2);
if (tex)
{
setupTexture(*tex);
activateTexture(2, tex);
}
tex = mat.getTexture(3);
if (tex)
{
setupTexture(*tex);
activateTexture(3, tex);
}
for (k = 4; k < inlGetNumTextStages(); ++k)
{
activateTexture(k, NULL);
}
if (mat.getTexture(3) != NULL) // is there a diffuse map ?
{
nglBindFragmentShaderATI(ATIWaterShaderHandle);
}
else
{
nglBindFragmentShaderATI(ATIWaterShaderHandleNoDiffuseMap);
}
glEnable(GL_FRAGMENT_SHADER_ATI);
// set constants
if (mat.getTexture(0) && mat.getTexture(0)->isBumpMap())
{
float factor = NLMISC::safe_cast<CTextureBump *>(mat.getTexture(0))->getNormalizationFactor();
float cst[4] = { factor, factor, factor, 0.f };
nglSetFragmentShaderConstantATI(GL_CON_0_ATI, cst);
}
else
{
float cst[4] = { 1.f, 1.f, 1.f, 0.f };
nglSetFragmentShaderConstantATI(GL_CON_0_ATI, cst);
}
//
if (mat.getTexture(1) && mat.getTexture(1)->isBumpMap())
{
float factor = NLMISC::safe_cast<CTextureBump *>(mat.getTexture(1))->getNormalizationFactor();
float cst[4] = { factor, factor, factor, 0.f };
nglSetFragmentShaderConstantATI(GL_CON_1_ATI, cst);
}
else
{
float cst[4] = { 1.f, 1.f, 1.f, 0.f };
nglSetFragmentShaderConstantATI(GL_CON_0_ATI, cst);
}
}
// ***************************************************************************
/** water setup for ARB_fragment_program
*/
void CDriverGL::setupWaterPassARB(const CMaterial &mat)
{
H_AUTO_OGL(CDriverGL_setupWaterPassARB)
uint k;
ITexture *tex = mat.getTexture(0);
if (tex)
{
tex->setUploadFormat(ITexture::RGBA8888);
setupTexture(*tex);
activateTexture(0, tex);
}
tex = mat.getTexture(1);
if (tex)
{
tex->setUploadFormat(ITexture::RGBA8888);
setupTexture(*tex);
activateTexture(1, tex);
}
tex = mat.getTexture(2);
if (tex)
{
setupTexture(*tex);
activateTexture(2, tex);
}
tex = mat.getTexture(3);
if (tex)
{
setupTexture(*tex);
activateTexture(3, tex);
}
for (k = 4; k < inlGetNumTextStages(); ++k)
{
activateTexture(k, NULL);
}
nglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, ARBWaterShader[(_FogEnabled ? 1 : 0) | (mat.getTexture(3) != NULL ? 2 : 0)]);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
// setup the constant
if (mat.getTexture(0) && mat.getTexture(0)->isBumpMap())
{
float factor = 0.25f * NLMISC::safe_cast<CTextureBump *>(mat.getTexture(0))->getNormalizationFactor();
nglProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, 2.f * factor, -1.f * factor, 0.f, 0.f); // scale_bias from [0, 1] to [-1, 1] and factor applied
}
else
{
nglProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, 2.f, -1.f, 0.f, 0.f); // scale_bias from [0, 1] to [-1, 1] and factor applied
}
// setup the constant
if (mat.getTexture(1) && mat.getTexture(1)->isBumpMap())
{
float factor = NLMISC::safe_cast<CTextureBump *>(mat.getTexture(1))->getNormalizationFactor();
nglProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 1, 2.f * factor, -1.f * factor, 0.f, 0.f); // scale_bias from [0, 1] to [-1, 1] and factor applied
}
else
{
nglProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 1, 2.f, -1.f, 0.f, 0.f); // scale_bias from [0, 1] to [-1, 1] and factor applied
}
if (_FogEnabled)
{
if (_FogStart == _FogEnd)
{
nglProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 2, 0.f, 0.f, 0.f, 0.f);
}
else
{
/** Unfortunately, the EXT_vertex_shader extension has to output the fog values in the [0, 1] range to work with the standard pipeline.
* So we must add a special path for this case, where the fog coordinate is 'unscaled' again.
* NB : this is fixed in later drivers (from 6.14.10.6343), so check this
*/
if (_Extensions.EXTVertexShader && !_ATIFogRangeFixed)
{
nglProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 2, 1.f, 0.f, 0.f, 0.f);
}
else
{
nglProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 2, - 1.f/ (_FogEnd - _FogStart), _FogEnd / (_FogEnd - _FogStart), 0.f, 0.f);
}
}
}
}
// ***************************************************************************
/** Presetupped texture shader for water shader on NV20
*/
static const uint8 WaterNoDiffuseTexAddrMode[IDRV_MAT_MAXTEXTURES] =
{
CMaterial::FetchTexture,
CMaterial::OffsetTexture,
CMaterial::OffsetTexture,
CMaterial::TextureOff
};
static const uint8 WaterTexAddrMode[IDRV_MAT_MAXTEXTURES] =
{
CMaterial::FetchTexture,
CMaterial::OffsetTexture,
CMaterial::OffsetTexture,
CMaterial::FetchTexture
};
static const float IdentityTexMat[4] = { 1.f, 0.f, 0.f, 1.f };
// ***************************************************************************
void CDriverGL::setupWaterPassNV20(const CMaterial &mat)
{
H_AUTO_OGL(CDriverGL_setupWaterPassNV20)
static bool setupDone = false;
static CMaterial::CTexEnv texEnvReplace;
static CMaterial::CTexEnv texEnvModulate;
if (!setupDone)
{
texEnvReplace.Env.OpRGB = CMaterial::Replace;
texEnvReplace.Env.OpAlpha = CMaterial::Replace;
// use default setup for texenv modulate
setupDone = true;
}
// activate the textures & set the matrixs
ITexture *tex = mat.getTexture(0);
if (tex)
{
setupTexture(*tex);
activateTexture(0, tex);
_DriverGLStates.activeTextureARB(1);
if (tex->isBumpMap())
{
CTextureBump *tb = static_cast<CTextureBump *>(tex);
// set the matrix for the texture shader
float factor = tb->getNormalizationFactor();
float tsMatrix[4] = { 0.25f * factor, 0.f, 0.f, 0.25f * factor };
glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, tsMatrix);
}
else
{
glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, IdentityTexMat);
}
}
tex = mat.getTexture(1);
if (tex)
{
setupTexture(*tex);
activateTexture(1, tex);
_DriverGLStates.activeTextureARB(2);
if (tex->isBumpMap())
{
CTextureBump *tb = static_cast<CTextureBump *>(tex);
// set the matrix for the texture shader
float factor = tb->getNormalizationFactor();
float tsMatrix[4] = { factor, 0.f, 0.f, factor };
glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, tsMatrix);
}
else
{
glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, IdentityTexMat);
}
}
tex = mat.getTexture(2);
if (tex)
{
setupTexture(*tex);
activateTexture(2, tex);
}
tex = mat.getTexture(3);
if (tex)
{
setupTexture(*tex);
activateTexture(3, tex);
}
for (uint k = 4; k < inlGetNumTextStages(); ++k)
{
activateTexture(k, NULL);
}
// setup the texture shaders
enableNVTextureShader(true);
activateTexEnvMode(0, texEnvReplace);
activateTexEnvMode(1, texEnvReplace);
nlctassert(IDRV_MAT_MAXTEXTURES == 4); // if this value changes, may have to change the arrays WaterNoDiffuseTexAddrMode & WaterTexAddrMode
if (mat.getTexture(3) == NULL)
{
setTextureShaders(WaterNoDiffuseTexAddrMode, mat._Textures);
activateTexEnvMode(2, texEnvReplace);
}
else
{
setTextureShaders(WaterTexAddrMode, mat._Textures);
activateTexEnvMode(2, texEnvReplace);
activateTexEnvMode(3, texEnvModulate);
}
}
// ***************************************************************************
void CDriverGL::setupWaterPass(uint /* pass */)
{
H_AUTO_OGL(CDriverGL_setupWaterPass)
nlassert (_CurrentMaterial);
CMaterial &mat = *_CurrentMaterial;
nlassert(_CurrentMaterial->getShader() == CMaterial::Water);
if (_Extensions.NVTextureShader)
{
setupWaterPassNV20(mat);
}
else if (ARBWaterShader[0])
{
setupWaterPassARB(mat);
}
else if (ATIWaterShaderHandleNoDiffuseMap)
{
setupWaterPassR200(mat);
}
}
// ***************************************************************************
void CDriverGL::endWaterMultiPass()
{
H_AUTO_OGL(CDriverGL_endWaterMultiPass)
nlassert(_CurrentMaterial->getShader() == CMaterial::Water);
Changed: #878 Fix typos in comments/code
2010-06-13 14:58:11 +00:00
// NB : as fragment shaders / programs bypass the texture envs, no special env enum is added (c.f CTexEnvSpecial)
initial version
2010-05-06 00:08:41 +00:00
if (_Extensions.NVTextureShader) return;
if (ARBWaterShader[0])
{
glDisable(GL_FRAGMENT_PROGRAM_ARB);
}
else if (ATIWaterShaderHandleNoDiffuseMap)
{
glDisable(GL_FRAGMENT_SHADER_ATI);
}
}
} // NL3D
Reference in a new issue Copy permalink