Technique Class Reference

#include <technique.h>

Classes
class	Pass

Public Member Functions
	Technique (const std::string &name)
	Technique (const Technique &src)
	~Technique ()
const std::string &	getName () const
const std::string &	getFallback () const
bool	isCompiled () const
bool	isCompiled (int programVersion) const
void	compile ()
int	getNumPasses () const
const Pass &	getPass (int idx) const
Pass &	getPass (int idx)

Static Public Member Functions
static TechniquePtr	getTechnique (const std::string &name)

Protected Types
typedef std::vector< Pass >	PassList

Protected Attributes
PassList	passes

Detailed Description

Definition at line 14 of file technique.h.

Member Typedef Documentation

typedef std::vector< Pass > Technique::PassList

protected

Definition at line 386 of file technique.h.

Constructor & Destructor Documentation

Technique::Technique ( const std::string &  name)

explicit

Create a technique by loading and parsing the definition in [name].technique

Referenced by getTechnique().

Technique::Technique ( const Technique &  src)

explicit

Create a technique by copying another technique

Definition at line 601 of file technique.cpp.

                                           :
    name( src.name )
    , fallback( src.fallback )
    , compiled( false )
    , programVersion( 0 )
    , passes( src.passes )
{
    // Not much else to do
    // Compiled techniques are still valid, and setting any parameter
    // that would invalidate it would result in recompilation
    // FIXME: should result in recompilation, not necessarily true now
}

Technique::~Technique

(

)

Definition at line 614 of file technique.cpp.

{
}

Member Function Documentation

void Technique::compile

(

)

Definition at line 618 of file technique.cpp.

References GFXGetProgramVersion(), and passes.

{
    if (!compiled || (GFXGetProgramVersion() != programVersion)) {
        for (PassList::iterator it = passes.begin(); it != passes.end(); ++it)
            it->compile();
        compiled = true;
        programVersion = GFXGetProgramVersion();
    }
}

const std::string& Technique::getFallback ( ) const

inline

Definition at line 402 of file technique.h.

    {
        return fallback;
    }

const std::string& Technique::getName ( ) const

inline

Definition at line 398 of file technique.h.

    {
        return name;
    }

int Technique::getNumPasses ( ) const

inline

Definition at line 421 of file technique.h.

References passes.

    {
        return passes.size();
    }

const Pass& Technique::getPass ( int  idx) const

inline

Definition at line 425 of file technique.h.

References passes.

    {
        return passes[idx];
    }

Pass& Technique::getPass ( int  idx)

inline

Definition at line 429 of file technique.h.

References passes.

    {
        return passes[idx];
    }

TechniquePtr Technique::getTechnique ( const std::string &  name)

static

Cached technique factory function

Definition at line 631 of file technique.cpp.

References Technique(), techniqueCache, VSFileSystem::vs_fprintf(), and __impl::Exception::what().

Referenced by Mesh::initTechnique().

{
    TechniqueMap::const_iterator it = techniqueCache.find( name );
    if ( it != techniqueCache.end() ) {
        return it->second;
    } else {
        TechniquePtr ptr( new Technique( name ) );
        while ( !ptr->isCompiled() ) {
            try {
                ptr->compile();
                VSFileSystem::vs_fprintf( stdout,
                                         "Compilation of technique %s successful\n",
                                         ptr->getName().c_str() );
            }
            catch (ProgramCompileError e) {
                std::string fallback = ptr->getFallback();
                VSFileSystem::vs_fprintf( stderr,
                                         "Compilation of technique %s failed... trying %s\n"
                                         "Cause: %s\n",
                                         ptr->getName().c_str(),
                                         fallback.c_str(),
                                         e.what() );
                if (!fallback.empty() && fallback != name)
                    ptr = getTechnique( fallback );
                else
                    break;
            }
        }
        if ( ptr->isCompiled() )
            techniqueCache[name] = ptr;
        else
            throw InvalidParameters( "Could not compile any technique for \""+name+"\"" );
        return ptr;
    }
}

bool Technique::isCompiled ( ) const

inline

returns true if the technique has been compiled

Definition at line 408 of file technique.h.

    {
        return compiled;
    }

bool Technique::isCompiled ( int  programVersion) const

inline

returns true if the technique has been compiled with a matching program version

Definition at line 414 of file technique.h.

    {
        return compiled && this->programVersion == programVersion;
    }

Member Data Documentation

PassList Technique::passes

protected

Definition at line 387 of file technique.h.

Referenced by compile(), getNumPasses(), and getPass().

---

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

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