Mark constant data as const

[libs/gl.git] / source / render / object.cpp

diff --git a/source/render/object.cpp b/source/render/object.cpp
index dc1f4f3f1a7996bd55008732df21c0c826f27af5..479e77afa986ac124137a4726717d055af56910a 100644 (file)
--- a/source/render/object.cpp
+++ b/source/render/object.cpp
@@ -1,4 +1,5 @@
 #include <msp/datafile/collection.h>
+#include <msp/fs/utils.h>
 #include <msp/strings/format.h>
 #include "error.h"
 #include "material.h"
@@ -10,14 +11,13 @@
 #include "renderer.h"
 #include "resourcemanager.h"
 #include "technique.h"
-#include "texturing.h"
 
 using namespace std;
 
 namespace Msp {
 namespace GL {
 
-Matrix Object::identity_matrix;
+const Matrix Object::identity_matrix;
 
 Object::Object():
        lods(1),
@@ -56,12 +56,11 @@ Object::LevelOfDetail &Object::get_lod(unsigned i, const char *caller)
 
 void Object::set_mesh(unsigned i, const Mesh *m)
 {
-       RefPtr<const Mesh> &ptr = get_lod(i, "Object::set_mesh").mesh;
+       const Mesh *&ptr = get_lod(i, "Object::set_mesh").mesh;
        if(i==0 && ptr && lod0_watched)
                if(ResourceManager *rm = ptr->get_manager())
                        rm->unobserve_resource(*ptr, *this);
        ptr = m;
-       ptr.keep();
        lod0_watched = false;
 
        if(i==0 && m)
@@ -77,12 +76,12 @@ void Object::set_mesh(unsigned i, const Mesh *m)
 void Object::update_bounding_sphere()
 {
        vector<Vector3> points;
-       for(vector<LevelOfDetail>::const_iterator i=lods.begin(); i!=lods.end(); ++i)
+       for(const LevelOfDetail &l: lods)
        {
-               if(!i->mesh || !i->mesh->is_loaded())
+               if(!l.mesh || !l.mesh->is_loaded())
                        continue;
 
-               const VertexArray &vertices = i->mesh->get_vertices();
+               const VertexArray &vertices = l.mesh->get_vertices();
 
                int offset = vertices.get_format().offset(VERTEX3);
                bool three = true;
@@ -98,8 +97,8 @@ void Object::update_bounding_sphere()
                points.reserve(points.size()+n_vertices);
                for(unsigned j=0; j<n_vertices; ++j)
                {
-                       const float *v = vertices[j];
-                       points.push_back(Vector3(v[offset], v[offset+1], (three ? v[offset+2] : 0.0f)));
+                       const float *v = reinterpret_cast<const float *>(vertices[j]+offset);
+                       points.push_back(Vector3(v[0], v[1], (three ? v[2] : 0.0f)));
                }
        }
 
@@ -116,14 +115,12 @@ const Mesh *Object::get_mesh(unsigned i) const
        if(i>=lods.size())
                return 0;
 
-       return lods[i].mesh.get();
+       return lods[i].mesh;
 }
 
 void Object::set_technique(unsigned i, const Technique *t)
 {
-       RefPtr<const Technique> &ptr = get_lod(i, "Object::set_technique").technique;
-       ptr = t;
-       ptr.keep();
+       get_lod(i, "Object::set_technique").technique = t;
 }
 
 const Technique *Object::get_technique(unsigned i) const
@@ -131,16 +128,16 @@ const Technique *Object::get_technique(unsigned i) const
        if(i>=lods.size())
                return 0;
 
-       return lods[i].technique.get();
+       return lods[i].technique;
 }
 
-void Object::render(Renderer &renderer, const Tag &tag) const
+void Object::render(Renderer &renderer, Tag tag) const
 {
        const RenderPass *pass = get_pass(tag, 0);
        if(!pass)
                return;
 
-       const Mesh *mesh = lods.front().mesh.get();
+       const Mesh *mesh = lods.front().mesh;
        if (!mesh)
                throw logic_error("no mesh");
 
@@ -152,14 +149,14 @@ void Object::render(Renderer &renderer, const Tag &tag) const
        finish_render(renderer, tag);
 }
 
-void Object::render(Renderer &renderer, const ObjectInstance &inst, const Tag &tag) const
+void Object::render(Renderer &renderer, const ObjectInstance &inst, Tag tag) const
 {
        unsigned lod = min<unsigned>(inst.get_level_of_detail(renderer), lods.size()-1);
        const RenderPass *pass = get_pass(tag, lod);
        if(!pass)
                return;
 
-       const Mesh *mesh = lods[lod].mesh.get();
+       const Mesh *mesh = lods[lod].mesh;
        if (!mesh)
                throw logic_error("no mesh");
 
@@ -173,9 +170,9 @@ void Object::render(Renderer &renderer, const ObjectInstance &inst, const Tag &t
        finish_render(renderer, tag);
 }
 
-const RenderPass *Object::get_pass(const Tag &tag, unsigned lod) const
+const RenderPass *Object::get_pass(Tag tag, unsigned lod) const
 {
-       const Technique *tech = lods[lod].technique.get();
+       const Technique *tech = lods[lod].technique;
        if(!tech)
                throw logic_error("no technique");
        return tech->find_pass(tag);
@@ -183,13 +180,13 @@ const RenderPass *Object::get_pass(const Tag &tag, unsigned lod) const
 
 void Object::resource_loaded(Resource &res)
 {
-       if(&res==lods.front().mesh.get() && bounding_sphere.is_empty())
+       if(&res==lods.front().mesh && bounding_sphere.is_empty())
                update_bounding_sphere();
 }
 
 void Object::resource_removed(Resource &res)
 {
-       if(&res==lods.front().mesh.get())
+       if(&res==lods.front().mesh)
                lod0_watched = false;
 }
 
@@ -249,10 +246,11 @@ void Object::LodLoader::mesh_inline()
 {
        RefPtr<Mesh> msh = new Mesh;
        load_sub(*msh);
-       lod.mesh = msh;
+       get_collection().add(format("%s/lod%d.mesh", FS::basename(get_source()), index), msh.get());
+       lod.mesh = msh.release();
 }
 
-void Object::LodLoader::technique(const std::string &n)
+void Object::LodLoader::technique(const string &n)
 {
        obj.set_technique(index, &get_collection().get<Technique>(n));
 }
@@ -260,11 +258,12 @@ void Object::LodLoader::technique(const std::string &n)
 void Object::LodLoader::technique_inline()
 {
        RefPtr<Technique> tech = new Technique;
-       if(coll)
-               load_sub(*tech, get_collection());
-       else
-               load_sub(*tech);
-       lod.technique = tech;
+       Technique::Loader ldr(*tech, get_collection());
+       string name = format("%s/lod%d.tech", FS::basename(get_source()), index);
+       ldr.set_inline_base_name(name);
+       load_sub(*tech, get_collection());
+       get_collection().add(name, tech.get());
+       lod.technique = tech.release();
 }
 
 } // namespace GL