2 Copyright (C) 2001-2006, William Joseph.
5 This file is part of GtkRadiant.
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.
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.
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
23 #include "globaldefs.h"
25 #include "picomodel.h"
28 #include "idatastream.h"
30 #include "modelskin.h"
33 #include "renderable.h"
34 #include "selectable.h"
36 #include "math/frustum.h"
37 #include "string/string.h"
38 #include "generic/static.h"
39 #include "shaderlib.h"
41 #include "instancelib.h"
42 #include "transformlib.h"
43 #include "traverselib.h"
46 class VectorLightList : public LightList {
47 typedef std::vector<const RendererLight *> Lights;
50 void addLight(const RendererLight &light)
52 m_lights.push_back(&light);
60 void evaluateLights() const
64 void lightsChanged() const
68 void forEachLight(const RendererLightCallback &callback) const
70 for (Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i) {
77 public OpenGLRenderable {
79 CopiedString m_shader;
82 Array<ArbitraryMeshVertex> m_vertices;
83 Array<RenderIndex> m_indices;
93 PicoSurface(picoSurface_t *surface)
95 CopyPicoSurface(surface);
104 void render(RenderStateFlags state) const
106 if ((state & RENDER_BUMP) != 0) {
107 if (GlobalShaderCache().useShaderLanguage()) {
108 glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
109 glVertexAttribPointerARB(c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
110 &m_vertices.data()->texcoord);
111 glVertexAttribPointerARB(c_attr_Tangent, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
112 &m_vertices.data()->tangent);
113 glVertexAttribPointerARB(c_attr_Binormal, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
114 &m_vertices.data()->bitangent);
116 glVertexAttribPointerARB(11, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
117 glVertexAttribPointerARB(8, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
118 glVertexAttribPointerARB(9, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->tangent);
119 glVertexAttribPointerARB(10, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
120 &m_vertices.data()->bitangent);
123 glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
124 glTexCoordPointer(2, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
126 glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->vertex);
127 glDrawElements(GL_TRIANGLES, GLsizei(m_indices.size()), RenderIndexTypeID, m_indices.data());
130 GLfloat modelview[16];
131 glGetFloatv(GL_MODELVIEW_MATRIX, modelview); // I know this is slow as hell, but hey - we're in _DEBUG
132 Matrix4 modelview_inv(
133 modelview[0], modelview[1], modelview[2], modelview[3],
134 modelview[4], modelview[5], modelview[6], modelview[7],
135 modelview[8], modelview[9], modelview[10], modelview[11],
136 modelview[12], modelview[13], modelview[14], modelview[15]);
137 matrix4_full_invert(modelview_inv);
138 Matrix4 modelview_inv_transposed = matrix4_transposed(modelview_inv);
142 for (Array<ArbitraryMeshVertex>::const_iterator i = m_vertices.begin(); i != m_vertices.end(); ++i) {
143 Vector3 normal = normal3f_to_vector3((*i).normal);
144 normal = matrix4_transformed_direction(modelview_inv, vector3_normalised(
145 matrix4_transformed_direction(modelview_inv_transposed, normal))); // do some magic
146 Vector3 normalTransformed = vector3_added(vertex3f_to_vector3((*i).vertex), vector3_scaled(normal, 8));
147 glVertex3fv(vertex3f_to_array((*i).vertex));
148 glVertex3fv(vector3_to_array(normalTransformed));
154 VolumeIntersectionValue intersectVolume(const VolumeTest &test, const Matrix4 &localToWorld) const
156 return test.TestAABB(m_aabb_local, localToWorld);
159 const AABB &localAABB() const
164 void render(Renderer &renderer, const Matrix4 &localToWorld, Shader *state) const
166 renderer.SetState(state, Renderer::eFullMaterials);
167 renderer.addRenderable(*this, localToWorld);
170 void render(Renderer &renderer, const Matrix4 &localToWorld) const
172 render(renderer, localToWorld, m_state);
175 void testSelect(Selector &selector, SelectionTest &test, const Matrix4 &localToWorld)
177 test.BeginMesh(localToWorld);
179 SelectionIntersection best;
180 testSelect(test, best);
182 selector.addIntersection(best);
186 const char *getShader() const
188 return m_shader.c_str();
191 Shader *getState() const
200 m_state = GlobalShaderCache().capture(m_shader.c_str());
205 GlobalShaderCache().release(m_shader.c_str());
210 m_aabb_local = AABB();
211 for (std::size_t i = 0; i < m_vertices.size(); ++i) {
212 aabb_extend_by_point_safe(m_aabb_local, reinterpret_cast<const Vector3 &>( m_vertices[i].vertex ));
216 for (Array<RenderIndex>::iterator i = m_indices.begin(); i != m_indices.end(); i += 3) {
217 ArbitraryMeshVertex &a = m_vertices[*(i + 0)];
218 ArbitraryMeshVertex &b = m_vertices[*(i + 1)];
219 ArbitraryMeshVertex &c = m_vertices[*(i + 2)];
221 ArbitraryMeshTriangle_sumTangents(a, b, c);
224 for (Array<ArbitraryMeshVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i) {
225 vector3_normalise(reinterpret_cast<Vector3 &>((*i).tangent ));
226 vector3_normalise(reinterpret_cast<Vector3 &>((*i).bitangent ));
230 void testSelect(SelectionTest &test, SelectionIntersection &best)
233 VertexPointer(VertexPointer::pointer(&m_vertices.data()->vertex), sizeof(ArbitraryMeshVertex)),
234 IndexPointer(m_indices.data(), IndexPointer::index_type(m_indices.size())),
239 void CopyPicoSurface(picoSurface_t *surface)
241 picoShader_t *shader = PicoGetSurfaceShader(surface);
245 m_shader = PicoGetShaderName(shader);
248 m_vertices.resize(PicoGetSurfaceNumVertexes(surface));
249 m_indices.resize(PicoGetSurfaceNumIndexes(surface));
251 for (std::size_t i = 0; i < m_vertices.size(); ++i) {
252 picoVec_t *xyz = PicoGetSurfaceXYZ(surface, int(i));
253 m_vertices[i].vertex = vertex3f_from_array(xyz);
255 picoVec_t *normal = PicoGetSurfaceNormal(surface, int(i));
256 m_vertices[i].normal = normal3f_from_array(normal);
258 picoVec_t *st = PicoGetSurfaceST(surface, 0, int(i));
259 m_vertices[i].texcoord = TexCoord2f(st[0], st[1]);
262 picoVec_t* color = PicoGetSurfaceColor( surface, 0, int(i) );
263 m_vertices[i].colour = Colour4b( color[0], color[1], color[2], color[3] );
267 picoIndex_t *indexes = PicoGetSurfaceIndexes(surface, 0);
268 for (std::size_t j = 0; j < m_indices.size(); ++j) {
269 m_indices[j] = indexes[j];
275 void constructQuad(std::size_t index, const Vector3 &a, const Vector3 &b, const Vector3 &c, const Vector3 &d,
276 const Vector3 &normal)
278 m_vertices[index * 4 + 0] = ArbitraryMeshVertex(
279 vertex3f_for_vector3(a),
280 normal3f_for_vector3(normal),
281 texcoord2f_from_array(aabb_texcoord_topleft)
283 m_vertices[index * 4 + 1] = ArbitraryMeshVertex(
284 vertex3f_for_vector3(b),
285 normal3f_for_vector3(normal),
286 texcoord2f_from_array(aabb_texcoord_topright)
288 m_vertices[index * 4 + 2] = ArbitraryMeshVertex(
289 vertex3f_for_vector3(c),
290 normal3f_for_vector3(normal),
291 texcoord2f_from_array(aabb_texcoord_botright)
293 m_vertices[index * 4 + 3] = ArbitraryMeshVertex(
294 vertex3f_for_vector3(d),
295 normal3f_for_vector3(normal),
296 texcoord2f_from_array(aabb_texcoord_botleft)
302 AABB aabb(Vector3(0, 0, 0), Vector3(8, 8, 8));
305 aabb_corners(aabb, points);
307 m_vertices.resize(24);
309 constructQuad(0, points[2], points[1], points[5], points[6], aabb_normals[0]);
310 constructQuad(1, points[1], points[0], points[4], points[5], aabb_normals[1]);
311 constructQuad(2, points[0], points[1], points[2], points[3], aabb_normals[2]);
312 constructQuad(3, points[0], points[3], points[7], points[4], aabb_normals[3]);
313 constructQuad(4, points[3], points[2], points[6], points[7], aabb_normals[4]);
314 constructQuad(5, points[7], points[6], points[5], points[4], aabb_normals[5]);
316 m_indices.resize(36);
318 RenderIndex indices[36] = {
322 12, 13, 14, 12, 14, 15,
323 16, 17, 18, 16, 18, 19,
324 20, 21, 22, 10, 22, 23,
328 Array<RenderIndex>::iterator j = m_indices.begin();
329 for (RenderIndex *i = indices; i != indices + (sizeof(indices) / sizeof(RenderIndex)); ++i) {
340 typedef std::pair<CopiedString, int> PicoModelKey;
346 typedef std::vector<PicoSurface *> surfaces_t;
347 surfaces_t m_surfaces;
351 Callback<void()> m_lightsChanged;
358 PicoModel(picoModel_t *model)
360 CopyPicoModel(model);
365 for (surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i) {
370 typedef surfaces_t::const_iterator const_iterator;
372 const_iterator begin() const
374 return m_surfaces.begin();
377 const_iterator end() const
379 return m_surfaces.end();
382 std::size_t size() const
384 return m_surfaces.size();
387 VolumeIntersectionValue intersectVolume(const VolumeTest &test, const Matrix4 &localToWorld) const
389 return test.TestAABB(m_aabb_local, localToWorld);
392 virtual const AABB &localAABB() const
397 void render(Renderer &renderer, const VolumeTest &volume, const Matrix4 &localToWorld,
398 std::vector<Shader *> states) const
400 for (surfaces_t::const_iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i) {
401 if ((*i)->intersectVolume(volume, localToWorld) != c_volumeOutside) {
402 (*i)->render(renderer, localToWorld, states[i - m_surfaces.begin()]);
407 void testSelect(Selector &selector, SelectionTest &test, const Matrix4 &localToWorld)
409 for (surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i) {
410 if ((*i)->intersectVolume(test.getVolume(), localToWorld) != c_volumeOutside) {
411 (*i)->testSelect(selector, test, localToWorld);
417 void CopyPicoModel(picoModel_t *model)
419 m_aabb_local = AABB();
421 /* each surface on the model will become a new map drawsurface */
422 int numSurfaces = PicoGetModelNumSurfaces(model);
423 //% SYs_FPrintf( SYS_VRB, "Model %s has %d surfaces\n", name, numSurfaces );
424 for (int s = 0; s < numSurfaces; ++s) {
426 picoSurface_t *surface = PicoGetModelSurface(model, s);
431 /* only handle triangle surfaces initially (fixme: support patches) */
432 if (PicoGetSurfaceType(surface) != PICO_TRIANGLES) {
436 /* fix the surface's normals */
437 PicoFixSurfaceNormals(surface);
439 PicoSurface *picosurface = new PicoSurface(surface);
440 aabb_extend_by_aabb_safe(m_aabb_local, picosurface->localAABB());
441 m_surfaces.push_back(picosurface);
447 PicoSurface *picosurface = new PicoSurface();
448 m_aabb_local = picosurface->localAABB();
449 m_surfaces.push_back(picosurface);
454 Surface_addLight(PicoSurface &surface, VectorLightList &lights, const Matrix4 &localToWorld, const RendererLight &light)
456 if (light.testAABB(aabb_for_oriented_aabb(surface.localAABB(), localToWorld))) {
457 lights.addLight(light);
461 class PicoModelInstance :
462 public scene::Instance,
464 public SelectionTestable,
465 public LightCullable,
466 public SkinnedModel {
468 InstanceTypeCastTable m_casts;
472 InstanceContainedCast<PicoModelInstance, Bounded>::install(m_casts);
473 InstanceContainedCast<PicoModelInstance, Cullable>::install(m_casts);
474 InstanceStaticCast<PicoModelInstance, Renderable>::install(m_casts);
475 InstanceStaticCast<PicoModelInstance, SelectionTestable>::install(m_casts);
476 InstanceStaticCast<PicoModelInstance, SkinnedModel>::install(m_casts);
479 InstanceTypeCastTable &get()
485 PicoModel &m_picomodel;
487 const LightList *m_lightList;
488 typedef Array<VectorLightList> SurfaceLightLists;
489 SurfaceLightLists m_surfaceLightLists;
501 typedef Array<Remap> SurfaceRemaps;
502 SurfaceRemaps m_skins;
504 PicoModelInstance(const PicoModelInstance &);
506 PicoModelInstance operator=(const PicoModelInstance &);
509 typedef LazyStatic<TypeCasts> StaticTypeCasts;
513 Bounded &get(NullType<Bounded>)
518 Cullable &get(NullType<Cullable>)
525 m_lightList->lightsChanged();
528 typedef MemberCaller<PicoModelInstance, void(), &PicoModelInstance::lightsChanged> LightsChangedCaller;
530 void constructRemaps()
532 ASSERT_MESSAGE(m_skins.size() == m_picomodel.size(), "ERROR");
533 ModelSkin *skin = NodeTypeCast<ModelSkin>::cast(path().parent());
534 if (skin != 0 && skin->realised()) {
535 SurfaceRemaps::iterator j = m_skins.begin();
536 for (PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i, ++j) {
537 const char *remap = skin->getRemap((*i)->getShader());
538 if (!string_empty(remap)) {
540 (*j).second = GlobalShaderCache().capture(remap);
551 ASSERT_MESSAGE(m_skins.size() == m_picomodel.size(), "ERROR");
552 for (SurfaceRemaps::iterator i = m_skins.begin(); i != m_skins.end(); ++i) {
553 if ((*i).second != 0) {
554 GlobalShaderCache().release((*i).first.c_str());
566 PicoModelInstance(const scene::Path &path, scene::Instance *parent, PicoModel &picomodel) :
567 Instance(path, parent, this, StaticTypeCasts::instance().get()),
568 m_picomodel(picomodel),
569 m_surfaceLightLists(m_picomodel.size()),
570 m_skins(m_picomodel.size())
572 m_lightList = &GlobalShaderCache().attach(*this);
573 m_picomodel.m_lightsChanged = LightsChangedCaller(*this);
575 Instance::setTransformChangedCallback(LightsChangedCaller(*this));
584 Instance::setTransformChangedCallback(Callback<void()>());
586 m_picomodel.m_lightsChanged = Callback<void()>();
587 GlobalShaderCache().detach(*this);
590 void render(Renderer &renderer, const VolumeTest &volume, const Matrix4 &localToWorld) const
592 SurfaceLightLists::const_iterator j = m_surfaceLightLists.begin();
593 SurfaceRemaps::const_iterator k = m_skins.begin();
594 for (PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i, ++j, ++k) {
595 if ((*i)->intersectVolume(volume, localToWorld) != c_volumeOutside) {
596 renderer.setLights(*j);
597 (*i)->render(renderer, localToWorld, (*k).second != 0 ? (*k).second : (*i)->getState());
602 void renderSolid(Renderer &renderer, const VolumeTest &volume) const
604 m_lightList->evaluateLights();
606 render(renderer, volume, Instance::localToWorld());
609 void renderWireframe(Renderer &renderer, const VolumeTest &volume) const
611 renderSolid(renderer, volume);
614 void testSelect(Selector &selector, SelectionTest &test)
616 m_picomodel.testSelect(selector, test, Instance::localToWorld());
619 bool testLight(const RendererLight &light) const
621 return light.testAABB(worldAABB());
624 void insertLight(const RendererLight &light)
626 const Matrix4 &localToWorld = Instance::localToWorld();
627 SurfaceLightLists::iterator j = m_surfaceLightLists.begin();
628 for (PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i) {
629 Surface_addLight(*(*i), *j++, localToWorld, light);
635 for (SurfaceLightLists::iterator i = m_surfaceLightLists.begin(); i != m_surfaceLightLists.end(); ++i) {
641 class PicoModelNode : public scene::Node::Symbiot, public scene::Instantiable {
643 NodeTypeCastTable m_casts;
647 NodeStaticCast<PicoModelNode, scene::Instantiable>::install(m_casts);
650 NodeTypeCastTable &get()
658 InstanceSet m_instances;
659 PicoModel m_picomodel;
662 typedef LazyStatic<TypeCasts> StaticTypeCasts;
664 PicoModelNode() : m_node(this, this, StaticTypeCasts::instance().get())
668 PicoModelNode(picoModel_t *model) : m_node(this, this, StaticTypeCasts::instance().get()), m_picomodel(model)
682 scene::Instance *create(const scene::Path &path, scene::Instance *parent)
684 return new PicoModelInstance(path, parent, m_picomodel);
687 void forEachInstance(const scene::Instantiable::Visitor &visitor)
689 m_instances.forEachInstance(visitor);
692 void insert(scene::Instantiable::Observer *observer, const scene::Path &path, scene::Instance *instance)
694 m_instances.insert(observer, path, instance);
697 scene::Instance *erase(scene::Instantiable::Observer *observer, const scene::Path &path)
699 return m_instances.erase(observer, path);
706 template<typename Key, typename Type>
710 static Type* construct( const Key& key ){
711 return new Type( key );
713 static void destroy( Type* value ){
718 template<typename Key, typename Type, typename creation_policy = create_new<Key, Type> >
719 class cache_element : public creation_policy
722 inline cache_element() : m_count( 0 ), m_value( 0 ) {}
723 inline ~cache_element(){
724 ASSERT_MESSAGE( m_count == 0, "destroyed a reference before it was released\n" );
729 inline Type* capture( const Key& key ){
730 if ( ++m_count == 1 ) {
735 inline void release(){
736 ASSERT_MESSAGE( !empty(), "failed to release reference - not found in cache\n" );
737 if ( --m_count == 0 ) {
744 inline void refresh( const Key& key ){
745 m_value->refresh( key );
748 inline void construct( const Key& key ){
749 m_value = creation_policy::construct( key );
751 inline void destroy(){
752 creation_policy::destroy( m_value );
759 class create_picomodel
761 typedef PicoModelKey key_type;
762 typedef PicoModel value_type;
764 static value_type* construct( const key_type& key ){
765 picoModel_t* picomodel = PicoLoadModel( const_cast<char*>( key.first.c_str() ), key.second );
766 value_type* value = new value_type( picomodel );
767 PicoFreeModel( picomodel );
770 static void destroy( value_type* value ){
779 typedef PicoModel value_type;
782 typedef PicoModelKey key_type;
783 typedef cache_element<key_type, value_type, create_picomodel> elem_type;
784 typedef std::map<key_type, elem_type> cache_type;
786 value_type* capture( const key_type& key ){
787 return m_cache[key].capture( key );
789 void release( const key_type& key ){
790 m_cache[key].release();
797 ModelCache g_model_cache;
801 typedef struct remap_s {
802 char m_remapbuff[64 + 1024];
812 RemapWrapper( const char* name ){
813 parse_namestr( name );
815 m_model = g_model_cache.capture( ModelCache::key_type( m_name, m_frame ) );
819 virtual ~RemapWrapper(){
820 g_model_cache.release( ModelCache::key_type( m_name, m_frame ) );
822 for ( shaders_t::iterator i = m_shaders.begin(); i != m_shaders.end(); ++i )
824 GlobalShaderCache().release( ( *i ).c_str() );
827 for ( remaps_t::iterator j = m_remaps.begin(); j != m_remaps.end(); ++j )
833 VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
834 return m_model->intersectVolume( test, localToWorld );
837 virtual const AABB& localAABB() const {
838 return m_model->localAABB();
841 void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
842 m_model->render( renderer, volume, localToWorld, m_states );
845 void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
846 m_model->testSelect( selector, test, localToWorld );
850 void add_remap( const char *remap ){
856 while ( *ch && *ch != ';' )
861 globalErrorStream() << "WARNING: Shader _remap key found in a model entity without a ; character\n";
864 pRemap = new remap_t;
866 strncpy( pRemap->m_remapbuff, remap, sizeof( pRemap->m_remapbuff ) );
868 pRemap->m_remapbuff[ch - remap] = '\0';
870 pRemap->original = pRemap->m_remapbuff;
871 pRemap->remap = pRemap->m_remapbuff + ( ch - remap ) + 1;
873 m_remaps.push_back( pRemap );
877 void parse_namestr( const char *name ){
879 bool hasName, hasFrame;
881 hasName = hasFrame = false;
885 for ( s = ptr = name; ; ++ptr )
887 if ( !hasName && ( *ptr == ':' || *ptr == '\0' ) ) {
890 m_name = CopiedString( s, ptr );
893 else if ( *ptr == '?' || *ptr == '\0' ) {
896 m_frame = atoi( CopiedString( s, ptr ).c_str() );
899 else if ( *ptr == '&' || *ptr == '\0' ) {
901 add_remap( CopiedString( s, ptr ).c_str() );
905 if ( *ptr == '\0' ) {
911 void construct_shaders(){
912 const char* global_shader = shader_for_remap( "*" );
914 m_shaders.reserve( m_model->size() );
915 m_states.reserve( m_model->size() );
916 for ( PicoModel::iterator i = m_model->begin(); i != m_model->end(); ++i )
918 const char* shader = shader_for_remap( ( *i )->getShader() );
920 ( shader[0] != '\0' )
922 : ( global_shader[0] != '\0' )
924 : ( *i )->getShader() );
925 m_states.push_back( GlobalShaderCache().capture( m_shaders.back().c_str() ) );
929 inline const char* shader_for_remap( const char* remap ){
930 for ( remaps_t::iterator i = m_remaps.begin(); i != m_remaps.end(); ++i )
932 if ( shader_equal( remap, ( *i )->original ) ) {
933 return ( *i )->remap;
943 typedef std::vector<remap_t*> remaps_t;
945 typedef std::vector<CopiedString> shaders_t;
947 typedef std::vector<Shader*> states_t;
951 class RemapWrapperInstance : public scene::Instance, public Renderable, public SelectionTestable
953 RemapWrapper& m_remapwrapper;
955 RemapWrapperInstance( const scene::Path& path, scene::Instance* parent, RemapWrapper& remapwrapper ) : Instance( path, parent ), m_remapwrapper( remapwrapper ){
956 scene::Instance::m_cullable = &m_remapwrapper;
957 scene::Instance::m_render = this;
958 scene::Instance::m_select = this;
961 void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
962 m_remapwrapper.render( renderer, volume, Instance::localToWorld() );
964 void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
965 renderSolid( renderer, volume );
968 void testSelect( Selector& selector, SelectionTest& test ){
969 m_remapwrapper.testSelect( selector, test, Instance::localToWorld() );
973 class RemapWrapperNode : public scene::Node::Symbiot, public scene::Instantiable
976 typedef RemapWrapperInstance instance_type;
977 InstanceSet m_instances;
978 RemapWrapper m_remapwrapper;
980 RemapWrapperNode( const char* name ) : m_node( this ), m_remapwrapper( name ){
981 m_node.m_instance = this;
991 scene::Instance* create( const scene::Path& path, scene::Instance* parent ){
992 return new instance_type( path, parent, m_remapwrapper );
994 void forEachInstance( const scene::Instantiable::Visitor& visitor ){
995 m_instances.forEachInstance( visitor );
997 void insert( scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance ){
998 m_instances.insert( observer, path, instance );
1000 scene::Instance* erase( scene::Instantiable::Observer* observer, const scene::Path& path ){
1001 return m_instances.erase( observer, path );
1005 scene::Node& LoadRemapModel( const char* name ){
1006 return ( new RemapWrapperNode( name ) )->node();
1012 size_t picoInputStreamReam(void *inputStream, unsigned char *buffer, size_t length)
1014 return reinterpret_cast<InputStream *>( inputStream )->read(buffer, length);
1017 scene::Node &loadPicoModel(const picoModule_t *module, ArchiveFile &file)
1019 picoModel_t *model = PicoModuleLoadModelStream(module, &file.getInputStream(), picoInputStreamReam, file.size(), 0,
1021 PicoModelNode *modelNode = new PicoModelNode(model);
1022 PicoFreeModel(model);
1023 return modelNode->node();