IQ3Shader.hpp

// Copyright (C) 2006-2012 Nikolaus Gebhardt / Thomas Alten
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in duckcpp/duckcpp.hpp
 
#ifndef DCPP_I_Q3_LEVEL_SHADER_HPP_INCLUDED
#define DCPP_I_Q3_LEVEL_SHADER_HPP_INCLUDED
 
#include <duckcpp/core/engine/irrArray.hpp>
#include <duckcpp/core/engine/fast_atof.hpp>
#include <duckcpp/core/engine/IFileSystem.hpp>
#include <duckcpp/core/engine/IVideoDriver.hpp>
#include <duckcpp/core/engine/coreutil.hpp>
#include <algorithm>
 
namespace dcpp::scene::kqe
{
 
static dcpp::nub::string irrEmptyUstring("");
 
enum eQ3MeshIndex
{
    E_Q3_MESH_GEOMETRY = 0,
    E_Q3_MESH_ITEMS,
    E_Q3_MESH_BILLBOARD,
    E_Q3_MESH_FOG,
    E_Q3_MESH_UNRESOLVED,
    E_Q3_MESH_SIZE
};
 
class Q3LevelLoadParameter
{
public:
    Q3LevelLoadParameter():
        defaultLightMapMaterial ( dcpp::video::EMT_LIGHTMAP_M4 ),
        defaultModulate ( dcpp::video::EMFN_MODULATE_4X ),
        defaultFilter ( dcpp::video::EMF_BILINEAR_FILTER ),
        patchTesselation ( 8 ),
        verbose ( 0 ),
        startTime ( 0 ), endTime ( 0 ),
        mergeShaderBuffer ( 1 ),
        cleanUnResolvedMeshes ( 1 ),
        loadAllShaders ( 0 ),
        loadSkyShader ( 0 ),
        alpharef ( 1 ),
        swapLump ( 0 ),
#ifdef __BIG_ENDIAN__
        swapHeader ( 1 )
#else
        swapHeader ( 0 )
#endif
    {
        std::copy_n("scripts\x0", 8, scriptDir);
    }
 
public:
    dcpp::video::E_MATERIAL_TYPE defaultLightMapMaterial;
    dcpp::video::E_MODULATE_FUNC defaultModulate;
    dcpp::video::E_MATERIAL_FLAG defaultFilter;
    dcpp::int32_kt patchTesselation;
    dcpp::int32_kt verbose;
    dcpp::uint32_kt startTime;
    dcpp::uint32_kt endTime;
    dcpp::int32_kt mergeShaderBuffer;
    dcpp::int32_kt cleanUnResolvedMeshes;
    dcpp::int32_kt loadAllShaders;
    dcpp::int32_kt loadSkyShader;
    dcpp::int32_kt alpharef;
    dcpp::int32_kt swapLump;
    dcpp::int32_kt swapHeader;
    dcpp::char_kt scriptDir [ 64 ];
};
 
// some useful using type aliases
using tStringList = dcpp::nub::array< dcpp::nub::string >;
using tTexArray = dcpp::nub::array< dcpp::video::ITexture* >;
 
// string helper.. TODO: move to generic files
inline dcpp::int16_kt isEqual ( const dcpp::nub::string &string, dcpp::uint32_kt &pos, const dcpp::char_kt * const list[], dcpp::uint16_kt listSize )
{
    const char * in = string.data() + pos;
 
    for ( dcpp::uint16_kt i = 0; i != listSize; ++i )
    {
        if (string.size() < pos)
            return -2;
        dcpp::uint32_kt len = (dcpp::uint32_kt) strlen ( list[i] );
        if (string.size() < pos+len)
            continue;
        if ( in [len] != 0 && in [len] != ' ' )
            continue;
        if ( strncmp ( in, list[i], len ) )
            continue;
 
        pos += len + 1;
        return (dcpp::int16_kt) i;
    }
    return -2;
}
 
inline dcpp::float32_kt getAsFloat ( const dcpp::nub::string &string, dcpp::uint32_kt &pos )
{
    const char * in = string.data() + pos;
 
    dcpp::float32_kt value = 0.f;
    pos += (dcpp::uint32_kt) ( dcpp::nub::fast_atof_move ( in, value ) - in ) + 1;
    return value;
}
 
inline dcpp::nub::vector3df getAsVector3df ( const dcpp::nub::string &string, dcpp::uint32_kt &pos )
{
    dcpp::nub::vector3df v;
 
    v.X = getAsFloat ( string, pos );
    v.Z = getAsFloat ( string, pos );
    v.Y = getAsFloat ( string, pos );
 
    return v;
}
 
 
/*
    extract substrings
*/
inline void getAsStringList ( tStringList &list, dcpp::int32_kt max, const dcpp::nub::string &string, dcpp::uint32_kt &startPos )
{
    list.clear ();
 
    dcpp::int32_kt finish = 0;
    dcpp::int32_kt endPos;
    do
    {
        endPos = string.findNext ( ' ', startPos );
        if ( endPos == -1 )
        {
            finish = 1;
            endPos = string.size();
        }
 
        list.push_back ( string.subString ( startPos, endPos - startPos ) );
        startPos = endPos + 1;
 
        if ( list.size() >= (dcpp::uint32_kt) max )
            finish = 1;
 
    } while ( !finish );
 
}
 
class SBlendFunc
{
public:
    SBlendFunc(dcpp::video::E_MODULATE_FUNC mod):
        type(dcpp::video::EMT_SOLID),
        modulate(mod),
        param0(0.f),
        isTransparent(0)
    {}
 
public:
    dcpp::video::E_MATERIAL_TYPE type;
    dcpp::video::E_MODULATE_FUNC modulate;
 
    dcpp::float32_kt param0;
    dcpp::uint32_kt isTransparent;
};
 
// parses the content of Variable cull
inline bool getCullingFunction ( const dcpp::nub::string &cull )
{
    if ( cull.size() == 0 )
        return true;
 
    bool ret = true;
    static const dcpp::char_kt * funclist[] = { "none", "disable", "twosided" };
 
    dcpp::uint32_kt pos = 0;
    switch ( isEqual ( cull, pos, funclist, 3 ) )
    {
        case 0:
        case 1:
        case 2:
            ret = false;
            break;
    }
    return ret;
}
 
// parses the content of Variable depthfunc
// return a z-test
inline dcpp::uint8_kt getDepthFunction ( const dcpp::nub::string &string )
{
    dcpp::uint8_kt ret = dcpp::video::ECFN_LESSEQUAL;
 
    if ( string.size() == 0 )
        return ret;
 
    static const dcpp::char_kt * funclist[] = { "lequal","equal" };
 
    dcpp::uint32_kt pos = 0;
    switch ( isEqual ( string, pos, funclist, 2 ) )
    {
        case 0:
            ret = dcpp::video::ECFN_LESSEQUAL;
            break;
        case 1:
            ret = dcpp::video::ECFN_EQUAL;
            break;
    }
    return ret;
}
 
inline static void getBlendFunc ( const dcpp::nub::string &string, SBlendFunc &blendfunc )
{
    if ( string.size() == 0 )
        return;
 
    // maps to E_BLEND_FACTOR
    static const dcpp::char_kt * funclist[] =
    {
        "gl_zero",
        "gl_one",
        "gl_dst_color",
        "gl_one_minus_dst_color",
        "gl_src_color",
        "gl_one_minus_src_color",
        "gl_src_alpha",
        "gl_one_minus_src_alpha",
        "gl_dst_alpha",
        "gl_one_minus_dst_alpha",
        "gl_src_alpha_sat",
 
        "add",
        "filter",
        "blend",
 
        "ge128",
        "gt0",
    };
 
    dcpp::uint32_kt pos = 0;
    dcpp::int32_kt srcFact = isEqual ( string, pos, funclist, 16 );
 
    if ( srcFact < 0 )
        return;
 
    dcpp::uint32_kt resolved = 0;
    dcpp::int32_kt dstFact = isEqual ( string, pos, funclist, 16 );
 
    switch ( srcFact )
    {
        case dcpp::video::EBF_ZERO:
            switch ( dstFact )
            {
                // gl_zero gl_src_color == gl_dst_color gl_zero
                case dcpp::video::EBF_SRC_COLOR:
                    blendfunc.type = dcpp::video::EMT_ONETEXTURE_BLEND;
                    blendfunc.param0 = dcpp::video::pack_textureBlendFunc ( dcpp::video::EBF_DST_COLOR, dcpp::video::EBF_ZERO, blendfunc.modulate );
                    blendfunc.isTransparent = 1;
                    resolved = 1;
                    break;
            } break;
 
        case dcpp::video::EBF_ONE:
            switch ( dstFact )
            {
                // gl_one gl_zero
                case dcpp::video::EBF_ZERO:
                    blendfunc.type = dcpp::video::EMT_SOLID;
                    blendfunc.isTransparent = 0;
                    resolved = 1;
                    break;
 
                // gl_one gl_one
                case dcpp::video::EBF_ONE:
                    blendfunc.type = dcpp::video::EMT_TRANSPARENT_ADD_COLOR;
                    blendfunc.isTransparent = 1;
                    resolved = 1;
                    break;
            } break;
 
        case dcpp::video::EBF_SRC_ALPHA:
            switch ( dstFact )
            {
                // gl_src_alpha gl_one_minus_src_alpha
                case dcpp::video::EBF_ONE_MINUS_SRC_ALPHA:
                    blendfunc.type = dcpp::video::EMT_TRANSPARENT_ALPHA_CHANNEL;
                    blendfunc.param0 = 1.f/255.f;
                    blendfunc.isTransparent = 1;
                    resolved = 1;
                    break;
            } break;
 
        case 11:
            // add
            blendfunc.type = dcpp::video::EMT_TRANSPARENT_ADD_COLOR;
            blendfunc.isTransparent = 1;
            resolved = 1;
            break;
        case 12:
            // filter = gl_dst_color gl_zero or gl_zero gl_src_color
            blendfunc.type = dcpp::video::EMT_ONETEXTURE_BLEND;
            blendfunc.param0 = dcpp::video::pack_textureBlendFunc ( dcpp::video::EBF_DST_COLOR, dcpp::video::EBF_ZERO, blendfunc.modulate );
            blendfunc.isTransparent = 1;
            resolved = 1;
            break;
        case 13:
            // blend = gl_src_alpha gl_one_minus_src_alpha
            blendfunc.type = dcpp::video::EMT_TRANSPARENT_ALPHA_CHANNEL;
            blendfunc.param0 = 1.f/255.f;
            blendfunc.isTransparent = 1;
            resolved = 1;
            break;
        case 14:
            // alphafunc ge128
            blendfunc.type = dcpp::video::EMT_TRANSPARENT_ALPHA_CHANNEL;
            blendfunc.param0 = 0.5f;
            blendfunc.isTransparent = 1;
            resolved = 1;
            break;
        case 15:
            // alphafunc gt0
            blendfunc.type = dcpp::video::EMT_TRANSPARENT_ALPHA_CHANNEL;
            blendfunc.param0 = 1.f / 255.f;
            blendfunc.isTransparent = 1;
            resolved = 1;
            break;
 
    }
 
    // use the generic blender
    if ( 0 == resolved )
    {
        blendfunc.type = dcpp::video::EMT_ONETEXTURE_BLEND;
        blendfunc.param0 = dcpp::video::pack_textureBlendFunc (
                (dcpp::video::E_BLEND_FACTOR) srcFact,
                (dcpp::video::E_BLEND_FACTOR) dstFact,
                blendfunc.modulate);
 
        blendfunc.isTransparent = 1;
    }
}
 
// random noise [-1;1]
class Noiser
{
public:
    static dcpp::float32_kt get ()
    {
        static dcpp::uint32_kt RandomSeed = 0x69666966;
        RandomSeed = (RandomSeed * 3631 + 1);
 
        dcpp::float32_kt value = ( (dcpp::float32_kt) (RandomSeed & 0x7FFF ) * (1.0f / (dcpp::float32_kt)(0x7FFF >> 1) ) ) - 1.f;
        return value;
    }
};
 
enum eQ3ModifierFunction
{
    TCMOD           = 0,
    DEFORMVERTEXES      = 1,
    RGBGEN          = 2,
    TCGEN           = 3,
    MAP         = 4,
    ALPHAGEN        = 5,
 
    FUNCTION2       = 0x10,
    SCROLL          = FUNCTION2 + 1,
    SCALE           = FUNCTION2 + 2,
    ROTATE          = FUNCTION2 + 3,
    STRETCH         = FUNCTION2 + 4,
    TURBULENCE      = FUNCTION2 + 5,
    WAVE            = FUNCTION2 + 6,
 
    IDENTITY        = FUNCTION2 + 7,
    VERTEX          = FUNCTION2 + 8,
    TEXTURE         = FUNCTION2 + 9,
    LIGHTMAP        = FUNCTION2 + 10,
    ENVIRONMENT     = FUNCTION2 + 11,
    DOLLAR_LIGHTMAP     = FUNCTION2 + 12,
    BULGE           = FUNCTION2 + 13,
    AUTOSPRITE      = FUNCTION2 + 14,
    AUTOSPRITE2     = FUNCTION2 + 15,
    TRANSFORM       = FUNCTION2 + 16,
    EXACTVERTEX     = FUNCTION2 + 17,
    CONSTANT        = FUNCTION2 + 18,
    LIGHTINGSPECULAR    = FUNCTION2 + 19,
    MOVE            = FUNCTION2 + 20,
    NORMAL          = FUNCTION2 + 21,
    IDENTITYLIGHTING    = FUNCTION2 + 22,
 
    WAVE_MODIFIER_FUNCTION  = 0x30,
    SINUS           = WAVE_MODIFIER_FUNCTION + 1,
    COSINUS         = WAVE_MODIFIER_FUNCTION + 2,
    SQUARE          = WAVE_MODIFIER_FUNCTION + 3,
    TRIANGLE        = WAVE_MODIFIER_FUNCTION + 4,
    SAWTOOTH        = WAVE_MODIFIER_FUNCTION + 5,
    SAWTOOTH_INVERSE    = WAVE_MODIFIER_FUNCTION + 6,
    NOISE           = WAVE_MODIFIER_FUNCTION + 7,
 
    UNKNOWN         = -2
};
 
class SModifierFunction
{
public:
    SModifierFunction():
        masterfunc0 ( UNKNOWN ), masterfunc1( UNKNOWN ), func ( SINUS ),
        tcgen( TEXTURE ), rgbgen ( IDENTITY ), alphagen ( UNKNOWN ),
        base ( 0 ), amp ( 1 ), phase ( 0 ), frequency ( 1 ),
        wave ( 1 ),
        x ( 0 ), y ( 0 ), z( 0 ), count( 0 )
    {}
 
public:
    // "tcmod","deformvertexes","rgbgen", "tcgen"
    eQ3ModifierFunction masterfunc0;
    // depends
    eQ3ModifierFunction masterfunc1;
    // depends
    eQ3ModifierFunction func;
 
    eQ3ModifierFunction tcgen;
    eQ3ModifierFunction rgbgen;
    eQ3ModifierFunction alphagen;
 
public:
    union
    {
        dcpp::float32_kt base;
        dcpp::float32_kt bulgewidth;
    };
 
    union
    {
        dcpp::float32_kt amp;
        dcpp::float32_kt bulgeheight;
    };
 
    dcpp::float32_kt phase;
 
    union
    {
        dcpp::float32_kt frequency;
        dcpp::float32_kt bulgespeed;
    };
 
    union
    {
        dcpp::float32_kt wave;
        dcpp::float32_kt div;
    };
 
public:
    dcpp::float32_kt x;
    dcpp::float32_kt y;
    dcpp::float32_kt z;
    dcpp::uint32_kt count;
 
public:
    dcpp::float32_kt evaluate ( dcpp::float32_kt dt ) const
    {
        // phase in 0 and 1..
        dcpp::float32_kt x = dcpp::nub::fract( (dt + phase ) * frequency );
        dcpp::float32_kt y = 0.f;
 
        switch ( func )
        {
            case SINUS:
                y = sinf ( x * dcpp::nub::PI * 2.f );
                break;
            case COSINUS:
                y = cosf ( x * dcpp::nub::PI * 2.f );
                break;
            case SQUARE:
                y = x < 0.5f ? 1.f : -1.f;
                break;
            case TRIANGLE:
                y = x < 0.5f ? ( 4.f * x ) - 1.f : ( -4.f * x ) + 3.f;
                break;
            case SAWTOOTH:
                y = x;
                break;
            case SAWTOOTH_INVERSE:
                y = 1.f - x;
                break;
            case NOISE:
                y = Noiser::get();
                break;
            default:
                break;
        }
 
        return base + ( y * amp );
    }
};
 
inline dcpp::nub::vector3df getMD3Normal ( dcpp::uint32_kt i, dcpp::uint32_kt j )
{
    const dcpp::float32_kt lng = i * 2.0f * dcpp::nub::PI / 255.0f;
    const dcpp::float32_kt lat = j * 2.0f * dcpp::nub::PI / 255.0f;
    return dcpp::nub::vector3df(cosf ( lat ) * sinf ( lng ),
            sinf ( lat ) * sinf ( lng ),
            cosf ( lng ));
}
 
//
inline void getModifierFunc ( SModifierFunction& fill, const dcpp::nub::string &string, dcpp::uint32_kt &pos )
{
    if ( string.size() == 0 )
        return;
 
    static const dcpp::char_kt * funclist[] =
    {
        "sin","cos","square",
        "triangle", "sawtooth","inversesawtooth", "noise"
    };
 
    fill.func = (eQ3ModifierFunction) isEqual ( string,pos, funclist,7 );
    fill.func = fill.func == UNKNOWN ? SINUS : (eQ3ModifierFunction) ((dcpp::uint32_kt) fill.func + WAVE_MODIFIER_FUNCTION + 1);
 
    fill.base = getAsFloat ( string, pos );
    fill.amp = getAsFloat ( string, pos );
    fill.phase = getAsFloat ( string, pos );
    fill.frequency = getAsFloat ( string, pos );
}
 
// name = "a b c .."
class SVariable
{
public:
    dcpp::nub::string name;
    dcpp::nub::string content;
 
public:
    SVariable ( const dcpp::char_kt * n, const dcpp::char_kt *c = 0 ) : name ( n ), content (c) {}
 
public:
    virtual ~SVariable () {}
 
public:
    void clear ()
    {
        name = "";
        content = "";
    }
 
    dcpp::int32_kt isValid () const
    {
        return name.size();
    }
 
    bool operator == ( const SVariable &other ) const
    {
        return 0 == strcmp ( name.data(), other.name.data() );
    }
 
    bool operator < ( const SVariable &other ) const
    {
        return 0 > strcmp ( name.data(), other.name.data() );
    }
};
 
// string database. "a" = "Hello", "b" = "1234.6"
class SVarGroup
{
public:
    SVarGroup () { Variable.setAllocStrategy ( dcpp::nub::ALLOC_STRATEGY_SAFE ); }
 
public:
    virtual ~SVarGroup () {}
 
public:
    dcpp::uint32_kt isDefined ( const dcpp::char_kt * name, const dcpp::char_kt * content = 0 ) const
    {
        for ( dcpp::uint32_kt i = 0; i != Variable.size (); ++i )
        {
            if ( 0 == strcmp ( Variable[i].name.data(), name ) &&
                (  0 == content || strstr ( Variable[i].content.data(), content ) )
                )
            {
                return i + 1;
            }
        }
        return 0;
    }
 
    // searches for Variable name and returns is content
    // if Variable is not found a reference to an Empty String is returned
    const dcpp::nub::string &get( const dcpp::char_kt * name ) const
    {
        SVariable search ( name );
        dcpp::int32_kt index = Variable.linear_search ( search );
        if ( index < 0 )
            return irrEmptyUstring;
 
        return Variable [ index ].content;
    }
 
    // set the Variable name
    void set ( const dcpp::char_kt * name, const dcpp::char_kt * content = 0 )
    {
        dcpp::uint32_kt index = isDefined ( name, 0 );
        if ( 0 == index )
        {
            Variable.push_back ( SVariable ( name, content ) );
        }
        else
        {
            Variable [ index ].content = content;
        }
    }
 
public:
    dcpp::nub::array < SVariable > Variable;
};
 
class SVarGroupList: public IReferenceCounted
{
public:
    SVarGroupList ()
    {
        VariableGroup.setAllocStrategy ( dcpp::nub::ALLOC_STRATEGY_SAFE );
    }
 
public:
    virtual ~SVarGroupList () {}
 
public:
    dcpp::nub::array < SVarGroup > VariableGroup;
};
 
class IShader
{
public:
    IShader ()
        : ID ( 0 ), VarGroup ( 0 )  {}
 
public:
    bool operator == (const IShader &other ) const
    {
        return 0 == strcmp ( name.data(), other.name.data() );
        //return name == other.name;
    }
 
    bool operator < (const IShader &other ) const
    {
        return strcmp ( name.data(), other.name.data() ) < 0;
        //return name < other.name;
    }
 
    dcpp::uint32_kt getGroupSize () const
    {
        if ( 0 == VarGroup )
            return 0;
        return VarGroup->VariableGroup.size ();
    }
 
    const SVarGroup * getGroup ( dcpp::uint32_kt stage ) const
    {
        if ( 0 == VarGroup || stage >= VarGroup->VariableGroup.size () )
            return 0;
 
        return &VarGroup->VariableGroup [ stage ];
    }
 
public:
    // id
    dcpp::int32_kt ID;
    SVarGroupList * VarGroup; // reference
 
    // Shader: shader name ( also first variable in first Vargroup )
    // Entity: classname ( variable in Group(1) )
    dcpp::nub::string name;
};
 
using IEntity = IShader;
 
using tQ3EntityList = dcpp::nub::array < IEntity >;
 
/*
    dump shader like original layout, regardless of internal data holding
    no recursive folding..
*/
inline void dumpVarGroup ( dcpp::nub::string &dest, const SVarGroup * group, dcpp::int32_kt stack )
{
    dcpp::nub::string buf;
 
    if ( stack > 0 )
    {
        buf = "";
        for (dcpp::int32_kt i = 0; i < stack - 1; ++i )
            buf += '\t';
 
        buf += "{\n";
        dest.append ( buf );
    }
 
    for ( dcpp::uint32_kt g = 0; g != group->Variable.size(); ++g )
    {
        buf = "";
        for (dcpp::int32_kt i = 0; i < stack; ++i )
            buf += '\t';
 
        buf += group->Variable[g].name;
        buf += " ";
        buf += group->Variable[g].content;
        buf += "\n";
        dest.append ( buf );
    }
 
    if ( stack > 1 )
    {
        buf = "";
        for (dcpp::int32_kt i = 0; i < stack - 1; ++i )
            buf += '\t';
 
        buf += "}\n";
        dest.append ( buf );
    }
}
 
inline dcpp::nub::string & dumpShader ( dcpp::nub::string &dest, const IShader * shader, bool entity = false )
{
    if ( 0 == shader )
        return dest;
 
    const dcpp::uint32_kt size = shader->VarGroup->VariableGroup.size ();
    for ( dcpp::uint32_kt i = 0; i != size; ++i )
    {
        const SVarGroup * group = &shader->VarGroup->VariableGroup[ i ];
        dumpVarGroup ( dest, group, dcpp::nub::clamp( (int)i, 0, 2 ) );
    }
 
    if ( !entity )
    {
        if ( size <= 1 )
        {
            dest.append ( "{\n" );
        }
        dest.append ( "}\n" );
    }
    return dest;
}
 
/*
    kqe doesn't care much about tga & jpg
    load one or multiple files stored in name started at startPos to the texture array textures
    if texture is not loaded 0 will be added ( to find missing textures easier)
*/
inline void getTextures(tTexArray &textures,
            const dcpp::nub::string &name, dcpp::uint32_kt &startPos,
            const dcpp::io::IFileSystem *fileSystem,
            dcpp::video::IVideoDriver* driver)
{
    static const char * const extension[] =
    {
        ".jpg",
        ".jpeg",
        ".png",
        ".dds",
        ".tga",
        ".bmp",
        ".pcx"
    };
 
    tStringList stringList;
    getAsStringList(stringList, -1, name, startPos);
 
    textures.clear();
 
    dcpp::io::path loadFile;
    for ( dcpp::uint32_kt i = 0; i!= stringList.size (); ++i )
    {
        dcpp::video::ITexture* texture = 0;
        for (dcpp::uint32_kt g = 0; g != 7; ++g)
        {
            dcpp::nub::cutFilenameExtension ( loadFile, stringList[i] );
 
            if ( loadFile == "$whiteimage" )
            {
                texture = driver->getTexture( "$whiteimage" );
                if ( 0 == texture )
                {
                    dcpp::nub::dimension2du s ( 2, 2 );
                    dcpp::uint32_kt image[4] = { 0xFFFFFFFF, 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF };
                    dcpp::video::IImage* w = driver->createImageFromData ( dcpp::video::ECF_A8R8G8B8, s,&image );
                    texture = driver->addTexture( "$whiteimage", w );
                    w->drop ();
                }
 
            }
            else
            if ( loadFile == "$redimage" )
            {
                texture = driver->getTexture( "$redimage" );
                if ( 0 == texture )
                {
                    dcpp::nub::dimension2du s ( 2, 2 );
                    dcpp::uint32_kt image[4] = { 0xFFFF0000, 0xFFFF0000,0xFFFF0000,0xFFFF0000 };
                    dcpp::video::IImage* w = driver->createImageFromData ( dcpp::video::ECF_A8R8G8B8, s,&image );
                    texture = driver->addTexture( "$redimage", w );
                    w->drop ();
                }
            }
            else
            if ( loadFile == "$blueimage" )
            {
                texture = driver->getTexture( "$blueimage" );
                if ( 0 == texture )
                {
                    dcpp::nub::dimension2du s ( 2, 2 );
                    dcpp::uint32_kt image[4] = { 0xFF0000FF, 0xFF0000FF,0xFF0000FF,0xFF0000FF };
                    dcpp::video::IImage* w = driver->createImageFromData ( dcpp::video::ECF_A8R8G8B8, s,&image );
                    texture = driver->addTexture( "$blueimage", w );
                    w->drop ();
                }
            }
            else
            if ( loadFile == "$checkerimage" )
            {
                texture = driver->getTexture( "$checkerimage" );
                if ( 0 == texture )
                {
                    dcpp::nub::dimension2du s ( 2, 2 );
                    dcpp::uint32_kt image[4] = { 0xFFFFFFFF, 0xFF000000,0xFF000000,0xFFFFFFFF };
                    dcpp::video::IImage* w = driver->createImageFromData ( dcpp::video::ECF_A8R8G8B8, s,&image );
                    texture = driver->addTexture( "$checkerimage", w );
                    w->drop ();
                }
            }
            else
            if ( loadFile == "$lightmap" )
            {
                texture = 0;
            }
            else
            {
                loadFile.append ( extension[g] );
            }
 
            texture = driver->findTexture( loadFile );
            if ( texture )
                break;
 
            if ( fileSystem->existFile ( loadFile ) )
            {
                texture = driver->getTexture( loadFile );
                if ( texture )
                    break;
                texture = 0;
            }
        }
        // take 0 Texture
        textures.push_back(texture);
    }
}
 
class IShaderManager : public IReferenceCounted
{
};
 
}   // namespace dcpp::scene::kqe
 
#endif