 |
+
+
+
+ Irrlicht 3D Engine
+
+
+
+ |
+
+
+
+
+
+
+
+
+
+
+ 
+
+ |
+
+
+
00001 // Copyright (C) 2006-2012 Nikolaus Gebhardt / Thomas Alten +00002 // This file is part of the "Irrlicht Engine". +00003 // For conditions of distribution and use, see copyright notice in irrlicht.h +00004 +00005 #ifndef __I_Q3_LEVEL_SHADER_H_INCLUDED__ +00006 #define __I_Q3_LEVEL_SHADER_H_INCLUDED__ +00007 +00008 #include "irrArray.h" +00009 #include "fast_atof.h" +00010 #include "IFileSystem.h" +00011 #include "IVideoDriver.h" +00012 #include "coreutil.h" +00013 +00014 namespace irr +00015 { +00016 namespace scene +00017 { +00018 namespace quake3 +00019 { +00020 +00021 static core::stringc irrEmptyStringc(""); +00022 +00024 enum eQ3MeshIndex +00025 { +00026 E_Q3_MESH_GEOMETRY = 0, +00027 E_Q3_MESH_ITEMS, +00028 E_Q3_MESH_BILLBOARD, +00029 E_Q3_MESH_FOG, +00030 E_Q3_MESH_UNRESOLVED, +00031 E_Q3_MESH_SIZE +00032 }; +00033 +00037 struct Q3LevelLoadParameter +00038 { +00039 Q3LevelLoadParameter () +00040 :defaultLightMapMaterial ( video::EMT_LIGHTMAP_M4 ), +00041 defaultModulate ( video::EMFN_MODULATE_4X ), +00042 defaultFilter ( video::EMF_BILINEAR_FILTER ), +00043 patchTesselation ( 8 ), +00044 verbose ( 0 ), +00045 startTime ( 0 ), endTime ( 0 ), +00046 mergeShaderBuffer ( 1 ), +00047 cleanUnResolvedMeshes ( 1 ), +00048 loadAllShaders ( 0 ), +00049 loadSkyShader ( 0 ), +00050 alpharef ( 1 ), +00051 swapLump ( 0 ), +00052 #ifdef __BIG_ENDIAN__ +00053 swapHeader ( 1 ) +00054 #else +00055 swapHeader ( 0 ) +00056 #endif +00057 { +00058 memcpy ( scriptDir, "scripts\x0", 8 ); +00059 } +00060 +00061 video::E_MATERIAL_TYPE defaultLightMapMaterial; +00062 video::E_MODULATE_FUNC defaultModulate; +00063 video::E_MATERIAL_FLAG defaultFilter; +00064 s32 patchTesselation; +00065 s32 verbose; +00066 u32 startTime; +00067 u32 endTime; +00068 s32 mergeShaderBuffer; +00069 s32 cleanUnResolvedMeshes; +00070 s32 loadAllShaders; +00071 s32 loadSkyShader; +00072 s32 alpharef; +00073 s32 swapLump; +00074 s32 swapHeader; +00075 c8 scriptDir [ 64 ]; +00076 }; +00077 +00078 // some useful typedefs +00079 typedef core::array< core::stringc > tStringList; +00080 typedef core::array< video::ITexture* > tTexArray; +00081 +00082 // string helper.. TODO: move to generic files +00083 inline s16 isEqual ( const core::stringc &string, u32 &pos, const c8 *list[], u16 listSize ) +00084 { +00085 const char * in = string.c_str () + pos; +00086 +00087 for ( u16 i = 0; i != listSize; ++i ) +00088 { +00089 if (string.size() < pos) +00090 return -2; +00091 u32 len = (u32) strlen ( list[i] ); +00092 if (string.size() < pos+len) +00093 continue; +00094 if ( in [len] != 0 && in [len] != ' ' ) +00095 continue; +00096 if ( strncmp ( in, list[i], len ) ) +00097 continue; +00098 +00099 pos += len + 1; +00100 return (s16) i; +00101 } +00102 return -2; +00103 } +00104 +00105 inline f32 getAsFloat ( const core::stringc &string, u32 &pos ) +00106 { +00107 const char * in = string.c_str () + pos; +00108 +00109 f32 value = 0.f; +00110 pos += (u32) ( core::fast_atof_move ( in, value ) - in ) + 1; +00111 return value; +00112 } +00113 +00115 inline core::vector3df getAsVector3df ( const core::stringc &string, u32 &pos ) +00116 { +00117 core::vector3df v; +00118 +00119 v.X = getAsFloat ( string, pos ); +00120 v.Z = getAsFloat ( string, pos ); +00121 v.Y = getAsFloat ( string, pos ); +00122 +00123 return v; +00124 } +00125 +00126 +00127 /* +00128 extract substrings +00129 */ +00130 inline void getAsStringList ( tStringList &list, s32 max, const core::stringc &string, u32 &startPos ) +00131 { +00132 list.clear (); +00133 +00134 s32 finish = 0; +00135 s32 endPos; +00136 do +00137 { +00138 endPos = string.findNext ( ' ', startPos ); +00139 if ( endPos == -1 ) +00140 { +00141 finish = 1; +00142 endPos = string.size(); +00143 } +00144 +00145 list.push_back ( string.subString ( startPos, endPos - startPos ) ); +00146 startPos = endPos + 1; +00147 +00148 if ( list.size() >= (u32) max ) +00149 finish = 1; +00150 +00151 } while ( !finish ); +00152 +00153 } +00154 +00156 struct SBlendFunc +00157 { +00158 SBlendFunc ( video::E_MODULATE_FUNC mod ) +00159 : type ( video::EMT_SOLID ), modulate ( mod ), +00160 param0( 0.f ), +00161 isTransparent ( 0 ) {} +00162 +00163 video::E_MATERIAL_TYPE type; +00164 video::E_MODULATE_FUNC modulate; +00165 +00166 f32 param0; +00167 u32 isTransparent; +00168 }; +00169 +00170 // parses the content of Variable cull +00171 inline bool getCullingFunction ( const core::stringc &cull ) +00172 { +00173 if ( cull.size() == 0 ) +00174 return true; +00175 +00176 bool ret = true; +00177 static const c8 * funclist[] = { "none", "disable", "twosided" }; +00178 +00179 u32 pos = 0; +00180 switch ( isEqual ( cull, pos, funclist, 3 ) ) +00181 { +00182 case 0: +00183 case 1: +00184 case 2: +00185 ret = false; +00186 break; +00187 } +00188 return ret; +00189 } +00190 +00191 // parses the content of Variable depthfunc +00192 // return a z-test +00193 inline u8 getDepthFunction ( const core::stringc &string ) +00194 { +00195 u8 ret = video::ECFN_LESSEQUAL; +00196 +00197 if ( string.size() == 0 ) +00198 return ret; +00199 +00200 static const c8 * funclist[] = { "lequal","equal" }; +00201 +00202 u32 pos = 0; +00203 switch ( isEqual ( string, pos, funclist, 2 ) ) +00204 { +00205 case 0: +00206 ret = video::ECFN_LESSEQUAL; +00207 case 1: +00208 ret = video::ECFN_EQUAL; +00209 break; +00210 } +00211 return ret; +00212 } +00213 +00214 +00226 inline static void getBlendFunc ( const core::stringc &string, SBlendFunc &blendfunc ) +00227 { +00228 if ( string.size() == 0 ) +00229 return; +00230 +00231 // maps to E_BLEND_FACTOR +00232 static const c8 * funclist[] = +00233 { +00234 "gl_zero", +00235 "gl_one", +00236 "gl_dst_color", +00237 "gl_one_minus_dst_color", +00238 "gl_src_color", +00239 "gl_one_minus_src_color", +00240 "gl_src_alpha", +00241 "gl_one_minus_src_alpha", +00242 "gl_dst_alpha", +00243 "gl_one_minus_dst_alpha", +00244 "gl_src_alpha_sat", +00245 +00246 "add", +00247 "filter", +00248 "blend", +00249 +00250 "ge128", +00251 "gt0", +00252 }; +00253 +00254 +00255 u32 pos = 0; +00256 s32 srcFact = isEqual ( string, pos, funclist, 16 ); +00257 +00258 if ( srcFact < 0 ) +00259 return; +00260 +00261 u32 resolved = 0; +00262 s32 dstFact = isEqual ( string, pos, funclist, 16 ); +00263 +00264 switch ( srcFact ) +00265 { +00266 case video::EBF_ZERO: +00267 switch ( dstFact ) +00268 { +00269 // gl_zero gl_src_color == gl_dst_color gl_zero +00270 case video::EBF_SRC_COLOR: +00271 blendfunc.type = video::EMT_ONETEXTURE_BLEND; +00272 blendfunc.param0 = video::pack_textureBlendFunc ( video::EBF_DST_COLOR, video::EBF_ZERO, blendfunc.modulate ); +00273 blendfunc.isTransparent = 1; +00274 resolved = 1; +00275 break; +00276 } break; +00277 +00278 case video::EBF_ONE: +00279 switch ( dstFact ) +00280 { +00281 // gl_one gl_zero +00282 case video::EBF_ZERO: +00283 blendfunc.type = video::EMT_SOLID; +00284 blendfunc.isTransparent = 0; +00285 resolved = 1; +00286 break; +00287 +00288 // gl_one gl_one +00289 case video::EBF_ONE: +00290 blendfunc.type = video::EMT_TRANSPARENT_ADD_COLOR; +00291 blendfunc.isTransparent = 1; +00292 resolved = 1; +00293 break; +00294 } break; +00295 +00296 case video::EBF_SRC_ALPHA: +00297 switch ( dstFact ) +00298 { +00299 // gl_src_alpha gl_one_minus_src_alpha +00300 case video::EBF_ONE_MINUS_SRC_ALPHA: +00301 blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL; +00302 blendfunc.param0 = 1.f/255.f; +00303 blendfunc.isTransparent = 1; +00304 resolved = 1; +00305 break; +00306 } break; +00307 +00308 case 11: +00309 // add +00310 blendfunc.type = video::EMT_TRANSPARENT_ADD_COLOR; +00311 blendfunc.isTransparent = 1; +00312 resolved = 1; +00313 break; +00314 case 12: +00315 // filter = gl_dst_color gl_zero or gl_zero gl_src_color +00316 blendfunc.type = video::EMT_ONETEXTURE_BLEND; +00317 blendfunc.param0 = video::pack_textureBlendFunc ( video::EBF_DST_COLOR, video::EBF_ZERO, blendfunc.modulate ); +00318 blendfunc.isTransparent = 1; +00319 resolved = 1; +00320 break; +00321 case 13: +00322 // blend = gl_src_alpha gl_one_minus_src_alpha +00323 blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL; +00324 blendfunc.param0 = 1.f/255.f; +00325 blendfunc.isTransparent = 1; +00326 resolved = 1; +00327 break; +00328 case 14: +00329 // alphafunc ge128 +00330 blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL; +00331 blendfunc.param0 = 0.5f; +00332 blendfunc.isTransparent = 1; +00333 resolved = 1; +00334 break; +00335 case 15: +00336 // alphafunc gt0 +00337 blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL; +00338 blendfunc.param0 = 1.f / 255.f; +00339 blendfunc.isTransparent = 1; +00340 resolved = 1; +00341 break; +00342 +00343 } +00344 +00345 // use the generic blender +00346 if ( 0 == resolved ) +00347 { +00348 blendfunc.type = video::EMT_ONETEXTURE_BLEND; +00349 blendfunc.param0 = video::pack_textureBlendFunc ( +00350 (video::E_BLEND_FACTOR) srcFact, +00351 (video::E_BLEND_FACTOR) dstFact, +00352 blendfunc.modulate); +00353 +00354 blendfunc.isTransparent = 1; +00355 } +00356 } +00357 +00358 // random noise [-1;1] +00359 struct Noiser +00360 { +00361 static f32 get () +00362 { +00363 static u32 RandomSeed = 0x69666966; +00364 RandomSeed = (RandomSeed * 3631 + 1); +00365 +00366 f32 value = ( (f32) (RandomSeed & 0x7FFF ) * (1.0f / (f32)(0x7FFF >> 1) ) ) - 1.f; +00367 return value; +00368 } +00369 }; +00370 +00371 enum eQ3ModifierFunction +00372 { +00373 TCMOD = 0, +00374 DEFORMVERTEXES = 1, +00375 RGBGEN = 2, +00376 TCGEN = 3, +00377 MAP = 4, +00378 ALPHAGEN = 5, +00379 +00380 FUNCTION2 = 0x10, +00381 SCROLL = FUNCTION2 + 1, +00382 SCALE = FUNCTION2 + 2, +00383 ROTATE = FUNCTION2 + 3, +00384 STRETCH = FUNCTION2 + 4, +00385 TURBULENCE = FUNCTION2 + 5, +00386 WAVE = FUNCTION2 + 6, +00387 +00388 IDENTITY = FUNCTION2 + 7, +00389 VERTEX = FUNCTION2 + 8, +00390 TEXTURE = FUNCTION2 + 9, +00391 LIGHTMAP = FUNCTION2 + 10, +00392 ENVIRONMENT = FUNCTION2 + 11, +00393 DOLLAR_LIGHTMAP = FUNCTION2 + 12, +00394 BULGE = FUNCTION2 + 13, +00395 AUTOSPRITE = FUNCTION2 + 14, +00396 AUTOSPRITE2 = FUNCTION2 + 15, +00397 TRANSFORM = FUNCTION2 + 16, +00398 EXACTVERTEX = FUNCTION2 + 17, +00399 CONSTANT = FUNCTION2 + 18, +00400 LIGHTINGSPECULAR = FUNCTION2 + 19, +00401 MOVE = FUNCTION2 + 20, +00402 NORMAL = FUNCTION2 + 21, +00403 IDENTITYLIGHTING = FUNCTION2 + 22, +00404 +00405 WAVE_MODIFIER_FUNCTION = 0x30, +00406 SINUS = WAVE_MODIFIER_FUNCTION + 1, +00407 COSINUS = WAVE_MODIFIER_FUNCTION + 2, +00408 SQUARE = WAVE_MODIFIER_FUNCTION + 3, +00409 TRIANGLE = WAVE_MODIFIER_FUNCTION + 4, +00410 SAWTOOTH = WAVE_MODIFIER_FUNCTION + 5, +00411 SAWTOOTH_INVERSE = WAVE_MODIFIER_FUNCTION + 6, +00412 NOISE = WAVE_MODIFIER_FUNCTION + 7, +00413 +00414 +00415 UNKNOWN = -2 +00416 +00417 }; +00418 +00419 struct SModifierFunction +00420 { +00421 SModifierFunction () +00422 : masterfunc0 ( UNKNOWN ), masterfunc1( UNKNOWN ), func ( SINUS ), +00423 tcgen( TEXTURE ), rgbgen ( IDENTITY ), alphagen ( UNKNOWN ), +00424 base ( 0 ), amp ( 1 ), phase ( 0 ), frequency ( 1 ), +00425 wave ( 1 ), +00426 x ( 0 ), y ( 0 ), z( 0 ), count( 0 ) {} +00427 +00428 // "tcmod","deformvertexes","rgbgen", "tcgen" +00429 eQ3ModifierFunction masterfunc0; +00430 // depends +00431 eQ3ModifierFunction masterfunc1; +00432 // depends +00433 eQ3ModifierFunction func; +00434 +00435 eQ3ModifierFunction tcgen; +00436 eQ3ModifierFunction rgbgen; +00437 eQ3ModifierFunction alphagen; +00438 +00439 union +00440 { +00441 f32 base; +00442 f32 bulgewidth; +00443 }; +00444 +00445 union +00446 { +00447 f32 amp; +00448 f32 bulgeheight; +00449 }; +00450 +00451 f32 phase; +00452 +00453 union +00454 { +00455 f32 frequency; +00456 f32 bulgespeed; +00457 }; +00458 +00459 union +00460 { +00461 f32 wave; +00462 f32 div; +00463 }; +00464 +00465 f32 x; +00466 f32 y; +00467 f32 z; +00468 u32 count; +00469 +00470 f32 evaluate ( f32 dt ) const +00471 { +00472 // phase in 0 and 1.. +00473 f32 x = core::fract( (dt + phase ) * frequency ); +00474 f32 y = 0.f; +00475 +00476 switch ( func ) +00477 { +00478 case SINUS: +00479 y = sinf ( x * core::PI * 2.f ); +00480 break; +00481 case COSINUS: +00482 y = cosf ( x * core::PI * 2.f ); +00483 break; +00484 case SQUARE: +00485 y = x < 0.5f ? 1.f : -1.f; +00486 break; +00487 case TRIANGLE: +00488 y = x < 0.5f ? ( 4.f * x ) - 1.f : ( -4.f * x ) + 3.f; +00489 break; +00490 case SAWTOOTH: +00491 y = x; +00492 break; +00493 case SAWTOOTH_INVERSE: +00494 y = 1.f - x; +00495 break; +00496 case NOISE: +00497 y = Noiser::get(); +00498 break; +00499 default: +00500 break; +00501 } +00502 +00503 return base + ( y * amp ); +00504 } +00505 +00506 +00507 }; +00508 +00509 inline core::vector3df getMD3Normal ( u32 i, u32 j ) +00510 { +00511 const f32 lng = i * 2.0f * core::PI / 255.0f; +00512 const f32 lat = j * 2.0f * core::PI / 255.0f; +00513 return core::vector3df(cosf ( lat ) * sinf ( lng ), +00514 sinf ( lat ) * sinf ( lng ), +00515 cosf ( lng )); +00516 } +00517 +00518 // +00519 inline void getModifierFunc ( SModifierFunction& fill, const core::stringc &string, u32 &pos ) +00520 { +00521 if ( string.size() == 0 ) +00522 return; +00523 +00524 static const c8 * funclist[] = +00525 { +00526 "sin","cos","square", +00527 "triangle", "sawtooth","inversesawtooth", "noise" +00528 }; +00529 +00530 fill.func = (eQ3ModifierFunction) isEqual ( string,pos, funclist,7 ); +00531 fill.func = fill.func == UNKNOWN ? SINUS : (eQ3ModifierFunction) ((u32) fill.func + WAVE_MODIFIER_FUNCTION + 1); +00532 +00533 fill.base = getAsFloat ( string, pos ); +00534 fill.amp = getAsFloat ( string, pos ); +00535 fill.phase = getAsFloat ( string, pos ); +00536 fill.frequency = getAsFloat ( string, pos ); +00537 } +00538 +00539 +00540 // name = "a b c .." +00541 struct SVariable +00542 { +00543 core::stringc name; +00544 core::stringc content; +00545 +00546 SVariable ( const c8 * n, const c8 *c = 0 ) : name ( n ), content (c) {} +00547 virtual ~SVariable () {} +00548 +00549 void clear () +00550 { +00551 name = ""; +00552 content = ""; +00553 } +00554 +00555 s32 isValid () const +00556 { +00557 return name.size(); +00558 } +00559 +00560 bool operator == ( const SVariable &other ) const +00561 { +00562 return 0 == strcmp ( name.c_str(), other.name.c_str () ); +00563 } +00564 +00565 bool operator < ( const SVariable &other ) const +00566 { +00567 return 0 > strcmp ( name.c_str(), other.name.c_str () ); +00568 } +00569 +00570 }; +00571 +00572 +00573 // string database. "a" = "Hello", "b" = "1234.6" +00574 struct SVarGroup +00575 { +00576 SVarGroup () { Variable.setAllocStrategy ( core::ALLOC_STRATEGY_SAFE ); } +00577 virtual ~SVarGroup () {} +00578 +00579 u32 isDefined ( const c8 * name, const c8 * content = 0 ) const +00580 { +00581 for ( u32 i = 0; i != Variable.size (); ++i ) +00582 { +00583 if ( 0 == strcmp ( Variable[i].name.c_str(), name ) && +00584 ( 0 == content || strstr ( Variable[i].content.c_str(), content ) ) +00585 ) +00586 { +00587 return i + 1; +00588 } +00589 } +00590 return 0; +00591 } +00592 +00593 // searches for Variable name and returns is content +00594 // if Variable is not found a reference to an Empty String is returned +00595 const core::stringc &get( const c8 * name ) const +00596 { +00597 SVariable search ( name ); +00598 s32 index = Variable.linear_search ( search ); +00599 if ( index < 0 ) +00600 return irrEmptyStringc; +00601 +00602 return Variable [ index ].content; +00603 } +00604 +00605 // set the Variable name +00606 void set ( const c8 * name, const c8 * content = 0 ) +00607 { +00608 u32 index = isDefined ( name, 0 ); +00609 if ( 0 == index ) +00610 { +00611 Variable.push_back ( SVariable ( name, content ) ); +00612 } +00613 else +00614 { +00615 Variable [ index ].content = content; +00616 } +00617 } +00618 +00619 +00620 core::array < SVariable > Variable; +00621 }; +00622 +00624 struct SVarGroupList: public IReferenceCounted +00625 { +00626 SVarGroupList () +00627 { +00628 VariableGroup.setAllocStrategy ( core::ALLOC_STRATEGY_SAFE ); +00629 } +00630 virtual ~SVarGroupList () {} +00631 +00632 core::array < SVarGroup > VariableGroup; +00633 }; +00634 +00635 +00637 struct IShader +00638 { +00639 IShader () +00640 : ID ( 0 ), VarGroup ( 0 ) {} +00641 virtual ~IShader () {} +00642 +00643 void operator = (const IShader &other ) +00644 { +00645 ID = other.ID; +00646 VarGroup = other.VarGroup; +00647 name = other.name; +00648 } +00649 +00650 bool operator == (const IShader &other ) const +00651 { +00652 return 0 == strcmp ( name.c_str(), other.name.c_str () ); +00653 //return name == other.name; +00654 } +00655 +00656 bool operator < (const IShader &other ) const +00657 { +00658 return strcmp ( name.c_str(), other.name.c_str () ) < 0; +00659 //return name < other.name; +00660 } +00661 +00662 u32 getGroupSize () const +00663 { +00664 if ( 0 == VarGroup ) +00665 return 0; +00666 return VarGroup->VariableGroup.size (); +00667 } +00668 +00669 const SVarGroup * getGroup ( u32 stage ) const +00670 { +00671 if ( 0 == VarGroup || stage >= VarGroup->VariableGroup.size () ) +00672 return 0; +00673 +00674 return &VarGroup->VariableGroup [ stage ]; +00675 } +00676 +00677 // id +00678 s32 ID; +00679 SVarGroupList *VarGroup; // reference +00680 +00681 // Shader: shader name ( also first variable in first Vargroup ) +00682 // Entity: classname ( variable in Group(1) ) +00683 core::stringc name; +00684 }; +00685 +00686 typedef IShader IEntity; +00687 +00688 typedef core::array < IEntity > tQ3EntityList; +00689 +00690 /* +00691 dump shader like original layout, regardless of internal data holding +00692 no recursive folding.. +00693 */ +00694 inline void dumpVarGroup ( core::stringc &dest, const SVarGroup * group, s32 stack ) +00695 { +00696 core::stringc buf; +00697 s32 i; +00698 +00699 +00700 if ( stack > 0 ) +00701 { +00702 buf = ""; +00703 for ( i = 0; i < stack - 1; ++i ) +00704 buf += '\t'; +00705 +00706 buf += "{\n"; +00707 dest.append ( buf ); +00708 } +00709 +00710 for ( u32 g = 0; g != group->Variable.size(); ++g ) +00711 { +00712 buf = ""; +00713 for ( i = 0; i < stack; ++i ) +00714 buf += '\t'; +00715 +00716 buf += group->Variable[g].name; +00717 buf += " "; +00718 buf += group->Variable[g].content; +00719 buf += "\n"; +00720 dest.append ( buf ); +00721 } +00722 +00723 if ( stack > 1 ) +00724 { +00725 buf = ""; +00726 for ( i = 0; i < stack - 1; ++i ) +00727 buf += '\t'; +00728 +00729 buf += "}\n"; +00730 dest.append ( buf ); +00731 } +00732 +00733 } +00734 +00738 inline core::stringc & dumpShader ( core::stringc &dest, const IShader * shader, bool entity = false ) +00739 { +00740 if ( 0 == shader ) +00741 return dest; +00742 +00743 const SVarGroup * group; +00744 +00745 const u32 size = shader->VarGroup->VariableGroup.size (); +00746 for ( u32 i = 0; i != size; ++i ) +00747 { +00748 group = &shader->VarGroup->VariableGroup[ i ]; +00749 dumpVarGroup ( dest, group, core::clamp( (int)i, 0, 2 ) ); +00750 } +00751 +00752 if ( !entity ) +00753 { +00754 if ( size <= 1 ) +00755 { +00756 dest.append ( "{\n" ); +00757 } +00758 dest.append ( "}\n" ); +00759 } +00760 return dest; +00761 } +00762 +00763 +00764 /* +00765 quake3 doesn't care much about tga & jpg +00766 load one or multiple files stored in name started at startPos to the texture array textures +00767 if texture is not loaded 0 will be added ( to find missing textures easier) +00768 */ +00769 inline void getTextures(tTexArray &textures, +00770 const core::stringc &name, u32 &startPos, +00771 io::IFileSystem *fileSystem, +00772 video::IVideoDriver* driver) +00773 { +00774 static const char* extension[] = +00775 { +00776 ".jpg", +00777 ".jpeg", +00778 ".png", +00779 ".dds", +00780 ".tga", +00781 ".bmp", +00782 ".pcx" +00783 }; +00784 +00785 tStringList stringList; +00786 getAsStringList(stringList, -1, name, startPos); +00787 +00788 textures.clear(); +00789 +00790 io::path loadFile; +00791 for ( u32 i = 0; i!= stringList.size (); ++i ) +00792 { +00793 video::ITexture* texture = 0; +00794 for (u32 g = 0; g != 7 ; ++g) +00795 { +00796 core::cutFilenameExtension ( loadFile, stringList[i] ); +00797 +00798 if ( loadFile == "$whiteimage" ) +00799 { +00800 texture = driver->getTexture( "$whiteimage" ); +00801 if ( 0 == texture ) +00802 { +00803 core::dimension2du s ( 2, 2 ); +00804 u32 image[4] = { 0xFFFFFFFF, 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF }; +00805 video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image ); +00806 texture = driver->addTexture( "$whiteimage", w ); +00807 w->drop (); +00808 } +00809 +00810 } +00811 else +00812 if ( loadFile == "$redimage" ) +00813 { +00814 texture = driver->getTexture( "$redimage" ); +00815 if ( 0 == texture ) +00816 { +00817 core::dimension2du s ( 2, 2 ); +00818 u32 image[4] = { 0xFFFF0000, 0xFFFF0000,0xFFFF0000,0xFFFF0000 }; +00819 video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image ); +00820 texture = driver->addTexture( "$redimage", w ); +00821 w->drop (); +00822 } +00823 } +00824 else +00825 if ( loadFile == "$blueimage" ) +00826 { +00827 texture = driver->getTexture( "$blueimage" ); +00828 if ( 0 == texture ) +00829 { +00830 core::dimension2du s ( 2, 2 ); +00831 u32 image[4] = { 0xFF0000FF, 0xFF0000FF,0xFF0000FF,0xFF0000FF }; +00832 video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image ); +00833 texture = driver->addTexture( "$blueimage", w ); +00834 w->drop (); +00835 } +00836 } +00837 else +00838 if ( loadFile == "$checkerimage" ) +00839 { +00840 texture = driver->getTexture( "$checkerimage" ); +00841 if ( 0 == texture ) +00842 { +00843 core::dimension2du s ( 2, 2 ); +00844 u32 image[4] = { 0xFFFFFFFF, 0xFF000000,0xFF000000,0xFFFFFFFF }; +00845 video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image ); +00846 texture = driver->addTexture( "$checkerimage", w ); +00847 w->drop (); +00848 } +00849 } +00850 else +00851 if ( loadFile == "$lightmap" ) +00852 { +00853 texture = 0; +00854 } +00855 else +00856 { +00857 loadFile.append ( extension[g] ); +00858 } +00859 +00860 if ( fileSystem->existFile ( loadFile ) ) +00861 { +00862 texture = driver->getTexture( loadFile ); +00863 if ( texture ) +00864 break; +00865 texture = 0; +00866 } +00867 } +00868 // take 0 Texture +00869 textures.push_back(texture); +00870 } +00871 } +00872 +00873 +00875 class IShaderManager : public IReferenceCounted +00876 { +00877 }; +00878 +00879 } // end namespace quake3 +00880 } // end namespace scene +00881 } // end namespace irr +00882 +00883 #endif +00884 +