rays 0.1.12 → 0.1.13

data/src/{program.h → shader_program.h}

@@ -1,34 +1,33 @@
 // -*- c++ -*-
 #pragma once
-#ifndef __RAYS_SRC_PROGRAM_H__
-#define __RAYS_SRC_PROGRAM_H__
+#ifndef __RAYS_SRC_SHADER_PROGRAM_H__
+#define __RAYS_SRC_SHADER_PROGRAM_H__
 
 
 #include <xot/pimpl.h>
-#include <rays/opengl.h>
+#include <rays/defs.h>
+#include <rays/coord.h>
+#include "opengl.h"
 
 
 namespace Rays
 {
 
 
-	class Shader;
+	class ShaderSource;
+	class Texture;
 
 
-	class Program
+	class ShaderProgram
 	{
 
-		typedef Program This;
+		typedef ShaderProgram This;
 
 		public:
 
-			Program ();
+			ShaderProgram (const ShaderSource& vertex, const ShaderSource& fragment);
 
-			~Program ();
-
-			void attach (const Shader& shader);
-
-			void detach (const Shader& shader);
+			~ShaderProgram ();
 
 			void set_uniform (const char* name, int arg1);
 
@@ -50,9 +49,13 @@ namespace Rays
 
 			void set_uniform (const char* name, const float* args, size_t size);
 
-			void push ();
+			void set_uniform (const char* name, const Coord2& vec2);
+
+			void set_uniform (const char* name, const Coord3& vec3);
 
-			void pop ();
+			void set_uniform (const char* name, const Coord4& vec4);
+
+			void set_uniform (const char* name, const Texture& texture);
 
 			GLuint id () const;
 
@@ -60,11 +63,20 @@ namespace Rays
 
 			bool operator ! () const;
 
+			friend bool operator == (const This& lhs, const This& rhs);
+
+			friend bool operator != (const This& lhs, const This& rhs);
+
 			struct Data;
 
-			Xot::PImpl<Data, true> self;
+			Xot::PSharedImpl<Data> self;
+
+	};// ShaderProgram
+
+
+	void ShaderProgram_activate (const ShaderProgram& program);
 
-	};// Program
+	void ShaderProgram_deactivate ();
 
 
 }// Rays

data/src/shader_source.cpp

@@ -0,0 +1,140 @@
+#include "shader_source.h"
+
+
+#include "rays/exception.h"
+#include "rays/debug.h"
+
+
+namespace Rays
+{
+
+
+	struct ShaderSource::Data
+	{
+
+		GLuint id = 0;
+
+		GLenum type = 0;
+
+		String source;
+
+		Data ()
+		{
+		}
+
+		~Data ()
+		{
+			clear();
+		}
+
+		void compile (GLenum type_, const char* source_)
+		{
+			if (!is_valid_type(type_) || !source_ || !*source_)
+				argument_error(__FILE__, __LINE__);
+
+			if (is_valid())
+				invalid_state_error(__FILE__, __LINE__);
+
+			id = glCreateShader(type_);
+			glShaderSource(id, 1, &source_, NULL);
+			glCompileShader(id);
+
+			GLint status = GL_FALSE;
+			glGetShaderiv(id, GL_COMPILE_STATUS, &status);
+			if (status == GL_FALSE)
+				opengl_error(__FILE__, __LINE__, get_compile_log().c_str());
+
+			type   = type_;
+			source = source_;
+		}
+
+		String get_compile_log () const
+		{
+			GLsizei len = 0;
+			glGetShaderiv(id, GL_INFO_LOG_LENGTH, &len);
+			if (len <= 0) return "";
+
+			std::unique_ptr<char[]> buffer(new char[len]);
+			int written = 0;
+			glGetShaderInfoLog(id, len, &written, &buffer[0]);
+			return buffer.get();
+		}
+
+		void clear ()
+		{
+			if (id > 0) glDeleteShader(id);
+
+			id   = 0;
+			type = 0;
+			source.clear();
+		}
+
+		bool is_valid () const
+		{
+			return is_valid_type(type) && id > 0;
+		}
+
+		static bool is_valid_type (GLenum type)
+		{
+			return type == GL_VERTEX_SHADER || type == GL_FRAGMENT_SHADER;
+		}
+
+	};// ShaderSource::Data
+
+
+	ShaderSource::ShaderSource ()
+	{
+	}
+
+	ShaderSource::ShaderSource (GLenum type, const char* source)
+	{
+		self->compile(type, source);
+	}
+
+	ShaderSource::~ShaderSource ()
+	{
+	}
+
+	const char*
+	ShaderSource::source () const
+	{
+		return self->source;
+	}
+
+	GLenum
+	ShaderSource::type () const
+	{
+		return self->type;
+	}
+
+	GLuint
+	ShaderSource::id () const
+	{
+		return self->id;
+	}
+
+	ShaderSource::operator bool () const
+	{
+		return self->is_valid();
+	}
+
+	bool
+	ShaderSource::operator ! () const
+	{
+		return !operator bool();
+	}
+
+	bool
+	operator == (const ShaderSource& lhs, const ShaderSource& rhs)
+	{
+		return (!lhs && !rhs) || lhs.self->id == rhs.self->id;
+	}
+
+	bool
+	operator != (const ShaderSource& lhs, const ShaderSource& rhs)
+	{
+		return !operator==(lhs, rhs);
+	}
+
+
+}// Rays

data/src/shader_source.h

@@ -0,0 +1,52 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_SHADER_SOURCE_H__
+#define __RAYS_SRC_SHADER_SOURCE_H__
+
+
+#include <xot/pimpl.h>
+#include "opengl.h"
+
+
+namespace Rays
+{
+
+
+	class ShaderSource
+	{
+
+		typedef ShaderSource This;
+
+		public:
+
+			ShaderSource ();
+
+			ShaderSource (GLenum type, const char* source);
+
+			~ShaderSource ();
+
+			const char* source () const;
+
+			GLenum type () const;
+
+			GLuint id () const;
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			friend bool operator == (const This& lhs, const This& rhs);
+
+			friend bool operator != (const This& lhs, const This& rhs);
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+	};// ShaderSource
+
+
+}// Rays
+
+
+#endif//EOH

data/src/texture.cpp

@@ -1,9 +1,12 @@
-#include "rays/texture.h"
+#include "texture.h"
 
 
+#include <assert.h>
 #include "rays/exception.h"
 #include "rays/bitmap.h"
-#include "rays/opengl.h"
+#include "rays/debug.h"
+#include "opengl.h"
+#include "color_space.h"
 #include "frame_buffer.h"
 
 
@@ -14,14 +17,17 @@ namespace Rays
 	struct Texture::Data
 	{
 
-		int id, width, height, width_pow2, height_pow2;
+		Context context = NULL;
+
+		GLuint id = 0;
+
+		int width, height, width_pow2, height_pow2;
 
 		ColorSpace color_space;
 
-		bool alpha_only, dirty;
+		bool modified;
 
 		Data ()
-		:	id(-1)
 		{
 			clear();
 		}
@@ -33,47 +39,40 @@ namespace Rays
 
 		void clear ()
 		{
-			if (id >= 0)
-			{
-				GLuint id_ = id;
-				glDeleteTextures(1, &id_);
-			}
-
-			id = -1;
-			width = height = width_pow2 = height_pow2 = 0;
+			delete_texture();
+
+			width       =
+			height      =
+			width_pow2  =
+			height_pow2 = 0;
 			color_space = COLORSPACE_UNKNOWN;
-			alpha_only = dirty = false;
+			modified    = false;
 		}
 
-	};// Texture::Data
+		void delete_texture ()
+		{
+			if (!has_id()) return;
 
+			Context current_context = OpenGL_get_context();
 
-	static void
-	create_texture (
-		Texture::Data* self, const Bitmap* bitmap, GLenum format, GLenum type)
-	{
-		if (!self || (bitmap && !*bitmap))
-			argument_error(__FILE__, __LINE__);
+			assert(context);
+			OpenGL_set_context(context);
 
-		GLuint id = 0;
-		glGenTextures(1, &id);
-		glBindTexture(GL_TEXTURE_2D, id);
-		if (glIsTexture(id) == GL_FALSE)
-			opengl_error(__FILE__, __LINE__, "failed to create texture.");
+			glDeleteTextures(1, &id);
 
-		self->id = id;
+			OpenGL_set_context(current_context);
 
-		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);//GL_LINEAR);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);//GL_LINEAR);
+			context = NULL;
+			id      = 0;
+		}
 
-		glTexImage2D(
-			GL_TEXTURE_2D, 0, format, self->width_pow2, self->height_pow2, 0,
-			format, type, bitmap ? bitmap->pixels() : NULL);
+		bool has_id () const
+		{
+			return context && id > 0;
+		}
+
+	};// Texture::Data
 
-		check_error(__FILE__, __LINE__);
-	}
 
 	static int
 	min_pow2 (int num)
@@ -84,26 +83,35 @@ namespace Rays
 	}
 
 	static void
-	colorspace_for_alphabitmap (ColorSpace* result, ColorSpace cs)
+	setup_texture (Texture::Data* self, const void* pixels = NULL)
 	{
-		if (!result || !cs)
-			argument_error(__FILE__, __LINE__);
+		assert(self && !self->has_id());
 
-		*result = COLORSPACE_UNKNOWN;
+		if (self->context)
+			invalid_state_error(__FILE__, __LINE__);
 
-		if (cs.is_float())
-			*result = GRAY_float;
-		else
-		{
-			switch (cs.bpc())
-			{
-				case 8:  *result = GRAY_8;  break;
-				case 16: *result = GRAY_16; break;
-				case 24: *result = GRAY_24; break;
-				case 32: *result = GRAY_32; break;
-				default: rays_error(__FILE__, __LINE__, "invalid bpc.");
-			}
-		}
+		self->context = OpenGL_get_context();
+		if (!self->context)
+			opengl_error(__FILE__, __LINE__);
+
+		glGenTextures(1, &self->id);
+		glBindTexture(GL_TEXTURE_2D, self->id);
+		if (glIsTexture(self->id) == GL_FALSE)
+			opengl_error(__FILE__, __LINE__, "failed to create texture.");
+
+		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);//GL_LINEAR);
+
+		GLenum format, type;
+		ColorSpace_get_gl_format_and_type(&format, &type, self->color_space);
+
+		glTexImage2D(
+			GL_TEXTURE_2D, 0, format, self->width_pow2, self->height_pow2, 0,
+			format, type, pixels);
+
+		OpenGL_check_error(__FILE__, __LINE__);
 	}
 
 	template <int BytesPerPixel>
@@ -141,134 +149,104 @@ namespace Rays
 	static inline void
 	copy_pixels (
 		size_t width,
-		uchar* dest, size_t dest_offset, const uchar* src, size_t src_offset)
+		uchar* dest, size_t dest_stride, const uchar* src, size_t src_stride)
 	{
-		if (!dest || !src || dest_offset <= 0 || src_offset <= 0)
+		if (!dest || !src || dest_stride <= 0 || src_stride <= 0)
 			argument_error(__FILE__, __LINE__);
 
 		while (width--)
 		{
 			copy_pixel<BytesPerPixel>(dest, src);
-			dest += dest_offset;
-			src  += src_offset;
+			dest += dest_stride;
+			src  += src_stride;
 		}
 	}
 
 	static inline void
 	copy_pixels (
 		size_t Bpp, size_t width,
-		uchar* dest, size_t dest_offset, const uchar* src, size_t src_offset)
+		uchar* dest, size_t dest_stride, const uchar* src, size_t src_stride)
 	{
 		switch (Bpp)
 		{
-			case 1: copy_pixels<1>(width, dest, dest_offset, src, src_offset); break;
-			case 2: copy_pixels<2>(width, dest, dest_offset, src, src_offset); break;
-			case 3: copy_pixels<3>(width, dest, dest_offset, src, src_offset); break;
-			case 4: copy_pixels<4>(width, dest, dest_offset, src, src_offset); break;
+			case 1: copy_pixels<1>(width, dest, dest_stride, src, src_stride); break;
+			case 2: copy_pixels<2>(width, dest, dest_stride, src, src_stride); break;
+			case 3: copy_pixels<3>(width, dest, dest_stride, src, src_stride); break;
+			case 4: copy_pixels<4>(width, dest, dest_stride, src, src_stride); break;
 		}
 	}
 
 	static void
-	copy_bitmap (Bitmap* dest, const Bitmap& src, int src_offset = 0)
+	copy_bitmap (Bitmap* dest, const Bitmap& src)
 	{
-		if (!dest || !src || src_offset < 0)
+		if (!dest || !src)
 			argument_error(__FILE__, __LINE__);
 
+		int width    = std::min(src.width(),  dest->width());
+		int height   = std::min(src.height(), dest->height());
 		int src_Bpp  = src.color_space().Bpp();
-		int src_Bpc  = src.color_space().Bpc();
 		int dest_Bpp = dest->color_space().Bpp();
 
-		if (src_offset >= (src_Bpp / src_Bpc))
-			rays_error(__FILE__, __LINE__, "invalid src_offset.");
-
-		int width  = std::min(src.width(),  dest->width());
-		int height = std::min(src.height(), dest->height());
-
 		for (int y = 0; y < height; ++y)
 		{
-			const uchar* s = src.  at<uchar>(0, y) + src_offset * src_Bpc;
-			      uchar* d = dest->at<uchar>(0, y);
-			copy_pixels(src_Bpp, width, d, dest_Bpp, s, src_Bpp);
+			copy_pixels(
+				src_Bpp, width,
+				dest->at<uchar>(0, y), dest_Bpp,
+				src.  at<uchar>(0, y),  src_Bpp);
 		}
 	}
 
-	static void
-	setup_texture (
-		Texture::Data* self, int width, int height, const ColorSpace& cs,
-		const Bitmap* bitmap, bool alpha_only)
-	{
-		if (!self || width <= 0 || height <= 0 || !cs || (bitmap && !*bitmap))
-			argument_error(__FILE__, __LINE__);
 
-		GLenum format, type;
-		cs.get_gl_enums(&format, &type, alpha_only);
+	Texture::Texture ()
+	{
+	}
 
-		self->clear();
+	Texture::Texture (int width, int height, const ColorSpace& cs)
+	{
+		if (width <= 0 || height <= 0 || !cs)
+			argument_error(__FILE__, __LINE__);
 
 		self->width       = width;
 		self->height      = height;
 		self->width_pow2  = min_pow2(width);
 		self->height_pow2 = min_pow2(height);
 		self->color_space = cs;
-		self->alpha_only  = alpha_only;
-		self->dirty       = true;
-
-		if (alpha_only)
-		{
-			colorspace_for_alphabitmap(&self->color_space, cs);
-			if (!self->color_space.is_gray())
-				rays_error(__FILE__, __LINE__, "alpha_only takes only gray color-space.");
-		}
-
-		Bitmap bmp;
-		if (bitmap)
-		{
-			if (
-				self->color_space != cs ||
-				self->width_pow2  != self->width ||
-				self->height_pow2 != self->height)
-			{
-				bmp = Bitmap(self->width_pow2, self->height_pow2, self->color_space);
-				if (!bmp)
-					rays_error(__FILE__, __LINE__, "creating bitmap failed.");
-
-				copy_bitmap(&bmp, *bitmap, alpha_only ? self->color_space.alpha_pos() : 0);
-				bitmap = &bmp;
-			}
-		}
+		self->modified    = true;
 
-		create_texture(self, bitmap, format, type);
+		setup_texture(self.get());
 	}
 
-
-	Texture::Texture ()
+	Texture::Texture (const Bitmap& bitmap)
 	{
-	}
+		if (!bitmap)
+			argument_error(__FILE__, __LINE__);
 
-	Texture::Texture (int width, int height, const ColorSpace& cs, bool alpha_only)
-	{
-		setup_texture(
-			self.get(), width, height, cs,
-			NULL, alpha_only);
-	}
+		self->width       = bitmap.width();
+		self->height      = bitmap.height();
+		self->width_pow2  = min_pow2(self->width);
+		self->height_pow2 = min_pow2(self->height);
+		self->color_space = bitmap.color_space();
+		self->modified    = true;
+
+		Bitmap bmp = bitmap;
+		if (
+			self->width_pow2  != self->width ||
+			self->height_pow2 != self->height)
+		{
+			bmp = Bitmap(self->width_pow2, self->height_pow2, self->color_space);
+			if (!bmp)
+				rays_error(__FILE__, __LINE__);
 
-	Texture::Texture (const Bitmap& bitmap, bool alpha_only)
-	{
-		setup_texture(
-			self.get(), bitmap.width(), bitmap.height(), bitmap.color_space(),
-			&bitmap, alpha_only);
+			copy_bitmap(&bmp, bitmap);
+		}
+
+		setup_texture(self.get(), bmp.pixels());
 	}
 
 	Texture::~Texture ()
 	{
 	}
 
-	GLuint
-	Texture::id () const
-	{
-		return self->id;
-	}
-
 	int
 	Texture::width () const
 	{
@@ -276,62 +254,60 @@ namespace Rays
 	}
 
 	int
-	Texture::height () const
+	Texture::reserved_width () const
 	{
-		return self->height;
+		return self->width_pow2;
 	}
 
-	const ColorSpace&
-	Texture::color_space () const
+	int
+	Texture::height () const
 	{
-		return self->color_space;
+		return self->height;
 	}
 
-	bool
-	Texture::alpha_only () const
+	int
+	Texture::reserved_height () const
 	{
-		return self->alpha_only;
+		return self->height_pow2;
 	}
 
-	float
-	Texture::s (float x) const
+	const ColorSpace&
+	Texture::color_space () const
 	{
-		return x / (float) self->width_pow2;
+		return self->color_space;
 	}
 
-	float
-	Texture::t (float y) const
+	Context
+	Texture::context () const
 	{
-		return y / (float) self->height_pow2;
+		return self->context;
 	}
 
-	float
-	Texture::s_max () const
+	GLuint
+	Texture::id () const
 	{
-		return s(self->width);
+		return self->id;
 	}
 
-	float
-	Texture::t_max () const
+	void
+	Texture::set_modified (bool modified)
 	{
-		return t(self->height);
+		self->modified = modified;
 	}
 
 	bool
-	Texture::dirty () const
-	{
-		return self->dirty;
-	}
-
-	void
-	Texture::set_dirty (bool b)
+	Texture::modified () const
 	{
-		self->dirty = b;
+		return self->modified;
 	}
 
 	Texture::operator bool () const
 	{
-		return self->id >= 0 && self->width > 0 && self->height > 0;
+		return
+			self->has_id()   &&
+			self->width  > 0 &&
+			self->height > 0 &&
+			self->color_space;
 	}
 
 	bool