2 * @file objectrenderer.cpp
3 * @brief Implements ObjectRenderer and derived classes
6 #include "objectrenderer.h"
15 * ObjectRenderer constructor
16 * Note the ShaderProgram constructor which compiles the shaders for GPU rendering (if they exist)
18 ObjectRenderer::ObjectRenderer(const ObjectType & type,
19 const char * vert_glsl_file, const char * frag_glsl_file, const char * geom_glsl_file)
20 : m_type(type), m_shader_program(), m_indexes(), m_buffer_builder(NULL)
22 m_shader_program.InitialiseShaders(vert_glsl_file, frag_glsl_file, geom_glsl_file);
23 m_shader_program.Use();
24 glUniform4f(m_shader_program.GetUniformLocation("colour"), 0,0,0,1); //TODO: Allow different colours
30 void ObjectRenderer::RenderUsingGPU()
32 if (!m_shader_program.Valid())
33 Warn("Shader is invalid (objects are of type %d)", m_type);
34 m_shader_program.Use();
36 glDrawElements(GL_LINES, m_indexes.size()*2, GL_UNSIGNED_INT, 0);
40 * Helper structuretransforms coordinates to pixels
43 ObjectRenderer::CPURenderBounds::CPURenderBounds(const Rect & bounds, const View & view, const CPURenderTarget & target)
45 Rect view_bounds = view.TransformToViewCoords(bounds);
46 x = view_bounds.x * Real(target.w);
47 y = view_bounds.y * Real(target.h);
48 w = view_bounds.w * Real(target.w);
49 h = view_bounds.h * Real(target.h);
50 //Debug("CPURenderBounds %s -> %s -> {%li,%li,%li,%li}", bounds.Str().c_str(), view_bounds.Str().c_str(), x, y, w, h);
54 * Default implementation for rendering using CPU
56 void ObjectRenderer::RenderUsingCPU(const Objects & objects, const View & view, const CPURenderTarget & target)
58 Error("Cannot render objects of type %d on CPU", m_type);
62 * Prepare index buffers for both CPU and GPU rendering to receive indexes (but don't add any yet!)
64 void ObjectRenderer::PrepareBuffers(unsigned max_objects)
66 if (m_buffer_builder != NULL) // We already have a BufferBuilder
68 Fatal("Has been called before, without FinaliseBuffers being called since!");
70 // Empty and reserve the indexes vector (for CPU rendering)
72 m_indexes.reserve(max_objects); //TODO: Can probably make this smaller? Or leave it out? Do we care?
74 // Initialise and resize the ibo (for GPU rendering)
76 m_ibo.SetUsage(GraphicsBuffer::BufferUsageStaticDraw);
77 m_ibo.SetType(GraphicsBuffer::BufferTypeIndex);
78 m_ibo.Resize(max_objects * 2 * sizeof(uint32_t));
79 // BufferBuilder is used to construct the ibo
80 m_buffer_builder = new BufferBuilder<uint32_t>(m_ibo.Map(false, true, true), m_ibo.GetSize()); // new matches delete in ObjectRenderer::FinaliseBuffers
85 * Add object index to the buffers for CPU and GPU rendering
87 void ObjectRenderer::AddObjectToBuffers(unsigned index)
89 if (m_buffer_builder == NULL) // No BufferBuilder!
91 Fatal("Called without calling PrepareBuffers");
93 m_buffer_builder->Add(2*index); // ibo for GPU rendering
94 m_buffer_builder->Add(2*index+1);
95 m_indexes.push_back(index); // std::vector of indices for CPU rendering
99 * Finalise the index buffers for CPU and GPU rendering
101 void ObjectRenderer::FinaliseBuffers()
103 if (m_buffer_builder == NULL) // No BufferBuilder!
105 Fatal("Called without calling PrepareBuffers");
107 // For GPU rendering, UnMap the ibo
109 // ... and delete the BufferBuilder used to create it
110 delete m_buffer_builder; // delete matches new in ObjectRenderer::PrepareBuffers
111 m_buffer_builder = NULL;
113 // Nothing is necessary for CPU rendering
120 void RectFilledRenderer::RenderUsingCPU(const Objects & objects, const View & view, const CPURenderTarget & target)
122 for (unsigned i = 0; i < m_indexes.size(); ++i)
124 CPURenderBounds bounds(objects.bounds[m_indexes[i]], view, target);
125 for (int64_t x = max(0L, bounds.x); x <= min(bounds.x+bounds.w, target.w-1); ++x)
127 for (int64_t y = max(0L, bounds.y); y <= min(bounds.y+bounds.h, target.h-1); ++y)
129 int index = (x+target.w*y)*4;
130 target.pixels[index+0] = 0;
131 target.pixels[index+1] = 0;
132 target.pixels[index+2] = 0;
133 target.pixels[index+3] = 255;
142 void RectOutlineRenderer::RenderUsingCPU(const Objects & objects, const View & view, const CPURenderTarget & target)
144 for (unsigned i = 0; i < m_indexes.size(); ++i)
146 CPURenderBounds bounds(objects.bounds[m_indexes[i]], view, target);
147 for (int64_t x = max(0L, bounds.x); x <= min(bounds.x+bounds.w, target.w-1); ++x)
149 int64_t top = (x+target.w*bounds.y)*4;
150 int64_t bottom = (x+target.w*(bounds.y+bounds.h))*4;
152 if (top >= 0L && top <4*target.w*target.h)
154 for (int j = 0; j < 3; ++j)
155 target.pixels[top+j] = 0;
156 target.pixels[top+3] = 255;
158 if (bottom >= 0L && bottom <4*target.w*target.h)
160 for (int j = 0; j < 3; ++j)
161 target.pixels[bottom+j] = 0;
162 target.pixels[bottom+3] = 255;
166 for (int64_t y = max(0L, bounds.y); y <= min(bounds.y+bounds.h, target.h-1); ++y)
168 int64_t left = (bounds.x >= 0L && bounds.x < target.w) ? (bounds.x + target.w*y)*4 : -1L;
169 int64_t right = (bounds.x+bounds.w >= 0L && bounds.x+bounds.w < target.w) ? (bounds.x+bounds.w + target.w*y)*4 : -1L;
170 if (left >= 0L && left <4*target.w*target.h)
172 for (int j = 0; j < 3; ++j)
173 target.pixels[left+j] = 0;
174 target.pixels[left+3] = 255;
176 if (right >= 0L && right <4*target.w*target.h)
178 for (int j = 0; j < 3; ++j)
179 target.pixels[right+j] = 0;
180 target.pixels[right+3] = 255;
189 void CircleFilledRenderer::RenderUsingCPU(const Objects & objects, const View & view, const CPURenderTarget & target)
191 for (unsigned i = 0; i < m_indexes.size(); ++i)
193 CPURenderBounds bounds(objects.bounds[m_indexes[i]], view, target);
194 int64_t centre_x = bounds.x + bounds.w / 2;
195 int64_t centre_y = bounds.y + bounds.h / 2;
197 //Debug("Centre is %d, %d", centre_x, centre_y);
198 //Debug("Bounds are %d,%d,%d,%d", bounds.x, bounds.y, bounds.w, bounds.h);
199 //Debug("Windos is %d,%d", target.w, target.h);
200 for (int64_t x = max(0L, bounds.x); x <= min(bounds.x+bounds.w, target.w-1); ++x)
202 for (int64_t y = max(0L, bounds.y); y <= min(bounds.y + bounds.h, target.h-1); ++y)
204 double dx = 2.0*(double)(x - centre_x)/(double)(bounds.w);
205 double dy = 2.0*(double)(y - centre_y)/(double)(bounds.h);
206 int64_t index = (x+target.w*y)*4;
208 if (dx*dx + dy*dy <= 1.0)
210 target.pixels[index+0] = 0;
211 target.pixels[index+1] = 0;
212 target.pixels[index+2] = 0;
213 target.pixels[index+3] = 255;
223 * For debug, save pixels to bitmap
225 void ObjectRenderer::SaveBMP(const CPURenderTarget & target, const char * filename)
227 SDL_Surface * surf = SDL_CreateRGBSurfaceFrom(target.pixels, target.w, target.h, 8*4, target.w*4,
228 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
229 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
231 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff
232 #endif //SDL_BYTEORDER
235 Fatal("SDL_CreateRGBSurfaceFrom(pixels...) failed - %s", SDL_GetError());
236 if (SDL_SaveBMP(surf, filename) != 0)
237 Fatal("SDL_SaveBMP failed - %s", SDL_GetError());
240 SDL_FreeSurface(surf);