TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-13 15:44:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge pull request #442 from rextimmy/gfx_cleanup

Browse source 
Removed old fixed function code from GFX.
This commit is contained in:
Brian Roberts 2021-01-05 03:00:04 -06:00 • committed by GitHub
commit 4de1449c4b
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
62 changed files with 99 additions and 1692 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Engine/source/gfx/D3D11/gfxD3D11Device.cpp
View file

@ -961,7 +961,7 @@ void GFXD3D11Device::reacquireDefaultPoolResources()
mDynamicPB = new GFXD3D11PrimitiveBuffer(this, 0, 0, GFXBufferTypeDynamic);
D3D11_BUFFER_DESC desc;
desc.ByteWidth = sizeof(U16) * MAX_DYNAMIC_INDICES;
desc.ByteWidth = sizeof(U16) * GFX_MAX_DYNAMIC_INDICES;
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
@ -1019,7 +1019,7 @@ GFXD3D11VertexBuffer * GFXD3D11Device::createVBPool( const GFXVertexFormat *vert
vertexFormat->getDecl();
D3D11_BUFFER_DESC desc;
desc.ByteWidth = vertSize * MAX_DYNAMIC_VERTS;
desc.ByteWidth = vertSize * GFX_MAX_DYNAMIC_VERTS;
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
@ -1283,7 +1283,7 @@ GFXPrimitiveBuffer * GFXD3D11Device::allocPrimitiveBuffer(U32 numIndices, U32 nu
if(bufferType == GFXBufferTypeVolatile)
{
// Get it from the pool if it's a volatile...
AssertFatal(numIndices < MAX_DYNAMIC_INDICES, "Cannot allocate that many indices in a volatile buffer, increase MAX_DYNAMIC_INDICES.");
AssertFatal(numIndices < GFX_MAX_DYNAMIC_INDICES, "Cannot allocate that many indices in a volatile buffer, increase GFX_MAX_DYNAMIC_INDICES.");
res->ib = mDynamicPB->ib;
res->mVolatileBuffer = mDynamicPB;
@ -1362,7 +1362,7 @@ GFXVertexBuffer * GFXD3D11Device::allocVertexBuffer(U32 numVerts, const GFXVerte
if(bufferType == GFXBufferTypeVolatile)
{
// NOTE: Volatile VBs are pooled and will be allocated at lock time.
AssertFatal(numVerts <= MAX_DYNAMIC_VERTS, "GFXD3D11Device::allocVertexBuffer - Volatile vertex buffer is too big... see MAX_DYNAMIC_VERTS!");
AssertFatal(numVerts <= GFX_MAX_DYNAMIC_VERTS, "GFXD3D11Device::allocVertexBuffer - Volatile vertex buffer is too big... see GFX_MAX_DYNAMIC_VERTS!");
}
else
{

9
Engine/source/gfx/D3D11/gfxD3D11Device.h
View file

@ -176,11 +176,6 @@ protected:
/// Called by base GFXDevice to actually set a const buffer
virtual void setShaderConstBufferInternal(GFXShaderConstBuffer* buffer);
virtual void setMatrix( GFXMatrixType /*mtype*/, const MatrixF &/*mat*/ ) { };
virtual void setLightInternal(U32 /*lightStage*/, const GFXLightInfo /*light*/, bool /*lightEnable*/) { };
virtual void setLightMaterialInternal(const GFXLightMaterial /*mat*/) { };
virtual void setGlobalAmbientInternal(LinearColorF /*color*/) { };
// }
// Index buffer management
@ -286,8 +281,8 @@ public:
virtual void setVertexStreamFrequency( U32 stream, U32 frequency );
// }
virtual U32 getMaxDynamicVerts() { return MAX_DYNAMIC_VERTS; }
virtual U32 getMaxDynamicIndices() { return MAX_DYNAMIC_INDICES; }
virtual U32 getMaxDynamicVerts() { return GFX_MAX_DYNAMIC_VERTS; }
virtual U32 getMaxDynamicIndices() { return GFX_MAX_DYNAMIC_INDICES; }
inline U32 primCountToIndexCount(GFXPrimitiveType primType, U32 primitiveCount);

2
Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp
View file

@ -87,8 +87,6 @@ void GFXD3D11EnumTranslate::init()
GFXD3D11TextureFilter[GFXTextureFilterPoint] = D3D11_FILTER_MIN_MAG_MIP_POINT;
GFXD3D11TextureFilter[GFXTextureFilterLinear] = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
GFXD3D11TextureFilter[GFXTextureFilterAnisotropic] = D3D11_FILTER_ANISOTROPIC;
GFXD3D11TextureFilter[GFXTextureFilterPyramidalQuad] = D3D11_FILTER_ANISOTROPIC;
GFXD3D11TextureFilter[GFXTextureFilterGaussianQuad] = D3D11_FILTER_ANISOTROPIC;
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GFXD3D11Blend[GFXBlendZero] = D3D11_BLEND_ZERO;

4
Engine/source/gfx/D3D11/gfxD3D11PrimitiveBuffer.cpp
View file

@ -48,7 +48,7 @@ void GFXD3D11PrimitiveBuffer::lock(U32 indexStart, U32 indexEnd, void **indexPtr
case GFXBufferTypeVolatile:
// Get our range now...
AssertFatal(indexStart == 0, "Cannot get a subrange on a volatile buffer.");
AssertFatal(indexEnd < MAX_DYNAMIC_INDICES, "Cannot get more than MAX_DYNAMIC_INDICES in a volatile buffer. Up the constant!");
AssertFatal(indexEnd < GFX_MAX_DYNAMIC_INDICES, "Cannot get more than GFX_MAX_DYNAMIC_INDICES in a volatile buffer. Up the constant!");
// Get the primtive buffer
mVolatileBuffer = D3D11->mDynamicPB;
@ -56,7 +56,7 @@ void GFXD3D11PrimitiveBuffer::lock(U32 indexStart, U32 indexEnd, void **indexPtr
AssertFatal( mVolatileBuffer, "GFXD3D11PrimitiveBuffer::lock - No dynamic primitive buffer was available!");
// We created the pool when we requested this volatile buffer, so assume it exists...
if(mVolatileBuffer->mIndexCount + indexEnd > MAX_DYNAMIC_INDICES)
if(mVolatileBuffer->mIndexCount + indexEnd > GFX_MAX_DYNAMIC_INDICES)
{
flags = D3D11_MAP_WRITE_DISCARD;
mVolatileStart = indexStart = 0;

4
Engine/source/gfx/D3D11/gfxD3D11StateBlock.h
View file

@ -63,12 +63,12 @@ private:
D3D11_BLEND_DESC mBlendDesc;
D3D11_RASTERIZER_DESC mRasterizerDesc;
D3D11_DEPTH_STENCIL_DESC mDepthStencilDesc;
D3D11_SAMPLER_DESC mSamplerDesc[TEXTURE_STAGE_COUNT];
D3D11_SAMPLER_DESC mSamplerDesc[GFX_TEXTURE_STAGE_COUNT];
ID3D11BlendState* mBlendState;
ID3D11DepthStencilState* mDepthStencilState;
ID3D11RasterizerState* mRasterizerState;
ID3D11SamplerState* mSamplerStates[TEXTURE_STAGE_COUNT];
ID3D11SamplerState* mSamplerStates[GFX_TEXTURE_STAGE_COUNT];
GFXStateBlockDesc mDesc;
U32 mCachedHashValue;

2
Engine/source/gfx/D3D11/gfxD3D11TextureManager.h
View file

@ -54,7 +54,7 @@ protected:
bool _freeTexture(GFXTextureObject *texture, bool zombify = false);
private:
U32 mCurTexSet[TEXTURE_STAGE_COUNT];
U32 mCurTexSet[GFX_TEXTURE_STAGE_COUNT];
void _innerCreateTexture(GFXD3D11TextureObject *obj, U32 height, U32 width, U32 depth, GFXFormat format, GFXTextureProfile *profile, U32 numMipLevels, bool forceMips = false, S32 antialiasLevel = 0);
};

4
Engine/source/gfx/D3D11/gfxD3D11VertexBuffer.cpp
View file

@ -62,11 +62,11 @@ void GFXD3D11VertexBuffer::lock(U32 vertexStart, U32 vertexEnd, void **vertexPtr
// Get our range now...
AssertFatal(vertexStart == 0, "Cannot get a subrange on a volatile buffer.");
AssertFatal(vertexEnd <= MAX_DYNAMIC_VERTS, "Cannot get more than MAX_DYNAMIC_VERTS in a volatile buffer. Up the constant!");
AssertFatal(vertexEnd <= GFX_MAX_DYNAMIC_VERTS, "Cannot get more than GFX_MAX_DYNAMIC_VERTS in a volatile buffer. Up the constant!");
AssertFatal(mVolatileBuffer->lockedVertexStart == 0 && mVolatileBuffer->lockedVertexEnd == 0, "Got more than one lock on the volatile pool.");
// We created the pool when we requested this volatile buffer, so assume it exists...
if( mVolatileBuffer->mNumVerts + vertexEnd > MAX_DYNAMIC_VERTS )
if( mVolatileBuffer->mNumVerts + vertexEnd > GFX_MAX_DYNAMIC_VERTS )
{
flags = D3D11_MAP_WRITE_DISCARD;
mVolatileStart = vertexStart = 0;

5
Engine/source/gfx/Null/gfxNullDevice.cpp
View file

@ -354,11 +354,6 @@ void GFXNullDevice::enumerateAdapters( Vector<GFXAdapter*> &adapterList )
adapterList.push_back(toAdd);
}
void GFXNullDevice::setLightInternal(U32 lightStage, const GFXLightInfo light, bool lightEnable)
{
}
void GFXNullDevice::init( const GFXVideoMode &mode, PlatformWindow *window )
{
mCardProfiler = new GFXNullCardProfiler();

5
Engine/source/gfx/Null/gfxNullDevice.h
View file

@ -99,9 +99,6 @@ protected:
virtual void setTextureInternal(U32 textureUnit, const GFXTextureObject*texture) { };
virtual void setLightInternal(U32 lightStage, const GFXLightInfo light, bool lightEnable);
virtual void setLightMaterialInternal(const GFXLightMaterial mat) { };
virtual void setGlobalAmbientInternal(LinearColorF color) { };
/// @name State Initalization.
/// @{
@ -110,8 +107,6 @@ protected:
/// is created.
virtual void initStates() { };
virtual void setMatrix( GFXMatrixType mtype, const MatrixF &mat ) { };
virtual GFXVertexBuffer *allocVertexBuffer( U32 numVerts,
const GFXVertexFormat *vertexFormat,
U32 vertSize,

18
Engine/source/gfx/bitmap/gBitmap.cpp
View file

@ -882,20 +882,8 @@ U8 GBitmap::getChanelValueAt(U32 x, U32 y, U32 chan)
//-----------------------------------------------------------------------------
bool GBitmap::combine( const GBitmap *bitmapA, const GBitmap *bitmapB, const GFXTextureOp combineOp )
bool GBitmap::combine( const GBitmap *bitmapA, const GBitmap *bitmapB, const TextureOp combineOp )
{
// Check valid texture ops
switch( combineOp )
{
case GFXTOPAdd:
case GFXTOPSubtract:
break;
default:
Con::errorf( "GBitmap::combine - Invalid op type" );
return false;
}
// Check bitmapA format
switch( bitmapA->getFormat() )
{
@ -970,11 +958,11 @@ bool GBitmap::combine( const GBitmap *bitmapA, const GBitmap *bitmapB, const GFX
// Combine them (clamp values 0-U8_MAX)
switch( combineOp )
{
case GFXTOPAdd:
case Add:
*destBits++ = getMin( U8( pxA + pxB ), U8_MAX );
break;
case GFXTOPSubtract:
case Subtract:
*destBits++ = getMax( U8( pxA - pxB ), U8( 0 ) );
break;
default:

8
Engine/source/gfx/bitmap/gBitmap.h
View file

@ -62,6 +62,12 @@ public:
c_maxMipLevels = 13
};
enum TextureOp
{
Add,
Subtract
};
struct Registration
{
/// The read function prototype.
@ -218,7 +224,7 @@ public:
///
/// @note There are some restrictions on ops and formats that will probably change
/// based on how we use this function.
bool combine( const GBitmap *bitmapA, const GBitmap *bitmapB, const GFXTextureOp combineOp );
bool combine( const GBitmap *bitmapA, const GBitmap *bitmapB, const TextureOp combineOp );
/// Fills the first mip level of the bitmap with the specified color.
void fill( const ColorI &rColor );

65
Engine/source/gfx/gfxAPI.cpp
View file

@ -98,74 +98,9 @@ ImplementEnumType( GFXTextureFilterType,
{ GFXTextureFilterPoint, "GFXTextureFilterPoint" },
{ GFXTextureFilterLinear, "GFXTextureFilterLinear" },
{ GFXTextureFilterAnisotropic, "GFXTextureFilterAnisotropic" },
{ GFXTextureFilterPyramidalQuad, "GFXTextureFilterPyramidalQuad" },
{ GFXTextureFilterGaussianQuad, "GFXTextureFilterGaussianQuad" }
EndImplementEnumType;
ImplementEnumType( GFXTextureOp,
"The texture operators.\n"
"@ingroup GFX" )
{ GFXTOPDisable, "GFXTOPDisable" },
{ GFXTOPSelectARG1, "GFXTOPSelectARG1" },
{ GFXTOPSelectARG2, "GFXTOPSelectARG2" },
{ GFXTOPModulate, "GFXTOPModulate" },
{ GFXTOPModulate2X, "GFXTOPModulate2X" },
{ GFXTOPModulate4X, "GFXTOPModulate4X" },
{ GFXTOPAdd, "GFXTOPAdd" },
{ GFXTOPAddSigned, "GFXTOPAddSigned" },
{ GFXTOPAddSigned2X, "GFXTOPAddSigned2X" },
{ GFXTOPSubtract, "GFXTOPSubtract" },
{ GFXTOPAddSmooth, "GFXTOPAddSmooth" },
{ GFXTOPBlendDiffuseAlpha, "GFXTOPBlendDiffuseAlpha" },
{ GFXTOPBlendTextureAlpha, "GFXTOPBlendTextureAlpha" },
{ GFXTOPBlendFactorAlpha, "GFXTOPBlendFactorAlpha" },
{ GFXTOPBlendTextureAlphaPM, "GFXTOPBlendTextureAlphaPM" },
{ GFXTOPBlendCURRENTALPHA, "GFXTOPBlendCURRENTALPHA" },
{ GFXTOPPreModulate, "GFXTOPPreModulate" },
{ GFXTOPModulateAlphaAddColor, "GFXTOPModulateAlphaAddColor" },
{ GFXTOPModulateColorAddAlpha, "GFXTOPModulateColorAddAlpha" },
{ GFXTOPModulateInvAlphaAddColor, "GFXTOPModulateInvAlphaAddColor" },
{ GFXTOPModulateInvColorAddAlpha, "GFXTOPModulateInvColorAddAlpha" },
{ GFXTOPBumpEnvMap, "GFXTOPBumpEnvMap" },
{ GFXTOPBumpEnvMapLuminance, "GFXTOPBumpEnvMapLuminance" },
{ GFXTOPDotProduct3, "GFXTOPDotProduct3" },
{ GFXTOPLERP, "GFXTOPLERP" }
EndImplementEnumType;
ImplementEnumType( GFXTextureArgument,
"The texture arguments.\n"
"@ingroup GFX" )
{ GFXTADiffuse, "GFXTADiffuse" },
{ GFXTACurrent, "GFXTACurrent" },
{ GFXTATexture, "GFXTATexture" },
{ GFXTATFactor, "GFXTATFactor" },
{ GFXTASpecular, "GFXTASpecular" },
{ GFXTATemp, "GFXTATemp" },
{ GFXTAConstant, "GFXTAConstant" },
{ GFXTAComplement, "OneMinus" },
{ GFXTAAlphaReplicate, "AlphaReplicate" }
EndImplementEnumType;
ImplementEnumType( GFXTextureTransformFlags,
"The texture transform state flags.\n"
"@ingroup GFX" )
{ GFXTTFFDisable, "GFXTTFDisable" },
{ GFXTTFFCoord1D, "GFXTTFFCoord1D" },
{ GFXTTFFCoord2D, "GFXTTFFCoord2D" },
{ GFXTTFFCoord3D, "GFXTTFFCoord3D" },
{ GFXTTFFCoord4D, "GFXTTFFCoord4D" },
{ GFXTTFFProjected, "GFXTTFProjected" }
EndImplementEnumType;
ImplementEnumType( GFXFormat,
"The texture formats.\n"
"@note Not all formats are supported on all platforms.\n"

6
Engine/source/gfx/gfxAPI.h
View file

@ -40,10 +40,7 @@ DefineEnumType( GFXBlend );
DefineEnumType( GFXCmpFunc );
DefineEnumType( GFXTextureAddressMode );
DefineEnumType( GFXFormat );
DefineEnumType( GFXTextureTransformFlags );
DefineEnumType( GFXTextureFilterType );
DefineEnumType( GFXTextureOp );
DefineEnumType( GFXTextureArgument );
DefineEnumType( GFXCullMode );
DefineEnumType( GFXStencilOp );
DefineEnumType( GFXBlendOp );
@ -56,10 +53,7 @@ DefineConsoleType( TypeGFXBlend, GFXBlend );
DefineConsoleType( TypeGFXCmpFunc, GFXCmpFunc );
DefineConsoleType( TypeGFXTextureAddressMode, GFXTextureAddressMode );
DefineConsoleType( TypeGFXFormat, GFXFormat );
DefineConsoleType( TypeGFXTextureTransformFlags, GFXTextureTransformFlags );
DefineConsoleType( TypeGFXTextureFilterType, GFXTextureFilterType );
DefineConsoleType( TypeGFXTextureOp, GFXTextureOp );
DefineConsoleType( TypeGFXTextureArgument, GFXTextureArgument );
DefineConsoleType( TypeGFXCullMode, GFXCullMode );
DefineConsoleType( TypeGFXStencilOp, GFXStencilOp );
DefineConsoleType( TypeGFXBlendOp, GFXBlendOp );

137
Engine/source/gfx/gfxDevice.cpp
View file

@ -94,16 +94,12 @@ GFXDevice::GFXDevice()
VECTOR_SET_ASSOCIATION( mVideoModes );
VECTOR_SET_ASSOCIATION( mRTStack );
mWorldMatrixDirty = false;
mWorldStackSize = 0;
mProjectionMatrixDirty = false;
mViewMatrixDirty = false;
mTextureMatrixCheckDirty = false;
mViewMatrix.identity();
mProjectionMatrix.identity();
for( S32 i = 0; i < WORLD_STACK_MAX; i++ )
for( S32 i = 0; i < GFX_WORLD_STACK_MAX; i++ )
mWorldMatrix[i].identity();
AssertFatal(smGFXDevice == NULL, "Already a GFXDevice created! Bad!");
@ -123,8 +119,8 @@ GFXDevice::GFXDevice()
mPrimitiveBufferDirty = false;
mTexturesDirty = false;
// Use of TEXTURE_STAGE_COUNT in initialization is okay [7/2/2007 Pat]
for(U32 i = 0; i < TEXTURE_STAGE_COUNT; i++)
// Use of GFX_TEXTURE_STAGE_COUNT in initialization is okay [7/2/2007 Pat]
for(U32 i = 0; i < GFX_TEXTURE_STAGE_COUNT; i++)
{
mTextureDirty[i] = false;
mCurrentTexture[i] = NULL;
@ -136,24 +132,8 @@ GFXDevice::GFXDevice()
mCurrentTextureArray[i] = NULL;
mNewCubemapArray[i] = NULL;
mTexType[i] = GFXTDT_Normal;
mTextureMatrix[i].identity();
mTextureMatrixDirty[i] = false;
}
mLightsDirty = false;
for(U32 i = 0; i < LIGHT_STAGE_COUNT; i++)
{
mLightDirty[i] = false;
mCurrentLightEnable[i] = false;
}
mGlobalAmbientColorDirty = false;
mGlobalAmbientColor = LinearColorF(0.0f, 0.0f, 0.0f, 1.0f);
mLightMaterialDirty = false;
dMemset(&mCurrentLightMaterial, 0, sizeof(GFXLightMaterial));
// State block
mStateBlockDirty = false;
mCurrentStateBlock = NULL;
@ -173,8 +153,6 @@ GFXDevice::GFXDevice()
mViewport = RectI::Zero;
mViewportDirty = false;
mCurrentFrontBufferIdx = 0;
mDeviceSwizzle32 = NULL;
mDeviceSwizzle24 = NULL;
@ -260,7 +238,7 @@ GFXDevice::~GFXDevice()
mCurrentVertexBuffer[i] = NULL;
// Clear out our current texture references
for (U32 i = 0; i < TEXTURE_STAGE_COUNT; i++)
for (U32 i = 0; i < GFX_TEXTURE_STAGE_COUNT; i++)
{
mCurrentTexture[i] = NULL;
mNewTexture[i] = NULL;
@ -367,10 +345,6 @@ void GFXDevice::updateStates(bool forceSetAll /*=false*/)
rememberToEndScene = true;
}
setMatrix( GFXMatrixProjection, mProjectionMatrix );
setMatrix( GFXMatrixWorld, mWorldMatrix[mWorldStackSize] );
setMatrix( GFXMatrixView, mViewMatrix );
setVertexDecl( mCurrVertexDecl );
for ( U32 i=0; i < VERTEX_STREAM_COUNT; i++ )
@ -430,15 +404,6 @@ void GFXDevice::updateStates(bool forceSetAll /*=false*/)
}
}
// Set our material
setLightMaterialInternal(mCurrentLightMaterial);
// Set our lights
for(U32 i = 0; i < LIGHT_STAGE_COUNT; i++)
{
setLightInternal(i, mCurrentLight[i], mCurrentLightEnable[i]);
}
_updateRenderTargets();
if(rememberToEndScene)
@ -453,42 +418,6 @@ void GFXDevice::updateStates(bool forceSetAll /*=false*/)
// Normal update logic begins here.
mStateDirty = false;
// Update Projection Matrix
if( mProjectionMatrixDirty )
{
setMatrix( GFXMatrixProjection, mProjectionMatrix );
mProjectionMatrixDirty = false;
}
// Update World Matrix
if( mWorldMatrixDirty )
{
setMatrix( GFXMatrixWorld, mWorldMatrix[mWorldStackSize] );
mWorldMatrixDirty = false;
}
// Update View Matrix
if( mViewMatrixDirty )
{
setMatrix( GFXMatrixView, mViewMatrix );
mViewMatrixDirty = false;
}
if( mTextureMatrixCheckDirty )
{
for( S32 i = 0; i < getNumSamplers(); i++ )
{
if( mTextureMatrixDirty[i] )
{
mTextureMatrixDirty[i] = false;
setMatrix( (GFXMatrixType)(GFXMatrixTexture + i), mTextureMatrix[i] );
}
}
mTextureMatrixCheckDirty = false;
}
// Update the vertex declaration.
if ( mVertexDeclDirty )
{
@ -587,27 +516,6 @@ void GFXDevice::updateStates(bool forceSetAll /*=false*/)
}
}
}
// Set light material
if(mLightMaterialDirty)
{
setLightMaterialInternal(mCurrentLightMaterial);
mLightMaterialDirty = false;
}
// Set our lights
if(mLightsDirty)
{
mLightsDirty = false;
for(U32 i = 0; i < LIGHT_STAGE_COUNT; i++)
{
if(!mLightDirty[i])
continue;
mLightDirty[i] = false;
setLightInternal(i, mCurrentLight[i], mCurrentLightEnable[i]);
}
}
_updateRenderTargets();
@ -762,43 +670,6 @@ Point2F GFXDevice::getWorldToScreenScale() const
return scale;
}
//-----------------------------------------------------------------------------
// Set Light
//-----------------------------------------------------------------------------
void GFXDevice::setLight(U32 stage, GFXLightInfo* light)
{
AssertFatal(stage < LIGHT_STAGE_COUNT, "GFXDevice::setLight - out of range stage!");
if(!mLightDirty[stage])
{
mStateDirty = true;
mLightsDirty = true;
mLightDirty[stage] = true;
}
mCurrentLightEnable[stage] = (light != NULL);
if(mCurrentLightEnable[stage])
mCurrentLight[stage] = *light;
}
//-----------------------------------------------------------------------------
// Set Light Material
//-----------------------------------------------------------------------------
void GFXDevice::setLightMaterial(const GFXLightMaterial& mat)
{
mCurrentLightMaterial = mat;
mLightMaterialDirty = true;
mStateDirty = true;
}
void GFXDevice::setGlobalAmbientColor(const LinearColorF& color)
{
if(mGlobalAmbientColor != color)
{
mGlobalAmbientColor = color;
mGlobalAmbientColorDirty = true;
}
}
//-----------------------------------------------------------------------------
// Set texture
//-----------------------------------------------------------------------------

135
Engine/source/gfx/gfxDevice.h
View file

@ -72,9 +72,7 @@ class GFXShaderConstBuffer;
class GFXTextureManager;
// Global macro
#define GFX GFXDevice::get()
#define MAX_MRT_TARGETS 4
#define GFX GFXDevice::get()
//-----------------------------------------------------------------------------
@ -185,10 +183,6 @@ private:
friend class GFXTextureObject;
friend class GFXTexHandle;
friend class GFXVertexFormat;
friend class GFXTestFullscreenToggle;
friend class TestGFXTextureCube;
friend class TestGFXRenderTargetCube;
friend class TestGFXRenderTargetStack;
friend class GFXResource;
friend class LightMatInstance; // For stencil interface
@ -220,11 +214,11 @@ public:
/// The device has started rendering a frame's field (such as for side-by-side rendering)
deStartOfField,
/// left stereo frame has been rendered
deLeftStereoFrameRendered,
/// left stereo frame has been rendered
deLeftStereoFrameRendered,
/// right stereo frame has been rendered
deRightStereoFrameRendered,
/// right stereo frame has been rendered
deRightStereoFrameRendered,
/// The device is about to finish rendering a frame's field
deEndOfField,
@ -255,7 +249,7 @@ public:
{
RS_Standard = 0,
RS_StereoSideBySide = (1<<0), // Render into current Render Target side-by-side
RS_StereoSeparate = (1<<1) // Render in two separate passes (then combined by vr compositor)
RS_StereoSeparate = (1<<1) // Render in two separate passes (then combined by vr compositor)
};
enum GFXDeviceLimits
@ -503,17 +497,17 @@ protected:
GFXTDT_TextureArray
};
GFXTexHandle mCurrentTexture[TEXTURE_STAGE_COUNT];
GFXTexHandle mNewTexture[TEXTURE_STAGE_COUNT];
GFXCubemapHandle mCurrentCubemap[TEXTURE_STAGE_COUNT];
GFXCubemapHandle mNewCubemap[TEXTURE_STAGE_COUNT];
GFXCubemapArrayHandle mCurrentCubemapArray[TEXTURE_STAGE_COUNT];
GFXCubemapArrayHandle mNewCubemapArray[TEXTURE_STAGE_COUNT];
GFXTextureArrayHandle mCurrentTextureArray[TEXTURE_STAGE_COUNT];
GFXTextureArrayHandle mNewTextureArray[TEXTURE_STAGE_COUNT];
GFXTexHandle mCurrentTexture[GFX_TEXTURE_STAGE_COUNT];
GFXTexHandle mNewTexture[GFX_TEXTURE_STAGE_COUNT];
GFXCubemapHandle mCurrentCubemap[GFX_TEXTURE_STAGE_COUNT];
GFXCubemapHandle mNewCubemap[GFX_TEXTURE_STAGE_COUNT];
GFXCubemapArrayHandle mCurrentCubemapArray[GFX_TEXTURE_STAGE_COUNT];
GFXCubemapArrayHandle mNewCubemapArray[GFX_TEXTURE_STAGE_COUNT];
GFXTextureArrayHandle mCurrentTextureArray[GFX_TEXTURE_STAGE_COUNT];
GFXTextureArrayHandle mNewTextureArray[GFX_TEXTURE_STAGE_COUNT];
TexDirtyType mTexType[TEXTURE_STAGE_COUNT];
bool mTextureDirty[TEXTURE_STAGE_COUNT];
TexDirtyType mTexType[GFX_TEXTURE_STAGE_COUNT];
bool mTextureDirty[GFX_TEXTURE_STAGE_COUNT];
bool mTexturesDirty;
// This maps a GFXStateBlockDesc hash value to a GFXStateBlockRef
@ -542,60 +536,26 @@ protected:
/// @}
/// @name Light Tracking
/// @{
GFXLightInfo mCurrentLight[LIGHT_STAGE_COUNT];
bool mCurrentLightEnable[LIGHT_STAGE_COUNT];
bool mLightDirty[LIGHT_STAGE_COUNT];
bool mLightsDirty;
LinearColorF mGlobalAmbientColor;
bool mGlobalAmbientColorDirty;
/// @}
/// @name Fixed function material tracking
/// @{
GFXLightMaterial mCurrentLightMaterial;
bool mLightMaterialDirty;
/// @}
/// @name Bitmap modulation and color stack
/// @{
///
/// @}
/// @see getDeviceSwizzle32
Swizzle<U8, 4> *mDeviceSwizzle32;
/// @see getDeviceSwizzle24
Swizzle<U8, 3> *mDeviceSwizzle24;
//-----------------------------------------------------------------------------
/// @name Matrix managing variables
/// @{
///
MatrixF mWorldMatrix[WORLD_STACK_MAX];
bool mWorldMatrixDirty;
MatrixF mWorldMatrix[GFX_WORLD_STACK_MAX];
S32 mWorldStackSize;
MatrixF mProjectionMatrix;
bool mProjectionMatrixDirty;
MatrixF mViewMatrix;
bool mViewMatrixDirty;
MatrixF mTextureMatrix[TEXTURE_STAGE_COUNT];
bool mTextureMatrixDirty[TEXTURE_STAGE_COUNT];
bool mTextureMatrixCheckDirty;
/// @}
/// @name Current frustum planes
@ -621,10 +581,6 @@ protected:
virtual void setTextureInternal(U32 textureUnit, const GFXTextureObject*texture) = 0;
virtual void setLightInternal(U32 lightStage, const GFXLightInfo light, bool lightEnable) = 0;
virtual void setGlobalAmbientInternal(LinearColorF color) = 0;
virtual void setLightMaterialInternal(const GFXLightMaterial mat) = 0;
virtual bool beginSceneInternal() = 0;
virtual void endSceneInternal() = 0;
@ -637,21 +593,6 @@ protected:
/// @}
//-----------------------------------------------------------------------------
/// This function must be implemented differently per
/// API and it should set ONLY the current matrix.
/// For example, in OpenGL, there should be NO matrix stack
/// activity, all the stack stuff is managed in the GFX layer.
///
/// OpenGL does not have separate world and
/// view matrices. It has ModelView which is world * view.
/// You must take this into consideration.
///
/// @param mtype Which matrix to set, world/view/projection
/// @param mat Matrix to assign
virtual void setMatrix( GFXMatrixType mtype, const MatrixF &mat ) = 0;
//-----------------------------------------------------------------------------
protected:
@ -711,14 +652,8 @@ protected:
/// @}
//---------------------------------------
// SFX buffer
//---------------------------------------
protected:
GFXTexHandle mFrontBuffer[2];
U32 mCurrentFrontBufferIdx;
//---------------------------------------
// Render target related
//---------------------------------------
@ -850,8 +785,6 @@ public:
virtual void endField();
PlatformTimer *mFrameTime;
virtual GFXTexHandle & getFrontBuffer(){ return mFrontBuffer[mCurrentFrontBufferIdx]; }
void setPrimitiveBuffer( GFXPrimitiveBuffer *buffer );
/// Sets the vertex buffer.
@ -924,7 +857,6 @@ public:
void drawPrimitive( const GFXPrimitive &prim );
void drawPrimitive( U32 primitiveIndex );
void drawPrimitives();
void drawPrimitiveBuffer( GFXPrimitiveBuffer *buffer );
/// @}
//-----------------------------------------------------------------------------
@ -936,18 +868,8 @@ public:
/// Returns a hardware occlusion query object or NULL
/// if this device does not support them.
virtual GFXOcclusionQuery* createOcclusionQuery() { return NULL; }
/// @name Light Settings
/// NONE of these should be overridden by API implementations
/// because of the state caching stuff.
/// @{
void setLight(U32 stage, GFXLightInfo* light);
void setLightMaterial(const GFXLightMaterial& mat);
void setGlobalAmbientColor(const LinearColorF& color);
/// @}
virtual GFXOcclusionQuery* createOcclusionQuery() { return NULL; }
/// @name Texture State Settings
/// NONE of these should be overridden by API implementations
/// because of the state caching stuff.
@ -1136,23 +1058,20 @@ public:
inline void GFXDevice::setWorldMatrix( const MatrixF &newWorld )
{
mWorldMatrixDirty = true;
mStateDirty = true;
mWorldMatrix[mWorldStackSize] = newWorld;
}
inline void GFXDevice::pushWorldMatrix()
{
mWorldMatrixDirty = true;
mStateDirty = true;
mWorldStackSize++;
AssertFatal( mWorldStackSize < WORLD_STACK_MAX, "GFX: Exceeded world matrix stack size" );
AssertFatal( mWorldStackSize < GFX_WORLD_STACK_MAX, "GFX: Exceeded world matrix stack size" );
mWorldMatrix[mWorldStackSize] = mWorldMatrix[mWorldStackSize - 1];
}
inline void GFXDevice::popWorldMatrix()
{
mWorldMatrixDirty = true;
mStateDirty = true;
mWorldStackSize--;
AssertFatal( mWorldStackSize >= 0, "GFX: Negative WorldStackSize!" );
@ -1160,14 +1079,12 @@ inline void GFXDevice::popWorldMatrix()
inline void GFXDevice::multWorld( const MatrixF &mat )
{
mWorldMatrixDirty = true;
mStateDirty = true;
mWorldMatrix[mWorldStackSize].mul(mat);
}
inline void GFXDevice::setProjectionMatrix( const MatrixF &newProj )
{
mProjectionMatrixDirty = true;
mStateDirty = true;
mProjectionMatrix = newProj;
}
@ -1175,19 +1092,9 @@ inline void GFXDevice::setProjectionMatrix( const MatrixF &newProj )
inline void GFXDevice::setViewMatrix( const MatrixF &newView )
{
mStateDirty = true;
mViewMatrixDirty = true;
mViewMatrix = newView;
}
inline void GFXDevice::setTextureMatrix( const U32 stage, const MatrixF &texMat )
{
AssertFatal( stage < TEXTURE_STAGE_COUNT, "Out of range texture sampler" );
mStateDirty = true;
mTextureMatrixDirty[stage] = true;
mTextureMatrix[stage] = texMat;
mTextureMatrixCheckDirty = true;
}
//-----------------------------------------------------------------------------
// Buffer management

301
Engine/source/gfx/gfxEnums.h
View file

@ -34,24 +34,28 @@
// expensive than static vertices. These are in gfxEnums because they should be
// consistant across all APIs/platforms so that the dynamic buffer performance
// and behavior is also consistant. -patw
#define MAX_DYNAMIC_VERTS (8192*2)
#define MAX_DYNAMIC_INDICES (8192*4)
#define GFX_MAX_DYNAMIC_VERTS (8192*2)
#define GFX_MAX_DYNAMIC_INDICES (8192*4)
#define GFX_WORLD_STACK_MAX 24
#define GFX_TEXTURE_STAGE_COUNT 16
enum GFXBufferType
{
GFXBufferTypeStatic, ///< Static vertex buffers are created and rarely updated.
///< Updating might incur a performance penalty. Resizing a static vertex buffer is not
///< allowed.
GFXBufferTypeDynamic, ///< Dynamic vertex buffers are meant for vertices that can be changed
///< often. Vertices written into dynamic vertex buffers will remain valid
///< until the dynamic vertex buffer is released. Resizing a dynamic vertex buffer is not
///< allowed.
GFXBufferTypeVolatile, ///< Volatile vertex or index buffers are meant for vertices or indices that are essentially
///< only used once. They can be resized without any performance penalty.
GFXBufferTypeStatic, ///< Static vertex buffers are created and rarely updated.
///< Updating might incur a performance penalty. Resizing a static vertex buffer is not
///< allowed.
GFXBufferTypeDynamic, ///< Dynamic vertex buffers are meant for vertices that can be changed
///< often. Vertices written into dynamic vertex buffers will remain valid
///< until the dynamic vertex buffer is released. Resizing a dynamic vertex buffer is not
///< allowed.
GFXBufferTypeVolatile, ///< Volatile vertex or index buffers are meant for vertices or indices that are essentially
///< only used once. They can be resized without any performance penalty.
GFXBufferTypeImmutable, ///< Immutable buffers must specify the data when creating the buffer. Cannot be modified.
GFXBufferTypeImmutable, ///< Immutable buffers must specify the data when creating the buffer. Cannot be modified.
GFXBufferType_COUNT ///< Number of buffer types.
GFXBufferType_COUNT ///< Number of buffer types.
};
enum GFXTexCallbackCode
@ -60,7 +64,6 @@ enum GFXTexCallbackCode
GFXResurrect,
};
enum GFXPrimitiveType
{
GFXPT_FIRST = 0,
@ -72,15 +75,6 @@ enum GFXPrimitiveType
GFXPT_COUNT
};
enum GFXTextureType
{
GFXTextureType_Normal,
GFXTextureType_KeepBitmap,
GFXTextureType_Dynamic,
GFXTextureType_RenderTarget,
GFXTextureType_Count
};
enum GFXBitmapFlip
{
GFXBitmapFlip_None = 0,
@ -89,37 +83,6 @@ enum GFXBitmapFlip
GFXBitmapFlip_XY = GFXBitmapFlip_X | GFXBitmapFlip_Y
};
enum GFXTextureOp
{
GFXTOP_FIRST = 0,
GFXTOPDisable = 0,
GFXTOPSelectARG1,
GFXTOPSelectARG2,
GFXTOPModulate,
GFXTOPModulate2X,
GFXTOPModulate4X,
GFXTOPAdd,
GFXTOPAddSigned,
GFXTOPAddSigned2X,
GFXTOPSubtract,
GFXTOPAddSmooth,
GFXTOPBlendDiffuseAlpha,
GFXTOPBlendTextureAlpha,
GFXTOPBlendFactorAlpha,
GFXTOPBlendTextureAlphaPM,
GFXTOPBlendCURRENTALPHA,
GFXTOPPreModulate,
GFXTOPModulateAlphaAddColor,
GFXTOPModulateColorAddAlpha,
GFXTOPModulateInvAlphaAddColor,
GFXTOPModulateInvColorAddAlpha,
GFXTOPBumpEnvMap,
GFXTOPBumpEnvMapLuminance,
GFXTOPDotProduct3,
GFXTOPLERP,
GFXTOP_COUNT
};
enum GFXTextureAddressMode
{
GFXAddress_FIRST = 0,
@ -138,8 +101,6 @@ enum GFXTextureFilterType
GFXTextureFilterPoint,
GFXTextureFilterLinear,
GFXTextureFilterAnisotropic,
GFXTextureFilterPyramidalQuad,
GFXTextureFilterGaussianQuad,
GFXTextureFilter_COUNT
};
@ -248,13 +209,6 @@ inline U32 GFXFormat_getByteSize( GFXFormat format )
return 16;
}
enum GFXShadeMode
{
GFXShadeFlat = 1,
GFXShadeGouraud,
GFXShadePhong,
};
enum GFXClearFlags
{
GFXClearTarget = 1 << 0,
@ -328,13 +282,6 @@ enum GFXStencilOp
GFXStencilOp_COUNT
};
enum GFXMaterialColorSource
{
GFXMCSMaterial = 0,
GFXMCSColor1,
GFXMCSColor2,
};
enum GFXBlendOp
{
GFXBlendOp_FIRST = 0,
@ -346,195 +293,6 @@ enum GFXBlendOp
GFXBlendOp_COUNT
};
enum GFXRenderState
{
GFXRenderState_FIRST = 0,
GFXRSZEnable = 0,
GFXRSFillMode,
GFXRSShadeMode,
GFXRSZWriteEnable,
GFXRSAlphaTestEnable,
GFXRSLastPixel,
GFXRSSrcBlend,
GFXRSDestBlend,
GFXRSCullMode,
GFXRSZFunc,
GFXRSAlphaRef,
GFXRSAlphaFunc,
GFXRSDitherEnable,
GFXRSAlphaBlendEnable,
GFXRSFogEnable,
GFXRSSpecularEnable,
GFXRSFogColor,
GFXRSFogTableMode,
GFXRSFogStart,
GFXRSFogEnd,
GFXRSFogDensity,
GFXRSRangeFogEnable,
GFXRSStencilEnable,
GFXRSStencilFail,
GFXRSStencilZFail,
GFXRSStencilPass,
GFXRSStencilFunc,
GFXRSStencilRef,
GFXRSStencilMask,
GFXRSStencilWriteMask,
GFXRSTextureFactor,
GFXRSWrap0,
GFXRSWrap1,
GFXRSWrap2,
GFXRSWrap3,
GFXRSWrap4,
GFXRSWrap5,
GFXRSWrap6,
GFXRSWrap7,
GFXRSClipping,
GFXRSLighting,
GFXRSAmbient,
GFXRSFogVertexMode,
GFXRSColorVertex,
GFXRSLocalViewer,
GFXRSNormalizeNormals,
GFXRSDiffuseMaterialSource,
GFXRSSpecularMaterialSource,
GFXRSAmbientMaterialSource,
GFXRSEmissiveMaterialSource,
GFXRSVertexBlend,
GFXRSClipPlaneEnable,
GFXRSPointSize,
GFXRSPointSizeMin,
GFXRSPointSpriteEnable,
GFXRSPointScaleEnable,
GFXRSPointScale_A,
GFXRSPointScale_B,
GFXRSPointScale_C,
GFXRSMultiSampleantiAlias,
GFXRSMultiSampleMask,
GFXRSPatchEdgeStyle,
GFXRSDebugMonitorToken,
GFXRSPointSize_Max,
GFXRSIndexedVertexBlendEnable,
GFXRSColorWriteEnable,
GFXRSTweenFactor,
GFXRSBlendOp,
GFXRSPositionDegree,
GFXRSNormalDegree,
GFXRSScissorTestEnable,
GFXRSSlopeScaleDepthBias,
GFXRSAntiAliasedLineEnable,
GFXRSMinTessellationLevel,
GFXRSMaxTessellationLevel,
GFXRSAdaptiveTess_X,
GFXRSAdaptiveTess_Y,
GFXRSdaptiveTess_Z,
GFXRSAdaptiveTess_W,
GFXRSEnableAdaptiveTesselation,
GFXRSTwoSidedStencilMode,
GFXRSCCWStencilFail,
GFXRSCCWStencilZFail,
GFXRSCCWStencilPass,
GFXRSCCWStencilFunc,
GFXRSColorWriteEnable1,
GFXRSColorWriteEnable2,
GFXRSolorWriteEnable3,
GFXRSBlendFactor,
GFXRSSRGBWriteEnable,
GFXRSDepthBias,
GFXRSWrap8,
GFXRSWrap9,
GFXRSWrap10,
GFXRSWrap11,
GFXRSWrap12,
GFXRSWrap13,
GFXRSWrap14,
GFXRSWrap15,
GFXRSSeparateAlphaBlendEnable,
GFXRSSrcBlendAlpha,
GFXRSDestBlendAlpha,
GFXRSBlendOpAlpha,
GFXRenderState_COUNT ///< Don't use this one, this is a counter
};
#define GFXCOLORWRITEENABLE_RED 1
#define GFXCOLORWRITEENABLE_GREEN 2
#define GFXCOLORWRITEENABLE_BLUE 4
#define GFXCOLORWRITEENABLE_ALPHA 8
enum GFXTextureStageState
{
GFXTSS_FIRST = 0,
GFXTSSColorOp = 0,
GFXTSSColorArg1,
GFXTSSColorArg2,
GFXTSSAlphaOp,
GFXTSSAlphaArg1,
GFXTSSAlphaArg2,
GFXTSSBumpEnvMat00,
GFXTSSBumpEnvMat01,
GFXTSSBumpEnvMat10,
GFXTSSBumpEnvMat11,
GFXTSSTexCoordIndex,
GFXTSSBumpEnvlScale,
GFXTSSBumpEnvlOffset,
GFXTSSTextureTransformFlags,
GFXTSSColorArg0,
GFXTSSAlphaArg0,
GFXTSSResultArg,
GFXTSSConstant,
GFXTSS_COUNT ///< Don't use this one, this is a counter
};
enum GFXTextureTransformFlags
{
GFXTTFFDisable = 0,
GFXTTFFCoord1D = 1,
GFXTTFFCoord2D = 2,
GFXTTFFCoord3D = 3,
GFXTTFFCoord4D = 4,
GFXTTFFProjected = 256,
};
// CodeReview: This number is used for the declaration of variables, but it
// should *not* be used for any run-time purposes [7/2/2007 Pat]
#define TEXTURE_STAGE_COUNT 16
enum GFXSamplerState
{
GFXSAMP_FIRST = 0,
GFXSAMPAddressU = 0,
GFXSAMPAddressV,
GFXSAMPAddressW,
GFXSAMPBorderColor,
GFXSAMPMagFilter,
GFXSAMPMinFilter,
GFXSAMPMipFilter,
GFXSAMPMipMapLODBias,
GFXSAMPMaxMipLevel,
GFXSAMPMaxAnisotropy,
GFXSAMPSRGBTexture,
GFXSAMPElementIndex,
GFXSAMPDMapOffset,
GFXSAMP_COUNT ///< Don't use this one, this is a counter
};
enum GFXTextureArgument
{
GFXTA_FIRST = 0,
GFXTADiffuse = 0,
GFXTACurrent,
GFXTATexture,
GFXTATFactor,
GFXTASpecular,
GFXTATemp,
GFXTAConstant,
GFXTA_COUNT,
GFXTAComplement = 0x00000010, // take 1.0 - x (read modifier)
GFXTAAlphaReplicate = 0x00000020, // replicate alpha to color components (read modifier)
};
// Matrix stuff
#define WORLD_STACK_MAX 24
enum GFXMatrixType
{
GFXMatrixWorld = 256,
@ -551,30 +309,6 @@ enum GFXMatrixType
GFXMatrixTexture7 = 23,
};
// Light define
#define LIGHT_STAGE_COUNT 8
#define GFXVERTEXFLAG_F32 3
#define GFXVERTEXFLAG_POINT2F 0
#define GFXVERTEXFLAG_POINT3F 1
#define GFXVERTEXFLAG_POINT4F 2
#define GFXVERTEXFLAG_TEXCOORD_F32(CoordIndex) ( GFXVERTEXFLAG_F32 << ( CoordIndex * 2 + 16 ) )
#define GFXVERTEXFLAG_TEXCOORD_POINT2F(CoordIndex) ( GFXVERTEXFLAG_POINT2F )
#define GFXVERTEXFLAG_TEXCOORD_POINT3F(CoordIndex) ( GFXVERTEXFLAG_POINT3F << ( CoordIndex * 2 + 16 ) )
#define GFXVERTEXFLAG_TEXCOORD_POINT4F(CoordIndex) ( GFXVERTEXFLAG_POINT4F << ( CoordIndex * 2 + 16 ) )
#define STATE_STACK_SIZE 32
// Index Formats
enum GFXIndexFormat
{
GFXIndexFormat_FIRST = 0,
GFXIndexFormat16 = 0,
GFXIndexFormat32,
GFXIndexFormat_COUNT
};
enum GFXShaderConstType
{
/// GFX"S"hader"C"onstant"T"ype
@ -603,7 +337,6 @@ enum GFXShaderConstType
GFXSCT_SamplerTextureArray
};
/// Defines a vertex declaration type.
/// @see GFXVertexElement
/// @see GFXVertexFormat

8
Engine/source/gfx/gfxFontRenderBatcher.cpp
View file

@ -40,18 +40,10 @@ FontRenderBatcher::FontRenderBatcher() : mStorage(8096)
f.blendSrc = GFXBlendSrcAlpha;
f.blendDest = GFXBlendInvSrcAlpha;
f.samplersDefined = true;
f.samplers[0].alphaOp = GFXTOPModulate;
f.samplers[0].magFilter = GFXTextureFilterPoint;
f.samplers[0].minFilter = GFXTextureFilterPoint;
f.samplers[0].addressModeU = GFXAddressClamp;
f.samplers[0].addressModeV = GFXAddressClamp;
f.samplers[0].alphaArg1 = GFXTATexture;
f.samplers[0].alphaArg2 = GFXTADiffuse;
// This is an add operation because in D3D, when a texture of format D3DFMT_A8
// is used, the RGB channels are all set to 0. Therefore a modulate would
// result in the text always being black. This may not be the case in OpenGL
// so it may have to change. -bramage
f.samplers[0].textureColorOp = GFXTOPAdd;
f.setColorWrites(true, true, true, false); // NOTE: comment this out if alpha write is needed
mFontSB = GFX->createStateBlock(f);

23
Engine/source/gfx/gfxStateBlock.cpp
View file

@ -88,9 +88,6 @@ GFXStateBlockDesc::GFXStateBlockDesc()
stencilMask = 0xFFFFFFFF;
stencilWriteMask = 0xFFFFFFFF;
// FF lighting
ffLighting = false;
vertexColorEnable = false;
fillMode = GFXFillSolid;
@ -183,7 +180,7 @@ void GFXStateBlockDesc::addDesc(const GFXStateBlockDesc& desc)
if (desc.samplersDefined)
{
samplersDefined = true;
for (U32 i = 0; i < TEXTURE_STAGE_COUNT; i++)
for (U32 i = 0; i < GFX_TEXTURE_STAGE_COUNT; i++)
{
samplers[i] = desc.samplers[i];
}
@ -214,8 +211,6 @@ const String GFXStateBlockDesc::describeSelf() const
ret += String::ToString(" Stencil: %d, StencilFailOp: %s, StencilZFailOp: %s, StencilPassOp: %s, \n stencilFunc: %s, stencilRef: %d, stencilMask: 0x%x, stencilWriteMask: 0x%x\n",
stencilEnable, GFXStringCmpFunc[stencilFailOp], GFXStringCmpFunc[stencilZFailOp], GFXStringCmpFunc[stencilPassOp],
GFXStringCmpFunc[stencilFunc], stencilRef, stencilMask, stencilWriteMask);
ret += String::ToString(" FF Lighting: %d, VertexColors: %d, fillMode: %s",
ffLighting, vertexColorEnable, GFXStringFillMode[fillMode]);
return ret;
}
@ -274,7 +269,6 @@ void GFXStateBlockDesc::setColorWrites( bool red, bool green, bool blue, bool al
GFXSamplerStateDesc::GFXSamplerStateDesc()
{
textureColorOp = GFXTOPDisable;
addressModeU = GFXAddressWrap;
addressModeV = GFXAddressWrap;
addressModeW = GFXAddressWrap;
@ -283,15 +277,6 @@ GFXSamplerStateDesc::GFXSamplerStateDesc()
mipFilter = GFXTextureFilterLinear;
samplerFunc = GFXCmpNever;
maxAnisotropy = 1;
alphaArg1 = GFXTATexture;
alphaArg2 = GFXTADiffuse;
alphaArg3 = GFXTACurrent;
colorArg1 = GFXTACurrent;
colorArg2 = GFXTATexture;
colorArg3 = GFXTACurrent;
alphaOp = GFXTOPModulate;
textureTransform = GFXTTFFDisable;
resultArg = GFXTACurrent;
mipLODBias = 0.0f;
}
@ -299,14 +284,12 @@ GFXSamplerStateDesc GFXSamplerStateDesc::getWrapLinear()
{
// Linear with wrapping is already the default
GFXSamplerStateDesc ssd;
ssd.textureColorOp = GFXTOPModulate;
return ssd;
}
GFXSamplerStateDesc GFXSamplerStateDesc::getWrapPoint()
{
GFXSamplerStateDesc ssd;
ssd.textureColorOp = GFXTOPModulate;
ssd.magFilter = GFXTextureFilterPoint;
ssd.minFilter = GFXTextureFilterPoint;
ssd.mipFilter = GFXTextureFilterPoint;
@ -316,7 +299,6 @@ GFXSamplerStateDesc GFXSamplerStateDesc::getWrapPoint()
GFXSamplerStateDesc GFXSamplerStateDesc::getClampLinear()
{
GFXSamplerStateDesc ssd;
ssd.textureColorOp = GFXTOPModulate;
ssd.addressModeU = GFXAddressClamp;
ssd.addressModeV = GFXAddressClamp;
ssd.addressModeW = GFXAddressClamp;
@ -326,7 +308,6 @@ GFXSamplerStateDesc GFXSamplerStateDesc::getClampLinear()
GFXSamplerStateDesc GFXSamplerStateDesc::getClampPoint()
{
GFXSamplerStateDesc ssd;
ssd.textureColorOp = GFXTOPModulate;
ssd.addressModeU = GFXAddressClamp;
ssd.addressModeV = GFXAddressClamp;
ssd.addressModeW = GFXAddressClamp;
@ -334,4 +315,4 @@ GFXSamplerStateDesc GFXSamplerStateDesc::getClampPoint()
ssd.minFilter = GFXTextureFilterPoint;
ssd.mipFilter = GFXTextureFilterPoint;
return ssd;
}
}

20
Engine/source/gfx/gfxStateBlock.h
View file

@ -63,21 +63,6 @@ struct GFXSamplerStateDesc
/// Defaults to zero.
F32 mipLODBias;
GFXTextureOp textureColorOp;
GFXTextureOp alphaOp;
GFXTextureArgument alphaArg1;
GFXTextureArgument alphaArg2;
GFXTextureArgument alphaArg3;
GFXTextureArgument colorArg1;
GFXTextureArgument colorArg2;
GFXTextureArgument colorArg3;
GFXTextureArgument resultArg;
GFXTextureTransformFlags textureTransform;
GFXSamplerStateDesc();
/// Returns an modulate, wrap, and linear sampled state.
@ -153,16 +138,13 @@ struct GFXStateBlockDesc
U32 stencilMask;
U32 stencilWriteMask;
// FF lighting
bool ffLighting;
bool vertexColorEnable;
GFXFillMode fillMode;
// Sampler states
bool samplersDefined;
GFXSamplerStateDesc samplers[TEXTURE_STAGE_COUNT];
GFXSamplerStateDesc samplers[GFX_TEXTURE_STAGE_COUNT];
ColorI textureFactor;
GFXStateBlockDesc();

203
Engine/source/gfx/gfxStringEnumTranslate.cpp
View file

@ -28,12 +28,9 @@
//------------------------------------------------------------------------------
const char *GFXStringIndexFormat[GFXIndexFormat_COUNT];
const char *GFXStringSamplerState[GFXSAMP_COUNT];
const char *GFXStringTextureFormat[GFXFormat_COUNT];
const char *GFXStringTiledTextureFormat[GFXFormat_COUNT];
const char *GFXStringRenderTargetFormat[GFXFormat_COUNT];
const char *GFXStringRenderState[GFXRenderState_COUNT];
const char *GFXStringTextureFilter[GFXTextureFilter_COUNT];
const char *GFXStringBlend[GFXBlend_COUNT];
const char *GFXStringBlendOp[GFXBlendOp_COUNT];
@ -41,15 +38,9 @@ const char *GFXStringStencilOp[GFXStencilOp_COUNT];
const char *GFXStringCmpFunc[GFXCmp_COUNT];
const char *GFXStringCullMode[GFXCull_COUNT];
const char *GFXStringPrimType[GFXPT_COUNT];
const char *GFXStringTextureStageState[GFXTSS_COUNT];
const char *GFXStringTextureAddress[GFXAddress_COUNT];
const char *GFXStringTextureOp[GFXTOP_COUNT];
const char *GFXStringFillMode[GFXFill_COUNT];
StringValueLookupFn GFXStringRenderStateValueLookup[GFXRenderState_COUNT];
StringValueLookupFn GFXStringSamplerStateValueLookup[GFXSAMP_COUNT];
StringValueLookupFn GFXStringTextureStageStateValueLookup[GFXTSS_COUNT];
//------------------------------------------------------------------------------
const char *defaultStringValueLookup( const U32 &value )
@ -67,7 +58,6 @@ const char *defaultStringValueLookup( const U32 &value )
_STRING_VALUE_LOOKUP_FXN(GFXStringTextureAddress);
_STRING_VALUE_LOOKUP_FXN(GFXStringTextureFilter);
_STRING_VALUE_LOOKUP_FXN(GFXStringBlend);
_STRING_VALUE_LOOKUP_FXN(GFXStringTextureOp);
_STRING_VALUE_LOOKUP_FXN(GFXStringCmpFunc);
_STRING_VALUE_LOOKUP_FXN(GFXStringStencilOp);
_STRING_VALUE_LOOKUP_FXN(GFXStringCullMode);
@ -106,29 +96,6 @@ void GFXStringEnumTranslate::init()
sInitCalled = true;
INIT_LOOKUPTABLE( GFXStringIndexFormat, GFXIndexFormat, const char * );
GFX_STRING_ASSIGN_MACRO( GFXStringIndexFormat, GFXIndexFormat16 );
GFX_STRING_ASSIGN_MACRO( GFXStringIndexFormat, GFXIndexFormat32 );
VALIDATE_LOOKUPTABLE( GFXStringIndexFormat, GFXIndexFormat );
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
INIT_LOOKUPTABLE_EX( GFXStringSamplerState, GFXSAMP, const char *, GFXStringSamplerStateValueLookup );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringSamplerState, GFXSAMPAddressU, GFXStringTextureAddress );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringSamplerState, GFXSAMPAddressV, GFXStringTextureAddress );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringSamplerState, GFXSAMPAddressW, GFXStringTextureAddress );
GFX_STRING_ASSIGN_MACRO( GFXStringSamplerState, GFXSAMPBorderColor );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringSamplerState, GFXSAMPMagFilter, GFXStringTextureFilter );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringSamplerState, GFXSAMPMinFilter, GFXStringTextureFilter );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringSamplerState, GFXSAMPMipFilter, GFXStringTextureFilter );
GFX_STRING_ASSIGN_MACRO( GFXStringSamplerState, GFXSAMPMipMapLODBias );
GFX_STRING_ASSIGN_MACRO( GFXStringSamplerState, GFXSAMPMaxMipLevel );
GFX_STRING_ASSIGN_MACRO( GFXStringSamplerState, GFXSAMPMaxAnisotropy );
GFX_STRING_ASSIGN_MACRO( GFXStringSamplerState, GFXSAMPSRGBTexture );
GFX_STRING_ASSIGN_MACRO( GFXStringSamplerState, GFXSAMPElementIndex );
GFX_STRING_ASSIGN_MACRO( GFXStringSamplerState, GFXSAMPDMapOffset );
VALIDATE_LOOKUPTABLE( GFXStringSamplerState, GFXSAMP );
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
INIT_LOOKUPTABLE( GFXStringTextureFormat, GFXFormat, const char * );
@ -171,126 +138,7 @@ void GFXStringEnumTranslate::init()
GFX_STRING_ASSIGN_MACRO( GFXStringTextureFormat, GFXFormatBC2_SRGB );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureFormat, GFXFormatBC3_SRGB );
VALIDATE_LOOKUPTABLE( GFXStringTextureFormat, GFXFormat);
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
INIT_LOOKUPTABLE_EX( GFXStringRenderState, GFXRenderState, const char *, GFXStringRenderStateValueLookup );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSZEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSFillMode );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSZWriteEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSAlphaTestEnable );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSSrcBlend, GFXStringBlend );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSDestBlend, GFXStringBlend );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSCullMode, GFXStringCullMode );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSZFunc, GFXStringCmpFunc );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSAlphaRef );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSAlphaFunc, GFXStringCmpFunc );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSAlphaBlendEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSStencilEnable );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSStencilFail, GFXStringStencilOp );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSStencilZFail, GFXStringStencilOp );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSStencilPass, GFXStringStencilOp );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSStencilFunc, GFXStringCmpFunc );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSStencilRef );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSStencilMask );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSStencilWriteMask );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap0 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap1 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap2 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap3 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap4 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap5 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap6 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap7 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSClipPlaneEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSPointSize );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSPointSizeMin );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSPointSize_Max );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSPointSpriteEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSMultiSampleantiAlias );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSMultiSampleMask );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSShadeMode );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSLastPixel );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSClipping );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSPointScaleEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSPointScale_A );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSPointScale_B );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSPointScale_C );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSLighting );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSAmbient );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSFogVertexMode );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSColorVertex );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSLocalViewer );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSNormalizeNormals );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSDiffuseMaterialSource );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSSpecularMaterialSource );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSAmbientMaterialSource );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSEmissiveMaterialSource );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSVertexBlend );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSFogEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSSpecularEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSFogColor );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSFogTableMode );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSFogStart );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSFogEnd );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSFogDensity );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSRangeFogEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSDebugMonitorToken );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSIndexedVertexBlendEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSTweenFactor );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSTextureFactor );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSPatchEdgeStyle );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSDitherEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSColorWriteEnable );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSBlendOp, GFXStringBlendOp );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSPositionDegree );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSNormalDegree );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSAntiAliasedLineEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSAdaptiveTess_X );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSAdaptiveTess_Y );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSdaptiveTess_Z );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSAdaptiveTess_W );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSEnableAdaptiveTesselation );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSScissorTestEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSSlopeScaleDepthBias );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSMinTessellationLevel );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSMaxTessellationLevel );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSTwoSidedStencilMode );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSCCWStencilFail );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSCCWStencilZFail );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSCCWStencilPass );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSCCWStencilFunc );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSColorWriteEnable1 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSColorWriteEnable2 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSolorWriteEnable3 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSBlendFactor );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSSRGBWriteEnable );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSDepthBias );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap8 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap9 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap10 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap11 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap12 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap13 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap14 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSWrap15 );
GFX_STRING_ASSIGN_MACRO( GFXStringRenderState, GFXRSSeparateAlphaBlendEnable );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSSrcBlendAlpha, GFXStringBlend );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSDestBlendAlpha, GFXStringBlend );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringRenderState, GFXRSBlendOpAlpha, GFXStringBlendOp );
VALIDATE_LOOKUPTABLE( GFXStringRenderState, GFXRenderState );
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
INIT_LOOKUPTABLE( GFXStringTextureFilter, GFXTextureFilter, const char * );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureFilter, GFXTextureFilterNone );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureFilter, GFXTextureFilterPoint );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureFilter, GFXTextureFilterLinear );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureFilter, GFXTextureFilterAnisotropic );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureFilter, GFXTextureFilterPyramidalQuad );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureFilter, GFXTextureFilterGaussianQuad );
VALIDATE_LOOKUPTABLE( GFXStringTextureFilter, GFXTextureFilter );
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
INIT_LOOKUPTABLE( GFXStringBlend, GFXBlend, const char * );
@ -356,29 +204,6 @@ void GFXStringEnumTranslate::init()
GFX_STRING_ASSIGN_MACRO( GFXStringPrimType, GFXTriangleStrip );
VALIDATE_LOOKUPTABLE( GFXStringPrimType, GFXPT );
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
INIT_LOOKUPTABLE_EX( GFXStringTextureStageState, GFXTSS, const char *, GFXStringTextureStageStateValueLookup );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringTextureStageState, GFXTSSColorOp, GFXStringTextureOp );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSColorArg1 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSColorArg2 );
GFX_STRING_ASSIGN_MACRO_EX( GFXStringTextureStageState, GFXTSSAlphaOp, GFXStringTextureOp );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSAlphaArg1 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSAlphaArg2 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSBumpEnvMat00 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSBumpEnvMat01 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSBumpEnvMat10 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSBumpEnvMat11 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSTexCoordIndex );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSBumpEnvlScale );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSBumpEnvlOffset );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSTextureTransformFlags );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSColorArg0 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSAlphaArg0 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSResultArg );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureStageState, GFXTSSConstant );
VALIDATE_LOOKUPTABLE( GFXStringTextureStageState, GFXTSS );
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
INIT_LOOKUPTABLE( GFXStringTextureAddress, GFXAddress, const char * );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureAddress, GFXAddressWrap );
@ -389,34 +214,6 @@ void GFXStringEnumTranslate::init()
VALIDATE_LOOKUPTABLE(GFXStringTextureAddress, GFXAddress );
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
INIT_LOOKUPTABLE( GFXStringTextureOp, GFXTOP, const char * );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPDisable );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPSelectARG1 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPSelectARG2 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPModulate );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPModulate2X );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPModulate4X );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPAdd );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPAddSigned );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPAddSigned2X );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPSubtract );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPAddSmooth );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPBlendDiffuseAlpha );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPBlendTextureAlpha );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPBlendFactorAlpha );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPBlendTextureAlphaPM );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPBlendCURRENTALPHA );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPPreModulate );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPModulateAlphaAddColor );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPModulateColorAddAlpha );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPModulateInvAlphaAddColor );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPModulateInvColorAddAlpha );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPBumpEnvMap );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPBumpEnvMapLuminance );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPDotProduct3 );
GFX_STRING_ASSIGN_MACRO( GFXStringTextureOp, GFXTOPLERP );
VALIDATE_LOOKUPTABLE( GFXStringTextureOp, GFXTOP );
INIT_LOOKUPTABLE( GFXStringFillMode, GFXFill, const char * );
GFX_STRING_ASSIGN_MACRO( GFXStringFillMode, GFXFillPoint );
GFX_STRING_ASSIGN_MACRO( GFXStringFillMode, GFXFillWireframe );

11
Engine/source/gfx/gfxStringEnumTranslate.h
View file

@ -48,10 +48,7 @@ namespace GFXStringEnumTranslate
//------------------------------------------------------------------------------
extern const char *GFXStringIndexFormat[GFXIndexFormat_COUNT];
extern const char *GFXStringSamplerState[GFXSAMP_COUNT];
extern const char *GFXStringTextureFormat[GFXFormat_COUNT];
extern const char *GFXStringRenderState[GFXRenderState_COUNT];
extern const char *GFXStringTextureFilter[GFXTextureFilter_COUNT];
extern const char *GFXStringBlend[GFXBlend_COUNT];
extern const char *GFXStringBlendOp[GFXBlendOp_COUNT];
@ -59,17 +56,11 @@ extern const char *GFXStringStencilOp[GFXStencilOp_COUNT];
extern const char *GFXStringCmpFunc[GFXCmp_COUNT];
extern const char *GFXStringCullMode[GFXCull_COUNT];
extern const char *GFXStringPrimType[GFXPT_COUNT];
extern const char *GFXStringTextureStageState[GFXTSS_COUNT];
extern const char *GFXStringTextureAddress[GFXAddress_COUNT];
extern const char *GFXStringTextureOp[GFXTOP_COUNT];
extern const char *GFXStringFillMode[GFXFill_COUNT];
typedef const char *(*StringValueLookupFn)( const U32 &value );
extern StringValueLookupFn GFXStringRenderStateValueLookup[GFXRenderState_COUNT];
extern StringValueLookupFn GFXStringSamplerStateValueLookup[GFXSAMP_COUNT];
extern StringValueLookupFn GFXStringTextureStageStateValueLookup[GFXTSS_COUNT];
#define GFXREVERSE_LOOKUP( tablearray, enumprefix, val ) \
for( S32 i = enumprefix##_FIRST; i < enumprefix##_COUNT; i++ ) \
if( (S32)tablearray##[i] == val ) \
@ -86,4 +77,4 @@ extern EnumTable gTextureArgumentEnumTable_M;
//extern EnumTable::Enums srcBlendFactorLookup[9];
//extern EnumTable::Enums dstBlendFactorLookup[9];
#endif
#endif

49
Engine/source/gfx/gfxStructs.h
View file

@ -48,53 +48,6 @@
#include "gfx/gfxVertexTypes.h"
#endif
//-----------------------------------------------------------------------------
// This class is used to interact with an API's fixed function lights. See GFX->setLight
class GFXLightInfo
{
public:
enum Type {
Point = 0,
Spot = 1,
Vector = 2,
Ambient = 3,
};
Type mType;
Point3F mPos;
VectorF mDirection;
LinearColorF mColor;
LinearColorF mAmbient;
F32 mRadius;
F32 mInnerConeAngle;
F32 mOuterConeAngle;
/// @todo Revisit below (currently unused by fixed function lights)
Point3F position;
LinearColorF ambient;
LinearColorF diffuse;
LinearColorF specular;
VectorF spotDirection;
F32 spotExponent;
F32 spotCutoff;
F32 constantAttenuation;
F32 linearAttenuation;
F32 quadraticAttenuation;
};
//-----------------------------------------------------------------------------
// Material definition for FF lighting
struct GFXLightMaterial
{
LinearColorF ambient;
LinearColorF diffuse;
LinearColorF specular;
LinearColorF emissive;
F32 shininess;
};
//-----------------------------------------------------------------------------
struct GFXVideoMode
@ -144,7 +97,6 @@ struct GFXVideoMode
const String toString() const;
};
//-----------------------------------------------------------------------------
struct GFXPrimitive
@ -195,5 +147,4 @@ struct GFXShaderMacro
static void stringize( const Vector<GFXShaderMacro> &macros, String *outString );
};
#endif // _GFXSTRUCTS_H_

28
Engine/source/gfx/gl/gfxGLDevice.cpp
View file

@ -234,7 +234,7 @@ GFXGLDevice::GFXGLDevice(U32 adapterIndex) :
mTextureManager = new GFXGLTextureManager();
gScreenShot = new ScreenShotGL();
for(U32 i = 0; i < TEXTURE_STAGE_COUNT; i++)
for(U32 i = 0; i < GFX_TEXTURE_STAGE_COUNT; i++)
mActiveTextureType[i] = GL_ZERO;
mNumVertexStream = 2;
@ -260,7 +260,7 @@ GFXGLDevice::~GFXGLDevice()
mVolatilePBs[i] = NULL;
// Clear out our current texture references
for (U32 i = 0; i < TEXTURE_STAGE_COUNT; i++)
for (U32 i = 0; i < GFX_TEXTURE_STAGE_COUNT; i++)
{
mCurrentTexture[i] = NULL;
mNewTexture[i] = NULL;
@ -711,21 +711,6 @@ void GFXGLDevice::setPB(GFXGLPrimitiveBuffer* pb)
mCurrentPB = pb;
}
void GFXGLDevice::setLightInternal(U32 lightStage, const GFXLightInfo light, bool lightEnable)
{
// ONLY NEEDED ON FFP
}
void GFXGLDevice::setLightMaterialInternal(const GFXLightMaterial mat)
{
// ONLY NEEDED ON FFP
}
void GFXGLDevice::setGlobalAmbientInternal(LinearColorF color)
{
// ONLY NEEDED ON FFP
}
void GFXGLDevice::setTextureInternal(U32 textureUnit, const GFXTextureObject*texture)
{
GFXGLTextureObject *tex = static_cast<GFXGLTextureObject*>(const_cast<GFXTextureObject*>(texture));
@ -791,11 +776,6 @@ void GFXGLDevice::setTextureArrayInternal(U32 textureUnit, const GFXGLTextureArr
}
}
void GFXGLDevice::setMatrix( GFXMatrixType mtype, const MatrixF &mat )
{
// ONLY NEEDED ON FFP
}
void GFXGLDevice::setClipRect( const RectI &inRect )
{
AssertFatal(mCurrentRT.isValid(), "GFXGLDevice::setClipRect - must have a render target set to do any rendering operations!");
@ -838,8 +818,6 @@ void GFXGLDevice::setClipRect( const RectI &inRect )
mProjectionMatrix *= translate;
setMatrix(GFXMatrixProjection, mProjectionMatrix);
MatrixF mTempMatrix(true);
setViewMatrix( mTempMatrix );
setWorldMatrix( mTempMatrix );
@ -985,7 +963,7 @@ void GFXGLDevice::setShaderConstBufferInternal(GFXShaderConstBuffer* buffer)
U32 GFXGLDevice::getNumSamplers() const
{
return getMin((U32)TEXTURE_STAGE_COUNT,mPixelShaderVersion > 0.001f ? mMaxShaderTextures : mMaxFFTextures);
return getMin((U32)GFX_TEXTURE_STAGE_COUNT,mPixelShaderVersion > 0.001f ? mMaxShaderTextures : mMaxFFTextures);
}
GFXTextureObject* GFXGLDevice::getDefaultDepthTex() const

12
Engine/source/gfx/gl/gfxGLDevice.h
View file

@ -140,8 +140,8 @@ public:
virtual void preDestroy() { Parent::preDestroy(); }
virtual U32 getMaxDynamicVerts() { return MAX_DYNAMIC_VERTS; }
virtual U32 getMaxDynamicIndices() { return MAX_DYNAMIC_INDICES; }
virtual U32 getMaxDynamicVerts() { return GFX_MAX_DYNAMIC_VERTS; }
virtual U32 getMaxDynamicIndices() { return GFX_MAX_DYNAMIC_INDICES; }
GFXFence *createFence();
@ -177,10 +177,6 @@ protected:
virtual void setCubemapArrayInternal(U32 textureUnit, const GFXGLCubemapArray* texture);
virtual void setTextureArrayInternal(U32 textureUnit, const GFXGLTextureArray* texture);
virtual void setLightInternal(U32 lightStage, const GFXLightInfo light, bool lightEnable);
virtual void setLightMaterialInternal(const GFXLightMaterial mat);
virtual void setGlobalAmbientInternal(LinearColorF color);
/// @name State Initalization.
/// @{
@ -188,8 +184,6 @@ protected:
/// is created.
virtual void initStates() { }
virtual void setMatrix( GFXMatrixType mtype, const MatrixF &mat );
virtual GFXVertexBuffer *allocVertexBuffer( U32 numVerts,
const GFXVertexFormat *vertexFormat,
U32 vertSize,
@ -255,7 +249,7 @@ private:
GFXGLStateBlockRef mCurrentGLStateBlock;
GLenum mActiveTextureType[TEXTURE_STAGE_COUNT];
GLenum mActiveTextureType[GFX_TEXTURE_STAGE_COUNT];
Vector< StrongRefPtr<GFXGLVertexBuffer> > mVolatileVBs; ///< Pool of existing volatile VBs so we can reuse previously created ones
Vector< StrongRefPtr<GFXGLPrimitiveBuffer> > mVolatilePBs; ///< Pool of existing volatile PBs so we can reuse previously created ones

16
Engine/source/gfx/gl/gfxGLEnumTranslate.cpp
View file

@ -26,7 +26,6 @@
GLenum GFXGLPrimType[GFXPT_COUNT];
GLenum GFXGLBlend[GFXBlend_COUNT];
GLenum GFXGLBlendOp[GFXBlendOp_COUNT];
GLenum GFXGLSamplerState[GFXSAMP_COUNT];
GLenum GFXGLTextureFilter[GFXTextureFilter_COUNT];
GLenum GFXGLTextureAddress[GFXAddress_COUNT];
GLenum GFXGLCmpFunc[GFXCmp_COUNT];
@ -75,14 +74,7 @@ void GFXGLEnumTranslate::init()
GFXGLBlendOp[GFXBlendOpMin] = GL_MIN;
GFXGLBlendOp[GFXBlendOpMax] = GL_MAX;
// Sampler
GFXGLSamplerState[GFXSAMPMagFilter] = GL_TEXTURE_MAG_FILTER;
GFXGLSamplerState[GFXSAMPMinFilter] = GL_TEXTURE_MIN_FILTER;
GFXGLSamplerState[GFXSAMPAddressU] = GL_TEXTURE_WRAP_S;
GFXGLSamplerState[GFXSAMPAddressV] = GL_TEXTURE_WRAP_T;
GFXGLSamplerState[GFXSAMPAddressW] = GL_TEXTURE_WRAP_R;
GFXGLSamplerState[GFXSAMPMipMapLODBias] = GL_TEXTURE_LOD_BIAS;
// Comparison
GFXGLCmpFunc[GFXCmpNever] = GL_NEVER;
GFXGLCmpFunc[GFXCmpLess] = GL_LESS;
@ -96,10 +88,7 @@ void GFXGLEnumTranslate::init()
GFXGLTextureFilter[GFXTextureFilterNone] = GL_NEAREST;
GFXGLTextureFilter[GFXTextureFilterPoint] = GL_NEAREST;
GFXGLTextureFilter[GFXTextureFilterLinear] = GL_LINEAR;
GFXGLTextureFilter[GFXTextureFilterAnisotropic] = GL_LINEAR;
GFXGLTextureFilter[GFXTextureFilterPyramidalQuad] = GL_LINEAR;
GFXGLTextureFilter[GFXTextureFilterGaussianQuad] = GL_LINEAR;
GFXGLTextureAddress[GFXAddressWrap] = GL_REPEAT;
GFXGLTextureAddress[GFXAddressMirror] = GL_REPEAT;
@ -116,8 +105,7 @@ void GFXGLEnumTranslate::init()
GFXGLStencilOp[GFXStencilOpInvert] = GL_INVERT;
GFXGLStencilOp[GFXStencilOpIncr] = GL_INCR_WRAP;
GFXGLStencilOp[GFXStencilOpDecr] = GL_DECR_WRAP;
GFXGLStencilOp[GFXStencilOpDecr] = GL_DECR_WRAP;
// Texture formats
for(int i = 0; i < GFXFormat_COUNT; ++i)

1
Engine/source/gfx/gl/gfxGLEnumTranslate.h
View file

@ -34,7 +34,6 @@ namespace GFXGLEnumTranslate
extern GLenum GFXGLPrimType[GFXPT_COUNT];
extern GLenum GFXGLBlend[GFXBlend_COUNT];
extern GLenum GFXGLBlendOp[GFXBlendOp_COUNT];
extern GLenum GFXGLSamplerState[GFXSAMP_COUNT];
extern GLenum GFXGLTextureFilter[GFXTextureFilter_COUNT];
extern GLenum GFXGLTextureAddress[GFXAddress_COUNT];
extern GLenum GFXGLCmpFunc[GFXCmp_COUNT];

4
Engine/source/gfx/gl/gfxGLStateBlock.cpp
View file

@ -41,7 +41,7 @@ GFXGLStateBlock::GFXGLStateBlock(const GFXStateBlockDesc& desc) :
{
static Map<GFXSamplerStateDesc, U32> mSamplersMap;
for(int i = 0; i < TEXTURE_STAGE_COUNT; ++i)
for(int i = 0; i < GFX_TEXTURE_STAGE_COUNT; ++i)
{
GLuint &id = mSamplerObjects[i];
GFXSamplerStateDesc &ssd = mDesc.samplers[i];
@ -172,7 +172,7 @@ void GFXGLStateBlock::activate(const GFXGLStateBlock* oldState)
#undef CHECK_TOGGLE_STATE
//sampler objects
for (U32 i = 0; i < getMin(getOwningDevice()->getNumSamplers(), (U32) TEXTURE_STAGE_COUNT); i++)
for (U32 i = 0; i < getMin(getOwningDevice()->getNumSamplers(), (U32) GFX_TEXTURE_STAGE_COUNT); i++)
{
if(!oldState || oldState->mSamplerObjects[i] != mSamplerObjects[i])
glBindSampler(i, mSamplerObjects[i] );

2
Engine/source/gfx/gl/gfxGLStateBlock.h
View file

@ -63,7 +63,7 @@ public:
private:
GFXStateBlockDesc mDesc;
U32 mCachedHashValue;
U32 mSamplerObjects[TEXTURE_STAGE_COUNT];
U32 mSamplerObjects[GFX_TEXTURE_STAGE_COUNT];
};
typedef StrongRefPtr<GFXGLStateBlock> GFXGLStateBlockRef;

2
Engine/source/gfx/gl/gfxGLStateCache.h
View file

@ -141,7 +141,7 @@ public:
protected:
GLuint mActiveTexture, mBindedVBO, mBindedIBO, mBindedFBO_W, mBindedFBO_R;
TextureUnit mTextureUnits[TEXTURE_STAGE_COUNT];
TextureUnit mTextureUnits[GFX_TEXTURE_STAGE_COUNT];
U32 mVertexAttribActive;
};

6
Engine/source/gfx/primBuilder.cpp
View file

@ -199,9 +199,9 @@ void end( bool useGenericShaders )
if ( stripStart > 0 )
{
// TODO: Fix this to allow > MAX_DYNAMIC_VERTS!
// TODO: Fix this to allow > GFX_MAX_DYNAMIC_VERTS!
U32 copyVerts = getMin( (U32)MAX_DYNAMIC_VERTS, numVerts );
U32 copyVerts = getMin( (U32)GFX_MAX_DYNAMIC_VERTS, numVerts );
mVertBuff.set( GFX, copyVerts, GFXBufferTypeVolatile );
GFXVertexPCT *verts = mVertBuff.lock();
@ -216,7 +216,7 @@ void end( bool useGenericShaders )
{
while ( numVerts > 0 )
{
U32 copyVerts = getMin( (U32)MAX_DYNAMIC_VERTS, numVerts );
U32 copyVerts = getMin( (U32)GFX_MAX_DYNAMIC_VERTS, numVerts );
copyVerts -= copyVerts % vertStride;
mVertBuff.set( GFX, copyVerts, GFXBufferTypeVolatile );

47
Engine/source/gfx/sim/gfxStateBlockData.cpp
View file

@ -59,7 +59,7 @@ ConsoleDocClass( GFXStateBlockData,
GFXStateBlockData::GFXStateBlockData()
{
for (U32 i = 0; i < TEXTURE_STAGE_COUNT; i++)
for (U32 i = 0; i < GFX_TEXTURE_STAGE_COUNT; i++)
mSamplerStates[i] = NULL;
}
@ -210,9 +210,6 @@ void GFXStateBlockData::initPersistFields()
addGroup( "Fixed Function" );
addField( "ffLighting", TypeBool, Offset(mState.ffLighting, GFXStateBlockData),
"Enables fixed function lighting when rendering without a shader on geometry with vertex normals. The default is false." );
addField( "vertexColorEnable", TypeBool, Offset(mState.vertexColorEnable, GFXStateBlockData),
"Enables fixed function vertex coloring when rendering without a shader. The default is false." );
@ -224,7 +221,7 @@ void GFXStateBlockData::initPersistFields()
addField( "samplersDefined", TypeBool, Offset(mState.samplersDefined, GFXStateBlockData),
"Set to true if the sampler states are not all defaults." );
addField( "samplerStates", TYPEID<GFXSamplerStateData>(), Offset(mSamplerStates, GFXStateBlockData), TEXTURE_STAGE_COUNT,
addField( "samplerStates", TYPEID<GFXSamplerStateData>(), Offset(mSamplerStates, GFXStateBlockData), GFX_TEXTURE_STAGE_COUNT,
"The array of texture sampler states.\n"
"@note Not all graphics devices support 16 samplers. In general "
"all systems support 4 samplers with most modern cards doing 8." );
@ -243,7 +240,7 @@ bool GFXStateBlockData::onAdd()
if (!Parent::onAdd())
return false;
for (U32 i = 0; i < TEXTURE_STAGE_COUNT; i++)
for (U32 i = 0; i < GFX_TEXTURE_STAGE_COUNT; i++)
{
if (mSamplerStates[i])
mSamplerStates[i]->setSamplerState(mState.samplers[i]);
@ -284,38 +281,6 @@ void GFXSamplerStateData::initPersistFields()
{
Parent::initPersistFields();
addGroup( "Color Op" );
addField("textureColorOp", TypeGFXTextureOp, Offset(mState.textureColorOp, GFXSamplerStateData),
"The texture color blending operation. The default value is GFXTOPDisable which disables the sampler." );
addField("colorArg1", TYPEID< GFXTextureArgument >(), Offset(mState.colorArg1, GFXSamplerStateData),
"The first color argument for the texture stage. The default value is GFXTACurrent." );
addField("colorArg2", TYPEID< GFXTextureArgument >(), Offset(mState.colorArg2, GFXSamplerStateData),
"The second color argument for the texture stage. The default value is GFXTATexture." );
addField("colorArg3", TYPEID< GFXTextureArgument >(), Offset(mState.colorArg3, GFXSamplerStateData),
"The third color argument for triadic operations (multiply, add, and linearly interpolate). The default value is GFXTACurrent." );
endGroup( "Color Op" );
addGroup( "Alpha Op" );
addField("alphaOp", TypeGFXTextureOp, Offset(mState.alphaOp, GFXSamplerStateData),
"The texture alpha blending operation. The default value is GFXTOPModulate." );
addField("alphaArg1", TYPEID< GFXTextureArgument >(), Offset(mState.alphaArg1, GFXSamplerStateData),
"The first alpha argument for the texture stage. The default value is GFXTATexture." );
addField("alphaArg2", TYPEID< GFXTextureArgument >(), Offset(mState.alphaArg2, GFXSamplerStateData),
"The second alpha argument for the texture stage. The default value is GFXTADiffuse." );
addField("alphaArg3", TYPEID< GFXTextureArgument >(), Offset(mState.alphaArg3, GFXSamplerStateData),
"The third alpha channel selector operand for triadic operations (multiply, add, and linearly interpolate). The default value is GFXTACurrent." );
endGroup( "Alpha Op" );
addGroup( "Address Mode" );
addField("addressModeU", TypeGFXTextureAddressMode, Offset(mState.addressModeU, GFXSamplerStateData),
@ -348,12 +313,6 @@ void GFXSamplerStateData::initPersistFields()
endGroup( "Filter State" );
addField("textureTransform", TypeGFXTextureTransformFlags, Offset(mState.textureTransform, GFXSamplerStateData),
"Sets the texture transform state. The default is GFXTTFFDisable." );
addField("resultArg", TypeGFXTextureArgument, Offset(mState.resultArg, GFXSamplerStateData),
"The selection of the destination register for the result of this stage. The default is GFXTACurrent." );
addField("samplerFunc", TypeGFXCmpFunc, Offset(mState.samplerFunc, GFXSamplerStateData),
"Compares sampled data against existing sampled data. The default is GFXCmpNever.");
}

2
Engine/source/gfx/sim/gfxStateBlockData.h
View file

@ -38,7 +38,7 @@ class GFXStateBlockData : public SimObject
typedef SimObject Parent;
GFXStateBlockDesc mState;
GFXSamplerStateData* mSamplerStates[TEXTURE_STAGE_COUNT];
GFXSamplerStateData* mSamplerStates[GFX_TEXTURE_STAGE_COUNT];
public:
GFXStateBlockData();