]> git.tdb.fi Git - libs/gl.git/blob - source/instancearray.cpp
Ensure that mapped memory is unmapped in Texture2D::AsyncLoader
[libs/gl.git] / source / instancearray.cpp
1 #include <msp/core/algorithm.h>
2 #include <msp/core/maputils.h>
3 #include <msp/gl/extensions/arb_draw_instanced.h>
4 #include <msp/gl/extensions/arb_instanced_arrays.h>
5 #include <msp/gl/extensions/arb_vertex_array_object.h>
6 #include <msp/gl/extensions/arb_vertex_shader.h>
7 #include "buffer.h"
8 #include "camera.h"
9 #include "instancearray.h"
10 #include "mesh.h"
11 #include "object.h"
12 #include "objectinstance.h"
13 #include "renderer.h"
14 #include "technique.h"
15 #include "vertexsetup.h"
16
17 using namespace std;
18
19 namespace Msp {
20 namespace GL {
21
22 InstanceArray::InstanceArray(const Object &o):
23         object(o),
24         instance_data(0),
25         instance_buffer(0),
26         vtx_setup(0),
27         matrix_location(-1),
28         matrix_offset(0)
29 {
30         const Technique *tech = object.get_technique();
31         const Technique::PassMap &passes = tech->get_passes();
32         for(Technique::PassMap::const_iterator i=passes.begin(); i!=passes.end(); ++i)
33         {
34                 const Program *shprog = i->second.get_shader_program();
35                 if(!shprog)
36                         throw invalid_argument("InstanceArray::InstanceArray");
37
38                 int loc = shprog->get_attribute_location("instance_transform");
39                 if(matrix_location<0)
40                         matrix_location = loc;
41                 else if(loc!=matrix_location)
42                         throw invalid_argument("InstanceArray::InstanceArray");
43         }
44
45         if(ARB_vertex_array_object && ARB_instanced_arrays && ARB_draw_instanced)
46         {
47                 instance_data = new VertexArray((ATTRIB4,matrix_location, ATTRIB4,matrix_location+1, ATTRIB4,matrix_location+2));
48                 const VertexFormat &fmt = instance_data->get_format();
49                 matrix_offset = fmt.offset(make_indexed_component(ATTRIB4, matrix_location));
50
51                 instance_buffer = new Buffer(ARRAY_BUFFER);
52                 instance_data->use_buffer(instance_buffer);
53
54                 vtx_setup = new VertexSetup;
55                 vtx_setup->set_vertex_array(object.get_mesh()->get_vertices());
56                 vtx_setup->set_index_buffer(*object.get_mesh()->get_index_buffer());
57                 vtx_setup->set_instance_array(instance_data);
58         }
59         else
60                 static Require req(ARB_vertex_shader);
61 }
62
63 InstanceArray::~InstanceArray()
64 {
65         for(std::vector<ObjectInstance *>::iterator i=instances.begin(); i!=instances.end(); ++i)
66                 delete *i;
67         delete vtx_setup;
68         delete instance_data;
69         delete instance_buffer;
70 }
71
72 void InstanceArray::append(ObjectInstance *inst)
73 {
74         instances.push_back(inst);
75         if(instance_data)
76         {
77                 if(instance_data->size()<instances.size())
78                 {
79                         instance_data->append();
80                         unsigned req_size = instance_data->get_required_buffer_size();
81                         if(instance_buffer->get_size()>0 && instance_buffer->get_size()<req_size)
82                         {
83                                 delete instance_buffer;
84                                 instance_buffer = new Buffer(ARRAY_BUFFER);
85                                 instance_data->use_buffer(instance_buffer);
86                         }
87                 }
88                 update_instance_matrix(instances.size()-1);
89         }
90 }
91
92 void InstanceArray::remove(ObjectInstance &inst)
93 {
94         vector<ObjectInstance *>::iterator i = find(instances, &inst);
95         if(i==instances.end())
96                 throw key_error(&inst);
97
98         delete *i;
99         *i = instances.back();
100         instances.pop_back();
101 }
102
103 void InstanceArray::update_instance_matrix(unsigned index)
104 {
105         if(!instance_data)
106                 return;
107
108         const Matrix &m = *instances[index]->get_matrix();
109
110         float *d = instance_data->modify(instances.size()-1);
111         for(unsigned i=0; i<12; ++i)
112                 d[matrix_offset+i] = m(i/4, i%4);
113 }
114
115 void InstanceArray::render(Renderer &renderer, const Tag &tag) const
116 {
117         if(instances.empty())
118                 return;
119
120         if(instance_data)
121         {
122                 const Technique *tech = object.get_technique();
123                 if(!tech)
124                         throw logic_error("no technique");
125                 const RenderPass *pass = tech->find_pass(tag);
126                 if(!pass)
127                         return;
128
129                 const Mesh *mesh = object.get_mesh();
130                 mesh->get_vertices().refresh();
131                 if(instance_buffer->get_size()==0)
132                         instance_buffer->storage(instance_data->get_required_buffer_size());
133                 instance_data->refresh();
134
135                 Renderer::Push push(renderer);
136                 pass->apply(renderer);
137                 mesh->draw_instanced(renderer, *vtx_setup, instances.size());
138         }
139         else
140         {
141                 for(vector<ObjectInstance *>::const_iterator i=instances.begin(); i!=instances.end(); ++i)
142                 {
143                         const Matrix &m = *(*i)->get_matrix();
144                         for(unsigned j=0; j<3; ++j)
145                                 glVertexAttrib4f(matrix_location+j, m(j, 0), m(j, 1), m(j, 2), m(j, 3));
146                         (*i)->render(renderer, tag);
147                 }
148         }
149 }
150
151 } // namespace GL
152 } // namespace Msp