opengl 0.9.0-x64-mingw32

data/ext/opengl/gl-types.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+ *
+ * This program is distributed under the terms of the MIT license.
+ * See the included MIT-LICENSE file for the terms of this license.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* GL types - define if system GLheaders are not recent
+   Note: must be included before gl-enums.h */
+
+#if HAVE_STDINT_H
+#include <stdint.h>
+#endif
+
+#ifndef HAVE_TYPE_INT64_T
+typedef __int64 int64_t;
+#endif
+#ifndef HAVE_TYPE_UINT64_T
+typedef unsigned __int64 uint64_t;
+#endif
+
+#if HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+
+/* GL base */
+#ifndef GL_VERSION_1_5
+typedef ptrdiff_t GLintptr;
+typedef ptrdiff_t GLsizeiptr;
+#endif
+
+#ifndef GL_VERSION_2_0
+typedef char GLchar;
+#endif
+
+/* new GL types introduced by ARB extensions */
+#ifndef GL_ARB_half_float_pixel
+typedef unsigned short GLhalfARB;
+#endif
+
+#ifndef GL_ARB_shader_objects
+typedef char GLcharARB;
+typedef unsigned int GLhandleARB;
+#endif
+
+#ifndef GL_ARB_vertex_buffer_object
+typedef ptrdiff_t GLintptrARB;
+typedef ptrdiff_t GLsizeiptrARB;
+#endif
+
+/* new GL types introduced by other extensions */
+#ifndef GL_NV_half_float
+typedef unsigned short GLhalfNV;
+#endif
+
+#ifndef GL_EXT_timer_query
+typedef int64_t GLint64EXT;
+typedef uint64_t GLuint64EXT;
+#endif

data/ext/opengl/gl.c

@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 1999 - 2005 Yoshi <yoshi@giganet.net>
+ * Copyright (C) 2006 John M. Gabriele <jmg3000@gmail.com>
+ * Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+ *
+ * This program is distributed under the terms of the MIT license.
+ * See the included MIT-LICENSE file for the terms of this license.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "common.h"
+
+static VALUE module;
+
+void gl_init_enums(VALUE);
+void gl_init_functions_1_0__1_1(VALUE);
+void gl_init_functions_1_2(VALUE);
+void gl_init_functions_1_3(VALUE);
+void gl_init_functions_1_4(VALUE);
+void gl_init_functions_1_5(VALUE);
+void gl_init_functions_2_0(VALUE);
+void gl_init_functions_2_1(VALUE);
+void gl_init_functions_3_0(VALUE);
+void gl_init_functions_ext_3dfx(VALUE);
+void gl_init_functions_ext_arb(VALUE);
+void gl_init_functions_ext_ati(VALUE);
+void gl_init_functions_ext_ext(VALUE);
+void gl_init_functions_ext_gremedy(VALUE);
+void gl_init_functions_ext_nv(VALUE);
+void gl_init_buffer(void);
+
+static int opengl_version[2]; /* major, minor */
+static char *opengl_extensions = NULL;
+
+/* Returns current OpenGL version as major, minor or 0,0 if
+ * unknown (context not yet initialised etc.) The version is
+ * cached for subsequent calls.
+ */
+const int *GetOpenglVersion(void)
+{
+	if (opengl_version[0]==0) { /* not cached, query */
+		const char *vstr = (const char *) glGetString(GL_VERSION);
+		CHECK_GLERROR_FROM("glGetString");
+		if (vstr)
+			sscanf( vstr, "%d.%d", &opengl_version[0], &opengl_version[1] );
+	}
+	return opengl_version;
+}
+
+/* Checks if OpenGL version is at least the same or higher than
+ * major.minor
+ */
+GLboolean CheckOpenglVersion(int major, int minor)
+{
+	const int *version;
+
+	version = GetOpenglVersion();
+
+	if (version[0]>major || (version[0]==major && version[1] >=minor))
+		return GL_TRUE;
+	else
+		return GL_FALSE;
+}
+
+/* Returns supported OpenGL extensions as char* or NULL
+ * if unknown (context not yet initialised etc.) The list is
+ * cached for subsequent calls.
+ */
+const char *GetOpenglExtensions(void)
+{
+	if (opengl_extensions == NULL) {
+		const char *estr = (const char *) glGetString(GL_EXTENSIONS);
+		CHECK_GLERROR_FROM("glGetString");
+		if (estr) {
+			long len = strlen(estr);
+			opengl_extensions = ALLOC_N(GLchar,len+1+1); /* terminating null and added space */
+			strcpy(opengl_extensions,estr);
+			opengl_extensions[len] = ' '; /* add space char for easy searchs */
+			opengl_extensions[len+1] = '\0';
+		}
+	}
+	return opengl_extensions;	
+}
+
+/* Checks if extension is supported by the current OpenGL implementation
+ */
+GLboolean CheckExtension(const char *name)
+{
+	const char *extensions;
+	char *name_tmp;
+	long name_len;
+	GLboolean res;
+	
+	extensions = GetOpenglExtensions();
+	
+	if(extensions==NULL)
+		return GL_FALSE;
+
+	/* add trailing space */
+	name_len = strlen(name);
+	name_tmp = ALLOC_N(GLchar,name_len+1+1); /* terminating null and added space */
+	strcpy(name_tmp,name);
+	name_tmp[name_len] = ' '; /* add space char for search */
+	name_tmp[name_len+1] = '\0';
+
+	if (strstr(extensions,name_tmp))
+		res = GL_TRUE;
+	else
+		res = GL_FALSE;
+
+	xfree(name_tmp);
+	return res;	
+}
+
+/* wrapper for CheckOpenglVersion and CheckExtension, also used by macros
+ */
+GLboolean CheckVersionExtension(const char *name)
+{
+	if (name && name[0] && name[0]>='0' && name[0]<='9') { /* GL version query */
+		int major,minor;
+
+		if (sscanf( name, "%d.%d", &major, &minor ) != 2)
+				return GL_FALSE;
+	
+		return (CheckOpenglVersion(major,minor));
+	} else {
+		return (CheckExtension(name));
+	}
+}
+
+/* Checks if given OpenGL version or extension is available
+ */
+static VALUE
+IsAvailable(obj,arg1)
+VALUE obj,arg1;
+{
+	char *name = NULL;
+	VALUE s;
+	GLboolean res;
+
+	s = rb_funcall(arg1, rb_intern("to_s"), 0);
+	name = RSTRING_PTR(s);
+
+	res = CheckVersionExtension(name);
+
+	return GLBOOL2RUBY(res);
+}
+
+/* Checks whether non-zero buffer of type $buffer is bound
+ * - this affects several functions that pass data from/to OpenGL.
+ */
+GLint CheckBufferBinding(GLint buffer)
+{
+	GLint result = 0;
+	
+	/* check if the buffer functionality is supported */
+	switch(buffer) {
+		case GL_ARRAY_BUFFER_BINDING:
+		case GL_ELEMENT_ARRAY_BUFFER_BINDING:
+			if (!CheckOpenglVersion(1,5))
+				return 0;
+			break;
+		case GL_PIXEL_PACK_BUFFER_BINDING:
+		case GL_PIXEL_UNPACK_BUFFER_BINDING:
+			if (!CheckOpenglVersion(2,1))
+				return 0;
+			break;
+		default:
+			rb_raise(rb_eRuntimeError,"Internal Error: buffer type '%i' does not exist", buffer);
+			break;
+	}
+	glGetIntegerv(buffer,&result);
+	CHECK_GLERROR_FROM("glGetIntegerv");
+	return result;
+}
+
+DLLEXPORT void Init_gl()
+{
+  VALUE mOpenGL = rb_path2class("OpenGL");
+	VALUE version = rb_const_get(mOpenGL, rb_intern("VERSION"));
+
+  gl_init_buffer();
+
+	module = rb_define_module("Gl");
+
+  /* TODO remove */
+	rb_define_const(module, "BINDINGS_VERSION", version);
+	rb_define_const(module, "RUBY_OPENGL_VERSION", version);
+
+	gl_init_error(module);
+	gl_init_enums(module);
+	gl_init_functions_1_0__1_1(module);
+	gl_init_functions_1_2(module);
+	gl_init_functions_1_3(module);
+	gl_init_functions_1_4(module);
+	gl_init_functions_1_5(module);
+	gl_init_functions_2_0(module);
+	gl_init_functions_2_1(module);
+	gl_init_functions_3_0(module);
+	gl_init_functions_ext_3dfx(module);
+	gl_init_functions_ext_arb(module);
+	gl_init_functions_ext_ati(module);
+	gl_init_functions_ext_ext(module);
+	gl_init_functions_ext_gremedy(module);
+	gl_init_functions_ext_nv(module);
+
+	rb_define_module_function(module, "is_available?", IsAvailable, 1);
+	rb_define_module_function(module, "is_supported?", IsAvailable, 1);
+	rb_define_module_function(module, "extension_available?", IsAvailable, 1);
+	rb_define_module_function(module, "extension_supported?", IsAvailable, 1);
+	rb_define_module_function(module, "version_available?", IsAvailable, 1);
+	rb_define_module_function(module, "version_supported?", IsAvailable, 1);
+}

data/ext/opengl/gl_buffer.c

@@ -0,0 +1,177 @@
+#include "common.h"
+
+static GLvoid * (APIENTRY * fptr_glMapBuffer)(GLenum,GLenum);
+static GLboolean (APIENTRY * fptr_glUnmapBuffer)(GLenum);
+
+struct buffer {
+	GLenum target;
+	void *ptr;
+	GLsizeiptr len;
+};
+
+static void
+buffer_free(void *ptr) {
+	struct buffer *buf = ptr;
+	LOAD_GL_FUNC(glUnmapBuffer, "1.5");
+
+	if (buf->ptr != NULL)
+		fptr_glUnmapBuffer(buf->target);
+}
+
+static size_t
+buffer_memsize(const void *ptr) {
+	const struct buffer *buf = ptr;
+	return sizeof(struct buffer) + (size_t)buf->len;
+}
+
+static const rb_data_type_t buffer_type = {
+	"OpenGL/buffer",
+	{ NULL, buffer_free, buffer_memsize, },
+};
+
+VALUE
+rb_gl_buffer_s_map(VALUE klass, VALUE _target, VALUE _access) {
+	struct buffer *buf = ALLOC(struct buffer);
+	LOAD_GL_FUNC(glMapBuffer, "1.5");
+
+	buf->target = RUBY2GLENUM(_target);
+	buf->len		= 0;
+
+	buf->ptr = fptr_glMapBuffer(buf->target, RUBY2GLENUM(_access));
+
+	if (buf->ptr == NULL) {
+		xfree(buf);
+		CHECK_GLERROR_FROM("glMapBuffer");
+	}
+
+	return TypedData_Wrap_Struct(klass, &buffer_type, buf);
+}
+
+static VALUE
+rb_gl_buffer_addr(VALUE self) {
+	struct buffer *buf;
+
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+	return SIZET2NUM((size_t)buf->ptr);
+}
+
+static VALUE
+rb_gl_buffer_length(VALUE self) {
+	struct buffer *buf;
+
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+	return RETCONV_GLsizeiptr(buf->len);
+}
+
+static VALUE
+rb_gl_buffer_read(int argc, VALUE *argv, VALUE self) {
+	struct buffer *buf;
+	VALUE _length, _offset;
+	GLsizeiptr offset, length;
+
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+	rb_scan_args(argc, argv, "02", &_length, &_offset);
+
+	if (buf->len == 0 && NIL_P(_length))
+		rb_raise(rb_eArgError, "length must be provided for unbounded buffer");
+
+	length = NUM2SIZET(_length);
+
+	if (NIL_P(_offset)) {
+		offset = 0;
+	} else {
+		offset = NUM2SIZET(_offset);
+	}
+
+	if (buf->len != 0 && length + offset > buf->len)
+		rb_raise(rb_eArgError, "read to %lu past end of buffer %lu",
+				(unsigned long)(length + offset), (unsigned long)buf->len);
+
+	return rb_str_new((char *)buf->ptr + offset, length);
+}
+
+static VALUE
+rb_gl_buffer_target(VALUE self) {
+	struct buffer *buf;
+
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+	return RETCONV_GLenum(buf->target);
+}
+
+static VALUE
+rb_gl_buffer_unmap(VALUE self) {
+	struct buffer *buf;
+	LOAD_GL_FUNC(glUnmapBuffer, "1.5");
+
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+	if (!buf->ptr)
+		return self;
+
+	fptr_glUnmapBuffer(buf->target);
+
+	CHECK_GLERROR_FROM("glUnmapBuffer");
+
+	buf->ptr = NULL;
+	buf->len = 0;
+	buf->target = 0;
+
+	return self;
+}
+
+static VALUE
+rb_gl_buffer_write(int argc, VALUE *argv, VALUE self) {
+	struct buffer *buf;
+	VALUE _data, _offset;
+	GLsizeiptr offset;
+	long length;
+
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+	if (!buf->ptr)
+		rb_raise(rb_eArgError, "write to unmapped buffer");
+
+	rb_scan_args(argc, argv, "11", &_data, &_offset);
+
+	if (NIL_P(_data))
+		rb_raise(rb_eArgError, "cannot write nil to buffer");
+
+	_data = rb_String(_data);
+
+	length = RSTRING_LEN(_data);
+
+	if (NIL_P(_offset)) {
+		offset = 0;
+	} else {
+		offset = NUM2SIZET(_offset);
+	}
+
+	if (buf->len != 0 && length + offset > buf->len)
+		rb_raise(rb_eArgError, "write to %lu past end of buffer %lu",
+				(unsigned long)(length + offset), (unsigned long)buf->len);
+
+	memcpy((char *)buf->ptr + offset, RSTRING_PTR(_data), RSTRING_LEN(_data));
+
+	return self;
+}
+
+void
+gl_init_buffer(void) {
+	VALUE mOpenGL = rb_path2class("OpenGL");
+	VALUE cBuffer = rb_define_class_under(mOpenGL, "Buffer", rb_cObject);
+
+	rb_undef_alloc_func(cBuffer);
+	rb_define_singleton_method(cBuffer, "map", rb_gl_buffer_s_map, 2);
+
+	rb_define_method(cBuffer, "addr", rb_gl_buffer_addr, 0);
+	rb_define_method(cBuffer, "length", rb_gl_buffer_length, 0);
+	rb_define_method(cBuffer, "read", rb_gl_buffer_read, -1);
+	rb_define_method(cBuffer, "target", rb_gl_buffer_target, 0);
+	rb_define_method(cBuffer, "unmap", rb_gl_buffer_unmap, 0);
+	rb_define_method(cBuffer, "write", rb_gl_buffer_write, -1);
+}
+