IQ3Shader.h

Go to the documentation of this file.

// 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 irrlicht.h

#ifndef __I_Q3_LEVEL_SHADER_H_INCLUDED__
#define __I_Q3_LEVEL_SHADER_H_INCLUDED__

#include "irrArray.h"
#include "fast_atof.h"
#include "IFileSystem.h"
#include "IVideoDriver.h"
#include "coreutil.h"

namespace irr
{
namespace scene
{
namespace quake3
{

        static core::stringc irrEmptyStringc("");

        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
        };

        struct Q3LevelLoadParameter
        {
                Q3LevelLoadParameter ()
                        :defaultLightMapMaterial ( video::EMT_LIGHTMAP_M4 ),
                        defaultModulate ( video::EMFN_MODULATE_4X ),
                        defaultFilter ( 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
                        {
                                memcpy ( scriptDir, "scripts\x0", 8 );
                        }

                video::E_MATERIAL_TYPE defaultLightMapMaterial;
                video::E_MODULATE_FUNC defaultModulate;
                video::E_MATERIAL_FLAG defaultFilter;
                s32 patchTesselation;
                s32 verbose;
                u32 startTime;
                u32 endTime;
                s32 mergeShaderBuffer;
                s32 cleanUnResolvedMeshes;
                s32 loadAllShaders;
                s32 loadSkyShader;
                s32 alpharef;
                s32 swapLump;
                s32 swapHeader;
                c8 scriptDir [ 64 ];
        };

        // some useful typedefs
        typedef core::array< core::stringc > tStringList;
        typedef core::array< video::ITexture* > tTexArray;

        // string helper.. TODO: move to generic files
        inline s16 isEqual ( const core::stringc &string, u32 &pos, const c8 * const list[], u16 listSize )
        {
                const char * in = string.c_str () + pos;

                for ( u16 i = 0; i != listSize; ++i )
                {
                        if (string.size() < pos)
                                return -2;
                        u32 len = (u32) 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 (s16) i;
                }
                return -2;
        }

        inline f32 getAsFloat ( const core::stringc &string, u32 &pos )
        {
                const char * in = string.c_str () + pos;

                f32 value = 0.f;
                pos += (u32) ( core::fast_atof_move ( in, value ) - in ) + 1;
                return value;
        }

        inline core::vector3df getAsVector3df ( const core::stringc &string, u32 &pos )
        {
                core::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, s32 max, const core::stringc &string, u32 &startPos )
        {
                list.clear ();

                s32 finish = 0;
                s32 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() >= (u32) max )
                                finish = 1;

                } while ( !finish );

        }

        struct SBlendFunc
        {
                SBlendFunc ( video::E_MODULATE_FUNC mod )
                        : type ( video::EMT_SOLID ), modulate ( mod ),
                                param0( 0.f ),
                        isTransparent ( 0 ) {}

                video::E_MATERIAL_TYPE type;
                video::E_MODULATE_FUNC modulate;

                f32 param0;
                u32 isTransparent;
        };

        // parses the content of Variable cull
        inline bool getCullingFunction ( const core::stringc &cull )
        {
                if ( cull.size() == 0 )
                        return true;

                bool ret = true;
                static const c8 * funclist[] = { "none", "disable", "twosided" };

                u32 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 u8 getDepthFunction ( const core::stringc &string )
        {
                u8 ret = video::ECFN_LESSEQUAL;

                if ( string.size() == 0 )
                        return ret;

                static const c8 * funclist[] = { "lequal","equal" };

                u32 pos = 0;
                switch ( isEqual ( string, pos, funclist, 2 ) )
                {
                        case 0:
                                ret = video::ECFN_LESSEQUAL;
                                break;
                        case 1:
                                ret = video::ECFN_EQUAL;
                                break;
                }
                return ret;
        }


        inline static void getBlendFunc ( const core::stringc &string, SBlendFunc &blendfunc )
        {
                if ( string.size() == 0 )
                        return;

                // maps to E_BLEND_FACTOR
                static const c8 * 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",
                };


                u32 pos = 0;
                s32 srcFact = isEqual ( string, pos, funclist, 16 );

                if ( srcFact < 0 )
                        return;

                u32 resolved = 0;
                s32 dstFact = isEqual ( string, pos, funclist, 16 );

                switch ( srcFact )
                {
                        case video::EBF_ZERO:
                                switch ( dstFact )
                                {
                                        // gl_zero gl_src_color == gl_dst_color gl_zero
                                        case video::EBF_SRC_COLOR:
                                                blendfunc.type = video::EMT_ONETEXTURE_BLEND;
                                                blendfunc.param0 = video::pack_textureBlendFunc ( video::EBF_DST_COLOR, video::EBF_ZERO, blendfunc.modulate );
                                                blendfunc.isTransparent = 1;
                                                resolved = 1;
                                                break;
                                } break;

                        case video::EBF_ONE:
                                switch ( dstFact )
                                {
                                        // gl_one gl_zero
                                        case video::EBF_ZERO:
                                                blendfunc.type = video::EMT_SOLID;
                                                blendfunc.isTransparent = 0;
                                                resolved = 1;
                                                break;

                                        // gl_one gl_one
                                        case video::EBF_ONE:
                                                blendfunc.type = video::EMT_TRANSPARENT_ADD_COLOR;
                                                blendfunc.isTransparent = 1;
                                                resolved = 1;
                                                break;
                                } break;

                        case video::EBF_SRC_ALPHA:
                                switch ( dstFact )
                                {
                                        // gl_src_alpha gl_one_minus_src_alpha
                                        case video::EBF_ONE_MINUS_SRC_ALPHA:
                                                blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
                                                blendfunc.param0 = 1.f/255.f;
                                                blendfunc.isTransparent = 1;
                                                resolved = 1;
                                                break;
                                } break;

                        case 11:
                                // add
                                blendfunc.type = 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 = video::EMT_ONETEXTURE_BLEND;
                                blendfunc.param0 = video::pack_textureBlendFunc ( video::EBF_DST_COLOR, video::EBF_ZERO, blendfunc.modulate );
                                blendfunc.isTransparent = 1;
                                resolved = 1;
                                break;
                        case 13:
                                // blend = gl_src_alpha gl_one_minus_src_alpha
                                blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
                                blendfunc.param0 = 1.f/255.f;
                                blendfunc.isTransparent = 1;
                                resolved = 1;
                                break;
                        case 14:
                                // alphafunc ge128
                                blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
                                blendfunc.param0 = 0.5f;
                                blendfunc.isTransparent = 1;
                                resolved = 1;
                                break;
                        case 15:
                                // alphafunc gt0
                                blendfunc.type = 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 = video::EMT_ONETEXTURE_BLEND;
                        blendfunc.param0 = video::pack_textureBlendFunc (
                                        (video::E_BLEND_FACTOR) srcFact,
                                        (video::E_BLEND_FACTOR) dstFact,
                                        blendfunc.modulate);

                        blendfunc.isTransparent = 1;
                }
        }

        // random noise [-1;1]
        struct Noiser
        {
                static f32 get ()
                {
                        static u32 RandomSeed = 0x69666966;
                        RandomSeed = (RandomSeed * 3631 + 1);

                        f32 value = ( (f32) (RandomSeed & 0x7FFF ) * (1.0f / (f32)(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
        };

        struct SModifierFunction
        {
                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 ) {}

                // "tcmod","deformvertexes","rgbgen", "tcgen"
                eQ3ModifierFunction masterfunc0;
                // depends
                eQ3ModifierFunction masterfunc1;
                // depends
                eQ3ModifierFunction func;

                eQ3ModifierFunction tcgen;
                eQ3ModifierFunction rgbgen;
                eQ3ModifierFunction alphagen;

                union
                {
                        f32 base;
                        f32 bulgewidth;
                };

                union
                {
                        f32 amp;
                        f32 bulgeheight;
                };

                f32 phase;

                union
                {
                        f32 frequency;
                        f32 bulgespeed;
                };

                union
                {
                        f32 wave;
                        f32 div;
                };

                f32 x;
                f32 y;
                f32 z;
                u32 count;

                f32 evaluate ( f32 dt ) const
                {
                        // phase in 0 and 1..
                        f32 x = core::fract( (dt + phase ) * frequency );
                        f32 y = 0.f;

                        switch ( func )
                        {
                                case SINUS:
                                        y = sinf ( x * core::PI * 2.f );
                                        break;
                                case COSINUS:
                                        y = cosf ( x * core::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 core::vector3df getMD3Normal ( u32 i, u32 j )
        {
                const f32 lng = i * 2.0f * core::PI / 255.0f;
                const f32 lat = j * 2.0f * core::PI / 255.0f;
                return core::vector3df(cosf ( lat ) * sinf ( lng ),
                                sinf ( lat ) * sinf ( lng ),
                                cosf ( lng ));
        }

        //
        inline void getModifierFunc ( SModifierFunction& fill, const core::stringc &string, u32 &pos )
        {
                if ( string.size() == 0 )
                        return;

                static const c8 * funclist[] =
                {
                        "sin","cos","square",
                        "triangle", "sawtooth","inversesawtooth", "noise"
                };

                fill.func = (eQ3ModifierFunction) isEqual ( string,pos, funclist,7 );
                fill.func = fill.func == UNKNOWN ? SINUS : (eQ3ModifierFunction) ((u32) 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 .."
        struct SVariable
        {
                core::stringc name;
                core::stringc content;

                SVariable ( const c8 * n, const c8 *c = 0 ) : name ( n ), content (c) {}
                virtual ~SVariable () {}

                void clear ()
                {
                        name = "";
                        content = "";
                }

                s32 isValid () const
                {
                        return name.size();
                }

                bool operator == ( const SVariable &other ) const
                {
                        return 0 == strcmp ( name.c_str(), other.name.c_str () );
                }

                bool operator < ( const SVariable &other ) const
                {
                        return 0 > strcmp ( name.c_str(), other.name.c_str () );
                }

        };


        // string database. "a" = "Hello", "b" = "1234.6"
        struct SVarGroup
        {
                SVarGroup () { Variable.setAllocStrategy ( core::ALLOC_STRATEGY_SAFE ); }
                virtual ~SVarGroup () {}

                u32 isDefined ( const c8 * name, const c8 * content = 0 ) const
                {
                        for ( u32 i = 0; i != Variable.size (); ++i )
                        {
                                if ( 0 == strcmp ( Variable[i].name.c_str(), name ) &&
                                        (  0 == content || strstr ( Variable[i].content.c_str(), 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 core::stringc &get( const c8 * name ) const
                {
                        SVariable search ( name );
                        s32 index = Variable.linear_search ( search );
                        if ( index < 0 )
                                return irrEmptyStringc;

                        return Variable [ index ].content;
                }

                // set the Variable name
                void set ( const c8 * name, const c8 * content = 0 )
                {
                        u32 index = isDefined ( name, 0 );
                        if ( 0 == index )
                        {
                                Variable.push_back ( SVariable ( name, content ) );
                        }
                        else
                        {
                                Variable [ index ].content = content;
                        }
                }


                core::array < SVariable > Variable;
        };

        struct SVarGroupList: public IReferenceCounted
        {
                SVarGroupList ()
                {
                        VariableGroup.setAllocStrategy ( core::ALLOC_STRATEGY_SAFE );
                }
                virtual ~SVarGroupList () {}

                core::array < SVarGroup > VariableGroup;
        };


        struct IShader
        {
                IShader ()
                        : ID ( 0 ), VarGroup ( 0 )  {}
                virtual ~IShader () {}

                void operator = (const IShader &other )
                {
                        ID = other.ID;
                        VarGroup = other.VarGroup;
                        name = other.name;
                }

                bool operator == (const IShader &other ) const
                {
                        return 0 == strcmp ( name.c_str(), other.name.c_str () );
                        //return name == other.name;
                }

                bool operator < (const IShader &other ) const
                {
                        return strcmp ( name.c_str(), other.name.c_str () ) < 0;
                        //return name < other.name;
                }

                u32 getGroupSize () const
                {
                        if ( 0 == VarGroup )
                                return 0;
                        return VarGroup->VariableGroup.size ();
                }

                const SVarGroup * getGroup ( u32 stage ) const
                {
                        if ( 0 == VarGroup || stage >= VarGroup->VariableGroup.size () )
                                return 0;

                        return &VarGroup->VariableGroup [ stage ];
                }

                // id
                s32 ID;
                SVarGroupList *VarGroup; // reference

                // Shader: shader name ( also first variable in first Vargroup )
                // Entity: classname ( variable in Group(1) )
                core::stringc name;
        };

        typedef IShader IEntity;

        typedef core::array < IEntity > tQ3EntityList;

        /*
                dump shader like original layout, regardless of internal data holding
                no recursive folding..
        */
        inline void dumpVarGroup ( core::stringc &dest, const SVarGroup * group, s32 stack )
        {
                core::stringc buf;

                if ( stack > 0 )
                {
                        buf = "";
                        for (s32 i = 0; i < stack - 1; ++i )
                                buf += '\t';

                        buf += "{\n";
                        dest.append ( buf );
                }

                for ( u32 g = 0; g != group->Variable.size(); ++g )
                {
                        buf = "";
                        for (s32 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 (s32 i = 0; i < stack - 1; ++i )
                                buf += '\t';

                        buf += "}\n";
                        dest.append ( buf );
                }
        }

        inline core::stringc & dumpShader ( core::stringc &dest, const IShader * shader, bool entity = false )
        {
                if ( 0 == shader )
                        return dest;

                const u32 size = shader->VarGroup->VariableGroup.size ();
                for ( u32 i = 0; i != size; ++i )
                {
                        const SVarGroup * group = &shader->VarGroup->VariableGroup[ i ];
                        dumpVarGroup ( dest, group, core::clamp( (int)i, 0, 2 ) );
                }

                if ( !entity )
                {
                        if ( size <= 1 )
                        {
                                dest.append ( "{\n" );
                        }
                        dest.append ( "}\n" );
                }
                return dest;
        }


        /*
                quake3 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 core::stringc &name, u32 &startPos,
                                const io::IFileSystem *fileSystem,
                                video::IVideoDriver* driver)
        {
                static const char * const extension[] =
                {
                        ".jpg",
                        ".jpeg",
                        ".png",
                        ".dds",
                        ".tga",
                        ".bmp",
                        ".pcx"
                };

                tStringList stringList;
                getAsStringList(stringList, -1, name, startPos);

                textures.clear();

                io::path loadFile;
                for ( u32 i = 0; i!= stringList.size (); ++i )
                {
                        video::ITexture* texture = 0;
                        for (u32 g = 0; g != 7; ++g)
                        {
                                core::cutFilenameExtension ( loadFile, stringList[i] );

                                if ( loadFile == "$whiteimage" )
                                {
                                        texture = driver->getTexture( "$whiteimage" );
                                        if ( 0 == texture )
                                        {
                                                core::dimension2du s ( 2, 2 );
                                                u32 image[4] = { 0xFFFFFFFF, 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF };
                                                video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image );
                                                texture = driver->addTexture( "$whiteimage", w );
                                                w->drop ();
                                        }

                                }
                                else
                                if ( loadFile == "$redimage" )
                                {
                                        texture = driver->getTexture( "$redimage" );
                                        if ( 0 == texture )
                                        {
                                                core::dimension2du s ( 2, 2 );
                                                u32 image[4] = { 0xFFFF0000, 0xFFFF0000,0xFFFF0000,0xFFFF0000 };
                                                video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image );
                                                texture = driver->addTexture( "$redimage", w );
                                                w->drop ();
                                        }
                                }
                                else
                                if ( loadFile == "$blueimage" )
                                {
                                        texture = driver->getTexture( "$blueimage" );
                                        if ( 0 == texture )
                                        {
                                                core::dimension2du s ( 2, 2 );
                                                u32 image[4] = { 0xFF0000FF, 0xFF0000FF,0xFF0000FF,0xFF0000FF };
                                                video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image );
                                                texture = driver->addTexture( "$blueimage", w );
                                                w->drop ();
                                        }
                                }
                                else
                                if ( loadFile == "$checkerimage" )
                                {
                                        texture = driver->getTexture( "$checkerimage" );
                                        if ( 0 == texture )
                                        {
                                                core::dimension2du s ( 2, 2 );
                                                u32 image[4] = { 0xFFFFFFFF, 0xFF000000,0xFF000000,0xFFFFFFFF };
                                                video::IImage* w = driver->createImageFromData ( 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
        {
        };

} // end namespace quake3
} // end namespace scene
} // end namespace irr

#endif