rays 0.1.1

data/src/texture.cpp

@@ -0,0 +1,360 @@
+#include "rays/texture.h"
+
+
+#include <boost/scoped_array.hpp>
+#include <rays/bitmap.h>
+
+
+namespace Rays
+{
+
+
+	struct Texture::Data
+	{
+
+		Bitmap bitmap;
+
+		int id, width, height;
+
+		Data ()
+		:	id(-1), width(0), height(0)
+		{
+		}
+
+		~Data ()
+		{
+			clear();
+		}
+
+		void clear ()
+		{
+			if (id >= 0)
+			{
+				GLenum id_ = id;
+				glDeleteTextures(1, &id_);
+			}
+
+			bitmap = Bitmap();
+			id = -1;
+			width = height = 0;
+		}
+
+	};// Texture::Data
+
+
+	static bool
+	get_component_type (GLenum* result, ColorSpace cs)
+	{
+		if (!result || !cs) return false;
+
+		if (cs.is_float())
+			*result = GL_FLOAT;
+		else
+		{
+			switch (cs.bpc())
+			{
+				case 8:  *result = GL_UNSIGNED_BYTE; break;
+				case 16: *result = GL_UNSIGNED_SHORT; break;
+				case 32: *result = GL_UNSIGNED_INT; break;
+				default: return false;
+			}
+		}
+		return true;
+	}
+
+	static bool
+	create_texture (Texture::Data* self, GLenum format)
+	{
+		if (!self || !self->bitmap) return false;
+
+		GLenum type;
+		if (!get_component_type(&type, self->bitmap.color_space()))
+			return false;
+
+		GLuint id = 0;
+		glGenTextures(1, &id);
+		glBindTexture(GL_TEXTURE_2D, id);
+		if (glIsTexture(id) == GL_FALSE)
+			return false;
+
+		self->id = id;
+
+		glTexImage2D(
+			GL_TEXTURE_2D, 0, format, self->bitmap.width(), self->bitmap.height(), 0,
+			format, type, self->bitmap.data());
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);//GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);//GL_LINEAR);
+
+		return true;
+	}
+
+	static int
+	min_pow2 (int num)
+	{
+		int n = 1;
+		while (n < num) n *= 2;
+		return n;
+	}
+
+	static bool
+	colorspace_for_alphabitmap (ColorSpace* result, ColorSpace cs)
+	{
+		if (!result || !cs) return false;
+
+		*result = COLORSPACE_UNKNOWN;
+
+		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: return false;
+			}
+		}
+
+		return true;
+	}
+
+	template <int BytesPerPixel>
+	static inline void
+	copy_pixel (uchar* dest, const uchar* src)
+	{
+		*dest = *src;
+		copy_pixel<BytesPerPixel - 1>(dest + 1, src + 1);
+	}
+
+	template <>
+	inline void
+	copy_pixel<1> (uchar* dest, const uchar* src)
+	{
+		*dest = *src;
+	}
+
+	template <>
+	inline void
+	copy_pixel<2> (uchar* dest, const uchar* src)
+	{
+		assert(sizeof(ushort) == 2);
+		*(ushort*) dest = *(ushort*) src;
+	}
+
+	template <>
+	inline void
+	copy_pixel<4> (uchar* dest, const uchar* src)
+	{
+		assert(sizeof(ulong) == 4);
+		*(ulong*) dest = *(ulong*) src;
+	}
+
+	template <int BytesPerPixel>
+	static inline void
+	copy_pixels (
+		size_t width,
+		uchar* dest, size_t dest_offset, const uchar* src, size_t src_offset)
+	{
+		if (!dest || !src || dest_offset <= 0 || src_offset <= 0)
+			return;
+
+		while (width--)
+		{
+			copy_pixel<BytesPerPixel>(dest, src);
+			dest += dest_offset;
+			src  += src_offset;
+		}
+	}
+
+	static inline void
+	copy_pixels (
+		size_t Bpp, size_t width,
+		uchar* dest, size_t dest_offset, const uchar* src, size_t src_offset)
+	{
+		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;
+		}
+	}
+
+	static bool
+	copy_bitmap (Bitmap* dest, const Bitmap& src, int src_offset = 0)
+	{
+		if (!dest || !src || src_offset < 0)
+			return false;
+
+		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))
+			return false;
+
+		for (int y = 0; y < dest->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, dest->width(), d, dest_Bpp, s, src_Bpp);
+		}
+
+		return true;
+	}
+
+	static bool
+	create_alpha_texture (Texture::Data* self)
+	{
+		if (!self || !self->bitmap) return false;
+
+		ColorSpace cs = self->bitmap.color_space();
+		int width_pow2  = min_pow2(self->width);
+		int height_pow2 = min_pow2(self->height);
+
+		if (
+			width_pow2  != self->width  ||
+			height_pow2 != self->height ||
+			cs.is_rgb() ||
+			cs.is_bgr())
+		{
+			ColorSpace newcs;
+			if (!colorspace_for_alphabitmap(&newcs, cs))
+				return false;
+
+			Bitmap bmp(width_pow2, height_pow2, newcs);
+			if (!bmp) return false;
+
+			if (!copy_bitmap(&bmp, self->bitmap, cs.alpha_pos()))
+				return false;
+
+			self->bitmap = bmp;
+			cs = self->bitmap.color_space();
+		}
+
+		if (!self->bitmap.color_space().is_gray())
+			return false;
+
+		return create_texture(self, GL_ALPHA);
+	}
+
+	static bool
+	create_color_texture (Texture::Data* self)
+	{
+		if (!self || !self->bitmap) return false;
+
+		int width_pow2  = min_pow2(self->width);
+		int height_pow2 = min_pow2(self->height);
+
+		if (
+			width_pow2  != self->width ||
+			height_pow2 != self->height)
+		{
+			Bitmap bmp(
+				width_pow2, height_pow2, self->bitmap.color_space());
+			if (!bmp) return false;
+
+			if (!copy_bitmap(&bmp, self->bitmap))
+				return false;
+
+			self->bitmap = bmp;
+		}
+
+		ColorSpace cs = self->bitmap.color_space();
+
+		bool alpha = cs.has_alpha();
+		if (cs.is_rgb())
+			return create_texture(self, alpha ? GL_RGBA : GL_RGB);
+		else if (cs.is_bgr())
+			return create_texture(self, alpha ? GL_BGRA : GL_BGR);
+		else if (cs.is_gray())
+			return create_texture(self, GL_LUMINANCE);
+		else
+			return false;
+	}
+
+	static bool
+	setup_texture (
+		Texture::Data* self, const Bitmap& bitmap, bool alphaonly = false)
+	{
+		if (!self || !bitmap) return false;
+
+		self->clear();
+
+		self->bitmap = bitmap;
+		if (!self->bitmap) return false;
+
+		self->width  = self->bitmap.width();
+		self->height = self->bitmap.height();
+
+		if (alphaonly)
+			return create_alpha_texture(self);
+		else
+			return create_color_texture(self);
+	}
+
+
+	Texture::Texture ()
+	{
+	}
+
+	Texture::Texture (const Bitmap& bitmap, bool alphaonly)
+	{
+		setup_texture(self.get(), bitmap, alphaonly);
+	}
+
+	Texture::~Texture ()
+	{
+	}
+
+	GLuint
+	Texture::id () const
+	{
+		return self->id;
+	}
+
+	int
+	Texture::width () const
+	{
+		return self->width;
+	}
+
+	int
+	Texture::height () const
+	{
+		return self->height;
+	}
+
+	float
+	Texture::s_max () const
+	{
+		return (float) self->width / (float) self->bitmap.width();
+	}
+
+	float
+	Texture::t_max () const
+	{
+		return (float) self->height / (float) self->bitmap.height();
+	}
+
+	const Bitmap&
+	Texture::bitmap () const
+	{
+		return self->bitmap;
+	}
+
+	Texture::operator bool () const
+	{
+		return self->id >= 0 && self->width > 0 && self->height > 0;
+	}
+
+	bool
+	Texture::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays

data/src/transform.cpp

@@ -0,0 +1,88 @@
+#include "rays/painter.h"
+
+
+#include "rays/opengl.h"
+
+
+namespace Rays
+{
+
+
+	static bool
+	is_error ()
+	{
+		GLenum e = glGetError();
+		return e == GL_INVALID_OPERATION;
+	}
+
+	static bool
+	is_error (GLenum error)
+	{
+		GLenum e = glGetError();
+		return e == GL_INVALID_OPERATION || e == error;
+	}
+
+
+	bool
+	translate (coord x, coord y, coord z)
+	{
+		glTranslatef(x, y, z);
+		return !is_error();
+	}
+
+	bool
+	scale (coord x, coord y, coord z)
+	{
+		glScalef(x, y, z);
+		return !is_error();
+	}
+
+	bool
+	rotate (float angle, coord x, coord y, coord z)
+	{
+		glRotatef(angle, x, y, z);
+		return !is_error();
+	}
+
+
+	bool
+	set_matrix (coord value)
+	{
+		glLoadIdentity();
+		if (is_error()) return false;
+		if (value == 1) return true;
+		return scale(value, value, value);
+	}
+
+	bool 
+	set_matrix (const coord* elements, size_t size)
+	{
+		if (!elements || size != 16) return false;
+		glLoadMatrixf(elements);
+		return !is_error();
+	}
+
+	bool
+	get_matrix (coord* elements, size_t size)
+	{
+		if (!elements || size != 16) return false;
+		glGetFloatv(GL_MODELVIEW_MATRIX, elements);
+		return !is_error(GL_INVALID_ENUM);
+	}
+
+	bool
+	push_matrix ()
+	{
+		glPushMatrix();
+		return !is_error(GL_STACK_OVERFLOW);
+	}
+
+	bool
+	pop_matrix ()
+	{
+		glPopMatrix();
+		return !is_error(GL_STACK_UNDERFLOW);
+	}
+
+
+}// Rays

data/src/win32/bitmap.cpp

@@ -0,0 +1,212 @@
+#include "rays/bitmap.h"
+
+
+#include "gdi.h"
+
+
+namespace Rays
+{
+
+
+	struct Bitmap::Data
+	{
+
+		int width, height, pitch;
+
+		ColorSpace colorspace;
+
+		void* pixels;
+
+		Win32::MemoryDC memdc;
+
+		bool dirty;
+
+		Data ()
+		:	pixels(NULL), dirty(true)
+		{
+		}
+
+	};// Window::Data
+
+
+	static bool
+	init_bitmap_pixels (Bitmap* bmp)
+	{
+		if (!*bmp) return false;
+
+		memset(bmp->data(), 0, bmp->size());
+
+		if (!bmp->color_space().has_alpha())
+			return true;
+
+		int Bpp = bmp->color_space().Bpp();
+		for (int y = 0; y < bmp->height(); ++y)
+		{
+			unsigned char* p =
+				bmp->at<unsigned char>(0, y) + bmp->color_space().alpha_pos();
+			int w = bmp->width();
+			while (w--)
+			{
+				*p = 255;
+				p += Bpp;
+			}
+		}
+
+		return true;
+	}
+
+	static bool
+	setup (Bitmap* bmp, int w, int h, const ColorSpace& cs, HDC hdc = NULL)
+	{
+		if (w <= 0 || h <= 0 || !cs || !bmp || *bmp)
+			return false;
+
+		Bitmap::Data* self = bmp->self.get();
+
+		self->width      = w;
+		self->height     = h;
+		self->colorspace = cs;
+		self->pitch      = self->width * self->colorspace.Bpp();
+
+		int padding = 4 - self->pitch % 4;
+		if (padding < 4) self->pitch += padding;
+
+		BITMAPINFO bmpinfo;
+		memset(&bmpinfo, 0, sizeof(bmpinfo));
+
+		BITMAPINFOHEADER& header = bmpinfo.bmiHeader;
+		header.biSize        = sizeof(BITMAPINFOHEADER);
+		header.biWidth       = self->width;
+		header.biHeight      = self->height;
+		header.biPlanes      = 1;
+		header.biBitCount    = self->colorspace.bpp();
+		header.biCompression = BI_RGB;
+
+		Win32::DC dc = hdc ? Win32::DC(hdc) : Win32::screen_dc();
+
+		HBITMAP hbmp = CreateDIBSection(
+			dc.handle(), &bmpinfo, DIB_RGB_COLORS, (void**) &self->pixels, NULL, 0);
+		if (!hbmp) return false;
+
+		self->memdc = Win32::MemoryDC(dc.handle(), Win32::Bitmap(hbmp, true));
+		if (!self->memdc) return false;
+
+		return init_bitmap_pixels(bmp);
+	}
+
+
+	Bitmap::Bitmap ()
+	{
+	}
+
+	Bitmap::Bitmap (int width, int height, const ColorSpace& cs)
+	{
+		setup(this, width, height, cs);
+	}
+
+	Bitmap::~Bitmap ()
+	{
+	}
+
+	int
+	Bitmap::width () const
+	{
+		return self->width;
+	}
+
+	int
+	Bitmap::height () const
+	{
+		return self->height;
+	}
+
+	const ColorSpace&
+	Bitmap::color_space () const
+	{
+		return self->colorspace;
+	}
+
+	int
+	Bitmap::pitch () const
+	{
+		return self->pitch;
+	}
+
+	size_t
+	Bitmap::size () const
+	{
+		return pitch() * height();
+	}
+
+	bool
+	Bitmap::dirty () const
+	{
+		return self->dirty;
+	}
+
+	void
+	Bitmap::set_dirty (bool b)
+	{
+		self->dirty = b;
+	}
+
+	void*
+	Bitmap::data ()
+	{
+		return self->pixels;
+	}
+
+	const void*
+	Bitmap::data () const
+	{
+		return const_cast<Bitmap*>(this)->data();
+	}
+
+	Bitmap::operator bool () const
+	{
+		return
+			self &&
+			self->width > 0 && self->height > 0 && self->pitch > 0 &&
+			self->colorspace && self->pixels && self->memdc;
+	}
+
+	bool
+	Bitmap::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+	bool
+	load_bitmap (Bitmap* bitmap, const char* path)
+	{
+		return false;
+	}
+
+	bool
+	save_bitmap (const Bitmap& bitmap, const char* path)
+	{
+		return false;
+	}
+
+
+	bool draw_string (
+		HDC, coord, const char*, coord, coord, const Font&);
+
+	bool
+	draw_string (
+		Bitmap* bmp, const char* str, coord x, coord y, const Font& font)
+	{
+		if (!bmp || !*bmp || !str || !font) return false;
+
+		if (*str == '\0') return true;
+
+		if (!draw_string(bmp->self->memdc.handle(), bmp->height(), str, x, y, font))
+			return false;
+
+		bmp->set_dirty();
+		return true;
+	}
+
+
+}// Rays