radiant/nullmodel.cpp

   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 #include "nullmodel.h"
  23
  24 #include "debugging/debugging.h"
  25
  26 #include "iscenegraph.h"
  27 #include "irender.h"
  28 #include "iselection.h"
  29 #include "iundo.h"
  30 #include "ientity.h"
  31 #include "ireference.h"
  32 #include "igl.h"
  33 #include "cullable.h"
  34 #include "renderable.h"
  35 #include "selectable.h"
  36
  37 #include "math/frustum.h"
  38 #include "scenelib.h"
  39 #include "instancelib.h"
  40 #include "entitylib.h"
  41
  42 class NullModel :
  43 public Bounded,
  44 public Cullable
  45 {
  46   Shader* m_state;
  47   AABB m_aabb_local;
  48   RenderableSolidAABB m_aabb_solid;
  49   RenderableWireframeAABB m_aabb_wire;
  50 public:
  51   NullModel() : m_aabb_local(Vector3(0, 0, 0), Vector3(8, 8, 8)), m_aabb_solid(m_aabb_local), m_aabb_wire(m_aabb_local)
  52   {
  53     m_state = GlobalShaderCache().capture("");
  54   }
  55   ~NullModel()
  56   {
  57     GlobalShaderCache().release("");
  58   }
  59
  60   VolumeIntersectionValue intersectVolume(const VolumeTest& volume, const Matrix4& localToWorld) const
  61   {
  62     return volume.TestAABB(m_aabb_local, localToWorld);
  63   }
  64
  65   const AABB& localAABB() const
  66   {
  67     return m_aabb_local;
  68   }
  69
  70   void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
  71   {
  72     renderer.SetState(m_state, Renderer::eFullMaterials);
  73     renderer.addRenderable(m_aabb_solid, localToWorld);
  74   }
  75   void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
  76   {
  77     renderer.addRenderable(m_aabb_wire, localToWorld);
  78   }
  79
  80   void testSelect(Selector& selector, SelectionTest& test, const Matrix4& localToWorld)
  81   {
  82     test.BeginMesh(localToWorld);
  83
  84     SelectionIntersection best;
  85     aabb_testselect(m_aabb_local, test, best);
  86     if(best.valid())
  87     {
  88       selector.addIntersection(best);
  89     }
  90   }
  91 };
  92
  93 class NullModelInstance : public scene::Instance, public Renderable, public SelectionTestable
  94 {
  95   class TypeCasts
  96   {
  97     InstanceTypeCastTable m_casts;
  98   public:
  99     TypeCasts()
 100     {
 101       InstanceContainedCast<NullModelInstance, Bounded>::install(m_casts);
 102       InstanceContainedCast<NullModelInstance, Cullable>::install(m_casts);
 103       InstanceStaticCast<NullModelInstance, Renderable>::install(m_casts);
 104       InstanceStaticCast<NullModelInstance, SelectionTestable>::install(m_casts);
 105     }
 106     InstanceTypeCastTable& get()
 107     {
 108       return m_casts;
 109     }
 110   };
 111
 112   NullModel& m_nullmodel;
 113 public:
 114
 115   typedef LazyStatic<TypeCasts> StaticTypeCasts;
 116
 117   Bounded& get(NullType<Bounded>)
 118   {
 119     return m_nullmodel;
 120   }
 121   Cullable& get(NullType<Cullable>)
 122   {
 123     return m_nullmodel;
 124   }
 125
 126   NullModelInstance(const scene::Path& path, scene::Instance* parent, NullModel& nullmodel) :
 127     Instance(path, parent, this, StaticTypeCasts::instance().get()),
 128     m_nullmodel(nullmodel)
 129   {
 130   }
 131
 132   void renderSolid(Renderer& renderer, const VolumeTest& volume) const
 133   {
 134     m_nullmodel.renderSolid(renderer, volume, Instance::localToWorld());
 135   }
 136   void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
 137   {
 138     m_nullmodel.renderWireframe(renderer, volume, Instance::localToWorld());
 139   }
 140
 141   void testSelect(Selector& selector, SelectionTest& test)
 142   {
 143     m_nullmodel.testSelect(selector, test, Instance::localToWorld());
 144   }
 145 };
 146
 147 class NullModelNode : public scene::Node::Symbiot, public scene::Instantiable
 148 {
 149   class TypeCasts
 150   {
 151     NodeTypeCastTable m_casts;
 152   public:
 153     TypeCasts()
 154     {
 155       NodeStaticCast<NullModelNode, scene::Instantiable>::install(m_casts);
 156     }
 157     NodeTypeCastTable& get()
 158     {
 159       return m_casts;
 160     }
 161   };
 162
 163
 164   scene::Node m_node;
 165   InstanceSet m_instances;
 166   NullModel m_nullmodel;
 167 public:
 168
 169   typedef LazyStatic<TypeCasts> StaticTypeCasts;
 170
 171   NullModelNode() : m_node(this, this, StaticTypeCasts::instance().get())
 172   {
 173     m_node.m_isRoot = true;
 174   }
 175
 176   void release()
 177   {
 178     delete this;
 179   }
 180   scene::Node& node()
 181   {
 182     return m_node;
 183   }
 184
 185   scene::Instance* create(const scene::Path& path, scene::Instance* parent)
 186   {
 187     return new NullModelInstance(path, parent, m_nullmodel);
 188   }
 189   void forEachInstance(const scene::Instantiable::Visitor& visitor)
 190   {
 191     m_instances.forEachInstance(visitor);
 192   }
 193   void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
 194   {
 195     m_instances.insert(observer, path, instance);
 196   }
 197   scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path)
 198   {
 199     return m_instances.erase(observer, path);
 200   }
 201 };
 202
 203 NodeSmartReference NewNullModel()
 204 {
 205   return NodeSmartReference((new NullModelNode)->node());
 206 }
 207
 208 void NullModel_construct()
 209 {
 210 }
 211 void NullModel_destroy()
 212 {
 213 }
 214