/*
-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