rays 0.3.9 → 0.3.11

data/src/painter.h

@@ -4,26 +4,225 @@
 #define __RAYS_SRC_PAINTER_H__
 
 
+#include <vector>
 #include "rays/painter.h"
-#include "opengl.h"
+#include "rays/bounds.h"
+#include "rays/color.h"
+#include "rays/font.h"
+#include "rays/image.h"
+#include "rays/shader.h"
+#include "matrix.h"
+#include "texture.h"
 
 
 namespace Rays
 {
 
 
-	void Painter_draw (
-		Painter* painter, GLenum mode, const Color& color,
-		const Coord3* points,           size_t npoints,
-		const uint*   indices   = NULL, size_t nindices = 0,
-		const Coord3* texcoords = NULL);
+	enum ColorType
+	{
+
+		FILL = 0,
+
+		STROKE,
+
+		COLOR_TYPE_MAX
+
+	};// ColorType
+
+
+	enum PrimitiveMode
+	{
+
+		MODE_NONE           = -1,
+
+		MODE_POINTS         = 0x0,
+
+		MODE_LINES          = 0x1,
+
+		MODE_LINE_LOOP      = 0x2,
+
+		MODE_LINE_STRIP     = 0x3,
+
+		MODE_TRIANGLES      = 0x4,
+
+		MODE_TRIANGLE_STRIP = 0x5,
+
+		MODE_TRIANGLE_FAN   = 0x6,
+
+		MODE_QUADS          = 0x7,
+
+		MODE_QUAD_STRIP     = 0x8,
+
+		MODE_POLYGON        = 0x9,
+
+	};// PrimitiveMode
+
+
+	struct State
+	{
+
+		Color background, colors[COLOR_TYPE_MAX];
+
+		bool nocolors[COLOR_TYPE_MAX];
+
+		coord stroke_width;
+
+		float stroke_outset;
+
+		CapType stroke_cap;
+
+		JoinType stroke_join;
+
+		coord miter_limit;
+
+		uint nsegment;
+
+		coord line_height;
+
+		BlendMode blend_mode;
+
+		Bounds clip;
+
+		Font font;
+
+		Image texture;
+
+		TexCoordMode texcoord_mode;
+
+		TexCoordWrap texcoord_wrap;
+
+		Shader shader;
+
+		void init ()
+		{
+			background       .reset(0, 0);
+			  colors[FILL]   .reset(1, 1);
+			  colors[STROKE] .reset(1, 0);
+			nocolors[FILL]   = false;
+			nocolors[STROKE] = true;
+			stroke_width     = 0;
+			stroke_outset    = 0;
+			stroke_cap       = CAP_DEFAULT;
+			stroke_join      = JOIN_DEFAULT;
+			miter_limit      = JOIN_DEFAULT_MITER_LIMIT;
+			nsegment         = 0;
+			line_height      = -1;
+			blend_mode       = BLEND_NORMAL;
+			clip             .reset(-1);
+			font             = get_default_font();
+			texture          = Image();
+			texcoord_mode    = TEXCOORD_IMAGE;
+			texcoord_wrap    = TEXCOORD_CLAMP;
+			shader           = Shader();
+		}
+
+		bool get_color (Color* color, ColorType type) const
+		{
+			const Color& c = colors[type];
+			if (blend_mode == BLEND_REPLACE ? nocolors[type] : !c)
+				return false;
+
+			*color = c;
+			return true;
+		}
+
+		bool has_color () const
+		{
+			if (blend_mode == BLEND_REPLACE)
+				return !nocolors[FILL] || !nocolors[STROKE];
+			else
+				return colors[FILL] || colors[STROKE];
+		}
+
+	};// State
+
+
+	struct TextureInfo
+	{
+
+		const Texture& texture;
+
+		Point min, max;
+
+		TextureInfo (
+			const Texture& texture,
+			coord x_min, coord y_min,
+			coord x_max, coord y_max)
+		:	texture(texture)
+		{
+			min.reset(x_min, y_min);
+			max.reset(x_max, y_max);
+		}
+
+		operator bool () const
+		{
+			return
+				texture &&
+				min.x < max.x &&
+				min.y < max.y;
+		}
+
+		bool operator ! () const
+		{
+			return !operator bool();
+		}
+
+	};// TextureInfo
+
+
+	struct Painter::Data
+	{
+
+		bool painting       = false;
+
+		float pixel_density = 1;
+
+		Bounds viewport;
+
+		State              state;
+
+		std::vector<State> state_stack;
+
+		Matrix              position_matrix;
+
+		std::vector<Matrix> position_matrix_stack;
+
+		Image text_image;
+
+		Data ()
+		{
+			state.init();
+		}
+
+		virtual ~Data () = default;
+
+		void set_pixel_density (float density);
+
+	};// Painter::Data
+
+
+	void Painter_update_clip (Painter* painter);
 
 	void Painter_draw (
-		Painter* painter, GLenum mode,
-		const Coord3* points,           size_t npoints,
-		const uint*   indices   = NULL, size_t nindices = 0,
-		const Color*  colors    = NULL,
-		const Coord3* texcoords = NULL);
+		Painter* painter, PrimitiveMode mode, const Color* color,
+		const Coord3* points,              size_t npoints,
+		const uint*   indices      = NULL, size_t nindices = 0,
+		const Color*  colors       = NULL,
+		const Coord3* texcoords    = NULL,
+		const TextureInfo* texinfo = NULL,
+		const Shader* shader       = NULL);
+
+	void Painter_draw_image (
+		Painter* painter, const Image& image,
+		coord src_x, coord src_y, coord src_w, coord src_h,
+		coord dst_x, coord dst_y, coord dst_w, coord dst_h,
+		bool nofill = false, bool nostroke = false,
+		const Shader* shader = NULL);
+
+	void Painter_draw_text_line (
+		Painter* painter, const Font& font, const char* line, coord x, coord y,
+		coord width = 0, coord height = 0);
 
 
 }// Rays

data/src/polygon.cpp

@@ -50,6 +50,32 @@ namespace Rays
 {
 
 
+	static void
+	draw_polygon (
+		Painter* painter, PrimitiveMode mode, const Color& color,
+		const Coord3* points,           size_t npoints,
+		const uint*   indices   = NULL, size_t nindices = 0,
+		const Coord3* texcoords = NULL)
+	{
+		Painter_draw(
+			painter, mode, &color, points, npoints, indices, nindices,
+			NULL, texcoords);
+	}
+
+	static void
+	draw_polygon (
+		Painter* painter, PrimitiveMode mode,
+		const Coord3* points,  size_t npoints,
+		const uint*   indices   = NULL, size_t nindices = 0,
+		const Color*  colors    = NULL,
+		const Coord3* texcoords = NULL)
+	{
+		Painter_draw(
+			painter, mode, NULL, points, npoints, indices, nindices,
+			colors, texcoords);
+	}
+
+
 	class Triangles
 	{
 
@@ -119,8 +145,8 @@ namespace Rays
 
 				if (pcolors)
 				{
-					Painter_draw(
-						painter, GL_TRIANGLES,
+					draw_polygon(
+						painter, MODE_TRIANGLES,
 						&points[0],  points.size(),
 						&indices[0], indices.size(),
 						&(*pcolors)[0],
@@ -128,8 +154,8 @@ namespace Rays
 				}
 				else
 				{
-					Painter_draw(
-						painter, GL_TRIANGLES, color,
+					draw_polygon(
+						painter, MODE_TRIANGLES, color,
 						&points[0],  points.size(),
 						&indices[0], indices.size(),
 						ptexcoords ? &(*ptexcoords)[0] : NULL);
@@ -383,8 +409,8 @@ namespace Rays
 
 				for (const auto& polyline : polylines)
 				{
-					Painter_draw(
-						painter, polyline.loop() ? GL_LINE_LOOP : GL_LINE_STRIP, color,
+					draw_polygon(
+						painter, polyline.loop() ? MODE_LINE_LOOP : MODE_LINE_STRIP, color,
 						&polyline[0], polyline.size());
 				}
 			}
@@ -666,8 +692,7 @@ namespace Rays
 				invalid_state_error(__FILE__, __LINE__);
 
 			const auto& outline = polylines[0];
-			Painter_draw(
-				painter, GL_TRIANGLE_FAN, color, &outline[0], outline.size());
+			draw_polygon(painter, MODE_TRIANGLE_FAN, color, &outline[0], outline.size());
 		}
 
 		private:
@@ -802,7 +827,7 @@ namespace Rays
 
 		typedef Polygon::Data Super;
 
-		GLenum mode = 0;
+		PrimitiveMode mode = MODE_NONE;
 
 		EllipseData (
 			coord x, coord y, coord width, coord height,
@@ -826,7 +851,7 @@ namespace Rays
 			if (polylines.size() <= 0)
 				invalid_state_error(__FILE__, __LINE__);
 
-			if (mode == 0)
+			if (mode == MODE_NONE)
 			{
 				Super::fill(painter, color);
 				return;
@@ -836,7 +861,7 @@ namespace Rays
 				invalid_state_error(__FILE__, __LINE__);
 
 			const auto& outline = polylines[0];
-			Painter_draw(painter, mode, color, &outline[0], outline.size());
+			draw_polygon(painter, mode, color, &outline[0], outline.size());
 		}
 
 		private:
@@ -867,7 +892,7 @@ namespace Rays
 				float radian_from = Xot::deg2rad(0);
 				float radian_to   = Xot::deg2rad(360);
 
-				if (!has_hole) mode = GL_TRIANGLE_FAN;
+				if (!has_hole) mode = MODE_TRIANGLE_FAN;
 
 				std::vector<Point> points;
 				points.reserve(nsegment);
@@ -915,7 +940,7 @@ namespace Rays
 				if (!has_hole)
 				{
 					points.emplace_back(x + width / 2, y + height / 2);
-					mode = GL_TRIANGLE_FAN;
+					mode = MODE_TRIANGLE_FAN;
 				}
 
 				for (uint seg = 0; seg <= nsegment; ++seg)

data/src/renderer.h

@@ -0,0 +1,22 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_RENDERER_H__
+#define __RAYS_SRC_RENDERER_H__
+
+
+#include "rays/defs.h"
+
+
+namespace Rays
+{
+
+
+	void Renderer_init ();
+
+	void Renderer_fin ();
+
+
+}// Rays
+
+
+#endif//EOH

data/src/sdl/bitmap.cpp

@@ -0,0 +1,304 @@
+#include "../bitmap.h"
+
+
+#define STB_IMAGE_IMPLEMENTATION
+#include <stb_image.h>
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include <stb_image_write.h>
+
+#include <SDL.h>
+#include <xot/util.h>
+#include "rays/exception.h"
+#include "../font.h"
+#include "../texture.h"
+
+
+namespace Rays
+{
+
+
+	struct Bitmap::Data
+	{
+
+		SDL_Surface* surface = NULL;
+
+		ColorSpace color_space;
+
+		bool modified;
+
+		Data ()
+		{
+			clear();
+		}
+
+		~Data ()
+		{
+			clear();
+		}
+
+		void clear ()
+		{
+			if (surface) SDL_FreeSurface(surface);
+
+			surface     = NULL;
+			color_space = COLORSPACE_UNKNOWN;
+			modified    = false;
+		}
+
+	};// Bitmap::Data
+
+
+	void
+	Bitmap_setup (
+		Bitmap* bitmap, int w, int h, const ColorSpace& cs,
+		const void* pixels, bool clear_pixels)
+	{
+		if (w <= 0)
+			argument_error(__FILE__, __LINE__);
+		if (h <= 0)
+			argument_error(__FILE__, __LINE__);
+		if (!cs)
+			argument_error(__FILE__, __LINE__);
+
+		Bitmap::Data* self = bitmap->self.get();
+		self->clear();
+
+		Uint32 r = 0, g = 0, b = 0, a = 0;
+		int depth = 0;
+		switch (cs.type())
+		{
+			case RGB_888:
+			case RGBA_8888:
+				depth              = cs.bpp();
+				r                  = 0x000000FF;
+				g                  = 0x0000FF00;
+				b                  = 0x00FF0000;
+				if (depth == 32) a = 0xFF000000;
+				break;
+
+			case GRAY_8:
+				depth = 8;
+				break;
+
+			default:
+				not_implemented_error(__FILE__, __LINE__, "unsupported color space");
+		}
+
+		self->surface = SDL_CreateRGBSurface(0, w, h, depth, r, g, b, a);
+		if (!self->surface)
+			rays_error(__FILE__, __LINE__, SDL_GetError());
+
+		self->color_space = cs;
+		self->modified    = true;
+
+		if (pixels)
+		{
+			SDL_LockSurface(self->surface);
+			memcpy(self->surface->pixels, pixels, self->surface->pitch * h);
+			SDL_UnlockSurface(self->surface);
+		}
+		else if (clear_pixels)
+			SDL_FillRect(self->surface, NULL, 0);
+	}
+
+	void
+	Bitmap_draw_string (
+		Bitmap* bitmap, const RawFont& font,
+		const char* str, coord x, coord y, bool smooth)
+	{
+		if (!bitmap)
+			argument_error(__FILE__, __LINE__);
+		if (!*bitmap)
+			argument_error(__FILE__, __LINE__);
+		if (!font)
+			argument_error(__FILE__, __LINE__);
+		if (!str)
+			argument_error(__FILE__, __LINE__);
+
+		if (*str == '\0') return;
+
+		font.draw_string(bitmap->self->surface, bitmap->height(), str, x, y);
+		Bitmap_set_modified(bitmap);
+	}
+
+	void
+	Bitmap_set_modified (Bitmap* bitmap, bool modified)
+	{
+		bitmap->self->modified = modified;
+	}
+
+	bool
+	Bitmap_get_modified (const Bitmap& bitmap)
+	{
+		return bitmap.self->modified;
+	}
+
+	static const char*
+	get_ext (const char* path)
+	{
+		if (!path)
+			return NULL;
+
+		return strrchr(path, '.');
+	}
+
+	void
+	Bitmap_save (const Bitmap& bmp, const char* path)
+	{
+		const char* extension = get_ext(path);
+		if (!extension)
+		{
+			argument_error(
+				__FILE__, __LINE__, "invalid image file extension: '%s'", path);
+		}
+
+		const auto& cs = bmp.color_space();
+		int w          = bmp.width();
+		int h          = bmp.height();
+		int pitch      = w * cs.Bpp();
+
+		std::unique_ptr<uchar[]> pixels(new uchar[h * pitch]);
+		for (int y = 0; y < h; ++y)
+			memcpy(pixels.get() + pitch * y, bmp.at<uchar>(0, y), pitch);
+
+		String ext = extension;
+		ext.downcase();
+
+		int ret = 0;
+		if      (ext == ".bmp")
+			ret = stbi_write_bmp(path, w, h, cs.Bpp(), pixels.get());
+		else if (ext == ".png")
+			ret = stbi_write_png(path, w, h, cs.Bpp(), pixels.get(), 0);
+		else if (ext == ".jpg" || ext == ".jpeg")
+			ret = stbi_write_jpg(path, w, h, cs.Bpp(), pixels.get(), 90);
+		else if (ext == ".tga")
+			ret = stbi_write_tga(path, w, h, cs.Bpp(), pixels.get());
+		else
+			argument_error(__FILE__, __LINE__, "unknown image file type");
+
+		if (!ret)
+			rays_error(__FILE__, __LINE__, "failed to save: '%s'", path);
+	}
+
+	Bitmap
+	Bitmap_load (const char* path)
+	{
+		if (!path)
+			argument_error(__FILE__, __LINE__);
+
+		int w = 0, h = 0, Bpp = 0;
+		uchar* pixels = stbi_load(path, &w, &h, &Bpp, 0);
+		if (!pixels)
+			rays_error(__FILE__, __LINE__, "failed to load: '%s'", path);
+
+		ColorSpace cs;
+		switch (Bpp)
+		{
+			case 1: cs = GRAY_8;    break;
+			case 3: cs = RGB_888;   break;
+			case 4: cs = RGBA_8888; break;
+			default:
+				rays_error(__FILE__, __LINE__, "unsupported image file: '%s'", path);
+		}
+
+		Bitmap bmp(w, h, cs);
+		if (!bmp)
+			rays_error(__FILE__, __LINE__, "failed to create Bitmap object");
+
+		int pitch = Bpp * w;
+		for (int y = 0; y < h; ++y)
+			memcpy(bmp.at<uchar>(0, y), pixels + pitch * y, pitch);
+
+		return bmp;
+	}
+
+
+	Bitmap::Bitmap ()
+	{
+	}
+
+	Bitmap::Bitmap (
+		int width, int height, const ColorSpace& color_space, const void* pixels)
+	{
+		Bitmap_setup(this, width, height, color_space, pixels);
+	}
+
+	Bitmap::~Bitmap ()
+	{
+	}
+
+	Bitmap
+	Bitmap::dup () const
+	{
+		return Bitmap(width(), height(), color_space(), pixels());
+	}
+
+	int
+	Bitmap::width () const
+	{
+		if (!*this) return 0;
+		return self->surface->w;
+	}
+
+	int
+	Bitmap::height () const
+	{
+		if (!*this) return 0;
+		return self->surface->h;
+	}
+
+	const ColorSpace&
+	Bitmap::color_space () const
+	{
+		if (!*this)
+		{
+			static const ColorSpace UNKNOWN = COLORSPACE_UNKNOWN;
+			return UNKNOWN;
+		}
+		return self->color_space;
+	}
+
+	int
+	Bitmap::pitch () const
+	{
+		if (!*this) return 0;
+		return self->surface->pitch;
+	}
+
+	size_t
+	Bitmap::size () const
+	{
+		return pitch() * height();
+	}
+
+	void*
+	Bitmap::pixels ()
+	{
+		if (!*this) return NULL;
+		return self->surface->pixels;
+	}
+
+	const void*
+	Bitmap::pixels () const
+	{
+		return const_cast<This*>(this)->pixels();
+	}
+
+	Bitmap::operator bool () const
+	{
+		return
+			self->surface         &&
+			self->surface->w > 0  &&
+			self->surface->h > 0  &&
+			self->surface->pixels &&
+			self->color_space;
+	}
+
+	bool
+	Bitmap::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays