- Disabled useless "deprecated" warnings when using stdc functions
[xonotic/netradiant.git] / plugins / md3model / model.h
1 /*
2 Copyright (C) 2001-2006, William Joseph.
3 All Rights Reserved.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 #if !defined(INCLUDED_MODEL_H)
23 #define INCLUDED_MODEL_H
24
25 #include "cullable.h"
26 #include "renderable.h"
27 #include "selectable.h"
28 #include "modelskin.h"
29
30 #include "math/frustum.h"
31 #include "string/string.h"
32 #include "generic/static.h"
33 #include "stream/stringstream.h"
34 #include "os/path.h"
35 #include "scenelib.h"
36 #include "instancelib.h"
37 #include "transformlib.h"
38 #include "traverselib.h"
39 #include "render.h"
40
41 class VectorLightList : public LightList
42 {
43   typedef std::vector<const RendererLight*> Lights;
44   Lights m_lights;
45 public:
46   void addLight(const RendererLight& light)
47   {
48     m_lights.push_back(&light);
49   }
50   void clear()
51   {
52     m_lights.clear();
53   }
54   void evaluateLights() const
55   {
56   }
57   void lightsChanged() const
58   {
59   }
60   void forEachLight(const RendererLightCallback& callback) const
61   {
62     for(Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i)
63     {
64       callback(*(*i));
65     }
66   }
67 };
68
69 inline VertexPointer vertexpointer_arbitrarymeshvertex(const ArbitraryMeshVertex* array)
70 {
71   return VertexPointer(VertexPointer::pointer(&array->vertex), sizeof(ArbitraryMeshVertex));
72 }
73
74 inline void parseTextureName(CopiedString& name, const char* token)
75 {
76   StringOutputStream cleaned(256);
77   cleaned << PathCleaned(token);
78   name = StringRange(cleaned.c_str(), path_get_filename_base_end(cleaned.c_str())); // remove extension
79 }
80
81 // generic renderable triangle surface
82 class Surface : 
83 public OpenGLRenderable
84 {
85 public:
86   typedef VertexBuffer<ArbitraryMeshVertex> vertices_t;
87   typedef IndexBuffer indices_t;
88 private:
89
90   AABB m_aabb_local;
91   CopiedString m_shader;
92   Shader* m_state;
93
94   vertices_t m_vertices;
95   indices_t m_indices;
96
97   void CaptureShader()
98   {
99     m_state = GlobalShaderCache().capture(m_shader.c_str());
100   }
101   void ReleaseShader()
102   {
103     GlobalShaderCache().release(m_shader.c_str());
104   }
105
106 public:
107
108   Surface()
109     : m_shader(""), m_state(0)
110   {
111     CaptureShader();
112   }
113   ~Surface()
114   {
115     ReleaseShader();
116   }
117
118   vertices_t& vertices()
119   {
120     return m_vertices;
121   }
122   indices_t& indices()
123   {
124     return m_indices;
125   }
126
127   void setShader(const char* name)
128   {
129     ReleaseShader();
130     parseTextureName(m_shader, name);
131     CaptureShader();
132   }
133   const char* getShader() const
134   {
135     return m_shader.c_str();
136   }
137   Shader* getState() const
138   {
139     return m_state;
140   }
141   void updateAABB()
142   {
143     m_aabb_local = AABB();
144     for(vertices_t::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i)
145       aabb_extend_by_point_safe(m_aabb_local, reinterpret_cast<const Vector3&>((*i).vertex));
146
147
148
149     for(Surface::indices_t::iterator i = m_indices.begin(); i != m_indices.end(); i += 3)
150     {
151                         ArbitraryMeshVertex& a = m_vertices[*(i + 0)];
152                         ArbitraryMeshVertex& b = m_vertices[*(i + 1)];
153                         ArbitraryMeshVertex& c = m_vertices[*(i + 2)];
154
155       ArbitraryMeshTriangle_sumTangents(a, b, c);
156     }
157
158     for(Surface::vertices_t::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i)
159     {
160       vector3_normalise(reinterpret_cast<Vector3&>((*i).tangent));
161       vector3_normalise(reinterpret_cast<Vector3&>((*i).bitangent));
162     }
163   }
164
165   void render(RenderStateFlags state) const
166   {
167 #if 1
168     if((state & RENDER_BUMP) != 0)
169     {
170       if(GlobalShaderCache().useShaderLanguage())
171       {
172         glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
173         glVertexAttribPointerARB(c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
174         glVertexAttribPointerARB(c_attr_Tangent, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->tangent);
175         glVertexAttribPointerARB(c_attr_Binormal, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->bitangent);
176       }
177       else
178       {
179         glVertexAttribPointerARB(11, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
180         glVertexAttribPointerARB(8, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
181         glVertexAttribPointerARB(9, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->tangent);
182         glVertexAttribPointerARB(10, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->bitangent);
183       }
184     }
185     else
186     {
187       glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
188       glTexCoordPointer(2, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
189     }
190     glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->vertex);
191     glDrawElements(GL_TRIANGLES, GLsizei(m_indices.size()), RenderIndexTypeID, m_indices.data());
192 #else
193     glBegin(GL_TRIANGLES);
194     for(unsigned int i = 0; i < m_indices.size(); ++i)
195     {
196       glTexCoord2fv(&m_vertices[m_indices[i]].texcoord.s);
197       glNormal3fv(&m_vertices[m_indices[i]].normal.x);
198       glVertex3fv(&m_vertices[m_indices[i]].vertex.x);
199     }
200     glEnd();
201 #endif
202
203 #if defined(_DEBUG)
204     glBegin(GL_LINES);
205
206     for(VertexBuffer<ArbitraryMeshVertex>::const_iterator i = m_vertices.begin(); i != m_vertices.end(); ++i)
207     {
208       Vector3 normal = vector3_added(vertex3f_to_vector3((*i).vertex), vector3_scaled(normal3f_to_vector3((*i).normal), 8));
209       glVertex3fv(vertex3f_to_array((*i).vertex));
210       glVertex3fv(vector3_to_array(normal));
211     }
212     glEnd();
213 #endif
214   }
215
216   VolumeIntersectionValue intersectVolume(const VolumeTest& test, const Matrix4& localToWorld) const
217   {
218     return test.TestAABB(m_aabb_local, localToWorld);
219   }
220
221   const AABB& localAABB() const
222   {
223     return m_aabb_local;
224   }
225
226   void render(Renderer& renderer, const Matrix4& localToWorld, Shader* state) const
227   {
228     renderer.SetState(state, Renderer::eFullMaterials);
229     renderer.addRenderable(*this, localToWorld);
230   }
231
232   void render(Renderer& renderer, const Matrix4& localToWorld) const
233   {
234     render(renderer, localToWorld, m_state);
235   }
236
237   void testSelect(Selector& selector, SelectionTest& test, const Matrix4& localToWorld)
238   {
239     test.BeginMesh(localToWorld);
240
241     SelectionIntersection best;
242     test.TestTriangles(
243       vertexpointer_arbitrarymeshvertex(m_vertices.data()),
244       IndexPointer(m_indices.data(), IndexPointer::index_type(m_indices.size())),
245       best
246     );
247     if(best.valid())
248     {
249       selector.addIntersection(best);
250     }
251   }
252 };
253
254 // generic model node
255 class Model :
256 public Cullable,
257 public Bounded
258 {
259   typedef std::vector<Surface*> surfaces_t;
260   surfaces_t m_surfaces;
261
262   AABB m_aabb_local;
263 public:
264   Callback m_lightsChanged;
265
266   ~Model()
267   {
268     for(surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i)
269     {
270       delete *i;
271     }
272   }
273
274   typedef surfaces_t::const_iterator const_iterator;
275
276   const_iterator begin() const
277   {
278     return m_surfaces.begin();
279   }
280   const_iterator end() const
281   {
282     return m_surfaces.end();
283   }
284   std::size_t size() const
285   {
286     return m_surfaces.size();
287   }
288
289   Surface& newSurface()
290   {
291     m_surfaces.push_back(new Surface);
292     return *m_surfaces.back();
293   }
294   void updateAABB()
295   {
296     m_aabb_local = AABB();
297     for(surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i)
298     {
299       aabb_extend_by_aabb_safe(m_aabb_local, (*i)->localAABB());
300     }
301   }
302
303   VolumeIntersectionValue intersectVolume(const VolumeTest& test, const Matrix4& localToWorld) const
304   {
305     return test.TestAABB(m_aabb_local, localToWorld);
306   }
307
308   virtual const AABB& localAABB() const
309   {
310     return m_aabb_local;
311   }
312
313   void testSelect(Selector& selector, SelectionTest& test, const Matrix4& localToWorld)
314   {
315     for(surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i)
316     {
317       if((*i)->intersectVolume(test.getVolume(), localToWorld) != c_volumeOutside)
318       {
319         (*i)->testSelect(selector, test, localToWorld);
320       }
321     }
322   }
323 };
324
325 inline void Surface_addLight(const Surface& surface, VectorLightList& lights, const Matrix4& localToWorld, const RendererLight& light)
326 {
327   if(light.testAABB(aabb_for_oriented_aabb(surface.localAABB(), localToWorld)))
328   {
329     lights.addLight(light);
330   }
331 }
332
333 class ModelInstance :
334   public scene::Instance,
335   public Renderable,
336   public SelectionTestable,
337   public LightCullable,
338   public SkinnedModel
339 {
340   class TypeCasts
341   {
342     InstanceTypeCastTable m_casts;
343   public:
344     TypeCasts()
345     {
346       InstanceContainedCast<ModelInstance, Bounded>::install(m_casts);
347       InstanceContainedCast<ModelInstance, Cullable>::install(m_casts);
348       InstanceStaticCast<ModelInstance, Renderable>::install(m_casts);
349       InstanceStaticCast<ModelInstance, SelectionTestable>::install(m_casts);
350       InstanceStaticCast<ModelInstance, SkinnedModel>::install(m_casts);
351     }
352     InstanceTypeCastTable& get()
353     {
354       return m_casts;
355     }
356   };
357
358   Model& m_model;
359
360   const LightList* m_lightList;
361   typedef Array<VectorLightList> SurfaceLightLists;
362   SurfaceLightLists m_surfaceLightLists;
363
364   class Remap
365   {
366   public:
367     CopiedString first;
368     Shader* second;
369     Remap() : second(0)
370     {
371     }
372   };
373   typedef Array<Remap> SurfaceRemaps;
374   SurfaceRemaps m_skins;
375 public:
376
377   typedef LazyStatic<TypeCasts> StaticTypeCasts;
378
379   Bounded& get(NullType<Bounded>)
380   {
381     return m_model;
382   }
383   Cullable& get(NullType<Cullable>)
384   {
385     return m_model;
386   }
387
388   void lightsChanged()
389   {
390     m_lightList->lightsChanged();
391   }
392   typedef MemberCaller<ModelInstance, &ModelInstance::lightsChanged> LightsChangedCaller;
393
394   void constructRemaps()
395   {
396     ModelSkin* skin = NodeTypeCast<ModelSkin>::cast(path().parent());
397     if(skin != 0 && skin->realised())
398     {
399       SurfaceRemaps::iterator j = m_skins.begin();
400       for(Model::const_iterator i = m_model.begin(); i != m_model.end(); ++i, ++j)
401       {
402         const char* remap = skin->getRemap((*i)->getShader());
403         if(!string_empty(remap))
404         {
405           (*j).first = remap;
406           (*j).second = GlobalShaderCache().capture(remap);
407         }
408         else
409         {
410           (*j).second = 0;
411         }
412       }
413       SceneChangeNotify();
414     }
415   }
416   void destroyRemaps()
417   {
418     for(SurfaceRemaps::iterator i = m_skins.begin(); i != m_skins.end(); ++i)
419     {
420       if((*i).second != 0)
421       {
422         GlobalShaderCache().release((*i).first.c_str());
423         (*i).second = 0;
424       }
425     }
426   }
427   void skinChanged()
428   {
429     ASSERT_MESSAGE(m_skins.size() == m_model.size(), "ERROR");
430     destroyRemaps();
431     constructRemaps();
432   }
433
434   ModelInstance(const scene::Path& path, scene::Instance* parent, Model& model) :
435     Instance(path, parent, this, StaticTypeCasts::instance().get()), 
436     m_model(model),
437     m_surfaceLightLists(m_model.size()),
438     m_skins(m_model.size())
439   {
440     m_lightList = &GlobalShaderCache().attach(*this);
441     m_model.m_lightsChanged = LightsChangedCaller(*this);
442
443     Instance::setTransformChangedCallback(LightsChangedCaller(*this));
444
445     constructRemaps();
446   }
447   ~ModelInstance()
448   {
449     destroyRemaps();
450
451     Instance::setTransformChangedCallback(Callback());
452
453     m_model.m_lightsChanged = Callback();
454     GlobalShaderCache().detach(*this);
455   }
456
457   void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
458   {
459     SurfaceLightLists::const_iterator j = m_surfaceLightLists.begin();
460     SurfaceRemaps::const_iterator k = m_skins.begin();
461     for(Model::const_iterator i = m_model.begin(); i != m_model.end(); ++i, ++j, ++k)
462     {
463       if((*i)->intersectVolume(volume, localToWorld) != c_volumeOutside)
464       {
465         renderer.setLights(*j);
466         (*i)->render(renderer, localToWorld, (*k).second != 0 ? (*k).second : (*i)->getState());
467       }
468     }
469   }
470
471   void renderSolid(Renderer& renderer, const VolumeTest& volume) const
472   {
473     m_lightList->evaluateLights();
474
475     render(renderer, volume, Instance::localToWorld());
476   }
477   void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
478   {
479     renderSolid(renderer, volume);
480   }
481
482   void testSelect(Selector& selector, SelectionTest& test)
483   {
484     m_model.testSelect(selector, test, Instance::localToWorld());
485   }
486
487   bool testLight(const RendererLight& light) const
488   {
489     return light.testAABB(worldAABB());
490   }
491   void insertLight(const RendererLight& light)
492   {
493     const Matrix4& localToWorld = Instance::localToWorld();
494     SurfaceLightLists::iterator j = m_surfaceLightLists.begin();
495     for(Model::const_iterator i = m_model.begin(); i != m_model.end(); ++i)
496     {
497       Surface_addLight(*(*i), *j++, localToWorld, light);
498     }
499   }
500   void clearLights()
501   {
502     for(SurfaceLightLists::iterator i = m_surfaceLightLists.begin(); i != m_surfaceLightLists.end(); ++i)
503     {
504       (*i).clear();
505     }
506   }
507 };
508
509 class ModelNode : public scene::Node::Symbiot, public scene::Instantiable
510 {
511   class TypeCasts
512   {
513     NodeTypeCastTable m_casts;
514   public:
515     TypeCasts()
516     {
517       NodeStaticCast<ModelNode, scene::Instantiable>::install(m_casts);
518     }
519     NodeTypeCastTable& get()
520     {
521       return m_casts;
522     }
523   };
524
525
526   scene::Node m_node;
527   InstanceSet m_instances;
528   Model m_model;
529 public:
530
531   typedef LazyStatic<TypeCasts> StaticTypeCasts;
532
533   ModelNode() : m_node(this, this, StaticTypeCasts::instance().get())
534   {
535   }
536
537   Model& model()
538   {
539     return m_model;
540   }
541
542   void release()
543   {
544     delete this;
545   }
546   scene::Node& node()
547   {
548     return m_node;
549   }
550
551   scene::Instance* create(const scene::Path& path, scene::Instance* parent)
552   {
553     return new ModelInstance(path, parent, m_model);
554   }
555   void forEachInstance(const scene::Instantiable::Visitor& visitor)
556   {
557     m_instances.forEachInstance(visitor);
558   }
559   void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
560   {
561     m_instances.insert(observer, path, instance);
562   }
563   scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path)
564   {
565     return m_instances.erase(observer, path);
566   }
567 };
568
569
570 inline void Surface_constructQuad(Surface& surface, const Vector3& a, const Vector3& b, const Vector3& c, const Vector3& d, const Vector3& normal)
571 {
572   surface.vertices().push_back(
573     ArbitraryMeshVertex(
574       vertex3f_for_vector3(a),
575       normal3f_for_vector3(normal),
576       texcoord2f_from_array(aabb_texcoord_topleft)
577     )
578   );
579   surface.vertices().push_back(
580     ArbitraryMeshVertex(
581       vertex3f_for_vector3(b),
582       normal3f_for_vector3(normal),
583       texcoord2f_from_array(aabb_texcoord_topright)
584     )
585   );
586   surface.vertices().push_back(
587     ArbitraryMeshVertex(
588       vertex3f_for_vector3(c),
589       normal3f_for_vector3(normal),
590       texcoord2f_from_array(aabb_texcoord_botright)
591     )
592   );
593   surface.vertices().push_back(
594     ArbitraryMeshVertex(
595       vertex3f_for_vector3(d),
596       normal3f_for_vector3(normal),
597       texcoord2f_from_array(aabb_texcoord_botleft)
598     )
599   );
600 }
601
602 inline void Model_constructNull(Model& model)
603 {
604   Surface& surface = model.newSurface();
605
606   AABB aabb(Vector3(0, 0, 0), Vector3(8, 8, 8));
607
608   Vector3 points[8];
609         aabb_corners(aabb, points);
610
611   surface.vertices().reserve(24);
612
613   Surface_constructQuad(surface, points[2], points[1], points[5], points[6], aabb_normals[0]);
614   Surface_constructQuad(surface, points[1], points[0], points[4], points[5], aabb_normals[1]);
615   Surface_constructQuad(surface, points[0], points[1], points[2], points[3], aabb_normals[2]);
616   Surface_constructQuad(surface, points[0], points[3], points[7], points[4], aabb_normals[3]);
617   Surface_constructQuad(surface, points[3], points[2], points[6], points[7], aabb_normals[4]);
618   Surface_constructQuad(surface, points[7], points[6], points[5], points[4], aabb_normals[5]);
619
620   surface.indices().reserve(36);
621
622   RenderIndex indices[36] = {
623      0,  1,  2,  0,  2,  3,
624      4,  5,  6,  4,  6,  7,
625      8,  9, 10,  8, 10, 11,
626     12, 13, 14, 12, 14, 15,
627     16, 17, 18, 16, 18, 19,
628     20, 21, 22, 10, 22, 23,
629   };
630
631   for(RenderIndex* i = indices; i != indices+(sizeof(indices)/sizeof(RenderIndex)); ++i)
632   {
633     surface.indices().insert(*i);
634   }
635
636   surface.setShader("");
637
638   surface.updateAABB();
639
640   model.updateAABB();
641 }
642
643 #endif