#include "traverselib.h"
#include "render.h"
-class VectorLightList : public LightList
-{
-typedef std::vector<const RendererLight*> Lights;
-Lights m_lights;
+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 ) );
- }
-}
+ 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;
+ public OpenGLRenderable {
+ AABB m_aabb_local;
+ CopiedString m_shader;
+ Shader *m_state;
-Array<ArbitraryMeshVertex> m_vertices;
-Array<RenderIndex> m_indices;
+
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() );
+ 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 GDEF_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();
+ 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;
-}
+ }
+
+ 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] );
+ 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] );
+ 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();
-}
+ }
+
+ 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();
+ }
};
class PicoModel :
- public Cullable,
- public Bounded
-{
-typedef std::vector<PicoSurface*> surfaces_t;
-surfaces_t m_surfaces;
+ public Cullable,
+ public Bounded {
+ typedef std::vector<PicoSurface *> surfaces_t;
+ surfaces_t m_surfaces;
-AABB m_aabb_local;
+ AABB m_aabb_local;
public:
-Callback<void()> 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 );
- }
- }
-}
+ Callback<void()> 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 );
-}
+ 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
+inline void
+Surface_addLight(PicoSurface &surface, VectorLightList &lights, const Matrix4 &localToWorld, const RendererLight &light)
{
-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;
+ if (light.testAABB(aabb_for_oriented_aabb(surface.localAABB(), localToWorld))) {
+ lights.addLight(light);
+ }
}
-};
-
-PicoModel& m_picomodel;
-const LightList* m_lightList;
-typedef Array<VectorLightList> SurfaceLightLists;
-SurfaceLightLists m_surfaceLightLists;
+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 &);
-class Remap
-{
public:
-CopiedString first;
-Shader* second;
-Remap() : second( 0 ){
-}
+ 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, void(), &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<void()>());
+
+ m_picomodel.m_lightsChanged = Callback<void()>();
+ 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();
+ }
+ }
};
-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, void(), &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 );
+class PicoModelNode : public scene::Node::Symbiot, public scene::Instantiable {
+ class TypeCasts {
+ NodeTypeCastTable m_casts;
+ public:
+ TypeCasts()
+ {
+ NodeStaticCast<PicoModelNode, scene::Instantiable>::install(m_casts);
+ }
- Instance::setTransformChangedCallback( LightsChangedCaller( *this ) );
+ NodeTypeCastTable &get()
+ {
+ return m_casts;
+ }
+ };
- constructRemaps();
-}
-~PicoModelInstance(){
- destroyRemaps();
-
- Instance::setTransformChangedCallback( Callback<void()>() );
- m_picomodel.m_lightsChanged = Callback<void()>();
- GlobalShaderCache().detach( *this );
-}
+ scene::Node m_node;
+ InstanceSet m_instances;
+ PicoModel m_picomodel;
-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 );
-}
+ 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);
+ }
};
{
public:
static Type* construct( const Key& key ){
- return new Type( key );
+ return new Type( key );
}
static void destroy( Type* value ){
- delete value;
+ delete value;
}
};
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();
- }
+ 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;
+ 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();
- }
+ ASSERT_MESSAGE( !empty(), "failed to release reference - not found in cache\n" );
+ if ( --m_count == 0 ) {
+ destroy();
+ }
}
inline bool empty(){
- return m_count == 0;
+ return m_count == 0;
}
inline void refresh( const Key& key ){
- m_value->refresh( key );
+ m_value->refresh( key );
}
private:
inline void construct( const Key& key ){
- m_value = creation_policy::construct( key );
+ m_value = creation_policy::construct( key );
}
inline void destroy(){
- creation_policy::destroy( m_value );
+ creation_policy::destroy( m_value );
}
std::size_t m_count;
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;
+ 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;
+ delete value;
}
};
typedef std::map<key_type, elem_type> cache_type;
value_type* capture( const key_type& key ){
- return m_cache[key].capture( key );
+ return m_cache[key].capture( key );
}
void release( const key_type& key ){
- m_cache[key].release();
+ m_cache[key].release();
}
private:
typedef struct remap_s {
- char m_remapbuff[64 + 1024];
- char *original;
- char *remap;
+ char m_remapbuff[64 + 1024];
+ char *original;
+ char *remap;
} remap_t;
class RemapWrapper :
- public Cullable,
- public Bounded
+ public Cullable,
+ public Bounded
{
public:
RemapWrapper( const char* name ){
- parse_namestr( name );
+ parse_namestr( name );
- m_model = g_model_cache.capture( ModelCache::key_type( m_name, m_frame ) );
+ m_model = g_model_cache.capture( ModelCache::key_type( m_name, m_frame ) );
- construct_shaders();
+ construct_shaders();
}
virtual ~RemapWrapper(){
- g_model_cache.release( ModelCache::key_type( m_name, m_frame ) );
+ 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 ( 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 );
- }
+ 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 );
+ return m_model->intersectVolume( test, localToWorld );
}
virtual const AABB& localAABB() const {
- return m_model->localAABB();
+ return m_model->localAABB();
}
void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
- m_model->render( renderer, volume, localToWorld, m_states );
+ m_model->render( renderer, volume, localToWorld, m_states );
}
void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
- m_model->testSelect( selector, test, localToWorld );
+ m_model->testSelect( selector, test, localToWorld );
}
private:
void add_remap( const char *remap ){
- const char *ch;
- remap_t *pRemap;
+ const char *ch;
+ remap_t *pRemap;
- ch = remap;
+ ch = remap;
- while ( *ch && *ch != ';' )
- ch++;
+ 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;
+ 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 ) );
+ strncpy( pRemap->m_remapbuff, remap, sizeof( pRemap->m_remapbuff ) );
- pRemap->m_remapbuff[ch - remap] = '\0';
+ pRemap->m_remapbuff[ch - remap] = '\0';
- pRemap->original = pRemap->m_remapbuff;
- pRemap->remap = pRemap->m_remapbuff + ( ch - remap ) + 1;
+ pRemap->original = pRemap->m_remapbuff;
+ pRemap->remap = pRemap->m_remapbuff + ( ch - remap ) + 1;
- m_remaps.push_back( pRemap );
- }
+ 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;
- }
- }
+ 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() ) );
- }
+ 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 "";
+ 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;
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;
+ 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() );
+ m_remapwrapper.render( renderer, volume, Instance::localToWorld() );
}
void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
- renderSolid( renderer, volume );
+ renderSolid( renderer, volume );
}
void testSelect( Selector& selector, SelectionTest& test ){
- m_remapwrapper.testSelect( selector, test, Instance::localToWorld() );
+ m_remapwrapper.testSelect( selector, test, Instance::localToWorld() );
}
};
RemapWrapper m_remapwrapper;
public:
RemapWrapperNode( const char* name ) : m_node( this ), m_remapwrapper( name ){
- m_node.m_instance = this;
+ m_node.m_instance = this;
}
void release(){
- delete this;
+ delete this;
}
scene::Node& node(){
- return m_node;
+ return m_node;
}
scene::Instance* create( const scene::Path& path, scene::Instance* parent ){
- return new instance_type( path, parent, m_remapwrapper );
+ return new instance_type( path, parent, m_remapwrapper );
}
void forEachInstance( const scene::Instantiable::Visitor& visitor ){
- m_instances.forEachInstance( visitor );
+ m_instances.forEachInstance( visitor );
}
void insert( scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance ){
- m_instances.insert( observer, path, instance );
+ m_instances.insert( observer, path, instance );
}
scene::Instance* erase( scene::Instantiable::Observer* observer, const scene::Path& path ){
- return m_instances.erase( observer, path );
+ return m_instances.erase( observer, path );
}
};
scene::Node& LoadRemapModel( const char* name ){
- return ( new RemapWrapperNode( name ) )->node();
+ 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 );
+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();
+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