rays 0.3.10 → 0.3.11

data/src/opengl/painter.cpp

@@ -0,0 +1,756 @@
+#include "../painter.h"
+
+
+#include <math.h>
+#include <assert.h>
+#include <memory>
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include "rays/exception.h"
+#include "../glm.h"
+#include "../bitmap.h"
+#include "../image.h"
+#include "../font.h"
+#include "opengl.h"
+#include "texture.h"
+#include "frame_buffer.h"
+#include "shader.h"
+#include "shader_program.h"
+
+
+namespace Rays
+{
+
+
+	struct OpenGLState
+	{
+
+		GLint viewport[4];
+
+		GLclampf color_clear[4];
+
+		GLboolean depth_test;
+		GLint depth_func;
+
+		GLboolean scissor_test;
+		GLint scissor_box[4];
+
+		GLboolean blend;
+		GLint blend_equation_rgb, blend_equation_alpha;
+		GLint blend_src_rgb, blend_src_alpha, blend_dst_rgb, blend_dst_alpha;
+
+		GLint framebuffer_binding;
+
+		void push ()
+		{
+			glGetIntegerv(GL_VIEWPORT, viewport);
+
+			glGetFloatv(GL_COLOR_CLEAR_VALUE, color_clear);
+
+			glGetBooleanv(GL_DEPTH_TEST, &depth_test);
+			glGetIntegerv(GL_DEPTH_FUNC, &depth_func);
+
+			glGetBooleanv(GL_SCISSOR_TEST, &scissor_test);
+			glGetIntegerv(GL_SCISSOR_BOX, scissor_box);
+
+			glGetBooleanv(GL_BLEND, &blend);
+			glGetIntegerv(GL_BLEND_EQUATION_RGB,   &blend_equation_rgb);
+			glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &blend_equation_alpha);
+			glGetIntegerv(GL_BLEND_SRC_RGB,   &blend_src_rgb);
+			glGetIntegerv(GL_BLEND_SRC_ALPHA, &blend_src_alpha);
+			glGetIntegerv(GL_BLEND_DST_RGB,   &blend_dst_rgb);
+			glGetIntegerv(GL_BLEND_DST_ALPHA, &blend_dst_alpha);
+
+			glGetIntegerv(GL_FRAMEBUFFER_BINDING, &framebuffer_binding);
+		}
+
+		void pop ()
+		{
+			glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
+
+			glClearColor(
+				color_clear[0], color_clear[1], color_clear[2], color_clear[3]);
+
+			enable(GL_DEPTH_TEST, depth_test);
+			glDepthFunc(depth_func);
+
+			enable(GL_SCISSOR_TEST, scissor_test);
+			glScissor(scissor_box[0], scissor_box[1], scissor_box[2], scissor_box[3]);
+
+			enable(GL_BLEND, blend);
+			glBlendEquationSeparate(blend_equation_rgb, blend_equation_alpha);
+			glBlendFuncSeparate(
+				blend_src_rgb, blend_dst_rgb, blend_src_alpha, blend_dst_alpha);
+
+			glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_binding);
+		}
+
+		private:
+
+			void enable(GLenum type, GLboolean value)
+			{
+				if (value)
+					glEnable(type);
+				else
+					glDisable(type);
+			}
+
+	};// OpenGLState
+
+
+	class DefaultIndices
+	{
+
+		public:
+
+			void resize (size_t size)
+			{
+				indices.reserve(size);
+				while (indices.size() < size)
+					indices.emplace_back(indices.size());
+			}
+
+			void clear ()
+			{
+				decltype(indices)().swap(indices);
+			}
+
+			const uint* get () const
+			{
+				return &indices[0];
+			}
+
+		private:
+
+			std::vector<uint> indices;
+
+	};// DefaultIndices
+
+
+	struct PainterData : Painter::Data
+	{
+
+		FrameBuffer frame_buffer;
+
+		OpenGLState opengl_state;
+
+		DefaultIndices default_indices;
+
+		std::vector<GLint> locations;
+
+		std::vector<GLuint> buffers;
+
+		GLuint create_and_bind_buffer (GLenum target, const void* data, GLsizeiptr size)
+		{
+			GLuint id = 0;
+			glGenBuffers(1, &id);
+			OpenGL_check_error(__FILE__, __LINE__);
+
+			buffers.push_back(id);
+
+			glBindBuffer(target, id);
+			OpenGL_check_error(__FILE__, __LINE__);
+
+			glBufferData(target, size, data, GL_STREAM_DRAW);
+			OpenGL_check_error(__FILE__, __LINE__);
+
+			return id;
+		}
+
+		void cleanup ()
+		{
+			for (auto loc : locations)
+			{
+				glDisableVertexAttribArray(loc);
+				OpenGL_check_error(__FILE__, __LINE__);
+			}
+
+			if (!buffers.empty())
+			{
+				glDeleteBuffers((GLsizei) buffers.size(), &buffers[0]);
+				OpenGL_check_error(__FILE__, __LINE__);
+			}
+
+			locations.clear();
+			buffers.clear();
+		}
+
+	};// PainterData
+
+
+	static PainterData*
+	get_data (Painter* painter)
+	{
+		return (PainterData*) painter->self.get();
+	}
+
+	void
+	Painter_update_clip (Painter* painter)
+	{
+		PainterData* self = get_data(painter);
+		const Bounds& clip = self->state.clip;
+		if (clip)
+		{
+			coord y = self->frame_buffer ? clip.y : self->viewport.h - (clip.y + clip.h);
+			glEnable(GL_SCISSOR_TEST);
+			glScissor(
+				self->pixel_density * clip.x,
+				self->pixel_density * y,
+				self->pixel_density * clip.width,
+				self->pixel_density * clip.height);
+		}
+		else
+			glDisable(GL_SCISSOR_TEST);
+
+		OpenGL_check_error(__FILE__, __LINE__);
+	}
+
+	static const TextureInfo*
+	setup_texinfo (
+		PainterData* self, const TextureInfo* texinfo,
+		std::unique_ptr<TextureInfo>& ptr)
+	{
+		if (texinfo) return texinfo;
+
+		const Texture* tex =
+			self->state.texture ? &Image_get_texture(self->state.texture) : NULL;
+		if (!tex) return NULL;
+
+		ptr.reset(new TextureInfo(*tex, 0, 0, tex->width(), tex->height()));
+		return ptr.get();
+	}
+
+	static const Shader*
+	setup_shader (
+		PainterData* self, const Shader* shader, bool for_texture)
+	{
+		if (self->state.shader) return &self->state.shader;
+		if (shader)             return shader;
+		return for_texture
+			?	&Shader_get_default_shader_for_texture(self->state.texcoord_wrap)
+			:	&Shader_get_default_shader_for_shape();
+	}
+
+	static void
+	apply_uniform (
+		const ShaderProgram& program, const char* name,
+		std::function<void(GLint)> apply_fun)
+	{
+		GLint loc = glGetUniformLocation(program.id(), name);
+		if (loc < 0) return;
+
+		apply_fun(loc);
+		OpenGL_check_error(__FILE__, __LINE__);
+	}
+
+	static void
+	apply_attribute (
+		const ShaderProgram& program, const char* name,
+		std::function<void(GLint)> apply_fun)
+	{
+		GLint loc = glGetAttribLocation(program.id(), name);
+		if (loc < 0) return;
+
+		apply_fun(loc);
+		OpenGL_check_error(__FILE__, __LINE__);
+	}
+
+	static void
+	apply_builtin_uniforms (
+		const ShaderProgram& program, const ShaderBuiltinVariableNames& names,
+		const Matrix& position_matrix, const State& state,
+		const TextureInfo* texinfo)
+	{
+		const Texture* texture = texinfo ? &texinfo->texture : NULL;
+
+		Matrix texcoord_matrix(1);
+		if (texture && *texture)
+		{
+			bool normal = state.texcoord_mode == TEXCOORD_NORMAL;
+			texcoord_matrix.scale(
+				(normal ? texture->width()  : 1.0) / texture->reserved_width(),
+				(normal ? texture->height() : 1.0) / texture->reserved_height());
+		}
+
+		for (const auto& name : names.uniform_position_matrix_names)
+		{
+			apply_uniform(program, name, [&](GLint loc) {
+				glUniformMatrix4fv(loc, 1, GL_FALSE, position_matrix.array);
+			});
+		}
+		for (const auto& name : names.uniform_texcoord_matrix_names)
+		{
+			apply_uniform(program, name, [&](GLint loc) {
+				glUniformMatrix4fv(loc, 1, GL_FALSE, texcoord_matrix.array);
+			});
+		}
+
+		if (!texinfo || !texture || !*texture) return;
+
+		coord tw = texture->reserved_width();
+		coord th = texture->reserved_height();
+		Point min(texinfo->min.x / tw, texinfo->min.y / th);
+		Point max(texinfo->max.x / tw, texinfo->max.y / th);
+		Point offset(          1 / tw,              1 / th);
+
+		for (const auto& name : names.uniform_texcoord_min_names)
+		{
+			apply_uniform(program, name, [&](GLint loc) {
+				glUniform3fv(loc, 1, min.array);
+			});
+		}
+		for (const auto& name : names.uniform_texcoord_max_names)
+		{
+			apply_uniform(program, name, [&](GLint loc) {
+				glUniform3fv(loc, 1, max.array);
+			});
+		}
+		for (const auto& name : names.uniform_texcoord_offset_names)
+		{
+			apply_uniform(program, name, [&](GLint loc) {
+				glUniform3fv(loc, 1, offset.array);
+			});
+		}
+		for (const auto& name : names.uniform_texture_names)
+		{
+			apply_uniform(program, name, [&](GLint loc) {
+				glActiveTexture(GL_TEXTURE0);
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				glBindTexture(GL_TEXTURE_2D, Texture_get_id(*texture));
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				glUniform1i(loc, 0);
+			});
+		}
+	}
+
+	template <typename COORD>
+	static GLenum get_gl_type ();
+
+	template <>
+	GLenum
+	get_gl_type<float> ()
+	{
+		return GL_FLOAT;
+	}
+
+	template <typename CoordN>
+	static void
+	apply_attribute (
+		PainterData* self,
+		const ShaderProgram& program, const auto& names,
+		const CoordN* values, size_t nvalues)
+	{
+		GLuint buffer = 0;
+		for (const auto& name : names)
+		{
+			#ifndef IOS
+				if (buffer == 0)
+				{
+					buffer = self->create_and_bind_buffer(
+						GL_ARRAY_BUFFER, values, sizeof(CoordN) * nvalues);
+					values = 0;
+				}
+			#endif
+
+			apply_attribute(program, name, [&](GLint loc) {
+				glEnableVertexAttribArray(loc);
+				OpenGL_check_error(
+					__FILE__, __LINE__, "loc: %d %s\n", loc, name.c_str());
+
+				glVertexAttribPointer(
+					loc, CoordN::SIZE, get_gl_type<coord>(), GL_FALSE, 0, values);
+
+				self->locations.push_back(loc);
+			});
+		}
+
+		glBindBuffer(GL_ARRAY_BUFFER, 0);
+		OpenGL_check_error(__FILE__, __LINE__);
+	}
+
+	static void
+	apply_attributes (
+		PainterData* self,
+		const ShaderProgram& program, const ShaderBuiltinVariableNames& names,
+		const Coord3* points, size_t npoints, const Coord3* texcoords,
+		const Color* color, const Color* colors)
+	{
+		assert(npoints > 0);
+		assert(!!color != !!colors);
+
+		apply_attribute(
+			self, program, names.attribute_position_names,
+			points, npoints);
+
+		apply_attribute(
+			self, program, names.attribute_texcoord_names,
+			texcoords ? texcoords : points, npoints);
+
+		if (colors)
+		{
+			apply_attribute(
+				self, program, names.attribute_color_names,
+				colors, npoints);
+		}
+		else if (color)
+		{
+#if defined(GL_VERSION_2_1) && !defined(GL_VERSION_3_0)
+			// to fix that GL 2.1 with glVertexAttrib4fv() draws nothing
+			// with specific glsl 'attribute' name.
+			std::vector<Color> colors_(npoints, *color);
+			apply_attribute(
+				self, program, names.attribute_color_names,
+				(const Coord4*) &colors_[0], npoints);
+#else
+			for (const auto& name : names.attribute_color_names)
+			{
+				apply_attribute(program, name, [&](GLint loc) {
+					glVertexAttrib4fv(loc, color->array);
+				});
+			}
+#endif
+		}
+	}
+
+	static void
+	draw_indices (
+		PainterData* self,
+		GLenum mode, const uint* indices, size_t nindices, size_t npoints)
+	{
+		if (!indices || nindices <= 0)
+		{
+			self->default_indices.resize(npoints);
+			indices  = self->default_indices.get();
+			nindices = npoints;
+		}
+
+		#ifdef IOS
+			glDrawElements(mode, (GLsizei) nindices, GL_UNSIGNED_INT, indices);
+			OpenGL_check_error(__FILE__, __LINE__);
+		#else
+			self->create_and_bind_buffer(
+				GL_ELEMENT_ARRAY_BUFFER, indices, sizeof(uint) * nindices);
+
+			glDrawElements(mode, (GLsizei) nindices, GL_UNSIGNED_INT, 0);
+			OpenGL_check_error(__FILE__, __LINE__);
+
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+			OpenGL_check_error(__FILE__, __LINE__);
+		#endif
+	}
+
+	void
+	Painter_draw (
+		Painter* painter, PrimitiveMode mode, const Color* color,
+		const Coord3* points,  size_t npoints,
+		const uint*   indices, size_t nindices,
+		const Color*  colors,
+		const Coord3* texcoords,
+		const TextureInfo* texinfo,
+		const Shader* shader)
+	{
+		if (!points)
+			argument_error(__FILE__, __LINE__);
+		if (npoints <= 0)
+			argument_error(__FILE__, __LINE__);
+
+		PainterData* self = get_data(painter);
+
+		if (!self->painting)
+			invalid_state_error(__FILE__, __LINE__, "'painting' should be true.");
+
+		std::unique_ptr<TextureInfo> ptexinfo;
+		texinfo = setup_texinfo(self, texinfo, ptexinfo);
+		shader  = setup_shader(self, shader, texinfo);
+
+		const ShaderProgram* program = Shader_get_program(*shader);
+		if (!program || !*program) return;
+
+		ShaderProgram_activate(*program);
+
+		const auto& names = Shader_get_builtin_variable_names(*shader);
+		apply_builtin_uniforms(
+			*program, names, self->position_matrix, self->state, texinfo);
+		apply_attributes(
+			self, *program, names, points, npoints, texcoords, color, colors);
+		draw_indices(self, (GLenum) mode, indices, nindices, npoints);
+		self->cleanup();
+
+		ShaderProgram_deactivate();
+	}
+
+	static inline void
+	debug_draw_text_line (
+		Painter* painter, const Font& font,
+		coord x, coord y, coord str_width, coord str_height)
+	{
+#if 0
+		painter->self->text_image.save("/tmp/font.png");
+
+		painter->push_state();
+		{
+			coord asc, desc, lead;
+			font.get_height(&asc, &desc, &lead);
+			//printf("%f %f %f %f \n", str_height, asc, desc, lead);
+
+			painter->set_stroke(0.5, 0.5, 1);
+			painter->no_fill();
+			painter->rect(x - 1, y - 1, str_width + 2, str_height + 2);
+
+			coord yy = y;
+			painter->set_stroke(1, 0.5, 0.5, 0.4);
+			painter->rect(x, yy, str_width, asc);//str_height);
+
+			yy += asc;
+			painter->set_stroke(1, 1, 0.5, 0.4);
+			painter->rect(x, yy, str_width, desc);
+
+			yy += desc;
+			painter->set_stroke(1, 0.5, 1, 0.4);
+			painter->rect(x, yy, str_width, lead);
+		}
+		painter->pop_state();
+#endif
+	}
+
+	void
+	Painter_draw_text_line (
+		Painter* painter, const Font& font,
+		const char* line, coord x, coord y,
+		coord width, coord height)
+	{
+		assert(painter && font && line && *line != '\0');
+
+		Painter::Data* self = painter->self.get();
+
+		float density          = self->pixel_density;
+		const RawFont& rawfont = Font_get_raw(font, density);
+		coord str_w            = rawfont.get_width(line);
+		coord str_h            = rawfont.get_height();
+		int tex_w              = ceil(str_w);
+		int tex_h              = ceil(str_h);
+		const Texture& texture = Image_get_texture(self->text_image);
+		if (
+			texture.width()  < tex_w ||
+			texture.height() < tex_h ||
+			self->text_image.pixel_density() != density)
+		{
+			int bmp_w = std::max(texture.width(),  tex_w);
+			int bmp_h = std::max(texture.height(), tex_h);
+			self->text_image = Image(Bitmap(bmp_w, bmp_h), density);
+		}
+
+		if (!self->text_image)
+			invalid_state_error(__FILE__, __LINE__);
+
+		assert(self->text_image.pixel_density() == density);
+
+		Bitmap_draw_string(
+			&self->text_image.bitmap(), rawfont, line, 0, 0, font.smooth());
+
+		str_w /= density;
+		str_h /= density;
+		if (width  == 0) width  = str_w;
+		if (height == 0) height = str_h;
+
+		Painter_draw_image(
+			painter, self->text_image,
+			0, 0, str_w, str_h,
+			x, y, str_w, str_h,
+			false, true, &Shader_get_shader_for_text());
+
+		debug_draw_text_line(painter, font, x, y, str_w / density, str_h / density);
+	}
+
+
+	Painter::Painter ()
+	:	self(new PainterData())
+	{
+	}
+
+	void
+	Painter::bind (const Image& image)
+	{
+		if (!image)
+			argument_error(__FILE__, __LINE__, "invalid image.");
+
+		if (self->painting)
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be false.");
+
+		FrameBuffer fb(Image_get_texture(image));
+		if (!fb)
+			rays_error(__FILE__, __LINE__, "invalid frame buffer.");
+
+		unbind();
+
+		get_data(this)->frame_buffer = fb;
+		canvas(0, 0, image.width(), image.height(), image.pixel_density());
+	}
+
+	void
+	Painter::unbind ()
+	{
+		if (self->painting)
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
+
+		get_data(this)->frame_buffer = FrameBuffer();
+	}
+
+	void
+	Painter::begin ()
+	{
+		PainterData* self = get_data(this);
+
+		if (self->painting)
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be false.");
+
+		self->opengl_state.push();
+
+		//glEnable(GL_CULL_FACE);
+
+		glEnable(GL_DEPTH_TEST);
+		glDepthFunc(GL_LEQUAL);
+		OpenGL_check_error(__FILE__, __LINE__);
+
+		glEnable(GL_BLEND);
+		set_blend_mode(self->state.blend_mode);
+
+		FrameBuffer& fb = self->frame_buffer;
+		if (fb)
+		{
+			FrameBuffer_bind(fb.id());
+
+			Texture& tex = fb.texture();
+			if (tex) tex.set_modified();
+		}
+
+		const Bounds& vp = self->viewport;
+		float density    = self->pixel_density;
+		glViewport(
+			(int) (vp.x      * density), (int) (vp.y      * density),
+			(int) (vp.width  * density), (int) (vp.height * density));
+		OpenGL_check_error(__FILE__, __LINE__);
+
+		coord x1 = vp.x, x2 = vp.x + vp.width;
+		coord y1 = vp.y, y2 = vp.y + vp.height;
+		coord z1 = vp.z, z2 = vp.z + vp.depth;
+		if (z1 == 0 && z2 == 0) {z1 = -1000; z2 = 1000;}
+		if (!fb) std::swap(y1, y2);
+
+		self->position_matrix.reset(1);
+		self->position_matrix *= to_rays(glm::ortho(x1, x2, y1, y2));
+
+		// map z to 0.0-1.0
+		self->position_matrix.scale(1, 1, 1.0 / (z2 - z1));
+		self->position_matrix.translate(0, 0, -z2);
+
+		//self->position_matrix.translate(0.375f, 0.375f);
+
+		Painter_update_clip(this);
+
+		self->painting = true;
+
+		glClear(GL_DEPTH_BUFFER_BIT);
+	}
+
+	void
+	Painter::end ()
+	{
+		PainterData* self = get_data(this);
+
+		if (!self->painting)
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
+
+		if (!self->state_stack.empty())
+			invalid_state_error(__FILE__, __LINE__, "state stack is not empty.");
+
+		if (!self->position_matrix_stack.empty())
+			invalid_state_error(__FILE__, __LINE__, "position matrix stack is not empty.");
+
+		self->painting = false;
+		self->opengl_state.pop();
+		self->default_indices.clear();
+
+		glFinish();
+
+		if (self->frame_buffer)
+			FrameBuffer_unbind();
+	}
+
+	void
+	Painter::clear ()
+	{
+		if (!self->painting)
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
+
+		const Color& c = self->state.background;
+		glClearColor(c.red, c.green, c.blue, c.alpha);
+		glClear(GL_COLOR_BUFFER_BIT);
+		OpenGL_check_error(__FILE__, __LINE__);
+	}
+
+	void
+	Painter::set_blend_mode (BlendMode mode)
+	{
+		self->state.blend_mode = mode;
+		switch (mode)
+		{
+			case BLEND_NORMAL:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(
+					GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_ADD:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_SUBTRACT:
+				glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_LIGHTEST:
+				glBlendEquationSeparate(GL_MAX, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_DARKEST:
+				glBlendEquationSeparate(GL_MIN, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_EXCLUSION:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(
+					GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_MULTIPLY:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_ZERO, GL_SRC_COLOR, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_SCREEN:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_ONE_MINUS_DST_COLOR, GL_ONE, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_REPLACE:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
+				break;
+
+			default:
+				argument_error(__FILE__, __LINE__, "unknown blend mode");
+				break;
+		}
+		OpenGL_check_error(__FILE__, __LINE__);
+	}
+
+
+}// Rays