/*
- Copyright (C) 1999-2007 id Software, Inc. and contributors.
- For a list of contributors, see the accompanying CONTRIBUTORS file.
+ Copyright (C) 2001-2006, William Joseph.
+ All Rights Reserved.
This file is part of GtkRadiant.
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#include "plugin.h"
+#include "model.h"
+
#include "picomodel.h"
-void pivot_draw( const vec3_t pivot ){
- vec3_t vCenter, vMin, vMax;
- VectorCopy( pivot, vCenter );
-
- g_QglTable.m_pfn_qglPointSize( 4 );
-
- g_QglTable.m_pfn_qglBegin( GL_POINTS );
- g_QglTable.m_pfn_qglVertex3fv( vCenter );
- g_QglTable.m_pfn_qglEnd();
-
- g_QglTable.m_pfn_qglBegin( GL_LINES );
- vCenter[0] -= 8;
- g_QglTable.m_pfn_qglVertex3fv( vCenter );
- vCenter[0] += 16;
- g_QglTable.m_pfn_qglVertex3fv( vCenter );
- vCenter[0] -= 8;
- vCenter[1] -= 8;
- g_QglTable.m_pfn_qglVertex3fv( vCenter );
- vCenter[1] += 16;
- g_QglTable.m_pfn_qglVertex3fv( vCenter );
- vCenter[1] -= 8;
- vCenter[2] -= 8;
- g_QglTable.m_pfn_qglVertex3fv( vCenter );
- vCenter[2] += 16;
- g_QglTable.m_pfn_qglVertex3fv( vCenter );
- vCenter[2] -= 8;
- g_QglTable.m_pfn_qglEnd();
-
- VectorCopy( vCenter, vMin );
- VectorCopy( vCenter, vMax );
- vMin[0] -= 4;
- vMin[1] -= 4;
- vMin[2] -= 4;
- vMax[0] += 4;
- vMax[1] += 4;
- vMax[2] += 4;
-
- g_QglTable.m_pfn_qglBegin( GL_LINE_LOOP );
- g_QglTable.m_pfn_qglVertex3f( vMin[0],vMin[1],vMin[2] );
- g_QglTable.m_pfn_qglVertex3f( vMax[0],vMin[1],vMin[2] );
- g_QglTable.m_pfn_qglVertex3f( vMax[0],vMax[1],vMin[2] );
- g_QglTable.m_pfn_qglVertex3f( vMin[0],vMax[1],vMin[2] );
- g_QglTable.m_pfn_qglEnd();
-
- g_QglTable.m_pfn_qglBegin( GL_LINE_LOOP );
- g_QglTable.m_pfn_qglVertex3f( vMin[0],vMin[1],vMax[2] );
- g_QglTable.m_pfn_qglVertex3f( vMax[0],vMin[1],vMax[2] );
- g_QglTable.m_pfn_qglVertex3f( vMax[0],vMax[1],vMax[2] );
- g_QglTable.m_pfn_qglVertex3f( vMin[0],vMax[1],vMax[2] );
- g_QglTable.m_pfn_qglEnd();
-
- g_QglTable.m_pfn_qglBegin( GL_LINES );
- g_QglTable.m_pfn_qglVertex3f( vMin[0],vMin[1],vMin[2] );
- g_QglTable.m_pfn_qglVertex3f( vMin[0],vMin[1],vMax[2] );
- g_QglTable.m_pfn_qglVertex3f( vMin[0],vMax[1],vMax[2] );
- g_QglTable.m_pfn_qglVertex3f( vMin[0],vMax[1],vMin[2] );
- g_QglTable.m_pfn_qglVertex3f( vMax[0],vMin[1],vMin[2] );
- g_QglTable.m_pfn_qglVertex3f( vMax[0],vMin[1],vMax[2] );
- g_QglTable.m_pfn_qglVertex3f( vMax[0],vMax[1],vMax[2] );
- g_QglTable.m_pfn_qglVertex3f( vMax[0],vMax[1],vMin[2] );
- g_QglTable.m_pfn_qglEnd();
+#include "iarchive.h"
+#include "idatastream.h"
+#include "imodel.h"
+#include "modelskin.h"
+
+#include "cullable.h"
+#include "renderable.h"
+#include "selectable.h"
+
+#include "math/frustum.h"
+#include "string/string.h"
+#include "generic/static.h"
+#include "shaderlib.h"
+#include "scenelib.h"
+#include "instancelib.h"
+#include "transformlib.h"
+#include "traverselib.h"
+#include "render.h"
+
+class VectorLightList : public LightList
+{
+typedef std::vector<const RendererLight*> Lights;
+Lights m_lights;
+public:
+void addLight( const RendererLight& light ){
+ m_lights.push_back( &light );
+}
+void clear(){
+ m_lights.clear();
+}
+void evaluateLights() const {
+}
+void lightsChanged() const {
+}
+void forEachLight( const RendererLightCallback& callback ) const {
+ for ( Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i )
+ {
+ callback( *( *i ) );
+ }
+}
+};
+
+class PicoSurface :
+ public OpenGLRenderable
+{
+AABB m_aabb_local;
+CopiedString m_shader;
+Shader* m_state;
+
+Array<ArbitraryMeshVertex> m_vertices;
+Array<RenderIndex> m_indices;
+
+public:
+
+PicoSurface(){
+ constructNull();
+ CaptureShader();
+}
+PicoSurface( picoSurface_t* surface ){
+ CopyPicoSurface( surface );
+ CaptureShader();
+}
+~PicoSurface(){
+ ReleaseShader();
+}
+
+void render( RenderStateFlags state ) const {
+ if ( ( state & RENDER_BUMP ) != 0 ) {
+ if ( GlobalShaderCache().useShaderLanguage() ) {
+ glNormalPointer( GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->normal );
+ glVertexAttribPointerARB( c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->texcoord );
+ glVertexAttribPointerARB( c_attr_Tangent, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->tangent );
+ glVertexAttribPointerARB( c_attr_Binormal, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->bitangent );
+ }
+ else
+ {
+ glVertexAttribPointerARB( 11, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->normal );
+ glVertexAttribPointerARB( 8, 2, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->texcoord );
+ glVertexAttribPointerARB( 9, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->tangent );
+ glVertexAttribPointerARB( 10, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->bitangent );
+ }
+ }
+ else
+ {
+ glNormalPointer( GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->normal );
+ glTexCoordPointer( 2, GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->texcoord );
+ }
+ glVertexPointer( 3, GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->vertex );
+ glDrawElements( GL_TRIANGLES, GLsizei( m_indices.size() ), RenderIndexTypeID, m_indices.data() );
+
+#if defined( _DEBUG )
+ GLfloat modelview[16];
+ glGetFloatv( GL_MODELVIEW_MATRIX, modelview ); // I know this is slow as hell, but hey - we're in _DEBUG
+ Matrix4 modelview_inv(
+ modelview[0], modelview[1], modelview[2], modelview[3],
+ modelview[4], modelview[5], modelview[6], modelview[7],
+ modelview[8], modelview[9], modelview[10], modelview[11],
+ modelview[12], modelview[13], modelview[14], modelview[15] );
+ matrix4_full_invert( modelview_inv );
+ Matrix4 modelview_inv_transposed = matrix4_transposed( modelview_inv );
+
+ glBegin( GL_LINES );
+
+ for ( Array<ArbitraryMeshVertex>::const_iterator i = m_vertices.begin(); i != m_vertices.end(); ++i )
+ {
+ Vector3 normal = normal3f_to_vector3( ( *i ).normal );
+ normal = matrix4_transformed_direction( modelview_inv, vector3_normalised( matrix4_transformed_direction( modelview_inv_transposed, normal ) ) ); // do some magic
+ Vector3 normalTransformed = vector3_added( vertex3f_to_vector3( ( *i ).vertex ), vector3_scaled( normal, 8 ) );
+ glVertex3fv( vertex3f_to_array( ( *i ).vertex ) );
+ glVertex3fv( vector3_to_array( normalTransformed ) );
+ }
+ glEnd();
+#endif
+}
+
+VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
+ return test.TestAABB( m_aabb_local, localToWorld );
+}
+
+const AABB& localAABB() const {
+ return m_aabb_local;
+}
+
+void render( Renderer& renderer, const Matrix4& localToWorld, Shader* state ) const {
+ renderer.SetState( state, Renderer::eFullMaterials );
+ renderer.addRenderable( *this, localToWorld );
+}
+
+void render( Renderer& renderer, const Matrix4& localToWorld ) const {
+ render( renderer, localToWorld, m_state );
+}
+
+void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
+ test.BeginMesh( localToWorld );
+
+ SelectionIntersection best;
+ testSelect( test, best );
+ if ( best.valid() ) {
+ selector.addIntersection( best );
+ }
+}
+
+const char* getShader() const {
+ return m_shader.c_str();
+}
+Shader* getState() const {
+ return m_state;
+}
+
+private:
+
+void CaptureShader(){
+ m_state = GlobalShaderCache().capture( m_shader.c_str() );
+}
+void ReleaseShader(){
+ GlobalShaderCache().release( m_shader.c_str() );
+}
+
+void UpdateAABB(){
+ m_aabb_local = AABB();
+ for ( std::size_t i = 0; i < m_vertices.size(); ++i )
+ aabb_extend_by_point_safe( m_aabb_local, reinterpret_cast<const Vector3&>( m_vertices[i].vertex ) );
+
+
+ for ( Array<RenderIndex>::iterator i = m_indices.begin(); i != m_indices.end(); i += 3 )
+ {
+ ArbitraryMeshVertex& a = m_vertices[*( i + 0 )];
+ ArbitraryMeshVertex& b = m_vertices[*( i + 1 )];
+ ArbitraryMeshVertex& c = m_vertices[*( i + 2 )];
+
+ ArbitraryMeshTriangle_sumTangents( a, b, c );
+ }
+
+ for ( Array<ArbitraryMeshVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i )
+ {
+ vector3_normalise( reinterpret_cast<Vector3&>( ( *i ).tangent ) );
+ vector3_normalise( reinterpret_cast<Vector3&>( ( *i ).bitangent ) );
+ }
+}
+
+void testSelect( SelectionTest& test, SelectionIntersection& best ){
+ test.TestTriangles(
+ VertexPointer( VertexPointer::pointer( &m_vertices.data()->vertex ), sizeof( ArbitraryMeshVertex ) ),
+ IndexPointer( m_indices.data(), IndexPointer::index_type( m_indices.size() ) ),
+ best
+ );
+}
+
+void CopyPicoSurface( picoSurface_t* surface ){
+ picoShader_t* shader = PicoGetSurfaceShader( surface );
+ if ( shader == 0 ) {
+ m_shader = "";
+ }
+ else{
+ m_shader = PicoGetShaderName( shader );
+ }
+
+ m_vertices.resize( PicoGetSurfaceNumVertexes( surface ) );
+ m_indices.resize( PicoGetSurfaceNumIndexes( surface ) );
+
+ for ( std::size_t i = 0; i < m_vertices.size(); ++i )
+ {
+ picoVec_t* xyz = PicoGetSurfaceXYZ( surface, int(i) );
+ m_vertices[i].vertex = vertex3f_from_array( xyz );
+
+ picoVec_t* normal = PicoGetSurfaceNormal( surface, int(i) );
+ m_vertices[i].normal = normal3f_from_array( normal );
+
+ picoVec_t* st = PicoGetSurfaceST( surface, 0, int(i) );
+ m_vertices[i].texcoord = TexCoord2f( st[0], st[1] );
+
+#if 0
+ picoVec_t* color = PicoGetSurfaceColor( surface, 0, int(i) );
+ m_vertices[i].colour = Colour4b( color[0], color[1], color[2], color[3] );
+#endif
+ }
+
+ picoIndex_t* indexes = PicoGetSurfaceIndexes( surface, 0 );
+ for ( std::size_t j = 0; j < m_indices.size(); ++j )
+ m_indices[ j ] = indexes[ j ];
+
+ UpdateAABB();
+}
+
+void constructQuad( std::size_t index, const Vector3& a, const Vector3& b, const Vector3& c, const Vector3& d, const Vector3& normal ){
+ m_vertices[index * 4 + 0] = ArbitraryMeshVertex(
+ vertex3f_for_vector3( a ),
+ normal3f_for_vector3( normal ),
+ texcoord2f_from_array( aabb_texcoord_topleft )
+ );
+ m_vertices[index * 4 + 1] = ArbitraryMeshVertex(
+ vertex3f_for_vector3( b ),
+ normal3f_for_vector3( normal ),
+ texcoord2f_from_array( aabb_texcoord_topright )
+ );
+ m_vertices[index * 4 + 2] = ArbitraryMeshVertex(
+ vertex3f_for_vector3( c ),
+ normal3f_for_vector3( normal ),
+ texcoord2f_from_array( aabb_texcoord_botright )
+ );
+ m_vertices[index * 4 + 3] = ArbitraryMeshVertex(
+ vertex3f_for_vector3( d ),
+ normal3f_for_vector3( normal ),
+ texcoord2f_from_array( aabb_texcoord_botleft )
+ );
+}
+
+void constructNull(){
+ AABB aabb( Vector3( 0, 0, 0 ), Vector3( 8, 8, 8 ) );
+
+ Vector3 points[8];
+ aabb_corners( aabb, points );
+
+ m_vertices.resize( 24 );
+
+ constructQuad( 0, points[2], points[1], points[5], points[6], aabb_normals[0] );
+ constructQuad( 1, points[1], points[0], points[4], points[5], aabb_normals[1] );
+ constructQuad( 2, points[0], points[1], points[2], points[3], aabb_normals[2] );
+ constructQuad( 3, points[0], points[3], points[7], points[4], aabb_normals[3] );
+ constructQuad( 4, points[3], points[2], points[6], points[7], aabb_normals[4] );
+ constructQuad( 5, points[7], points[6], points[5], points[4], aabb_normals[5] );
+
+ m_indices.resize( 36 );
+
+ RenderIndex indices[36] = {
+ 0, 1, 2, 0, 2, 3,
+ 4, 5, 6, 4, 6, 7,
+ 8, 9, 10, 8, 10, 11,
+ 12, 13, 14, 12, 14, 15,
+ 16, 17, 18, 16, 18, 19,
+ 20, 21, 22, 10, 22, 23,
+ };
+
+
+ Array<RenderIndex>::iterator j = m_indices.begin();
+ for ( RenderIndex* i = indices; i != indices + ( sizeof( indices ) / sizeof( RenderIndex ) ); ++i )
+ {
+ *j++ = *i;
+ }
+
+ m_shader = "";
+
+ UpdateAABB();
+}
+};
+
+
+typedef std::pair<CopiedString, int> PicoModelKey;
+
+
+class PicoModel :
+ public Cullable,
+ public Bounded
+{
+typedef std::vector<PicoSurface*> surfaces_t;
+surfaces_t m_surfaces;
+
+AABB m_aabb_local;
+public:
+Callback m_lightsChanged;
+
+PicoModel(){
+ constructNull();
+}
+PicoModel( picoModel_t* model ){
+ CopyPicoModel( model );
+}
+~PicoModel(){
+ for ( surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i )
+ delete *i;
+}
+
+typedef surfaces_t::const_iterator const_iterator;
+
+const_iterator begin() const {
+ return m_surfaces.begin();
+}
+const_iterator end() const {
+ return m_surfaces.end();
+}
+std::size_t size() const {
+ return m_surfaces.size();
+}
+
+VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
+ return test.TestAABB( m_aabb_local, localToWorld );
+}
+
+virtual const AABB& localAABB() const {
+ return m_aabb_local;
+}
+
+void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, std::vector<Shader*> states ) const {
+ for ( surfaces_t::const_iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i )
+ {
+ if ( ( *i )->intersectVolume( volume, localToWorld ) != c_volumeOutside ) {
+ ( *i )->render( renderer, localToWorld, states[i - m_surfaces.begin()] );
+ }
+ }
+}
+
+void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
+ for ( surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i )
+ {
+ if ( ( *i )->intersectVolume( test.getVolume(), localToWorld ) != c_volumeOutside ) {
+ ( *i )->testSelect( selector, test, localToWorld );
+ }
+ }
+}
+
+private:
+void CopyPicoModel( picoModel_t* model ){
+ m_aabb_local = AABB();
+
+ /* each surface on the model will become a new map drawsurface */
+ int numSurfaces = PicoGetModelNumSurfaces( model );
+ //% SYs_FPrintf( SYS_VRB, "Model %s has %d surfaces\n", name, numSurfaces );
+ for ( int s = 0; s < numSurfaces; ++s )
+ {
+ /* get surface */
+ picoSurface_t* surface = PicoGetModelSurface( model, s );
+ if ( surface == 0 ) {
+ continue;
+ }
+
+ /* only handle triangle surfaces initially (fixme: support patches) */
+ if ( PicoGetSurfaceType( surface ) != PICO_TRIANGLES ) {
+ continue;
+ }
+
+ /* fix the surface's normals */
+ PicoFixSurfaceNormals( surface );
+
+ PicoSurface* picosurface = new PicoSurface( surface );
+ aabb_extend_by_aabb_safe( m_aabb_local, picosurface->localAABB() );
+ m_surfaces.push_back( picosurface );
+ }
+}
+void constructNull(){
+ PicoSurface* picosurface = new PicoSurface();
+ m_aabb_local = picosurface->localAABB();
+ m_surfaces.push_back( picosurface );
+}
+};
+
+inline void Surface_addLight( PicoSurface& surface, VectorLightList& lights, const Matrix4& localToWorld, const RendererLight& light ){
+ if ( light.testAABB( aabb_for_oriented_aabb( surface.localAABB(), localToWorld ) ) ) {
+ lights.addLight( light );
+ }
+}
+
+class PicoModelInstance :
+ public scene::Instance,
+ public Renderable,
+ public SelectionTestable,
+ public LightCullable,
+ public SkinnedModel
+{
+class TypeCasts
+{
+InstanceTypeCastTable m_casts;
+public:
+TypeCasts(){
+ InstanceContainedCast<PicoModelInstance, Bounded>::install( m_casts );
+ InstanceContainedCast<PicoModelInstance, Cullable>::install( m_casts );
+ InstanceStaticCast<PicoModelInstance, Renderable>::install( m_casts );
+ InstanceStaticCast<PicoModelInstance, SelectionTestable>::install( m_casts );
+ InstanceStaticCast<PicoModelInstance, SkinnedModel>::install( m_casts );
+}
+InstanceTypeCastTable& get(){
+ return m_casts;
+}
+};
+
+PicoModel& m_picomodel;
+
+const LightList* m_lightList;
+typedef Array<VectorLightList> SurfaceLightLists;
+SurfaceLightLists m_surfaceLightLists;
+
+class Remap
+{
+public:
+CopiedString first;
+Shader* second;
+Remap() : second( 0 ){
+}
+};
+typedef Array<Remap> SurfaceRemaps;
+SurfaceRemaps m_skins;
+
+PicoModelInstance( const PicoModelInstance& );
+PicoModelInstance operator=( const PicoModelInstance& );
+public:
+typedef LazyStatic<TypeCasts> StaticTypeCasts;
+
+void* m_test;
+
+Bounded& get( NullType<Bounded>){
+ return m_picomodel;
+}
+Cullable& get( NullType<Cullable>){
+ return m_picomodel;
+}
+
+void lightsChanged(){
+ m_lightList->lightsChanged();
+}
+typedef MemberCaller<PicoModelInstance, &PicoModelInstance::lightsChanged> LightsChangedCaller;
+
+void constructRemaps(){
+ ASSERT_MESSAGE( m_skins.size() == m_picomodel.size(), "ERROR" );
+ ModelSkin* skin = NodeTypeCast<ModelSkin>::cast( path().parent() );
+ if ( skin != 0 && skin->realised() ) {
+ SurfaceRemaps::iterator j = m_skins.begin();
+ for ( PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i, ++j )
+ {
+ const char* remap = skin->getRemap( ( *i )->getShader() );
+ if ( !string_empty( remap ) ) {
+ ( *j ).first = remap;
+ ( *j ).second = GlobalShaderCache().capture( remap );
+ }
+ else
+ {
+ ( *j ).second = 0;
+ }
+ }
+ SceneChangeNotify();
+ }
+}
+void destroyRemaps(){
+ ASSERT_MESSAGE( m_skins.size() == m_picomodel.size(), "ERROR" );
+ for ( SurfaceRemaps::iterator i = m_skins.begin(); i != m_skins.end(); ++i )
+ {
+ if ( ( *i ).second != 0 ) {
+ GlobalShaderCache().release( ( *i ).first.c_str() );
+ ( *i ).second = 0;
+ }
+ }
+}
+void skinChanged(){
+ destroyRemaps();
+ constructRemaps();
+}
+
+PicoModelInstance( const scene::Path& path, scene::Instance* parent, PicoModel& picomodel ) :
+ Instance( path, parent, this, StaticTypeCasts::instance().get() ),
+ m_picomodel( picomodel ),
+ m_surfaceLightLists( m_picomodel.size() ),
+ m_skins( m_picomodel.size() ){
+ m_lightList = &GlobalShaderCache().attach( *this );
+ m_picomodel.m_lightsChanged = LightsChangedCaller( *this );
+
+ Instance::setTransformChangedCallback( LightsChangedCaller( *this ) );
+
+ constructRemaps();
+}
+~PicoModelInstance(){
+ destroyRemaps();
+
+ Instance::setTransformChangedCallback( Callback() );
+
+ m_picomodel.m_lightsChanged = Callback();
+ GlobalShaderCache().detach( *this );
+}
+
+void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
+ SurfaceLightLists::const_iterator j = m_surfaceLightLists.begin();
+ SurfaceRemaps::const_iterator k = m_skins.begin();
+ for ( PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i, ++j, ++k )
+ {
+ if ( ( *i )->intersectVolume( volume, localToWorld ) != c_volumeOutside ) {
+ renderer.setLights( *j );
+ ( *i )->render( renderer, localToWorld, ( *k ).second != 0 ? ( *k ).second : ( *i )->getState() );
+ }
+ }
+}
+
+void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
+ m_lightList->evaluateLights();
+
+ render( renderer, volume, Instance::localToWorld() );
+}
+void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
+ renderSolid( renderer, volume );
+}
+
+void testSelect( Selector& selector, SelectionTest& test ){
+ m_picomodel.testSelect( selector, test, Instance::localToWorld() );
+}
+
+bool testLight( const RendererLight& light ) const {
+ return light.testAABB( worldAABB() );
+}
+void insertLight( const RendererLight& light ){
+ const Matrix4& localToWorld = Instance::localToWorld();
+ SurfaceLightLists::iterator j = m_surfaceLightLists.begin();
+ for ( PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i )
+ {
+ Surface_addLight( *( *i ), *j++, localToWorld, light );
+ }
+}
+void clearLights(){
+ for ( SurfaceLightLists::iterator i = m_surfaceLightLists.begin(); i != m_surfaceLightLists.end(); ++i )
+ {
+ ( *i ).clear();
+ }
+}
+};
+
+class PicoModelNode : public scene::Node::Symbiot, public scene::Instantiable
+{
+class TypeCasts
+{
+NodeTypeCastTable m_casts;
+public:
+TypeCasts(){
+ NodeStaticCast<PicoModelNode, scene::Instantiable>::install( m_casts );
+}
+NodeTypeCastTable& get(){
+ return m_casts;
+}
+};
+
+
+scene::Node m_node;
+InstanceSet m_instances;
+PicoModel m_picomodel;
+
+public:
+typedef LazyStatic<TypeCasts> StaticTypeCasts;
+
+PicoModelNode() : m_node( this, this, StaticTypeCasts::instance().get() ){
+}
+PicoModelNode( picoModel_t* model ) : m_node( this, this, StaticTypeCasts::instance().get() ), m_picomodel( model ){
+}
+
+void release(){
+ delete this;
+}
+scene::Node& node(){
+ return m_node;
+}
+
+scene::Instance* create( const scene::Path& path, scene::Instance* parent ){
+ return new PicoModelInstance( path, parent, m_picomodel );
+}
+void forEachInstance( const scene::Instantiable::Visitor& visitor ){
+ m_instances.forEachInstance( visitor );
+}
+void insert( scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance ){
+ m_instances.insert( observer, path, instance );
+}
+scene::Instance* erase( scene::Instantiable::Observer* observer, const scene::Path& path ){
+ return m_instances.erase( observer, path );
+}
+};
+
+
+#if 0
+
+template<typename Key, typename Type>
+class create_new
+{
+public:
+static Type* construct( const Key& key ){
+ return new Type( key );
+}
+static void destroy( Type* value ){
+ delete value;
+}
+};
+
+template<typename Key, typename Type, typename creation_policy = create_new<Key, Type> >
+class cache_element : public creation_policy
+{
+public:
+inline cache_element() : m_count( 0 ), m_value( 0 ) {}
+inline ~cache_element(){
+ ASSERT_MESSAGE( m_count == 0, "destroyed a reference before it was released\n" );
+ if ( m_count > 0 ) {
+ destroy();
+ }
+}
+inline Type* capture( const Key& key ){
+ if ( ++m_count == 1 ) {
+ construct( key );
+ }
+ return m_value;
+}
+inline void release(){
+ ASSERT_MESSAGE( !empty(), "failed to release reference - not found in cache\n" );
+ if ( --m_count == 0 ) {
+ destroy();
+ }
+}
+inline bool empty(){
+ return m_count == 0;
+}
+inline void refresh( const Key& key ){
+ m_value->refresh( key );
+}
+private:
+inline void construct( const Key& key ){
+ m_value = creation_policy::construct( key );
+}
+inline void destroy(){
+ creation_policy::destroy( m_value );
+}
+
+std::size_t m_count;
+Type* m_value;
+};
+
+class create_picomodel
+{
+typedef PicoModelKey key_type;
+typedef PicoModel value_type;
+public:
+static value_type* construct( const key_type& key ){
+ picoModel_t* picomodel = PicoLoadModel( const_cast<char*>( key.first.c_str() ), key.second );
+ value_type* value = new value_type( picomodel );
+ PicoFreeModel( picomodel );
+ return value;
+}
+static void destroy( value_type* value ){
+ delete value;
+}
+};
+
+#include <map>
+
+class ModelCache
+{
+typedef PicoModel value_type;
+
+public:
+typedef PicoModelKey key_type;
+typedef cache_element<key_type, value_type, create_picomodel> elem_type;
+typedef std::map<key_type, elem_type> cache_type;
+
+value_type* capture( const key_type& key ){
+ return m_cache[key].capture( key );
+}
+void release( const key_type& key ){
+ m_cache[key].release();
+}
+
+private:
+cache_type m_cache;
+};
+
+ModelCache g_model_cache;
+
+
+
+typedef struct remap_s {
+ char m_remapbuff[64 + 1024];
+ char *original;
+ char *remap;
+} remap_t;
+
+class RemapWrapper :
+ public Cullable,
+ public Bounded
+{
+public:
+RemapWrapper( const char* name ){
+ parse_namestr( name );
+
+ m_model = g_model_cache.capture( ModelCache::key_type( m_name, m_frame ) );
+
+ construct_shaders();
+}
+virtual ~RemapWrapper(){
+ g_model_cache.release( ModelCache::key_type( m_name, m_frame ) );
+
+ for ( shaders_t::iterator i = m_shaders.begin(); i != m_shaders.end(); ++i )
+ {
+ GlobalShaderCache().release( ( *i ).c_str() );
+ }
+
+ for ( remaps_t::iterator j = m_remaps.begin(); j != m_remaps.end(); ++j )
+ {
+ delete ( *j );
+ }
+}
+
+VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
+ return m_model->intersectVolume( test, localToWorld );
+}
+
+virtual const AABB& localAABB() const {
+ return m_model->localAABB();
+}
+
+void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
+ m_model->render( renderer, volume, localToWorld, m_states );
+}
+
+void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
+ m_model->testSelect( selector, test, localToWorld );
+}
+
+private:
+void add_remap( const char *remap ){
+ const char *ch;
+ remap_t *pRemap;
+
+ ch = remap;
+
+ while ( *ch && *ch != ';' )
+ ch++;
+
+ if ( *ch == '\0' ) {
+ // bad remap
+ globalErrorStream() << "WARNING: Shader _remap key found in a model entity without a ; character\n";
+ }
+ else {
+ pRemap = new remap_t;
+
+ strncpy( pRemap->m_remapbuff, remap, sizeof( pRemap->m_remapbuff ) );
+
+ pRemap->m_remapbuff[ch - remap] = '\0';
+
+ pRemap->original = pRemap->m_remapbuff;
+ pRemap->remap = pRemap->m_remapbuff + ( ch - remap ) + 1;
+
+ m_remaps.push_back( pRemap );
+ }
+}
+
+void parse_namestr( const char *name ){
+ const char *ptr, *s;
+ bool hasName, hasFrame;
+
+ hasName = hasFrame = false;
+
+ m_frame = 0;
+
+ for ( s = ptr = name; ; ++ptr )
+ {
+ if ( !hasName && ( *ptr == ':' || *ptr == '\0' ) ) {
+ // model name
+ hasName = true;
+ m_name = CopiedString( s, ptr );
+ s = ptr + 1;
+ }
+ else if ( *ptr == '?' || *ptr == '\0' ) {
+ // model frame
+ hasFrame = true;
+ m_frame = atoi( CopiedString( s, ptr ).c_str() );
+ s = ptr + 1;
+ }
+ else if ( *ptr == '&' || *ptr == '\0' ) {
+ // a remap
+ add_remap( CopiedString( s, ptr ).c_str() );
+ s = ptr + 1;
+ }
+
+ if ( *ptr == '\0' ) {
+ break;
+ }
+ }
+}
+
+void construct_shaders(){
+ const char* global_shader = shader_for_remap( "*" );
+
+ m_shaders.reserve( m_model->size() );
+ m_states.reserve( m_model->size() );
+ for ( PicoModel::iterator i = m_model->begin(); i != m_model->end(); ++i )
+ {
+ const char* shader = shader_for_remap( ( *i )->getShader() );
+ m_shaders.push_back(
+ ( shader[0] != '\0' )
+ ? shader
+ : ( global_shader[0] != '\0' )
+ ? global_shader
+ : ( *i )->getShader() );
+ m_states.push_back( GlobalShaderCache().capture( m_shaders.back().c_str() ) );
+ }
+}
+
+inline const char* shader_for_remap( const char* remap ){
+ for ( remaps_t::iterator i = m_remaps.begin(); i != m_remaps.end(); ++i )
+ {
+ if ( shader_equal( remap, ( *i )->original ) ) {
+ return ( *i )->remap;
+ }
+ }
+ return "";
+}
+
+CopiedString m_name;
+int m_frame;
+PicoModel* m_model;
+
+typedef std::vector<remap_t*> remaps_t;
+remaps_t m_remaps;
+typedef std::vector<CopiedString> shaders_t;
+shaders_t m_shaders;
+typedef std::vector<Shader*> states_t;
+states_t m_states;
+};
+
+class RemapWrapperInstance : public scene::Instance, public Renderable, public SelectionTestable
+{
+RemapWrapper& m_remapwrapper;
+public:
+RemapWrapperInstance( const scene::Path& path, scene::Instance* parent, RemapWrapper& remapwrapper ) : Instance( path, parent ), m_remapwrapper( remapwrapper ){
+ scene::Instance::m_cullable = &m_remapwrapper;
+ scene::Instance::m_render = this;
+ scene::Instance::m_select = this;
+}
+
+void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
+ m_remapwrapper.render( renderer, volume, Instance::localToWorld() );
+}
+void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
+ renderSolid( renderer, volume );
+}
+
+void testSelect( Selector& selector, SelectionTest& test ){
+ m_remapwrapper.testSelect( selector, test, Instance::localToWorld() );
+}
+};
+
+class RemapWrapperNode : public scene::Node::Symbiot, public scene::Instantiable
+{
+scene::Node m_node;
+typedef RemapWrapperInstance instance_type;
+InstanceSet m_instances;
+RemapWrapper m_remapwrapper;
+public:
+RemapWrapperNode( const char* name ) : m_node( this ), m_remapwrapper( name ){
+ m_node.m_instance = this;
+}
+
+void release(){
+ delete this;
+}
+scene::Node& node(){
+ return m_node;
+}
+
+scene::Instance* create( const scene::Path& path, scene::Instance* parent ){
+ return new instance_type( path, parent, m_remapwrapper );
+}
+void forEachInstance( const scene::Instantiable::Visitor& visitor ){
+ m_instances.forEachInstance( visitor );
+}
+void insert( scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance ){
+ m_instances.insert( observer, path, instance );
+}
+scene::Instance* erase( scene::Instantiable::Observer* observer, const scene::Path& path ){
+ return m_instances.erase( observer, path );
+}
+};
+
+scene::Node& LoadRemapModel( const char* name ){
+ return ( new RemapWrapperNode( name ) )->node();
+}
+
+#endif
+
+
+size_t picoInputStreamReam( void* inputStream, unsigned char* buffer, size_t length ){
+ return reinterpret_cast<InputStream*>( inputStream )->read( buffer, length );
+}
+
+scene::Node& loadPicoModel( const picoModule_t* module, ArchiveFile& file ){
+ picoModel_t* model = PicoModuleLoadModelStream( module, &file.getInputStream(), picoInputStreamReam, file.size(), 0, file.getName() );
+ PicoModelNode* modelNode = new PicoModelNode( model );
+ PicoFreeModel( model );
+ return modelNode->node();
}
projects / xonotic / netradiant.git / blobdiff