__impl Namespace Reference

Classes
class	Exception
class	InvalidParameters
class	ProgramCompileError

Functions
template<typename T >
static T	parseEnum (const string &s, const map< string, T > &enumMap)
template<typename T >
static T	parseEnum (const string &s, const map< string, T > &enumMap, T deflt)
static Technique::Pass::TextureUnit::SourceType	parseSourceType (const string &s, string::size_type &sep)
static Technique::Pass::TextureUnit::Kind	parseTexKind (const string &s)
static Technique::Pass::Type	parsePassType (const std::string &s)
static bool	parseBool (const std::string &s)
static Technique::Pass::Tristate	parseTristate (const std::string &s)
static Technique::Pass::BlendMode	parseBlendMode (const std::string &s)
static Technique::Pass::Face	parseFace (const std::string &s)
static Technique::Pass::DepthFunction	parseDepthFunction (const std::string &s)
static Technique::Pass::PolyMode	parsePolyMode (const std::string &s)
static Technique::Pass::ShaderParam::Semantic	parseAutoParamSemantic (const std::string &s)
static int	parseIteration (const std::string &s)
static int	parseInt (const std::string &s)
static int	parseInt (const std::string &s, int deflt)
static float	parseFloat (const std::string &s)
static void	parseFloat4 (const std::string &s, float value[4])

Function Documentation

static Technique::Pass::ShaderParam::Semantic __impl::parseAutoParamSemantic ( const std::string &  s)

static

Definition at line 191 of file technique.cpp.

References Technique::Pass::ShaderParam::ActiveLightsArray, Technique::Pass::ShaderParam::ApparentLightSizeArray, Technique::Pass::ShaderParam::CloakingPhase, Technique::Pass::ShaderParam::Damage, Technique::Pass::ShaderParam::Damage4, Technique::Pass::ShaderParam::DetailPlane0, Technique::Pass::ShaderParam::DetailPlane1, Technique::Pass::ShaderParam::EnvColor, Technique::Pass::ShaderParam::GameTime, Technique::Pass::ShaderParam::NumLights, and parseEnum().

{
    static map< string, Technique::Pass::ShaderParam::Semantic >enumMap;
    if ( enumMap.empty() ) {
        enumMap["EnvColor"] = Technique::Pass::ShaderParam::EnvColor;
        enumMap["CloakingPhase"]     = Technique::Pass::ShaderParam::CloakingPhase;
        enumMap["Damage"]            = Technique::Pass::ShaderParam::Damage;
        enumMap["Damage4"]           = Technique::Pass::ShaderParam::Damage4;
        enumMap["DetailPlane0"]      = Technique::Pass::ShaderParam::DetailPlane0;
        enumMap["DetailPlane1"]      = Technique::Pass::ShaderParam::DetailPlane1;
        enumMap["NumLights"]         = Technique::Pass::ShaderParam::NumLights;
        enumMap["ActiveLightsArray"] = Technique::Pass::ShaderParam::ActiveLightsArray;
        enumMap["ApparentLightSizeArray"] = 
                                       Technique::Pass::ShaderParam::ApparentLightSizeArray;
        enumMap["GameTime"]          = Technique::Pass::ShaderParam::GameTime;
    }
    return parseEnum( s, enumMap );
}

static Technique::Pass::BlendMode __impl::parseBlendMode ( const std::string &  s)

static

Definition at line 137 of file technique.cpp.

References Technique::Pass::Add, Technique::Pass::AlphaBlend, Technique::Pass::Decal, Technique::Pass::Default, Technique::Pass::MultiAlphaBlend, Technique::Pass::Multiply, parseEnum(), and Technique::Pass::PremultAlphaBlend.

{
    static map<string, Technique::Pass::BlendMode> enumMap;
    if (enumMap.empty()) {
        enumMap["default"]     = Technique::Pass::Default;
        enumMap["add"]         = Technique::Pass::Add;
        enumMap["multiply"]    = Technique::Pass::Multiply;
        enumMap["alpha_blend"] = Technique::Pass::AlphaBlend;
        enumMap["decal"]       = Technique::Pass::Decal;
        enumMap["premult_alpha"]=Technique::Pass::PremultAlphaBlend;
        enumMap["multi_alpha_blend"]=Technique::Pass::MultiAlphaBlend;
    }
    return parseEnum(s, enumMap);
}

static bool __impl::parseBool ( const std::string &  s)

static

Definition at line 119 of file technique.cpp.

References XMLSupport::parse_bool().

{
    if ( s.empty() ) throw InvalidParameters( "Missing required attribute" );
    else
        return XMLSupport::parse_bool( s );
}

static Technique::Pass::DepthFunction __impl::parseDepthFunction ( const std::string &  s)

static

Definition at line 165 of file technique.cpp.

References Technique::Pass::Always, Technique::Pass::Equal, Technique::Pass::GEqual, Technique::Pass::Greater, Technique::Pass::LEqual, Technique::Pass::Less, Technique::Pass::Never, and parseEnum().

{
    static map< string, Technique::Pass::DepthFunction >enumMap;
    if ( enumMap.empty() ) {
        enumMap["less"]    = Technique::Pass::Less;
        enumMap["lequal"]  = Technique::Pass::LEqual;
        enumMap["greater"] = Technique::Pass::Greater;
        enumMap["gequal"]  = Technique::Pass::GEqual;
        enumMap["equal"]   = Technique::Pass::Equal;
        enumMap["always"]  = Technique::Pass::Always;
        enumMap["never"]   = Technique::Pass::Never;
    }
    return parseEnum(s, enumMap);
}

template<typename T >

static T __impl::parseEnum ( const string &  s, const map< string, T > &  enumMap  )

static

Definition at line 66 of file technique.cpp.

Referenced by parseAutoParamSemantic(), parseBlendMode(), parseDepthFunction(), parseFace(), parsePassType(), parsePolyMode(), parseSourceType(), parseTexKind(), parseTristate(), and Audio::__impl::parseVSFileType().

{
    typename map< string, T >::const_iterator it = enumMap.find( s );
    if ( it != enumMap.end() )
        return it->second;
    else throw InvalidParameters( "Enumerated value \""+s+"\" not recognized" );
}

template<typename T >

static T __impl::parseEnum ( const string &  s, const map< string, T > &  enumMap, T  deflt  )

static

Definition at line 75 of file technique.cpp.

{
    typename map< string, T >::const_iterator it = enumMap.find( s );
    if ( it != enumMap.end() )
        return it->second;
    else
        return deflt;
}

static Technique::Pass::Face __impl::parseFace ( const std::string &  s)

static

Definition at line 152 of file technique.cpp.

References Technique::Pass::Back, Technique::Pass::DefaultFace, Technique::Pass::Front, Technique::Pass::FrontAndBack, Technique::Pass::None, and parseEnum().

{
    static map< string, Technique::Pass::Face >enumMap;
    if ( enumMap.empty() ) {
        enumMap["none"]    = Technique::Pass::None;
        enumMap["back"]    = Technique::Pass::Back;
        enumMap["front"]   = Technique::Pass::Front;
        enumMap["both"]    = Technique::Pass::FrontAndBack;
        enumMap["default"] = Technique::Pass::DefaultFace;
    }
    return parseEnum( s, enumMap );
}

static float __impl::parseFloat ( const std::string &  s)

static

Definition at line 235 of file technique.cpp.

References XMLSupport::parse_floatf().

{
    if ( s.empty() ) throw InvalidParameters( "Invalid float attribute" );
    else
        return XMLSupport::parse_floatf( s );
}

static void __impl::parseFloat4 ( const std::string &  s, float  value[4]  )

static

Definition at line 242 of file technique.cpp.

References i, parseFloat(), and VSFileSystem::vs_dprintf().

{
    string::size_type ini = 0, end;
    int i = 0;
    while (i < 4 && ini != string::npos) {
        value[i++] = parseFloat( s.substr( ini, end = s.find_first_of( ',', ini ) ) );
        ini = ( (end == string::npos) ? end : (end+1) );
    }
    if (i >= 4 && ini != string::npos)
        VSFileSystem::vs_dprintf(1, "WARNING: invalid float4: %s\n", s.c_str());
    while (i < 4)
        value[i++] = 0;
}

static int __impl::parseInt ( const std::string &  s)

static

Definition at line 220 of file technique.cpp.

References XMLSupport::parse_int().

{
    if ( s.empty() ) throw InvalidParameters( "Invalid integer attribute" );
    else
        return XMLSupport::parse_int( s );
}

static int __impl::parseInt ( const std::string &  s, int  deflt  )

static

Definition at line 227 of file technique.cpp.

References XMLSupport::parse_int().

{
    if ( s.empty() )
        return deflt;
    else
        return XMLSupport::parse_int( s );
}

static int __impl::parseIteration ( const std::string &  s)

static

Definition at line 210 of file technique.cpp.

References XMLSupport::parse_int().

{
    static string once( "once" );
    if (s == once)
        return 0;
    else if ( s.empty() ) throw InvalidParameters( "Invalid iteration attribute" );
    else
        return XMLSupport::parse_int( s );
}

static Technique::Pass::Type __impl::parsePassType ( const std::string &  s)

static

Definition at line 109 of file technique.cpp.

References Technique::Pass::FixedPass, parseEnum(), and Technique::Pass::ShaderPass.

{
    static map< string, Technique::Pass::Type >enumMap;
    if ( enumMap.empty() ) {
        enumMap["fixed"]  = Technique::Pass::FixedPass;
        enumMap["shader"] = Technique::Pass::ShaderPass;
    }
    return parseEnum( s, enumMap );
}

static Technique::Pass::PolyMode __impl::parsePolyMode ( const std::string &  s)

static

Definition at line 180 of file technique.cpp.

References Technique::Pass::Fill, Technique::Pass::Line, parseEnum(), and Technique::Pass::Point.

{
    static map<string, Technique::Pass::PolyMode> enumMap;
    if (enumMap.empty()) {
        enumMap["point"]  = Technique::Pass::Point;
        enumMap["line"]   = Technique::Pass::Line;
        enumMap["fill"]   = Technique::Pass::Fill;
    }
    return parseEnum(s, enumMap);
}

static Technique::Pass::TextureUnit::SourceType __impl::parseSourceType ( const string &  s, string::size_type &  sep  )

static

Definition at line 84 of file technique.cpp.

References Technique::Pass::TextureUnit::Decal, Technique::Pass::TextureUnit::Detail, Technique::Pass::TextureUnit::Environment, Technique::Pass::TextureUnit::File, Technique::Pass::TextureUnit::None, and parseEnum().

Referenced by Technique::Pass::addTextureUnit().

{
    static map< string, Technique::Pass::TextureUnit::SourceType >enumMap;
    if ( enumMap.empty() ) {
        enumMap["decal"]  = Technique::Pass::TextureUnit::Decal;
        enumMap["file"]   = Technique::Pass::TextureUnit::File;
        enumMap["environment"] = Technique::Pass::TextureUnit::Environment;
        enumMap["detail"] = Technique::Pass::TextureUnit::Detail;
    }
    return parseEnum( s.substr( 0, sep = s.find_first_of( ':' ) ), enumMap, Technique::Pass::TextureUnit::None );
}

static Technique::Pass::TextureUnit::Kind __impl::parseTexKind ( const string &  s)

static

Definition at line 96 of file technique.cpp.

References parseEnum(), Technique::Pass::TextureUnit::Tex2D, Technique::Pass::TextureUnit::Tex3D, Technique::Pass::TextureUnit::TexCube, Technique::Pass::TextureUnit::TexDefault, and Technique::Pass::TextureUnit::TexSepCube.

{
    static map< string, Technique::Pass::TextureUnit::Kind >enumMap;
    if ( enumMap.empty() ) {
        enumMap["default"] = Technique::Pass::TextureUnit::TexDefault;
        enumMap["2d"] = Technique::Pass::TextureUnit::Tex2D;
        enumMap["3d"] = Technique::Pass::TextureUnit::Tex3D;
        enumMap["cube"]    = Technique::Pass::TextureUnit::TexCube;
        enumMap["separatedCube"] = Technique::Pass::TextureUnit::TexSepCube;
    }
    return parseEnum( s, enumMap, Technique::Pass::TextureUnit::TexDefault );
}

static Technique::Pass::Tristate __impl::parseTristate ( const std::string &  s)

static

Definition at line 126 of file technique.cpp.

References Technique::Pass::Auto, Technique::Pass::False, parseEnum(), and Technique::Pass::True.

{
    static map< string, Technique::Pass::Tristate >enumMap;
    if ( enumMap.empty() ) {
        enumMap["true"]  = Technique::Pass::True;
        enumMap["false"] = Technique::Pass::False;
        enumMap["auto"]  = Technique::Pass::Auto;
    }
    return parseEnum( s, enumMap );
}