#include "view.h"
#include "bufferbuilder.h"
-
+#include "screen.h"
#include "gl_core44.h"
using namespace IPDF;
using namespace std;
-#define RECT_VERT \
- "#version 140\n"\
- "#extension GL_ARB_shading_language_420pack : require\n"\
- "#extension GL_ARB_explicit_attrib_location : require\n"\
- "\n"\
- "layout(std140, binding=0) uniform ViewBounds\n"\
- "{\n"\
- "\tfloat bounds_x;\n"\
- "\tfloat bounds_y;\n"\
- "\tfloat bounds_w;\n"\
- "\tfloat bounds_h;\n"\
- "};\n"\
- "\n"\
- "layout(location = 0) in vec2 position;\n"\
- "\n"\
- "void main()\n"\
- "{\n"\
- "\tvec2 transformed_position;\n"\
- "\ttransformed_position.x = (position.x - bounds_x) / bounds_w;\n"\
- "\ttransformed_position.y = (position.y - bounds_y) / bounds_h;\n"\
- "\t// Transform to clip coordinates (-1,1, -1,1).\n"\
- "\tgl_Position.x = (transformed_position.x*2) - 1;\n"\
- "\tgl_Position.y = 1 - (transformed_position.y*2);\n"\
- "\tgl_Position.z = 0.0;\n"\
- "\tgl_Position.w = 1.0;\n"\
- "}\n"
-
-#define RECT_FRAG \
- "#version 140\n"\
- "\n"\
- "out vec4 output_colour;\n"\
- "\n"\
- "uniform vec4 colour;\n"\
- "\n"\
- "void main()\n"\
- "{\n"\
- "\toutput_colour = colour;\n"\
- "}\n"
-
-#define RECT_OUTLINE_GEOM \
- "#version 150\n"\
- "\n"\
- "layout(lines) in;\n"\
- "layout(line_strip, max_vertices = 5) out;\n"\
- "\n"\
- "void main()\n"\
- "{\n"\
- "\tgl_Position = gl_in[0].gl_Position;\n"\
- "\tEmitVertex();\n"\
- "\tgl_Position = vec4(gl_in[0].gl_Position.x, gl_in[1].gl_Position.y, 0.0, 1.0);\n"\
- "\tEmitVertex();\n"\
- "\tgl_Position = gl_in[1].gl_Position;\n"\
- "\tEmitVertex();\n"\
- "\tgl_Position = vec4(gl_in[1].gl_Position.x, gl_in[0].gl_Position.y, 0.0, 1.0);\n"\
- "\tEmitVertex();\n"\
- "\tgl_Position = gl_in[0].gl_Position;\n"\
- "\tEmitVertex();\n"\
- "\tEndPrimitive();\n"\
- "}\n"
-#define RECT_FILLED_GEOM \
- "#version 150\n"\
- "\n"\
- "layout(lines) in;\n"\
- "layout(triangle_strip, max_vertices = 4) out;\n"\
- "\n"\
- "void main()\n"\
- "{\n"\
- "\tgl_Position = gl_in[0].gl_Position;\n"\
- "\tEmitVertex();\n"\
- "\tgl_Position = vec4(gl_in[0].gl_Position.x, gl_in[1].gl_Position.y, 0.0, 1.0);\n"\
- "\tEmitVertex();\n"\
- "\tgl_Position = vec4(gl_in[1].gl_Position.x, gl_in[0].gl_Position.y, 0.0, 1.0);\n"\
- "\tEmitVertex();\n"\
- "\tgl_Position = gl_in[1].gl_Position;\n"\
- "\tEmitVertex();\n"\
- "\tEndPrimitive();\n"\
- "}\n"
-
-#define CIRCLE_FILLED_GEOM \
- "#version 150\n"\
- "\n"\
- "layout(lines) in;\n"\
- "layout(triangle_strip, max_vertices = 4) out;\n"\
- "out vec2 objcoords;\n"\
- "\n"\
- "void main()\n"\
- "{\n"\
- "\tgl_Position = gl_in[0].gl_Position;\n"\
- "\tobjcoords = vec2(-1.0, -1.0);\n"\
- "\tEmitVertex();\n"\
- "\tgl_Position = vec4(gl_in[0].gl_Position.x, gl_in[1].gl_Position.y, 0.0, 1.0);\n"\
- "\tobjcoords = vec2(-1.0, 1.0);\n"\
- "\tEmitVertex();\n"\
- "\tgl_Position = vec4(gl_in[1].gl_Position.x, gl_in[0].gl_Position.y, 0.0, 1.0);\n"\
- "\tobjcoords = vec2(1.0, -1.0);\n"\
- "\tEmitVertex();\n"\
- "\tgl_Position = gl_in[1].gl_Position;\n"\
- "\tobjcoords = vec2(1.0, 1.0);\n"\
- "\tEmitVertex();\n"\
- "\tEndPrimitive();\n"\
- "}\n"
+/**
+ * Constructs a view
+ * Allocates memory for ObjectRenderers
+ * @param document - The document to associate the View with
+ * @param bounds - Initial bounds of the View
+ * @param colour - Colour to use for rendering this view. TODO: Make sure this actually works, or just remove it
+ */
+View::View(Document & document, Screen & screen, const Rect & bounds, const Colour & colour)
+ : m_use_gpu_transform(USE_GPU_TRANSFORM), m_use_gpu_rendering(USE_GPU_RENDERING), m_bounds_dirty(true), m_buffer_dirty(true),
+ m_render_dirty(true), m_document(document), m_screen(screen), m_cached_display(), m_bounds(bounds), m_colour(colour), m_bounds_ubo(),
+ m_objbounds_vbo(), m_object_renderers(NUMBER_OF_OBJECT_TYPES), m_cpu_rendering_pixels(NULL)
+{
+ Debug("View Created - Bounds => {%s}", m_bounds.Str().c_str());
+
+ // Create ObjectRenderers - new's match delete's in View::~View
+ //TODO: Don't forget to put new renderers here or things will be segfaultastic
+ m_object_renderers[RECT_FILLED] = new RectFilledRenderer();
+ m_object_renderers[RECT_OUTLINE] = new RectOutlineRenderer();
+ m_object_renderers[CIRCLE_FILLED] = new CircleFilledRenderer();
+ m_object_renderers[BEZIER] = new BezierRenderer();
+
+ // To add rendering for a new type of object;
+ // 1. Add enum to ObjectType in ipdf.h
+ // 2. Implement class inheriting from ObjectRenderer using that type in objectrenderer.h and objectrenderer.cpp
+ // 3. Add it here
+ // 4. Profit
+}
-#define CIRCLE_FRAG \
- "#version 140\n"\
- "\n"\
- "in vec2 objcoords;\n"\
- "out vec4 output_colour;\n"\
- "\n"\
- "uniform vec4 colour;\n"\
- "\n"\
- "void main()\n"\
- "{\n"\
- "\tif ((objcoords.x)*(objcoords.x) + (objcoords.y)*(objcoords.y) > 1.0)\n"\
- "\t{\n"\
- "\t\tdiscard;\n"\
- "\t}\n"\
- "\toutput_colour = colour;\n"\
- "}\n"
+/**
+ * Destroy a view
+ * Frees memory used by ObjectRenderers
+ */
+View::~View()
+{
+ for (unsigned i = 0; i < m_object_renderers.size(); ++i)
+ {
+ delete m_object_renderers[i]; // delete's match new's in constructor
+ }
+ m_object_renderers.clear();
+ delete [] m_cpu_rendering_pixels;
+}
+/**
+ * Translate the view
+ * @param x, y - Amount to translate
+ */
void View::Translate(Real x, Real y)
{
x *= m_bounds.w;
m_bounds.y += y;
Debug("View Bounds => %s", m_bounds.Str().c_str());
if (!m_use_gpu_transform)
- {
m_buffer_dirty = true;
- }
m_bounds_dirty = true;
}
-void View::ScaleAroundPoint(Real x, Real y, Real scaleAmt)
+/**
+ * Scale the View at a point
+ * @param x, y - Coordinates to scale at (eg: Mouse cursor position)
+ * @param scale_amount - Amount to scale by
+ */
+void View::ScaleAroundPoint(Real x, Real y, Real scale_amount)
{
// x and y are coordinates in the window
// Convert to local coords.
x += m_bounds.x;
y += m_bounds.y;
- //Debug("Mouse wheel event %f %f %f\n", Float(x), Float(y), Float(scaleAmt));
-
Real top = y - m_bounds.y;
Real left = x - m_bounds.x;
- top *= scaleAmt;
- left *= scaleAmt;
+ top *= scale_amount;
+ left *= scale_amount;
m_bounds.x = x - left;
m_bounds.y = y - top;
- m_bounds.w *= scaleAmt;
- m_bounds.h *= scaleAmt;
- Debug("View Bounds => %s", m_bounds.Str().c_str());
+ m_bounds.w *= scale_amount;
+ m_bounds.h *= scale_amount;
+ //Debug("Scale at {%s, %s} by %s View Bounds => %s", x.Str().c_str(), y.Str().c_str(), scale_amount.Str().c_str(), m_bounds.Str().c_str());
if (!m_use_gpu_transform)
m_buffer_dirty = true;
m_bounds_dirty = true;
}
+/**
+ * Transform a point in the document to a point relative to the top left corner of the view
+ * This is the CPU coordinate transform code; used only if the CPU is doing coordinate transforms
+ * @param inp - Input Rect {x,y,w,h} in the document
+ * @returns output Rect {x,y,w,h} in the View
+ */
Rect View::TransformToViewCoords(const Rect& inp) const
{
Rect out;
out.x = (inp.x - m_bounds.x) / m_bounds.w;
out.y = (inp.y - m_bounds.y) / m_bounds.h;
-
out.w = inp.w / m_bounds.w;
out.h = inp.h / m_bounds.h;
return out;
}
-void View::DrawGrid()
-{
- //TODO: Implement this with OpenGL 3.1+
-#if 0
- // Draw some grid lines at fixed pixel positions
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(0.0, 1.0, 1.0, 0.0, -1.f, 1.f);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- glColor4f(0.9,0.9,0.9,0.1);
- const float num_lines = 50.0;
- for (float i = 0; i < num_lines; ++i)
- {
- glBegin(GL_LINES);
- glVertex2f(i*(1.0/num_lines), 0.0);
- glVertex2f(i*(1.0/num_lines), 1.0);
- glEnd();
- glBegin(GL_LINES);
- glVertex2f(0.0,i*(1.0/num_lines));
- glVertex2f(1.0,i*(1.0/num_lines));
- glEnd();
-
- }
-#endif
-}
-
+/**
+ * Render the view
+ * Updates FrameBuffer if the document, object bounds, or view bounds have changed, then Blits it
+ * Otherwise just Blits the cached FrameBuffer
+ * @param width - Width of View to render
+ * @param height - Height of View to render
+ */
void View::Render(int width, int height)
{
- if (width != m_cached_display.GetWidth() || height != m_cached_display.GetHeight())
+ // View dimensions have changed (ie: Window was resized)
+ int prev_width = m_cached_display.GetWidth();
+ int prev_height = m_cached_display.GetHeight();
+ if (width != prev_width || height != prev_height)
{
m_cached_display.Create(width, height);
m_bounds_dirty = true;
}
+ // View bounds have not changed; blit the FrameBuffer as it is
if (!m_bounds_dirty)
{
m_cached_display.UnBind();
m_cached_display.Blit();
return;
}
- m_cached_display.Bind();
- m_cached_display.Clear();
- if (!m_render_inited)
+ // Bind FrameBuffer for rendering, and clear it
+
+
+ if (m_render_dirty) // document has changed
PrepareRender();
- if (m_buffer_dirty)
+ if (m_buffer_dirty) // object bounds have changed
UpdateObjBoundsVBO();
- if (m_bounds_dirty)
+ if (m_use_gpu_transform)
{
- if (m_use_gpu_transform)
- {
- GLfloat glbounds[] = {static_cast<GLfloat>(Float(m_bounds.x)), static_cast<GLfloat>(Float(m_bounds.y)), static_cast<GLfloat>(Float(m_bounds.w)), static_cast<GLfloat>(Float(m_bounds.h))};
- m_bounds_ubo.Upload(sizeof(float)*4, glbounds);
- }
- else
- {
- GLfloat glbounds[] = {0.0f, 0.0f, 1.0f, 1.0f};
- m_bounds_ubo.Upload(sizeof(float)*4, glbounds);
- }
+ GLfloat glbounds[] = {static_cast<GLfloat>(Float(m_bounds.x)), static_cast<GLfloat>(Float(m_bounds.y)), static_cast<GLfloat>(Float(m_bounds.w)), static_cast<GLfloat>(Float(m_bounds.h)),
+ 0.0, 0.0, 640.0, 480.0};
+ m_bounds_ubo.Upload(sizeof(float)*8, glbounds);
}
- m_bounds_dirty = false;
-
- if (m_colour.a < 1.0f)
+ else
{
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ GLfloat glbounds[] = {0.0f, 0.0f, 1.0f, 1.0f,
+ 0.0f, 0.0f, 640.0f, 480.0f};
+ m_bounds_ubo.Upload(sizeof(float)*8, glbounds);
}
- m_objbounds_vbo.Bind();
- m_bounds_ubo.Bind();
- glEnableVertexAttribArray(0);
- glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
+ m_bounds_dirty = false;
- // Filled Rectangles
- m_rect_filled_shader.Use();
- m_filled_ibo.Bind();
- glDrawElements(GL_LINES, m_rendered_filled*2, GL_UNSIGNED_INT, 0);
+ m_cached_display.Bind(); //NOTE: This is redundant; Clear already calls Bind
+ m_cached_display.Clear();
- // Rectangle Outlines
- m_rect_outline_shader.Use();
- m_outline_ibo.Bind();
- glDrawElements(GL_LINES, m_rendered_outline*2, GL_UNSIGNED_INT, 0);
- // Filled Circles
- m_circle_filled_shader.Use();
- m_circle_ibo.Bind();
- glDrawElements(GL_LINES, m_rendered_circle*2, GL_UNSIGNED_INT, 0);
- glDisableVertexAttribArray(0);
- if (m_colour.a < 1.0f)
+ // Render using GPU
+ if (m_use_gpu_rendering)
{
- glDisable(GL_BLEND);
+ if (m_colour.a < 1.0f)
+ {
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ }
+ m_objbounds_vbo.Bind();
+ m_bounds_ubo.Bind();
+ glEnableVertexAttribArray(0);
+ glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
+
+ for (unsigned i = 0; i < m_object_renderers.size(); ++i)
+ {
+ m_object_renderers[i]->RenderUsingGPU();
+ }
+
+ glDisableVertexAttribArray(0);
+ if (m_colour.a < 1.0f)
+ {
+ glDisable(GL_BLEND);
+ }
}
- m_cached_display.UnBind();
- m_cached_display.Blit();
+ else // Rasterise on CPU then blit texture to GPU
+ {
+ // Dynamically resize CPU rendering target pixels if needed
+ if (m_cpu_rendering_pixels == NULL || width*height > prev_width*prev_height)
+ {
+ delete [] m_cpu_rendering_pixels;
+ m_cpu_rendering_pixels = new uint8_t[width*height*4];
+ if (m_cpu_rendering_pixels == NULL)
+ Fatal("Could not allocate %d*%d*4 = %d bytes for cpu rendered pixels", width, height, width*height*4);
+ }
+ // Clear CPU rendering pixels
+ for (int i = 0; i < width*height*4; ++i)
+ m_cpu_rendering_pixels[i] = 255;
+ for (unsigned i = 0; i < m_object_renderers.size(); ++i)
+ {
+ m_object_renderers[i]->RenderUsingCPU(m_document.m_objects, *this, {m_cpu_rendering_pixels, width, height});
+ }
+ m_screen.RenderPixels(0,0,width, height, m_cpu_rendering_pixels); //TODO: Make this work :(
+ // Debug for great victory (do something similar for GPU and compare?)
+ ObjectRenderer::SaveBMP({m_cpu_rendering_pixels, width, height}, "cpu_rendering_last_frame.bmp");
+ }
+ m_cached_display.UnBind(); // resets render target to the screen
+ m_cached_display.Blit(); // blit FrameBuffer to screen
}
-struct GPUObjBounds
-{
- float x0, y0;
- float x1, y1;
-};
-
void View::UpdateObjBoundsVBO()
{
m_objbounds_vbo.Invalidate();
m_objbounds_vbo.UnMap();
m_buffer_dirty = false;
}
-
+/**
+ * Prepare the document for rendering
+ * Will be called on View::Render if m_render_dirty is set
+ * (Called at least once, on the first Render)
+ */
void View::PrepareRender()
{
- // TODO: Error check here.
- m_rect_outline_shader.AttachGeometryProgram(RECT_OUTLINE_GEOM);
- m_rect_outline_shader.AttachVertexProgram(RECT_VERT);
- m_rect_outline_shader.AttachFragmentProgram(RECT_FRAG);
- m_rect_outline_shader.Link();
- m_rect_outline_shader.Use();
- glUniform4f(m_rect_outline_shader.GetUniformLocation("colour"), m_colour.r, m_colour.g, m_colour.b, m_colour.a);
-
- m_rect_filled_shader.AttachGeometryProgram(RECT_FILLED_GEOM);
- m_rect_filled_shader.AttachVertexProgram(RECT_VERT);
- m_rect_filled_shader.AttachFragmentProgram(RECT_FRAG);
- m_rect_filled_shader.Link();
- m_rect_filled_shader.Use();
- glUniform4f(m_rect_filled_shader.GetUniformLocation("colour"), m_colour.r, m_colour.g, m_colour.b, m_colour.a);
-
- m_circle_filled_shader.AttachGeometryProgram(CIRCLE_FILLED_GEOM);
- m_circle_filled_shader.AttachVertexProgram(RECT_VERT);
- m_circle_filled_shader.AttachFragmentProgram(CIRCLE_FRAG);
- m_circle_filled_shader.Link();
- m_circle_filled_shader.Use();
- glUniform4f(m_circle_filled_shader.GetUniformLocation("colour"), m_colour.r, m_colour.g, m_colour.b, m_colour.a);
-
+ Debug("Recreate buffers with %u objects", m_document.ObjectCount());
+ // Prepare bounds vbo
+ m_bounds_ubo.Invalidate();
m_bounds_ubo.SetType(GraphicsBuffer::BufferTypeUniform);
m_bounds_ubo.SetUsage(GraphicsBuffer::BufferUsageStreamDraw);
+
+ // Instead of having each ObjectRenderer go through the whole document
+ // we initialise them, go through the document once adding to the appropriate Renderers
+ // and then finalise them
+ // This will totally be efficient if we have like, a lot of distinct ObjectTypes. Which could totally happen. You never know.
- m_outline_ibo.SetUsage(GraphicsBuffer::BufferUsageStaticDraw);
- m_outline_ibo.SetType(GraphicsBuffer::BufferTypeIndex);
- m_outline_ibo.Resize(m_document.ObjectCount() * 2 * sizeof(uint32_t));
- BufferBuilder<uint32_t> outline_builder(m_outline_ibo.Map(false, true, true), m_outline_ibo.GetSize());
-
- m_filled_ibo.SetUsage(GraphicsBuffer::BufferUsageStaticDraw);
- m_filled_ibo.SetType(GraphicsBuffer::BufferTypeIndex);
- m_filled_ibo.Resize(m_document.ObjectCount() * 2 * sizeof(uint32_t));
- BufferBuilder<uint32_t> filled_builder(m_filled_ibo.Map(false, true, true), m_filled_ibo.GetSize());
-
- m_circle_ibo.SetUsage(GraphicsBuffer::BufferUsageStaticDraw);
- m_circle_ibo.SetType(GraphicsBuffer::BufferTypeIndex);
- m_circle_ibo.Resize(m_document.ObjectCount() * 2 * sizeof(uint32_t));
- BufferBuilder<uint32_t> circle_builder(m_circle_ibo.Map(false, true, true), m_circle_ibo.GetSize());
+ // Prepare the buffers
+ for (unsigned i = 0; i < m_object_renderers.size(); ++i)
+ {
+ m_object_renderers[i]->PrepareBuffers(m_document.ObjectCount());
+ }
- m_rendered_filled = m_rendered_outline = m_rendered_circle = 0;
- uint32_t currentIndex = 0;
+ // Add objects from Document to buffers
for (unsigned id = 0; id < m_document.ObjectCount(); ++id)
{
- if (m_document.m_objects.types[id] == RECT_OUTLINE)
- {
- outline_builder.Add(currentIndex++);
- outline_builder.Add(currentIndex++);
- m_rendered_outline++;
- }
- else if (m_document.m_objects.types[id] == RECT_FILLED)
- {
- filled_builder.Add(currentIndex++);
- filled_builder.Add(currentIndex++);
- m_rendered_filled++;
- }
- else
- {
- circle_builder.Add(currentIndex++);
- circle_builder.Add(currentIndex++);
- m_rendered_circle++;
- }
-
+ ObjectType type = m_document.m_objects.types[id];
+ m_object_renderers.at(type)->AddObjectToBuffers(id); // Use at() in case the document is corrupt TODO: Better error handling?
+ // (Also, Wow I just actually used std::vector::at())
+ // (Also, I just managed to make it throw an exception because I'm a moron)
+ Debug("Object of type %d", type);
}
- m_outline_ibo.UnMap();
- m_filled_ibo.UnMap();
- m_circle_ibo.UnMap();
- m_render_inited = true;
+ // Finish the buffers
+ for (unsigned i = 0; i < m_object_renderers.size(); ++i)
+ {
+ m_object_renderers[i]->FinaliseBuffers();
+ }
+ dynamic_cast<BezierRenderer*>(m_object_renderers[BEZIER])->PrepareBezierGPUBuffer(m_document.m_objects);
+ m_render_dirty = false;
}
git.ucc.asn.au / ipdf / code.git / blobdiff
UCC git Repository :: git.ucc.asn.au