rays 0.1.12 → 0.1.13

data/src/polygon.h

@@ -0,0 +1,32 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_POLYGON_H__
+#define __RAYS_SRC_POLYGON_H__
+
+
+#include <vector>
+#include <rays/polygon.h>
+
+
+namespace Rays
+{
+
+
+	class Painter;
+	struct Color;
+
+
+	void Polygon_fill (
+		const Polygon& polygon, Painter* painter, const Color& color);
+
+	void Polygon_stroke (
+		const Polygon& polygon, Painter* painter, const Color& color);
+
+	bool Polygon_triangulate (
+		Polygon::TrianglePointList* triangles, const Polygon& polygon);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/polyline.cpp

@@ -0,0 +1,158 @@
+#include "polyline.h"
+
+
+#include <assert.h>
+#include "rays/debug.h"
+
+
+using namespace ClipperLib;
+
+
+namespace Rays
+{
+
+
+	struct Polyline::Data
+	{
+
+		PointList points;
+
+		bool loop = false;
+
+		template <typename I, typename FUN>
+		void reset (I begin, I end, bool loop_, FUN to_point_fun)
+		{
+			size_t size = end - begin;
+			if (0 < size && size < 3 && loop_)
+				argument_error(__FILE__, __LINE__);
+
+			points.clear();
+			points.reserve(size);
+			for (auto it = begin; it != end; ++it)
+				points.emplace_back(to_point_fun(*it));
+
+			loop = loop_ && size > 0;
+		}
+
+	};// Polyline::Data
+
+
+	void
+	Polyline_create (
+		Polyline* polyline, const Path& path, bool loop, bool reverse)
+	{
+		assert(polyline);
+
+		Path cleaned;
+		ClipperLib::CleanPolygon(path, cleaned);
+
+		auto to_point = [](const IntPoint& point) {return from_clipper(point);};
+		if (reverse)
+			polyline->self->reset(cleaned.rbegin(), cleaned.rend(), loop, to_point);
+		else
+			polyline->self->reset(cleaned. begin(), cleaned. end(), loop, to_point);
+	}
+
+	template <typename I>
+	static void
+	reset_path (Path* path, I begin, I end)
+	{
+		path->clear();
+		for (auto it = begin; it != end; ++it)
+			path->emplace_back(to_clipper(*it));
+	}
+
+	void
+	Polyline_get_path (Path* path, const Polyline& polyline, bool reverse)
+	{
+		assert(path);
+
+		const auto& points = polyline.self->points;
+		if (reverse)
+			reset_path(path, points.rbegin(), points.rend());
+		else
+			reset_path(path, points. begin(), points. end());
+	}
+
+
+	Polyline::Polyline ()
+	{
+	}
+
+	Polyline::Polyline (const Point* points, size_t size, bool loop)
+	{
+		self->reset(points, points + size, loop, [](const Point& p) {return p;});
+	}
+
+	Polyline::~Polyline ()
+	{
+	}
+
+	bool
+	Polyline::expand (Polygon* result, coord width) const
+	{
+		return Polyline_expand(result, *this, width);
+	}
+
+	Bounds
+	Polyline::bounds () const
+	{
+		if (empty()) return Bounds(-1, -1, -1);
+
+		auto it = begin();
+		Bounds b(*it++, 0);
+		for (auto end = this->end(); it != end; ++it)
+			b |= *it;
+		return b;
+	}
+
+	bool
+	Polyline::loop () const
+	{
+		return self->loop;
+	}
+
+	size_t
+	Polyline::size () const
+	{
+		return self->points.size();
+	}
+
+	bool
+	Polyline::empty () const
+	{
+		return size() <= 0;
+	}
+
+	Polyline::const_iterator
+	Polyline::begin () const
+	{
+		return self->points.begin();
+	}
+
+	Polyline::const_iterator
+	Polyline::end () const
+	{
+		return self->points.end();
+	}
+
+	const Point&
+	Polyline::operator [] (size_t index) const
+	{
+		return self->points[index];
+	}
+
+	Polyline::operator bool () const
+	{
+		size_t s = size();
+		return !((s == 1 || s == 2) && self->loop);
+	}
+
+	bool
+	Polyline::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays

data/src/polyline.h

@@ -0,0 +1,67 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_POLYLINE_H__
+#define __RAYS_SRC_POLYLINE_H__
+
+
+#include <float.h>
+#include <clipper.hpp>
+#include <rays/polyline.h>
+#include <rays/exception.h>
+
+
+namespace Rays
+{
+
+
+	static const double CLIPPER_SCALE = 1000;
+
+
+	inline ClipperLib::cInt
+	to_clipper (coord value)
+	{
+		return (ClipperLib::cInt) (value * CLIPPER_SCALE);
+	}
+
+	inline coord
+	from_clipper (ClipperLib::cInt value)
+	{
+		double v = value / CLIPPER_SCALE;
+		if (v <= -FLT_MAX || FLT_MAX <= v)
+			argument_error(__FILE__, __LINE__);
+
+		return (coord) v;
+	}
+
+	inline ClipperLib::IntPoint
+	to_clipper (const Point& point)
+	{
+		return ClipperLib::IntPoint(
+			to_clipper(point.x),
+			to_clipper(point.y));
+	}
+
+	inline Point
+	from_clipper (const ClipperLib::IntPoint& point)
+	{
+		return Point(
+			from_clipper(point.X),
+			from_clipper(point.Y));
+	}
+
+
+	void Polyline_create (
+		Polyline* polyline, const ClipperLib::Path& path, bool loop,
+		bool reverse = false);
+
+	void Polyline_get_path (
+		ClipperLib::Path* path, const Polyline& polyline,
+		bool reverse = false);
+
+	bool Polyline_expand (Polygon* result, const Polyline& polyline, coord width);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/render_buffer.cpp

@@ -41,15 +41,22 @@ namespace Rays
 
 			GLuint id_ = 0;
 			glGenRenderbuffers(1, &id_);
-			check_error(__FILE__, __LINE__);
+			OpenGL_check_error(__FILE__, __LINE__);
 
 			id = id_;
 			glBindRenderbuffer(GL_RENDERBUFFER, id_);
-			check_error(__FILE__, __LINE__);
+			OpenGL_check_error(__FILE__, __LINE__);
 
 			glRenderbufferStorage(
-				GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width, height);
-			check_error(__FILE__, __LINE__);
+				GL_RENDERBUFFER,
+				#ifdef IOS
+					GL_DEPTH_COMPONENT16,
+				#else
+					GL_DEPTH_COMPONENT24,
+				#endif
+				width,
+				height);
+			OpenGL_check_error(__FILE__, __LINE__);
 
 			width  = width_;
 			height = height_;

data/src/render_buffer.h

@@ -6,7 +6,7 @@
 
 #include <xot/pimpl.h>
 #include <rays/defs.h>
-#include <rays/opengl.h>
+#include "opengl.h"
 
 
 namespace Rays
@@ -36,7 +36,7 @@ namespace Rays
 
 			struct Data;
 
-			Xot::PImpl<Data, true> self;
+			Xot::PSharedImpl<Data> self;
 
 	};// RenderBuffer
 

data/src/shader.cpp

@@ -1,187 +1,244 @@
-#include "rays/shader.h"
+#include "shader.h"
 
 
-#ifndef IOS
-#define USE_SHADER
-#endif
-
-
-#ifdef USE_SHADER
-
-
-#include <boost/scoped_array.hpp>
 #include "rays/exception.h"
+#include "opengl.h"
+#include "image.h"
+#include "shader_program.h"
+#include "shader_source.h"
 
 
 namespace Rays
 {
 
 
-	struct Shader::Data
-	{
-
-		int id;
-
-		Data ()
-		:	id(-1)
-		{
-		}
-
-		~Data ()
-		{
-			clear();
-		}
+	static const ShaderSource&
+	get_vertex_shader_source ()
+	{
+		static const ShaderSource SOURCE(
+			GL_VERTEX_SHADER,
+			"attribute vec3 "  ATTRIB_POSITION ";"
+			"varying   vec4 " VARYING_POSITION ";"
+			"uniform   mat4 " UNIFORM_POSITION_MATRIX ";"
+			"attribute vec3 "  ATTRIB_TEXCOORD ";"
+			"varying   vec4 " VARYING_TEXCOORD ";"
+			"uniform   mat4 " UNIFORM_TEXCOORD_MATRIX ";"
+			"attribute vec4 "  ATTRIB_COLOR ";"
+			"varying   vec4 " VARYING_COLOR ";"
+			"void main ()"
+			"{"
+			"  vec4 pos           = vec4(" ATTRIB_POSITION ", 1.0);"
+			"  vec4 texcoord      = vec4(" ATTRIB_TEXCOORD ", 1.0);"
+			   VARYING_POSITION " = pos;"
+			   VARYING_TEXCOORD " = " UNIFORM_TEXCOORD_MATRIX " * texcoord;"
+			   VARYING_COLOR    " = " ATTRIB_COLOR ";"
+			"  gl_Position        = " UNIFORM_POSITION_MATRIX " * pos;"
+			"}");
+		return SOURCE;
+	}
+
+	static ShaderSource
+	make_fragment_shader_source (const char* source)
+	{
+		static String SHARED_HEADER =
+			"#ifdef GL_ES\n"
+			"precision mediump float;\n"
+			"#endif\n"
+			"uniform sampler2D " UNIFORM_TEXTURE ";"
+			"uniform vec2 "      UNIFORM_TEXTURE_SIZE ";"
+			"uniform vec2 "      UNIFORM_TEXCOORD_MIN ";"
+			"uniform vec2 "      UNIFORM_TEXCOORD_MAX ";"
+			"vec2 normalizeTexCoord(vec2 texcoord)"
+			"{"
+			"  vec2 min = " UNIFORM_TEXCOORD_MIN ";"
+			"  vec2 len = " UNIFORM_TEXCOORD_MAX " - min;"
+			"  return (mod(texcoord - min, len) + min) / " UNIFORM_TEXTURE_SIZE ";"
+			"}"
+			"vec4 sampleTexture(vec2 texcoord)"
+			"{"
+			"  return texture2D(" UNIFORM_TEXTURE ", normalizeTexCoord(texcoord));"
+			"}\n";
+		return ShaderSource(GL_FRAGMENT_SHADER, SHARED_HEADER + source);
+	}
 
-		void clear ()
-		{
-			if (id >= 0) glDeleteShader((GLuint) id);
 
-			id = -1;
-		}
+	struct Shader::Data
+	{
 
-		bool is_valid () const
-		{
-			return id >= 0;
-		}
+		std::unique_ptr<ShaderProgram> program;
 
 	};// Shader::Data
 
 
-	void
-	compile_shader (Shader* this_, const char* source)
+	const ShaderProgram*
+	Shader_get_program (const Shader& shader)
 	{
-		if (!this_ || !source)
-			argument_error(__FILE__, __LINE__);
-
-		Shader::Data* self = this_->self.get();
-		if (self->is_valid())
-			invalid_state_error(__FILE__, __LINE__);
-
-		self->id = glCreateShader(GL_FRAGMENT_SHADER);
-		glShaderSource(self->id, 1, &source, NULL);
-		glCompileShader(self->id);
-
-		GLint status = GL_FALSE;
-		glGetShaderiv(self->id, GL_COMPILE_STATUS, &status);
-		if (status == GL_FALSE)
-		{
-			int len = 0;
-			glGetShaderiv(self->id, GL_INFO_LOG_LENGTH, &len);
-
-			boost::scoped_array<char> buffer(new char[len]);
-			int written = 0;
-			glGetShaderInfoLog(self->id, len, &written, &buffer[0]);
-
-			opengl_error(__FILE__, __LINE__, &buffer[0]);
-		}
-
-		check_error(__FILE__, __LINE__);
+		return shader.self->program ? shader.self->program.get() : NULL;
 	}
 
 
-	Shader::Shader ()
-	{
-	}
-
 	Shader::Shader (const char* source)
 	{
-		compile_shader(this, source);
+		if (!source) return;
+
+		self->program.reset(new ShaderProgram(
+			get_vertex_shader_source(),
+			make_fragment_shader_source(source)));
 	}
 
 	Shader::~Shader ()
 	{
 	}
 
-	GLuint
-	Shader::id () const
+	void
+	Shader::set_uniform (const char* name, int arg1)
 	{
-		return self->id;
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->program->set_uniform(name, arg1);
 	}
 
-	bool
-	Shader::operator == (const Shader& rhs) const
+	void
+	Shader::set_uniform (const char* name, int arg1, int arg2)
 	{
-		return self->id == rhs.self->id;
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->program->set_uniform(name, arg1, arg2);
 	}
 
-	bool
-	Shader::operator != (const Shader& rhs) const
+	void
+	Shader::set_uniform (const char* name, int arg1, int arg2, int arg3)
 	{
-		return !operator==(rhs);
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->program->set_uniform(name, arg1, arg2, arg3);
 	}
 
-	Shader::operator bool () const
+	void
+	Shader::set_uniform (const char* name, int arg1, int arg2, int arg3, int arg4)
 	{
-		return self->is_valid();
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->program->set_uniform(name, arg1, arg2, arg3, arg4);
 	}
 
-	bool
-	Shader::operator ! () const
+	void
+	Shader::set_uniform (const char* name, const int* args, size_t size)
 	{
-		return !operator bool();
-	}
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
 
+		self->program->set_uniform(name, args, size);
+	}
 
-}// Rays
+	void
+	Shader::set_uniform (const char* name, float arg1)
+	{
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
 
+		self->program->set_uniform(name, arg1);
+	}
 
-#else// USE_SHADER
+	void
+	Shader::set_uniform (const char* name, float arg1, float arg2)
+	{
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
 
+		self->program->set_uniform(name, arg1, arg2);
+	}
 
-#include "rays/exception.h"
+	void
+	Shader::set_uniform (const char* name, float arg1, float arg2, float arg3)
+	{
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
 
+		self->program->set_uniform(name, arg1, arg2, arg3);
+	}
 
-namespace Rays
-{
+	void
+	Shader::set_uniform (
+		const char* name, float arg1, float arg2, float arg3, float arg4)
+	{
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
 
+		self->program->set_uniform(name, arg1, arg2, arg3, arg4);
+	}
 
-	struct Shader::Data {};
+	void
+	Shader::set_uniform (const char* name, const float* args, size_t size)
+	{
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
 
+		self->program->set_uniform(name, args, size);
+	}
 
-	Shader::Shader ()
+	void
+	Shader::set_uniform (const char* name, const Coord2& vec2)
 	{
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->program->set_uniform(name, vec2);
 	}
 
-	Shader::Shader (const char* source)
+	void
+	Shader::set_uniform (const char* name, const Coord3& vec3)
 	{
-		not_implemented_error(__FILE__, __LINE__);
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->program->set_uniform(name, vec3);
 	}
 
-	Shader::~Shader ()
+	void
+	Shader::set_uniform (const char* name, const Coord4& vec4)
 	{
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->program->set_uniform(name, vec4);
 	}
 
-	GLuint
-	Shader::id () const
+	void
+	Shader::set_uniform (const char* name, const Image& texture)
 	{
-		return 0;
+		if (!self->program)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->program->set_uniform(name, Image_get_texture(texture));
 	}
 
-	bool
-	Shader::operator == (const Shader& rhs) const
+	Shader::operator bool () const
 	{
-		return false;
+		return self->program && *self->program;
 	}
 
 	bool
-	Shader::operator != (const Shader& rhs) const
+	Shader::operator ! () const
 	{
-		return !operator==(rhs);
+		return !operator bool();
 	}
 
-	Shader::operator bool () const
+	bool
+	operator == (const Shader& lhs, const Shader& rhs)
 	{
-		return false;
+		return (!lhs && !rhs) || lhs.self->program == rhs.self->program;
 	}
 
 	bool
-	Shader::operator ! () const
+	operator != (const Shader& lhs, const Shader& rhs)
 	{
-		return !operator bool();
+		return !operator==(lhs, rhs);
 	}
 
 
 }// Rays
-
-
-#endif// USE_SHADER