 |
+
+
+
+ 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 break; +00208 case 1: +00209 ret = video::ECFN_EQUAL; +00210 break; +00211 } +00212 return ret; +00213 } +00214 +00215 +00227 inline static void getBlendFunc ( const core::stringc &string, SBlendFunc &blendfunc ) +00228 { +00229 if ( string.size() == 0 ) +00230 return; +00231 +00232 // maps to E_BLEND_FACTOR +00233 static const c8 * funclist[] = +00234 { +00235 "gl_zero", +00236 "gl_one", +00237 "gl_dst_color", +00238 "gl_one_minus_dst_color", +00239 "gl_src_color", +00240 "gl_one_minus_src_color", +00241 "gl_src_alpha", +00242 "gl_one_minus_src_alpha", +00243 "gl_dst_alpha", +00244 "gl_one_minus_dst_alpha", +00245 "gl_src_alpha_sat", +00246 +00247 "add", +00248 "filter", +00249 "blend", +00250 +00251 "ge128", +00252 "gt0", +00253 }; +00254 +00255 +00256 u32 pos = 0; +00257 s32 srcFact = isEqual ( string, pos, funclist, 16 ); +00258 +00259 if ( srcFact < 0 ) +00260 return; +00261 +00262 u32 resolved = 0; +00263 s32 dstFact = isEqual ( string, pos, funclist, 16 ); +00264 +00265 switch ( srcFact ) +00266 { +00267 case video::EBF_ZERO: +00268 switch ( dstFact ) +00269 { +00270 // gl_zero gl_src_color == gl_dst_color gl_zero +00271 case video::EBF_SRC_COLOR: +00272 blendfunc.type = video::EMT_ONETEXTURE_BLEND; +00273 blendfunc.param0 = video::pack_textureBlendFunc ( video::EBF_DST_COLOR, video::EBF_ZERO, blendfunc.modulate ); +00274 blendfunc.isTransparent = 1; +00275 resolved = 1; +00276 break; +00277 } break; +00278 +00279 case video::EBF_ONE: +00280 switch ( dstFact ) +00281 { +00282 // gl_one gl_zero +00283 case video::EBF_ZERO: +00284 blendfunc.type = video::EMT_SOLID; +00285 blendfunc.isTransparent = 0; +00286 resolved = 1; +00287 break; +00288 +00289 // gl_one gl_one +00290 case video::EBF_ONE: +00291 blendfunc.type = video::EMT_TRANSPARENT_ADD_COLOR; +00292 blendfunc.isTransparent = 1; +00293 resolved = 1; +00294 break; +00295 } break; +00296 +00297 case video::EBF_SRC_ALPHA: +00298 switch ( dstFact ) +00299 { +00300 // gl_src_alpha gl_one_minus_src_alpha +00301 case video::EBF_ONE_MINUS_SRC_ALPHA: +00302 blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL; +00303 blendfunc.param0 = 1.f/255.f; +00304 blendfunc.isTransparent = 1; +00305 resolved = 1; +00306 break; +00307 } break; +00308 +00309 case 11: +00310 // add +00311 blendfunc.type = video::EMT_TRANSPARENT_ADD_COLOR; +00312 blendfunc.isTransparent = 1; +00313 resolved = 1; +00314 break; +00315 case 12: +00316 // filter = gl_dst_color gl_zero or gl_zero gl_src_color +00317 blendfunc.type = video::EMT_ONETEXTURE_BLEND; +00318 blendfunc.param0 = video::pack_textureBlendFunc ( video::EBF_DST_COLOR, video::EBF_ZERO, blendfunc.modulate ); +00319 blendfunc.isTransparent = 1; +00320 resolved = 1; +00321 break; +00322 case 13: +00323 // blend = gl_src_alpha gl_one_minus_src_alpha +00324 blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL; +00325 blendfunc.param0 = 1.f/255.f; +00326 blendfunc.isTransparent = 1; +00327 resolved = 1; +00328 break; +00329 case 14: +00330 // alphafunc ge128 +00331 blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL; +00332 blendfunc.param0 = 0.5f; +00333 blendfunc.isTransparent = 1; +00334 resolved = 1; +00335 break; +00336 case 15: +00337 // alphafunc gt0 +00338 blendfunc.type = video::EMT_TRANSPARENT_ALPHA_CHANNEL; +00339 blendfunc.param0 = 1.f / 255.f; +00340 blendfunc.isTransparent = 1; +00341 resolved = 1; +00342 break; +00343 +00344 } +00345 +00346 // use the generic blender +00347 if ( 0 == resolved ) +00348 { +00349 blendfunc.type = video::EMT_ONETEXTURE_BLEND; +00350 blendfunc.param0 = video::pack_textureBlendFunc ( +00351 (video::E_BLEND_FACTOR) srcFact, +00352 (video::E_BLEND_FACTOR) dstFact, +00353 blendfunc.modulate); +00354 +00355 blendfunc.isTransparent = 1; +00356 } +00357 } +00358 +00359 // random noise [-1;1] +00360 struct Noiser +00361 { +00362 static f32 get () +00363 { +00364 static u32 RandomSeed = 0x69666966; +00365 RandomSeed = (RandomSeed * 3631 + 1); +00366 +00367 f32 value = ( (f32) (RandomSeed & 0x7FFF ) * (1.0f / (f32)(0x7FFF >> 1) ) ) - 1.f; +00368 return value; +00369 } +00370 }; +00371 +00372 enum eQ3ModifierFunction +00373 { +00374 TCMOD = 0, +00375 DEFORMVERTEXES = 1, +00376 RGBGEN = 2, +00377 TCGEN = 3, +00378 MAP = 4, +00379 ALPHAGEN = 5, +00380 +00381 FUNCTION2 = 0x10, +00382 SCROLL = FUNCTION2 + 1, +00383 SCALE = FUNCTION2 + 2, +00384 ROTATE = FUNCTION2 + 3, +00385 STRETCH = FUNCTION2 + 4, +00386 TURBULENCE = FUNCTION2 + 5, +00387 WAVE = FUNCTION2 + 6, +00388 +00389 IDENTITY = FUNCTION2 + 7, +00390 VERTEX = FUNCTION2 + 8, +00391 TEXTURE = FUNCTION2 + 9, +00392 LIGHTMAP = FUNCTION2 + 10, +00393 ENVIRONMENT = FUNCTION2 + 11, +00394 DOLLAR_LIGHTMAP = FUNCTION2 + 12, +00395 BULGE = FUNCTION2 + 13, +00396 AUTOSPRITE = FUNCTION2 + 14, +00397 AUTOSPRITE2 = FUNCTION2 + 15, +00398 TRANSFORM = FUNCTION2 + 16, +00399 EXACTVERTEX = FUNCTION2 + 17, +00400 CONSTANT = FUNCTION2 + 18, +00401 LIGHTINGSPECULAR = FUNCTION2 + 19, +00402 MOVE = FUNCTION2 + 20, +00403 NORMAL = FUNCTION2 + 21, +00404 IDENTITYLIGHTING = FUNCTION2 + 22, +00405 +00406 WAVE_MODIFIER_FUNCTION = 0x30, +00407 SINUS = WAVE_MODIFIER_FUNCTION + 1, +00408 COSINUS = WAVE_MODIFIER_FUNCTION + 2, +00409 SQUARE = WAVE_MODIFIER_FUNCTION + 3, +00410 TRIANGLE = WAVE_MODIFIER_FUNCTION + 4, +00411 SAWTOOTH = WAVE_MODIFIER_FUNCTION + 5, +00412 SAWTOOTH_INVERSE = WAVE_MODIFIER_FUNCTION + 6, +00413 NOISE = WAVE_MODIFIER_FUNCTION + 7, +00414 +00415 +00416 UNKNOWN = -2 +00417 +00418 }; +00419 +00420 struct SModifierFunction +00421 { +00422 SModifierFunction () +00423 : masterfunc0 ( UNKNOWN ), masterfunc1( UNKNOWN ), func ( SINUS ), +00424 tcgen( TEXTURE ), rgbgen ( IDENTITY ), alphagen ( UNKNOWN ), +00425 base ( 0 ), amp ( 1 ), phase ( 0 ), frequency ( 1 ), +00426 wave ( 1 ), +00427 x ( 0 ), y ( 0 ), z( 0 ), count( 0 ) {} +00428 +00429 // "tcmod","deformvertexes","rgbgen", "tcgen" +00430 eQ3ModifierFunction masterfunc0; +00431 // depends +00432 eQ3ModifierFunction masterfunc1; +00433 // depends +00434 eQ3ModifierFunction func; +00435 +00436 eQ3ModifierFunction tcgen; +00437 eQ3ModifierFunction rgbgen; +00438 eQ3ModifierFunction alphagen; +00439 +00440 union +00441 { +00442 f32 base; +00443 f32 bulgewidth; +00444 }; +00445 +00446 union +00447 { +00448 f32 amp; +00449 f32 bulgeheight; +00450 }; +00451 +00452 f32 phase; +00453 +00454 union +00455 { +00456 f32 frequency; +00457 f32 bulgespeed; +00458 }; +00459 +00460 union +00461 { +00462 f32 wave; +00463 f32 div; +00464 }; +00465 +00466 f32 x; +00467 f32 y; +00468 f32 z; +00469 u32 count; +00470 +00471 f32 evaluate ( f32 dt ) const +00472 { +00473 // phase in 0 and 1.. +00474 f32 x = core::fract( (dt + phase ) * frequency ); +00475 f32 y = 0.f; +00476 +00477 switch ( func ) +00478 { +00479 case SINUS: +00480 y = sinf ( x * core::PI * 2.f ); +00481 break; +00482 case COSINUS: +00483 y = cosf ( x * core::PI * 2.f ); +00484 break; +00485 case SQUARE: +00486 y = x < 0.5f ? 1.f : -1.f; +00487 break; +00488 case TRIANGLE: +00489 y = x < 0.5f ? ( 4.f * x ) - 1.f : ( -4.f * x ) + 3.f; +00490 break; +00491 case SAWTOOTH: +00492 y = x; +00493 break; +00494 case SAWTOOTH_INVERSE: +00495 y = 1.f - x; +00496 break; +00497 case NOISE: +00498 y = Noiser::get(); +00499 break; +00500 default: +00501 break; +00502 } +00503 +00504 return base + ( y * amp ); +00505 } +00506 +00507 +00508 }; +00509 +00510 inline core::vector3df getMD3Normal ( u32 i, u32 j ) +00511 { +00512 const f32 lng = i * 2.0f * core::PI / 255.0f; +00513 const f32 lat = j * 2.0f * core::PI / 255.0f; +00514 return core::vector3df(cosf ( lat ) * sinf ( lng ), +00515 sinf ( lat ) * sinf ( lng ), +00516 cosf ( lng )); +00517 } +00518 +00519 // +00520 inline void getModifierFunc ( SModifierFunction& fill, const core::stringc &string, u32 &pos ) +00521 { +00522 if ( string.size() == 0 ) +00523 return; +00524 +00525 static const c8 * funclist[] = +00526 { +00527 "sin","cos","square", +00528 "triangle", "sawtooth","inversesawtooth", "noise" +00529 }; +00530 +00531 fill.func = (eQ3ModifierFunction) isEqual ( string,pos, funclist,7 ); +00532 fill.func = fill.func == UNKNOWN ? SINUS : (eQ3ModifierFunction) ((u32) fill.func + WAVE_MODIFIER_FUNCTION + 1); +00533 +00534 fill.base = getAsFloat ( string, pos ); +00535 fill.amp = getAsFloat ( string, pos ); +00536 fill.phase = getAsFloat ( string, pos ); +00537 fill.frequency = getAsFloat ( string, pos ); +00538 } +00539 +00540 +00541 // name = "a b c .." +00542 struct SVariable +00543 { +00544 core::stringc name; +00545 core::stringc content; +00546 +00547 SVariable ( const c8 * n, const c8 *c = 0 ) : name ( n ), content (c) {} +00548 virtual ~SVariable () {} +00549 +00550 void clear () +00551 { +00552 name = ""; +00553 content = ""; +00554 } +00555 +00556 s32 isValid () const +00557 { +00558 return name.size(); +00559 } +00560 +00561 bool operator == ( const SVariable &other ) const +00562 { +00563 return 0 == strcmp ( name.c_str(), other.name.c_str () ); +00564 } +00565 +00566 bool operator < ( const SVariable &other ) const +00567 { +00568 return 0 > strcmp ( name.c_str(), other.name.c_str () ); +00569 } +00570 +00571 }; +00572 +00573 +00574 // string database. "a" = "Hello", "b" = "1234.6" +00575 struct SVarGroup +00576 { +00577 SVarGroup () { Variable.setAllocStrategy ( core::ALLOC_STRATEGY_SAFE ); } +00578 virtual ~SVarGroup () {} +00579 +00580 u32 isDefined ( const c8 * name, const c8 * content = 0 ) const +00581 { +00582 for ( u32 i = 0; i != Variable.size (); ++i ) +00583 { +00584 if ( 0 == strcmp ( Variable[i].name.c_str(), name ) && +00585 ( 0 == content || strstr ( Variable[i].content.c_str(), content ) ) +00586 ) +00587 { +00588 return i + 1; +00589 } +00590 } +00591 return 0; +00592 } +00593 +00594 // searches for Variable name and returns is content +00595 // if Variable is not found a reference to an Empty String is returned +00596 const core::stringc &get( const c8 * name ) const +00597 { +00598 SVariable search ( name ); +00599 s32 index = Variable.linear_search ( search ); +00600 if ( index < 0 ) +00601 return irrEmptyStringc; +00602 +00603 return Variable [ index ].content; +00604 } +00605 +00606 // set the Variable name +00607 void set ( const c8 * name, const c8 * content = 0 ) +00608 { +00609 u32 index = isDefined ( name, 0 ); +00610 if ( 0 == index ) +00611 { +00612 Variable.push_back ( SVariable ( name, content ) ); +00613 } +00614 else +00615 { +00616 Variable [ index ].content = content; +00617 } +00618 } +00619 +00620 +00621 core::array < SVariable > Variable; +00622 }; +00623 +00625 struct SVarGroupList: public IReferenceCounted +00626 { +00627 SVarGroupList () +00628 { +00629 VariableGroup.setAllocStrategy ( core::ALLOC_STRATEGY_SAFE ); +00630 } +00631 virtual ~SVarGroupList () {} +00632 +00633 core::array < SVarGroup > VariableGroup; +00634 }; +00635 +00636 +00638 struct IShader +00639 { +00640 IShader () +00641 : ID ( 0 ), VarGroup ( 0 ) {} +00642 virtual ~IShader () {} +00643 +00644 void operator = (const IShader &other ) +00645 { +00646 ID = other.ID; +00647 VarGroup = other.VarGroup; +00648 name = other.name; +00649 } +00650 +00651 bool operator == (const IShader &other ) const +00652 { +00653 return 0 == strcmp ( name.c_str(), other.name.c_str () ); +00654 //return name == other.name; +00655 } +00656 +00657 bool operator < (const IShader &other ) const +00658 { +00659 return strcmp ( name.c_str(), other.name.c_str () ) < 0; +00660 //return name < other.name; +00661 } +00662 +00663 u32 getGroupSize () const +00664 { +00665 if ( 0 == VarGroup ) +00666 return 0; +00667 return VarGroup->VariableGroup.size (); +00668 } +00669 +00670 const SVarGroup * getGroup ( u32 stage ) const +00671 { +00672 if ( 0 == VarGroup || stage >= VarGroup->VariableGroup.size () ) +00673 return 0; +00674 +00675 return &VarGroup->VariableGroup [ stage ]; +00676 } +00677 +00678 // id +00679 s32 ID; +00680 SVarGroupList *VarGroup; // reference +00681 +00682 // Shader: shader name ( also first variable in first Vargroup ) +00683 // Entity: classname ( variable in Group(1) ) +00684 core::stringc name; +00685 }; +00686 +00687 typedef IShader IEntity; +00688 +00689 typedef core::array < IEntity > tQ3EntityList; +00690 +00691 /* +00692 dump shader like original layout, regardless of internal data holding +00693 no recursive folding.. +00694 */ +00695 inline void dumpVarGroup ( core::stringc &dest, const SVarGroup * group, s32 stack ) +00696 { +00697 core::stringc buf; +00698 s32 i; +00699 +00700 +00701 if ( stack > 0 ) +00702 { +00703 buf = ""; +00704 for ( i = 0; i < stack - 1; ++i ) +00705 buf += '\t'; +00706 +00707 buf += "{\n"; +00708 dest.append ( buf ); +00709 } +00710 +00711 for ( u32 g = 0; g != group->Variable.size(); ++g ) +00712 { +00713 buf = ""; +00714 for ( i = 0; i < stack; ++i ) +00715 buf += '\t'; +00716 +00717 buf += group->Variable[g].name; +00718 buf += " "; +00719 buf += group->Variable[g].content; +00720 buf += "\n"; +00721 dest.append ( buf ); +00722 } +00723 +00724 if ( stack > 1 ) +00725 { +00726 buf = ""; +00727 for ( i = 0; i < stack - 1; ++i ) +00728 buf += '\t'; +00729 +00730 buf += "}\n"; +00731 dest.append ( buf ); +00732 } +00733 +00734 } +00735 +00739 inline core::stringc & dumpShader ( core::stringc &dest, const IShader * shader, bool entity = false ) +00740 { +00741 if ( 0 == shader ) +00742 return dest; +00743 +00744 const SVarGroup * group; +00745 +00746 const u32 size = shader->VarGroup->VariableGroup.size (); +00747 for ( u32 i = 0; i != size; ++i ) +00748 { +00749 group = &shader->VarGroup->VariableGroup[ i ]; +00750 dumpVarGroup ( dest, group, core::clamp( (int)i, 0, 2 ) ); +00751 } +00752 +00753 if ( !entity ) +00754 { +00755 if ( size <= 1 ) +00756 { +00757 dest.append ( "{\n" ); +00758 } +00759 dest.append ( "}\n" ); +00760 } +00761 return dest; +00762 } +00763 +00764 +00765 /* +00766 quake3 doesn't care much about tga & jpg +00767 load one or multiple files stored in name started at startPos to the texture array textures +00768 if texture is not loaded 0 will be added ( to find missing textures easier) +00769 */ +00770 inline void getTextures(tTexArray &textures, +00771 const core::stringc &name, u32 &startPos, +00772 io::IFileSystem *fileSystem, +00773 video::IVideoDriver* driver) +00774 { +00775 static const char* extension[] = +00776 { +00777 ".jpg", +00778 ".jpeg", +00779 ".png", +00780 ".dds", +00781 ".tga", +00782 ".bmp", +00783 ".pcx" +00784 }; +00785 +00786 tStringList stringList; +00787 getAsStringList(stringList, -1, name, startPos); +00788 +00789 textures.clear(); +00790 +00791 io::path loadFile; +00792 for ( u32 i = 0; i!= stringList.size (); ++i ) +00793 { +00794 video::ITexture* texture = 0; +00795 for (u32 g = 0; g != 7 ; ++g) +00796 { +00797 core::cutFilenameExtension ( loadFile, stringList[i] ); +00798 +00799 if ( loadFile == "$whiteimage" ) +00800 { +00801 texture = driver->getTexture( "$whiteimage" ); +00802 if ( 0 == texture ) +00803 { +00804 core::dimension2du s ( 2, 2 ); +00805 u32 image[4] = { 0xFFFFFFFF, 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF }; +00806 video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image ); +00807 texture = driver->addTexture( "$whiteimage", w ); +00808 w->drop (); +00809 } +00810 +00811 } +00812 else +00813 if ( loadFile == "$redimage" ) +00814 { +00815 texture = driver->getTexture( "$redimage" ); +00816 if ( 0 == texture ) +00817 { +00818 core::dimension2du s ( 2, 2 ); +00819 u32 image[4] = { 0xFFFF0000, 0xFFFF0000,0xFFFF0000,0xFFFF0000 }; +00820 video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image ); +00821 texture = driver->addTexture( "$redimage", w ); +00822 w->drop (); +00823 } +00824 } +00825 else +00826 if ( loadFile == "$blueimage" ) +00827 { +00828 texture = driver->getTexture( "$blueimage" ); +00829 if ( 0 == texture ) +00830 { +00831 core::dimension2du s ( 2, 2 ); +00832 u32 image[4] = { 0xFF0000FF, 0xFF0000FF,0xFF0000FF,0xFF0000FF }; +00833 video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image ); +00834 texture = driver->addTexture( "$blueimage", w ); +00835 w->drop (); +00836 } +00837 } +00838 else +00839 if ( loadFile == "$checkerimage" ) +00840 { +00841 texture = driver->getTexture( "$checkerimage" ); +00842 if ( 0 == texture ) +00843 { +00844 core::dimension2du s ( 2, 2 ); +00845 u32 image[4] = { 0xFFFFFFFF, 0xFF000000,0xFF000000,0xFFFFFFFF }; +00846 video::IImage* w = driver->createImageFromData ( video::ECF_A8R8G8B8, s,&image ); +00847 texture = driver->addTexture( "$checkerimage", w ); +00848 w->drop (); +00849 } +00850 } +00851 else +00852 if ( loadFile == "$lightmap" ) +00853 { +00854 texture = 0; +00855 } +00856 else +00857 { +00858 loadFile.append ( extension[g] ); +00859 } +00860 +00861 if ( fileSystem->existFile ( loadFile ) ) +00862 { +00863 texture = driver->getTexture( loadFile ); +00864 if ( texture ) +00865 break; +00866 texture = 0; +00867 } +00868 } +00869 // take 0 Texture +00870 textures.push_back(texture); +00871 } +00872 } +00873 +00874 +00876 class IShaderManager : public IReferenceCounted +00877 { +00878 }; +00879 +00880 } // end namespace quake3 +00881 } // end namespace scene +00882 } // end namespace irr +00883 +00884 #endif +00885 +