Technique::Pass Class Reference

#include <technique.h>

Classes
struct	ShaderParam
struct	TextureUnit

Public Types
enum	Tristate { False =0, True =1, Auto =2 }
enum	Type { FixedPass, ShaderPass }
enum	BlendMode {   Default, Add, Multiply, AlphaBlend,   Decal, PremultAlphaBlend, MultiAlphaBlend }
enum	DepthFunction {   Less, LEqual, Greater, GEqual,   Equal, Always, Never }
enum	Face {   None, Front, Back, FrontAndBack,   DefaultFace }
enum	PolyMode { Point, Line, Fill }

Public Member Functions
	Pass ()
	~Pass ()
void	setProgram (const std::string &vertex, const std::string &fragment)
int	getCompiledProgram () const
void	addTextureUnit (const std::string &source, int target, const std::string &deflt, const std::string &paramName, Technique::Pass::TextureUnit::Kind texKind)
void	addShaderParam (const std::string &name, float value[4], bool optional)
void	addShaderParam (const std::string &name, ShaderParam::Semantic semantic, bool optional)
size_t	getNumTextureUnits () const
const TextureUnit &	getTextureUnit (int index) const
TextureUnit &	getTextureUnit (int index)
size_t	getNumShaderParams () const
const ShaderParam &	getShaderParam (int index) const
ShaderParam &	getShaderParam (int index)
void	compile ()
bool	isCompiled () const
bool	isCompiled (int programVersion) const

Public Attributes
Type	type
bool	sRGBAware
bool	colorWrite
Tristate	zWrite
unsigned int	perLightIteration
unsigned int	maxIterations
BlendMode	blendMode
DepthFunction	depthFunction
Face	cullMode
PolyMode	polyMode
float	offsetFactor
float	offsetUnits
float	lineWidth
int	sequence

Detailed Description

Definition at line 22 of file technique.h.

Member Enumeration Documentation

enum Technique::Pass::BlendMode

Enumerator
Default	Whatever the mesh specifies as blend mode
Add	Blend function ONE ONE
Multiply	Blend function SRCCOLOR ZERO
AlphaBlend	Blend function ALPHA INVSRCALPHA
Decal	Blend function ONE ZERO
PremultAlphaBlend	Blend function ONE INVSRCALPHA
MultiAlphaBlend	Blend function ALPHA INVSRCALPHA for the first pass, ALPHA ONE for subsequent passes

Definition at line 62 of file technique.h.

        {
            Default,
            
            Add,
            
            Multiply,
            
            AlphaBlend,
            
            Decal,
            
            PremultAlphaBlend,
            
            MultiAlphaBlend
        };

enum Technique::Pass::DepthFunction

Enumerator
Less
LEqual
Greater
GEqual
Equal
Always
Never

Definition at line 86 of file technique.h.

        {
            Less,
            LEqual,
            Greater,
            GEqual,
            Equal,
            Always,
            Never
        };

enum Technique::Pass::Face

Enumerator
None
Front
Back
FrontAndBack
DefaultFace

Definition at line 97 of file technique.h.

        {
            None,
            Front,
            Back,
            FrontAndBack,
            DefaultFace
        };

enum Technique::Pass::PolyMode

Enumerator
Point
Line
Fill

Definition at line 106 of file technique.h.

        {
            Point,
            Line,
            Fill
        };

enum Technique::Pass::Tristate

Enumerator
False
True
Auto

Definition at line 37 of file technique.h.

        {
            False=0,
            True =1,
            Auto =2
        };

enum Technique::Pass::Type

Enumerator
FixedPass	A fixed pass is one that uses up to 4 optional fixed-function texture targets: 0: base diffuse 1: specmap 2: damage diffuse 3: glow It is rendered using the fixed function pipeline.
ShaderPass	A shader pass is a configurable pass that uses shaders to do everything. Vertex and fragment programs must be specified.

Definition at line 44 of file technique.h.

        {
            FixedPass,
            
            ShaderPass
        };

Constructor & Destructor Documentation

Technique::Pass::Pass

(

)

Definition at line 261 of file technique.cpp.

    : program( 0 )
    , type( FixedPass )
    , colorWrite( true )
    , zWrite( True )
    , perLightIteration( 0 )
    , maxIterations( 0 )
    , blendMode( Default )
    , depthFunction( LEqual )
    , cullMode( DefaultFace )
    , polyMode( Fill )
    , offsetFactor( 0 )
    , offsetUnits( 0 )
    , lineWidth( 1 )
    , sequence( 0 )
{}

Technique::Pass::~Pass

(

)

Definition at line 278 of file technique.cpp.

{
    //Should deallocate the program... but... GFX doesn't have that API.
}

Member Function Documentation

void Technique::Pass::addShaderParam	(	const std::string &	name,
		float	value[4],
		bool	optional
	)

Add a constant shader param

Parameters

name	A string defining the shader's parameter name.
value	An array of 4 floats with the parameter's value.
optional	Optional parameters are allowed to be left unresolved.

Remarks

Parameters with less than 4 values will simply ignore the other values and should be fed with any dummy value (like 0).

void Technique::Pass::addShaderParam	(	const std::string &	name,
		ShaderParam::Semantic	semantic,
		bool	optional
	)

Add an automatic shader param

Parameters

name	A string defining the shader's parameter name.
semantic	The kind of value that will be automatically put in the variable.
optional	Optional parameters are allowed to be left unresolved.

void Technique::Pass::addTextureUnit	(	const std::string &	source,
		int	target,
		const std::string &	deflt,
		const std::string &	paramName,
		Technique::Pass::TextureUnit::Kind	texKind
	)

Add a texture unit

Parameters

source	A string of the form [type]:[path or index] that specifies the texture unit's data source.
target	The target texturing unit
deflt	A string of the form [type]:[path or index] that specifies the texture unit's default data source if the mesh lacks the specified decal in 'source'
paramName	The shader parameter name (for a shader pass) that is to be bound to this texture unit.

Remarks

[type] may be either Decal or File, mapping to equally named SourceType s

Definition at line 290 of file technique.cpp.

References Technique::Pass::TextureUnit::defaultIndex, Technique::Pass::TextureUnit::defaultPath, Technique::Pass::TextureUnit::defaultType, Technique::Pass::TextureUnit::origTargetIndex, __impl::parseSourceType(), Technique::Pass::TextureUnit::sourceIndex, Technique::Pass::TextureUnit::sourcePath, Technique::Pass::TextureUnit::sourceType, Technique::Pass::TextureUnit::targetIndex, Technique::Pass::TextureUnit::targetParamId, Technique::Pass::TextureUnit::targetParamName, and Technique::Pass::TextureUnit::texKind.

{
    textureUnits.resize( textureUnits.size()+1 );
    TextureUnit &newTU     = textureUnits.back();

    string::size_type ssep = string::npos, dsep = string::npos;
    newTU.sourceType = parseSourceType( source, ssep );
    newTU.defaultType     = parseSourceType( deflt, dsep );
    newTU.targetIndex     = 
    newTU.origTargetIndex = target;
    newTU.targetParamName = paramName;
    newTU.targetParamId   = -1;
    newTU.texKind = texKind;
    switch (newTU.sourceType)
    {
    case TextureUnit::Decal:
    case TextureUnit::Detail:
        if (ssep == string::npos) throw InvalidParameters( "Decal/Detail reference missing source index" );
        newTU.sourceIndex = atoi( source.c_str()+ssep+1 );
        break;
    case TextureUnit::File:
        if (ssep == string::npos) throw InvalidParameters( "File reference missing path" );
        newTU.sourcePath.assign( source, ssep+1, string::npos );
        break;
    case TextureUnit::Environment:
        break;
    default: throw InvalidParameters( "Missing source" );
    }
    switch (newTU.defaultType)
    {
    case TextureUnit::Decal:
    case TextureUnit::Detail:
        if (dsep == string::npos) throw InvalidParameters( "Decal/Detail reference missing source index" );
        newTU.defaultIndex = atoi( deflt.c_str()+dsep+1 );
        break;
    case TextureUnit::File:
        if (dsep == string::npos) throw InvalidParameters( "File reference missing path" );
        newTU.defaultPath.assign( deflt, dsep+1, string::npos );
        break;
    case TextureUnit::None: //FIXME added by chuck_starchaser; please verify correctness
    case TextureUnit::Environment: //FIXME added by chuck_starchaser; please verify correctness
    default: //FIXME added by chuck_starchaser; please verify correctness
        break; //FIXME added by chuck_starchaser; please verify correctness
    }
}

void Technique::Pass::compile

(

)

Compile the pass (shaders, fetch shader params, etc...)

Definition at line 365 of file technique.cpp.

References gl_options_t::ext_srgb_framebuffer, GFXCreateProgram(), GFXDestroyProgram(), GFXGetProgramVersion(), GFXNamedShaderConstant(), gl_options, max(), gl_options_t::nv_fp2, BaseUtil::Texture(), and VSFileSystem::vs_dprintf().

{
    if (type == ShaderPass) {
        int prog = program; // BEGIN TRANSACTION

        if (prog != 0 && programVersion != GFXGetProgramVersion()) {
            GFXDestroyProgram(program);
            prog = 0;
        }

        if (prog == 0) {
            std::string defines;
            
            // Automatic defines
            if (sRGBAware) {
                if (gl_options.ext_srgb_framebuffer)
                    defines += "#define SRGB_FRAMEBUFFER 1\n";
                else
                    defines += "#define SRGB_FRAMEBUFFER 0\n";
            }
            if (gl_options.nv_fp2)
                defines += "#define VGL_NV_fragment_program2 1\n";
            
            // Compile program
            prog = GFXCreateProgram( vertexProgram.c_str(), fragmentProgram.c_str(), 
                                     (defines.empty() ? NULL : defines.c_str()) );
            if (prog == 0) 
                throw ProgramCompileError(
                    "Error compiling program vp:\""+vertexProgram
                    +"\" fp:\""+fragmentProgram+"\"" );
            else
                VSFileSystem::vs_dprintf( 1, "Successfully compiled and linked program \"%s+%s\"\n",
                                          vertexProgram.c_str(), fragmentProgram.c_str() );
        }
        
        for (ShaderParamList::iterator it = shaderParams.begin(); it != shaderParams.end(); ++it) {
            it->id = GFXNamedShaderConstant( prog, it->name.c_str() );
            if (it->id < 0) {
                if (!it->optional) 
                    throw ProgramCompileError( "Cannot resolve shader constant \""+it->name+"\"" );
                else
                    VSFileSystem::vs_dprintf( 1, "Cannot resolve <<optional>> shader constant \"%s\" in program \"%s+%s\"\n", 
                                              it->name.c_str(), vertexProgram.c_str(), fragmentProgram.c_str() );
            }
        }
        int lastTU = -1;
        for (TextureUnitList::iterator tit = textureUnits.begin(); tit != textureUnits.end(); ++tit) {
            if (tit->sourceType == TextureUnit::File) {
                // Yep, we don't want to reload textures
                if (tit->texture.get() == 0) {
                    tit->texture.reset( new Texture( tit->sourcePath.c_str() ) );
                    if ( !tit->texture->LoadSuccess() ) throw InvalidParameters(
                            "Cannot load texture file \""+tit->sourcePath+"\"" );
                }
            } else if (tit->defaultType == TextureUnit::File) {
                // Yep, we don't want to reload textures
                if (tit->texture.get() == 0) {
                    tit->texture.reset( new Texture( tit->defaultPath.c_str() ) );
                    if ( !tit->texture->LoadSuccess() ) throw InvalidParameters(
                            "Cannot load texture file \""+tit->defaultPath+"\"" );
                }
            }
            if (!tit->targetParamName.empty()) {
                tit->targetParamId = GFXNamedShaderConstant( prog, tit->targetParamName.c_str() );
                if (tit->targetParamId < 0) {
                    if (tit->origTargetIndex >= 0)
                        throw ProgramCompileError(
                            "Cannot resolve shader constant \""+tit->targetParamName+"\"" );
                    else
                        tit->targetIndex = -1;
                } else {
                    if (tit->origTargetIndex < 0)
                        tit->targetIndex = lastTU+1;
                    lastTU = std::max( tit->targetIndex, lastTU );
                }
            }
        }
        
        // COMMIT ;-)
        program = prog;         
        programVersion = GFXGetProgramVersion();
    }
}

int Technique::Pass::getCompiledProgram ( ) const

inline

Get the vertex and fragment programs, compiled. 0 for fixed-function

Definition at line 301 of file technique.h.

        {
            return program;
        }

size_t Technique::Pass::getNumShaderParams ( ) const

inline

Get the number of shader params in this pass

Definition at line 358 of file technique.h.

Referenced by GameUnit< UnitType >::applyTechniqueOverrides().

        {
            return shaderParams.size();
        }

size_t Technique::Pass::getNumTextureUnits ( ) const

inline

Get the number of texture units in this pass

Definition at line 340 of file technique.h.

Referenced by OrigMeshContainer::operator<().

        {
            return textureUnits.size();
        }

const ShaderParam& Technique::Pass::getShaderParam ( int  index) const

inline

Get the specified shader param

Definition at line 364 of file technique.h.

References index.

Referenced by GameUnit< UnitType >::applyTechniqueOverrides().

        {
            return shaderParams[index];
        }

ShaderParam& Technique::Pass::getShaderParam ( int  index)

inline

Get the specified shader param

Definition at line 370 of file technique.h.

References index.

        {
            return shaderParams[index];
        }

const TextureUnit& Technique::Pass::getTextureUnit ( int  index) const

inline

Get the specified texture unit

Definition at line 346 of file technique.h.

References index.

Referenced by OrigMeshContainer::operator<().

        {
            return textureUnits[index];
        }

TextureUnit& Technique::Pass::getTextureUnit ( int  index)

inline

Get the specified texture unit

Definition at line 352 of file technique.h.

References index.

        {
            return textureUnits[index];
        }

bool Technique::Pass::isCompiled

(

)

const

Return whether the pass has been compiled or not

Definition at line 450 of file technique.cpp.

{
    return (type != ShaderPass) || (program != 0);
}

bool Technique::Pass::isCompiled

(

int

programVersion)

const

Return whether the pass has been compiled with a matching program version

Return whether the pass has been compiled or not with a matching program version

Definition at line 456 of file technique.cpp.

{
    return (type != ShaderPass) || (program != 0 && this->programVersion == programVersion);
}

void Technique::Pass::setProgram	(	const std::string &	vertex,
		const std::string &	fragment
	)

Set the vertex and fragment programs - throw on error

Definition at line 283 of file technique.cpp.

{
    vertexProgram   = vertex;
    fragmentProgram = fragment;
    program = 0;
}

Member Data Documentation

BlendMode Technique::Pass::blendMode

Blending mode - either default or an override

Definition at line 270 of file technique.h.

Referenced by setupGLState().

bool Technique::Pass::colorWrite

Whether to write the color buffer or not

Definition at line 258 of file technique.h.

Referenced by setupGLState().

Face Technique::Pass::cullMode

Polygon backface culling mode. Front will CULL Front faces, so standard is Back

Definition at line 276 of file technique.h.

Referenced by setupGLState().

DepthFunction Technique::Pass::depthFunction

Z-test function - far queue always overrides with Always

Definition at line 273 of file technique.h.

Referenced by setupGLState().

float Technique::Pass::lineWidth

Line width - for line-mode polygons

Definition at line 288 of file technique.h.

Referenced by setupGLState().

unsigned int Technique::Pass::maxIterations

The maximum number of iterations, 0 means infinite - nonzero helps keep performance acceptable

Definition at line 267 of file technique.h.

float Technique::Pass::offsetFactor

Polygon offset slope factor

Definition at line 282 of file technique.h.

Referenced by setupGLState().

float Technique::Pass::offsetUnits

Polygon offset units

Definition at line 285 of file technique.h.

Referenced by setupGLState().

unsigned int Technique::Pass::perLightIteration

The number of lights this pass can handle, 0 means infinite

Definition at line 264 of file technique.h.

PolyMode Technique::Pass::polyMode

Polygon rasterization mode

Definition at line 279 of file technique.h.

Referenced by setupGLState().

int Technique::Pass::sequence

Sequence number, the order in which passes are rendered

Definition at line 291 of file technique.h.

bool Technique::Pass::sRGBAware

Shaders are aware of SRGB frambuffers, so everything should be set up for sRGB blending if sRGB framebuffers are available. Shaders will be compiled with SRGB_FRAMEBUFFER set to 0 (not supported) or 1 (supported).

Definition at line 255 of file technique.h.

Referenced by setupGLState().

Type Technique::Pass::type

Type of pass - shader or fixed pipeline

Definition at line 249 of file technique.h.

Referenced by Mesh::ProcessDrawQueue().

Tristate Technique::Pass::zWrite

Whether to write the z-buffer or not - default or an override

Definition at line 261 of file technique.h.

---

The documentation for this class was generated from the following files:

• src/gfx/technique.h
• src/gfx/technique.cpp