plugins/model/model.cpp

   1 /*
   2    Copyright (C) 2001-2006, William Joseph.
   3    All Rights Reserved.
   4
   5    This file is part of GtkRadiant.
   6
   7    GtkRadiant is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    GtkRadiant is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GtkRadiant; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #include "model.h"
  23
  24 #include "picomodel.h"
  25
  26 #include "iarchive.h"
  27 #include "idatastream.h"
  28 #include "imodel.h"
  29 #include "modelskin.h"
  30
  31 #include "cullable.h"
  32 #include "renderable.h"
  33 #include "selectable.h"
  34
  35 #include "math/frustum.h"
  36 #include "string/string.h"
  37 #include "generic/static.h"
  38 #include "shaderlib.h"
  39 #include "scenelib.h"
  40 #include "instancelib.h"
  41 #include "transformlib.h"
  42 #include "traverselib.h"
  43 #include "render.h"
  44
  45 class VectorLightList : public LightList
  46 {
  47 typedef std::vector<const RendererLight*> Lights;
  48 Lights m_lights;
  49 public:
  50 void addLight( const RendererLight& light ){
  51         m_lights.push_back( &light );
  52 }
  53 void clear(){
  54         m_lights.clear();
  55 }
  56 void evaluateLights() const {
  57 }
  58 void lightsChanged() const {
  59 }
  60 void forEachLight( const RendererLightCallback& callback ) const {
  61         for ( Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i )
  62         {
  63                 callback( *( *i ) );
  64         }
  65 }
  66 };
  67
  68 class PicoSurface :
  69         public OpenGLRenderable
  70 {
  71 AABB m_aabb_local;
  72 CopiedString m_shader;
  73 Shader* m_state;
  74
  75 Array<ArbitraryMeshVertex> m_vertices;
  76 Array<RenderIndex> m_indices;
  77
  78 public:
  79
  80 PicoSurface(){
  81         constructNull();
  82         CaptureShader();
  83 }
  84 PicoSurface( picoSurface_t* surface ){
  85         CopyPicoSurface( surface );
  86         CaptureShader();
  87 }
  88 ~PicoSurface(){
  89         ReleaseShader();
  90 }
  91
  92 void render( RenderStateFlags state ) const {
  93         if ( ( state & RENDER_BUMP ) != 0 ) {
  94                 if ( GlobalShaderCache().useShaderLanguage() ) {
  95                         glNormalPointer( GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->normal );
  96                         glVertexAttribPointerARB( c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->texcoord );
  97                         glVertexAttribPointerARB( c_attr_Tangent, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->tangent );
  98                         glVertexAttribPointerARB( c_attr_Binormal, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->bitangent );
  99                 }
 100                 else
 101                 {
 102                         glVertexAttribPointerARB( 11, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->normal );
 103                         glVertexAttribPointerARB( 8, 2, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->texcoord );
 104                         glVertexAttribPointerARB( 9, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->tangent );
 105                         glVertexAttribPointerARB( 10, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->bitangent );
 106                 }
 107         }
 108         else
 109         {
 110                 glNormalPointer( GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->normal );
 111                 glTexCoordPointer( 2, GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->texcoord );
 112         }
 113         glVertexPointer( 3, GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->vertex );
 114         glDrawElements( GL_TRIANGLES, GLsizei( m_indices.size() ), RenderIndexTypeID, m_indices.data() );
 115
 116 #if defined( _DEBUG )
 117         GLfloat modelview[16];
 118         glGetFloatv( GL_MODELVIEW_MATRIX, modelview ); // I know this is slow as hell, but hey - we're in _DEBUG
 119         Matrix4 modelview_inv(
 120                 modelview[0], modelview[1], modelview[2], modelview[3],
 121                 modelview[4], modelview[5], modelview[6], modelview[7],
 122                 modelview[8], modelview[9], modelview[10], modelview[11],
 123                 modelview[12], modelview[13], modelview[14], modelview[15] );
 124         matrix4_full_invert( modelview_inv );
 125         Matrix4 modelview_inv_transposed = matrix4_transposed( modelview_inv );
 126
 127         glBegin( GL_LINES );
 128
 129         for ( Array<ArbitraryMeshVertex>::const_iterator i = m_vertices.begin(); i != m_vertices.end(); ++i )
 130         {
 131                 Vector3 normal = normal3f_to_vector3( ( *i ).normal );
 132                 normal = matrix4_transformed_direction( modelview_inv, vector3_normalised( matrix4_transformed_direction( modelview_inv_transposed, normal ) ) ); // do some magic
 133                 Vector3 normalTransformed = vector3_added( vertex3f_to_vector3( ( *i ).vertex ), vector3_scaled( normal, 8 ) );
 134                 glVertex3fv( vertex3f_to_array( ( *i ).vertex ) );
 135                 glVertex3fv( vector3_to_array( normalTransformed ) );
 136         }
 137         glEnd();
 138 #endif
 139 }
 140
 141 VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
 142         return test.TestAABB( m_aabb_local, localToWorld );
 143 }
 144
 145 const AABB& localAABB() const {
 146         return m_aabb_local;
 147 }
 148
 149 void render( Renderer& renderer, const Matrix4& localToWorld, Shader* state ) const {
 150         renderer.SetState( state, Renderer::eFullMaterials );
 151         renderer.addRenderable( *this, localToWorld );
 152 }
 153
 154 void render( Renderer& renderer, const Matrix4& localToWorld ) const {
 155         render( renderer, localToWorld, m_state );
 156 }
 157
 158 void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
 159         test.BeginMesh( localToWorld );
 160
 161         SelectionIntersection best;
 162         testSelect( test, best );
 163         if ( best.valid() ) {
 164                 selector.addIntersection( best );
 165         }
 166 }
 167
 168 const char* getShader() const {
 169         return m_shader.c_str();
 170 }
 171 Shader* getState() const {
 172         return m_state;
 173 }
 174
 175 private:
 176
 177 void CaptureShader(){
 178         m_state = GlobalShaderCache().capture( m_shader.c_str() );
 179 }
 180 void ReleaseShader(){
 181         GlobalShaderCache().release( m_shader.c_str() );
 182 }
 183
 184 void UpdateAABB(){
 185         m_aabb_local = AABB();
 186         for ( std::size_t i = 0; i < m_vertices.size(); ++i )
 187                 aabb_extend_by_point_safe( m_aabb_local, reinterpret_cast<const Vector3&>( m_vertices[i].vertex ) );
 188
 189
 190         for ( Array<RenderIndex>::iterator i = m_indices.begin(); i != m_indices.end(); i += 3 )
 191         {
 192                 ArbitraryMeshVertex& a = m_vertices[*( i + 0 )];
 193                 ArbitraryMeshVertex& b = m_vertices[*( i + 1 )];
 194                 ArbitraryMeshVertex& c = m_vertices[*( i + 2 )];
 195
 196                 ArbitraryMeshTriangle_sumTangents( a, b, c );
 197         }
 198
 199         for ( Array<ArbitraryMeshVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i )
 200         {
 201                 vector3_normalise( reinterpret_cast<Vector3&>( ( *i ).tangent ) );
 202                 vector3_normalise( reinterpret_cast<Vector3&>( ( *i ).bitangent ) );
 203         }
 204 }
 205
 206 void testSelect( SelectionTest& test, SelectionIntersection& best ){
 207         test.TestTriangles(
 208                 VertexPointer( VertexPointer::pointer( &m_vertices.data()->vertex ), sizeof( ArbitraryMeshVertex ) ),
 209                 IndexPointer( m_indices.data(), IndexPointer::index_type( m_indices.size() ) ),
 210                 best
 211                 );
 212 }
 213
 214 void CopyPicoSurface( picoSurface_t* surface ){
 215         picoShader_t* shader = PicoGetSurfaceShader( surface );
 216         if ( shader == 0 ) {
 217                 m_shader = "";
 218         }
 219         else{
 220                 m_shader = PicoGetShaderName( shader );
 221         }
 222
 223         m_vertices.resize( PicoGetSurfaceNumVertexes( surface ) );
 224         m_indices.resize( PicoGetSurfaceNumIndexes( surface ) );
 225
 226         for ( std::size_t i = 0; i < m_vertices.size(); ++i )
 227         {
 228                 picoVec_t* xyz = PicoGetSurfaceXYZ( surface, int(i) );
 229                 m_vertices[i].vertex = vertex3f_from_array( xyz );
 230
 231                 picoVec_t* normal = PicoGetSurfaceNormal( surface, int(i) );
 232                 m_vertices[i].normal = normal3f_from_array( normal );
 233
 234                 picoVec_t* st = PicoGetSurfaceST( surface, 0, int(i) );
 235                 m_vertices[i].texcoord = TexCoord2f( st[0], st[1] );
 236
 237 #if 0
 238                 picoVec_t* color = PicoGetSurfaceColor( surface, 0, int(i) );
 239                 m_vertices[i].colour = Colour4b( color[0], color[1], color[2], color[3] );
 240 #endif
 241         }
 242
 243         picoIndex_t* indexes = PicoGetSurfaceIndexes( surface, 0 );
 244         for ( std::size_t j = 0; j < m_indices.size(); ++j )
 245                 m_indices[ j ] = indexes[ j ];
 246
 247         UpdateAABB();
 248 }
 249
 250 void constructQuad( std::size_t index, const Vector3& a, const Vector3& b, const Vector3& c, const Vector3& d, const Vector3& normal ){
 251         m_vertices[index * 4 + 0] = ArbitraryMeshVertex(
 252                 vertex3f_for_vector3( a ),
 253                 normal3f_for_vector3( normal ),
 254                 texcoord2f_from_array( aabb_texcoord_topleft )
 255                 );
 256         m_vertices[index * 4 + 1] = ArbitraryMeshVertex(
 257                 vertex3f_for_vector3( b ),
 258                 normal3f_for_vector3( normal ),
 259                 texcoord2f_from_array( aabb_texcoord_topright )
 260                 );
 261         m_vertices[index * 4 + 2] = ArbitraryMeshVertex(
 262                 vertex3f_for_vector3( c ),
 263                 normal3f_for_vector3( normal ),
 264                 texcoord2f_from_array( aabb_texcoord_botright )
 265                 );
 266         m_vertices[index * 4 + 3] = ArbitraryMeshVertex(
 267                 vertex3f_for_vector3( d ),
 268                 normal3f_for_vector3( normal ),
 269                 texcoord2f_from_array( aabb_texcoord_botleft )
 270                 );
 271 }
 272
 273 void constructNull(){
 274         AABB aabb( Vector3( 0, 0, 0 ), Vector3( 8, 8, 8 ) );
 275
 276         Vector3 points[8];
 277         aabb_corners( aabb, points );
 278
 279         m_vertices.resize( 24 );
 280
 281         constructQuad( 0, points[2], points[1], points[5], points[6], aabb_normals[0] );
 282         constructQuad( 1, points[1], points[0], points[4], points[5], aabb_normals[1] );
 283         constructQuad( 2, points[0], points[1], points[2], points[3], aabb_normals[2] );
 284         constructQuad( 3, points[0], points[3], points[7], points[4], aabb_normals[3] );
 285         constructQuad( 4, points[3], points[2], points[6], points[7], aabb_normals[4] );
 286         constructQuad( 5, points[7], points[6], points[5], points[4], aabb_normals[5] );
 287
 288         m_indices.resize( 36 );
 289
 290         RenderIndex indices[36] = {
 291                 0,  1,  2,  0,  2,  3,
 292                 4,  5,  6,  4,  6,  7,
 293                 8,  9, 10,  8, 10, 11,
 294                 12, 13, 14, 12, 14, 15,
 295                 16, 17, 18, 16, 18, 19,
 296                 20, 21, 22, 10, 22, 23,
 297         };
 298
 299
 300         Array<RenderIndex>::iterator j = m_indices.begin();
 301         for ( RenderIndex* i = indices; i != indices + ( sizeof( indices ) / sizeof( RenderIndex ) ); ++i )
 302         {
 303                 *j++ = *i;
 304         }
 305
 306         m_shader = "";
 307
 308         UpdateAABB();
 309 }
 310 };
 311
 312
 313 typedef std::pair<CopiedString, int> PicoModelKey;
 314
 315
 316 class PicoModel :
 317         public Cullable,
 318         public Bounded
 319 {
 320 typedef std::vector<PicoSurface*> surfaces_t;
 321 surfaces_t m_surfaces;
 322
 323 AABB m_aabb_local;
 324 public:
 325 Callback m_lightsChanged;
 326
 327 PicoModel(){
 328         constructNull();
 329 }
 330 PicoModel( picoModel_t* model ){
 331         CopyPicoModel( model );
 332 }
 333 ~PicoModel(){
 334         for ( surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i )
 335                 delete *i;
 336 }
 337
 338 typedef surfaces_t::const_iterator const_iterator;
 339
 340 const_iterator begin() const {
 341         return m_surfaces.begin();
 342 }
 343 const_iterator end() const {
 344         return m_surfaces.end();
 345 }
 346 std::size_t size() const {
 347         return m_surfaces.size();
 348 }
 349
 350 VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
 351         return test.TestAABB( m_aabb_local, localToWorld );
 352 }
 353
 354 virtual const AABB& localAABB() const {
 355         return m_aabb_local;
 356 }
 357
 358 void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, std::vector<Shader*> states ) const {
 359         for ( surfaces_t::const_iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i )
 360         {
 361                 if ( ( *i )->intersectVolume( volume, localToWorld ) != c_volumeOutside ) {
 362                         ( *i )->render( renderer, localToWorld, states[i - m_surfaces.begin()] );
 363                 }
 364         }
 365 }
 366
 367 void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
 368         for ( surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i )
 369         {
 370                 if ( ( *i )->intersectVolume( test.getVolume(), localToWorld ) != c_volumeOutside ) {
 371                         ( *i )->testSelect( selector, test, localToWorld );
 372                 }
 373         }
 374 }
 375
 376 private:
 377 void CopyPicoModel( picoModel_t* model ){
 378         m_aabb_local = AABB();
 379
 380         /* each surface on the model will become a new map drawsurface */
 381         int numSurfaces = PicoGetModelNumSurfaces( model );
 382         //%  SYs_FPrintf( SYS_VRB, "Model %s has %d surfaces\n", name, numSurfaces );
 383         for ( int s = 0; s < numSurfaces; ++s )
 384         {
 385                 /* get surface */
 386                 picoSurface_t* surface = PicoGetModelSurface( model, s );
 387                 if ( surface == 0 ) {
 388                         continue;
 389                 }
 390
 391                 /* only handle triangle surfaces initially (fixme: support patches) */
 392                 if ( PicoGetSurfaceType( surface ) != PICO_TRIANGLES ) {
 393                         continue;
 394                 }
 395
 396                 /* fix the surface's normals */
 397                 PicoFixSurfaceNormals( surface );
 398
 399                 PicoSurface* picosurface = new PicoSurface( surface );
 400                 aabb_extend_by_aabb_safe( m_aabb_local, picosurface->localAABB() );
 401                 m_surfaces.push_back( picosurface );
 402         }
 403 }
 404 void constructNull(){
 405         PicoSurface* picosurface = new PicoSurface();
 406         m_aabb_local = picosurface->localAABB();
 407         m_surfaces.push_back( picosurface );
 408 }
 409 };
 410
 411 inline void Surface_addLight( PicoSurface& surface, VectorLightList& lights, const Matrix4& localToWorld, const RendererLight& light ){
 412         if ( light.testAABB( aabb_for_oriented_aabb( surface.localAABB(), localToWorld ) ) ) {
 413                 lights.addLight( light );
 414         }
 415 }
 416
 417 class PicoModelInstance :
 418         public scene::Instance,
 419         public Renderable,
 420         public SelectionTestable,
 421         public LightCullable,
 422         public SkinnedModel
 423 {
 424 class TypeCasts
 425 {
 426 InstanceTypeCastTable m_casts;
 427 public:
 428 TypeCasts(){
 429         InstanceContainedCast<PicoModelInstance, Bounded>::install( m_casts );
 430         InstanceContainedCast<PicoModelInstance, Cullable>::install( m_casts );
 431         InstanceStaticCast<PicoModelInstance, Renderable>::install( m_casts );
 432         InstanceStaticCast<PicoModelInstance, SelectionTestable>::install( m_casts );
 433         InstanceStaticCast<PicoModelInstance, SkinnedModel>::install( m_casts );
 434 }
 435 InstanceTypeCastTable& get(){
 436         return m_casts;
 437 }
 438 };
 439
 440 PicoModel& m_picomodel;
 441
 442 const LightList* m_lightList;
 443 typedef Array<VectorLightList> SurfaceLightLists;
 444 SurfaceLightLists m_surfaceLightLists;
 445
 446 class Remap
 447 {
 448 public:
 449 CopiedString first;
 450 Shader* second;
 451 Remap() : second( 0 ){
 452 }
 453 };
 454 typedef Array<Remap> SurfaceRemaps;
 455 SurfaceRemaps m_skins;
 456
 457 PicoModelInstance( const PicoModelInstance& );
 458 PicoModelInstance operator=( const PicoModelInstance& );
 459 public:
 460 typedef LazyStatic<TypeCasts> StaticTypeCasts;
 461
 462 void* m_test;
 463
 464 Bounded& get( NullType<Bounded>){
 465         return m_picomodel;
 466 }
 467 Cullable& get( NullType<Cullable>){
 468         return m_picomodel;
 469 }
 470
 471 void lightsChanged(){
 472         m_lightList->lightsChanged();
 473 }
 474 typedef MemberCaller<PicoModelInstance, &PicoModelInstance::lightsChanged> LightsChangedCaller;
 475
 476 void constructRemaps(){
 477         ASSERT_MESSAGE( m_skins.size() == m_picomodel.size(), "ERROR" );
 478         ModelSkin* skin = NodeTypeCast<ModelSkin>::cast( path().parent() );
 479         if ( skin != 0 && skin->realised() ) {
 480                 SurfaceRemaps::iterator j = m_skins.begin();
 481                 for ( PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i, ++j )
 482                 {
 483                         const char* remap = skin->getRemap( ( *i )->getShader() );
 484                         if ( !string_empty( remap ) ) {
 485                                 ( *j ).first = remap;
 486                                 ( *j ).second = GlobalShaderCache().capture( remap );
 487                         }
 488                         else
 489                         {
 490                                 ( *j ).second = 0;
 491                         }
 492                 }
 493                 SceneChangeNotify();
 494         }
 495 }
 496 void destroyRemaps(){
 497         ASSERT_MESSAGE( m_skins.size() == m_picomodel.size(), "ERROR" );
 498         for ( SurfaceRemaps::iterator i = m_skins.begin(); i != m_skins.end(); ++i )
 499         {
 500                 if ( ( *i ).second != 0 ) {
 501                         GlobalShaderCache().release( ( *i ).first.c_str() );
 502                         ( *i ).second = 0;
 503                 }
 504         }
 505 }
 506 void skinChanged(){
 507         destroyRemaps();
 508         constructRemaps();
 509 }
 510
 511 PicoModelInstance( const scene::Path& path, scene::Instance* parent, PicoModel& picomodel ) :
 512         Instance( path, parent, this, StaticTypeCasts::instance().get() ),
 513         m_picomodel( picomodel ),
 514         m_surfaceLightLists( m_picomodel.size() ),
 515         m_skins( m_picomodel.size() ){
 516         m_lightList = &GlobalShaderCache().attach( *this );
 517         m_picomodel.m_lightsChanged = LightsChangedCaller( *this );
 518
 519         Instance::setTransformChangedCallback( LightsChangedCaller( *this ) );
 520
 521         constructRemaps();
 522 }
 523 ~PicoModelInstance(){
 524         destroyRemaps();
 525
 526         Instance::setTransformChangedCallback( Callback() );
 527
 528         m_picomodel.m_lightsChanged = Callback();
 529         GlobalShaderCache().detach( *this );
 530 }
 531
 532 void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
 533         SurfaceLightLists::const_iterator j = m_surfaceLightLists.begin();
 534         SurfaceRemaps::const_iterator k = m_skins.begin();
 535         for ( PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i, ++j, ++k )
 536         {
 537                 if ( ( *i )->intersectVolume( volume, localToWorld ) != c_volumeOutside ) {
 538                         renderer.setLights( *j );
 539                         ( *i )->render( renderer, localToWorld, ( *k ).second != 0 ? ( *k ).second : ( *i )->getState() );
 540                 }
 541         }
 542 }
 543
 544 void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
 545         m_lightList->evaluateLights();
 546
 547         render( renderer, volume, Instance::localToWorld() );
 548 }
 549 void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
 550         renderSolid( renderer, volume );
 551 }
 552
 553 void testSelect( Selector& selector, SelectionTest& test ){
 554         m_picomodel.testSelect( selector, test, Instance::localToWorld() );
 555 }
 556
 557 bool testLight( const RendererLight& light ) const {
 558         return light.testAABB( worldAABB() );
 559 }
 560 void insertLight( const RendererLight& light ){
 561         const Matrix4& localToWorld = Instance::localToWorld();
 562         SurfaceLightLists::iterator j = m_surfaceLightLists.begin();
 563         for ( PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i )
 564         {
 565                 Surface_addLight( *( *i ), *j++, localToWorld, light );
 566         }
 567 }
 568 void clearLights(){
 569         for ( SurfaceLightLists::iterator i = m_surfaceLightLists.begin(); i != m_surfaceLightLists.end(); ++i )
 570         {
 571                 ( *i ).clear();
 572         }
 573 }
 574 };
 575
 576 class PicoModelNode : public scene::Node::Symbiot, public scene::Instantiable
 577 {
 578 class TypeCasts
 579 {
 580 NodeTypeCastTable m_casts;
 581 public:
 582 TypeCasts(){
 583         NodeStaticCast<PicoModelNode, scene::Instantiable>::install( m_casts );
 584 }
 585 NodeTypeCastTable& get(){
 586         return m_casts;
 587 }
 588 };
 589
 590
 591 scene::Node m_node;
 592 InstanceSet m_instances;
 593 PicoModel m_picomodel;
 594
 595 public:
 596 typedef LazyStatic<TypeCasts> StaticTypeCasts;
 597
 598 PicoModelNode() : m_node( this, this, StaticTypeCasts::instance().get() ){
 599 }
 600 PicoModelNode( picoModel_t* model ) : m_node( this, this, StaticTypeCasts::instance().get() ), m_picomodel( model ){
 601 }
 602
 603 void release(){
 604         delete this;
 605 }
 606 scene::Node& node(){
 607         return m_node;
 608 }
 609
 610 scene::Instance* create( const scene::Path& path, scene::Instance* parent ){
 611         return new PicoModelInstance( path, parent, m_picomodel );
 612 }
 613 void forEachInstance( const scene::Instantiable::Visitor& visitor ){
 614         m_instances.forEachInstance( visitor );
 615 }
 616 void insert( scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance ){
 617         m_instances.insert( observer, path, instance );
 618 }
 619 scene::Instance* erase( scene::Instantiable::Observer* observer, const scene::Path& path ){
 620         return m_instances.erase( observer, path );
 621 }
 622 };
 623
 624
 625 #if 0
 626
 627 template<typename Key, typename Type>
 628 class create_new
 629 {
 630 public:
 631 static Type* construct( const Key& key ){
 632         return new Type( key );
 633 }
 634 static void destroy( Type* value ){
 635         delete value;
 636 }
 637 };
 638
 639 template<typename Key, typename Type, typename creation_policy = create_new<Key, Type> >
 640 class cache_element : public creation_policy
 641 {
 642 public:
 643 inline cache_element() : m_count( 0 ), m_value( 0 ) {}
 644 inline ~cache_element(){
 645         ASSERT_MESSAGE( m_count == 0, "destroyed a reference before it was released\n" );
 646         if ( m_count > 0 ) {
 647                 destroy();
 648         }
 649 }
 650 inline Type* capture( const Key& key ){
 651         if ( ++m_count == 1 ) {
 652                 construct( key );
 653         }
 654         return m_value;
 655 }
 656 inline void release(){
 657         ASSERT_MESSAGE( !empty(), "failed to release reference - not found in cache\n" );
 658         if ( --m_count == 0 ) {
 659                 destroy();
 660         }
 661 }
 662 inline bool empty(){
 663         return m_count == 0;
 664 }
 665 inline void refresh( const Key& key ){
 666         m_value->refresh( key );
 667 }
 668 private:
 669 inline void construct( const Key& key ){
 670         m_value = creation_policy::construct( key );
 671 }
 672 inline void destroy(){
 673         creation_policy::destroy( m_value );
 674 }
 675
 676 std::size_t m_count;
 677 Type* m_value;
 678 };
 679
 680 class create_picomodel
 681 {
 682 typedef PicoModelKey key_type;
 683 typedef PicoModel value_type;
 684 public:
 685 static value_type* construct( const key_type& key ){
 686         picoModel_t* picomodel = PicoLoadModel( const_cast<char*>( key.first.c_str() ), key.second );
 687         value_type* value = new value_type( picomodel );
 688         PicoFreeModel( picomodel );
 689         return value;
 690 }
 691 static void destroy( value_type* value ){
 692         delete value;
 693 }
 694 };
 695
 696 #include <map>
 697
 698 class ModelCache
 699 {
 700 typedef PicoModel value_type;
 701
 702 public:
 703 typedef PicoModelKey key_type;
 704 typedef cache_element<key_type, value_type, create_picomodel> elem_type;
 705 typedef std::map<key_type, elem_type> cache_type;
 706
 707 value_type* capture( const key_type& key ){
 708         return m_cache[key].capture( key );
 709 }
 710 void release( const key_type& key ){
 711         m_cache[key].release();
 712 }
 713
 714 private:
 715 cache_type m_cache;
 716 };
 717
 718 ModelCache g_model_cache;
 719
 720
 721
 722 typedef struct remap_s {
 723         char m_remapbuff[64 + 1024];
 724         char *original;
 725         char *remap;
 726 } remap_t;
 727
 728 class RemapWrapper :
 729         public Cullable,
 730         public Bounded
 731 {
 732 public:
 733 RemapWrapper( const char* name ){
 734         parse_namestr( name );
 735
 736         m_model = g_model_cache.capture( ModelCache::key_type( m_name, m_frame ) );
 737
 738         construct_shaders();
 739 }
 740 virtual ~RemapWrapper(){
 741         g_model_cache.release( ModelCache::key_type( m_name, m_frame ) );
 742
 743         for ( shaders_t::iterator i = m_shaders.begin(); i != m_shaders.end(); ++i )
 744         {
 745                 GlobalShaderCache().release( ( *i ).c_str() );
 746         }
 747
 748         for ( remaps_t::iterator j = m_remaps.begin(); j != m_remaps.end(); ++j )
 749         {
 750                 delete ( *j );
 751         }
 752 }
 753
 754 VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
 755         return m_model->intersectVolume( test, localToWorld );
 756 }
 757
 758 virtual const AABB& localAABB() const {
 759         return m_model->localAABB();
 760 }
 761
 762 void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
 763         m_model->render( renderer, volume, localToWorld, m_states );
 764 }
 765
 766 void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
 767         m_model->testSelect( selector, test, localToWorld );
 768 }
 769
 770 private:
 771 void add_remap( const char *remap ){
 772         const char *ch;
 773         remap_t *pRemap;
 774
 775         ch = remap;
 776
 777         while ( *ch && *ch != ';' )
 778                 ch++;
 779
 780         if ( *ch == '\0' ) {
 781                 // bad remap
 782                 globalErrorStream() << "WARNING: Shader _remap key found in a model entity without a ; character\n";
 783         }
 784         else {
 785                 pRemap = new remap_t;
 786
 787                 strncpy( pRemap->m_remapbuff, remap, sizeof( pRemap->m_remapbuff ) );
 788
 789                 pRemap->m_remapbuff[ch - remap] = '\0';
 790
 791                 pRemap->original = pRemap->m_remapbuff;
 792                 pRemap->remap = pRemap->m_remapbuff + ( ch - remap ) + 1;
 793
 794                 m_remaps.push_back( pRemap );
 795         }
 796 }
 797
 798 void parse_namestr( const char *name ){
 799         const char *ptr, *s;
 800         bool hasName, hasFrame;
 801
 802         hasName = hasFrame = false;
 803
 804         m_frame = 0;
 805
 806         for ( s = ptr = name; ; ++ptr )
 807         {
 808                 if ( !hasName && ( *ptr == ':' || *ptr == '\0' ) ) {
 809                         // model name
 810                         hasName = true;
 811                         m_name = CopiedString( s, ptr );
 812                         s = ptr + 1;
 813                 }
 814                 else if ( *ptr == '?' || *ptr == '\0' ) {
 815                         // model frame
 816                         hasFrame = true;
 817                         m_frame = atoi( CopiedString( s, ptr ).c_str() );
 818                         s = ptr + 1;
 819                 }
 820                 else if ( *ptr == '&' || *ptr == '\0' ) {
 821                         // a remap
 822                         add_remap( CopiedString( s, ptr ).c_str() );
 823                         s = ptr + 1;
 824                 }
 825
 826                 if ( *ptr == '\0' ) {
 827                         break;
 828                 }
 829         }
 830 }
 831
 832 void construct_shaders(){
 833         const char* global_shader = shader_for_remap( "*" );
 834
 835         m_shaders.reserve( m_model->size() );
 836         m_states.reserve( m_model->size() );
 837         for ( PicoModel::iterator i = m_model->begin(); i != m_model->end(); ++i )
 838         {
 839                 const char* shader = shader_for_remap( ( *i )->getShader() );
 840                 m_shaders.push_back(
 841                         ( shader[0] != '\0' )
 842                         ? shader
 843                         : ( global_shader[0] != '\0' )
 844                         ? global_shader
 845                         : ( *i )->getShader() );
 846                 m_states.push_back( GlobalShaderCache().capture( m_shaders.back().c_str() ) );
 847         }
 848 }
 849
 850 inline const char* shader_for_remap( const char* remap ){
 851         for ( remaps_t::iterator i = m_remaps.begin(); i != m_remaps.end(); ++i )
 852         {
 853                 if ( shader_equal( remap, ( *i )->original ) ) {
 854                         return ( *i )->remap;
 855                 }
 856         }
 857         return "";
 858 }
 859
 860 CopiedString m_name;
 861 int m_frame;
 862 PicoModel* m_model;
 863
 864 typedef std::vector<remap_t*> remaps_t;
 865 remaps_t m_remaps;
 866 typedef std::vector<CopiedString> shaders_t;
 867 shaders_t m_shaders;
 868 typedef std::vector<Shader*> states_t;
 869 states_t m_states;
 870 };
 871
 872 class RemapWrapperInstance : public scene::Instance, public Renderable, public SelectionTestable
 873 {
 874 RemapWrapper& m_remapwrapper;
 875 public:
 876 RemapWrapperInstance( const scene::Path& path, scene::Instance* parent, RemapWrapper& remapwrapper ) : Instance( path, parent ), m_remapwrapper( remapwrapper ){
 877         scene::Instance::m_cullable = &m_remapwrapper;
 878         scene::Instance::m_render = this;
 879         scene::Instance::m_select = this;
 880 }
 881
 882 void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
 883         m_remapwrapper.render( renderer, volume, Instance::localToWorld() );
 884 }
 885 void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
 886         renderSolid( renderer, volume );
 887 }
 888
 889 void testSelect( Selector& selector, SelectionTest& test ){
 890         m_remapwrapper.testSelect( selector, test, Instance::localToWorld() );
 891 }
 892 };
 893
 894 class RemapWrapperNode : public scene::Node::Symbiot, public scene::Instantiable
 895 {
 896 scene::Node m_node;
 897 typedef RemapWrapperInstance instance_type;
 898 InstanceSet m_instances;
 899 RemapWrapper m_remapwrapper;
 900 public:
 901 RemapWrapperNode( const char* name ) : m_node( this ), m_remapwrapper( name ){
 902         m_node.m_instance = this;
 903 }
 904
 905 void release(){
 906         delete this;
 907 }
 908 scene::Node& node(){
 909         return m_node;
 910 }
 911
 912 scene::Instance* create( const scene::Path& path, scene::Instance* parent ){
 913         return new instance_type( path, parent, m_remapwrapper );
 914 }
 915 void forEachInstance( const scene::Instantiable::Visitor& visitor ){
 916         m_instances.forEachInstance( visitor );
 917 }
 918 void insert( scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance ){
 919         m_instances.insert( observer, path, instance );
 920 }
 921 scene::Instance* erase( scene::Instantiable::Observer* observer, const scene::Path& path ){
 922         return m_instances.erase( observer, path );
 923 }
 924 };
 925
 926 scene::Node& LoadRemapModel( const char* name ){
 927         return ( new RemapWrapperNode( name ) )->node();
 928 }
 929
 930 #endif
 931
 932
 933 size_t picoInputStreamReam( void* inputStream, unsigned char* buffer, size_t length ){
 934         return reinterpret_cast<InputStream*>( inputStream )->read( buffer, length );
 935 }
 936
 937 scene::Node& loadPicoModel( const picoModule_t* module, ArchiveFile& file ){
 938         picoModel_t* model = PicoModuleLoadModelStream( module, &file.getInputStream(), picoInputStreamReam, file.size(), 0, file.getName() );
 939         PicoModelNode* modelNode = new PicoModelNode( model );
 940         PicoFreeModel( model );
 941         return modelNode->node();
 942 }