opengl 0.8.0-x86-mingw32 → 0.9.0-x86-mingw32

data/ext/opengl/gl-ext-ext.c

@@ -45,8 +45,8 @@ VALUE obj,arg1,arg2;
 		rb_raise(rb_eArgError, "passed arrays must have the same length");
 	textures = ALLOC_N(GLuint,size);
 	priorities = ALLOC_N(GLclampf,size);
-	ary2cuint(arg1,textures,size);	
-	ary2cflt(arg2,priorities,size);	
+	ary2cuint(arg1,textures,size);
+	ary2cflt(arg2,priorities,size);
 	fptr_glPrioritizeTexturesEXT(size,textures,priorities);
 	xfree(textures);
 	xfree(priorities);
@@ -71,7 +71,7 @@ VALUE obj,arg1;
 	size = (GLsizei)RARRAY_LENINT(ary);
 	textures = ALLOC_N(GLuint,size);
 	residences = ALLOC_N(GLboolean,size);
-	ary2cuint(ary,textures,size);	
+	ary2cuint(ary,textures,size);
 	r = fptr_glAreTexturesResidentEXT(size,textures,residences);
 	retary = rb_ary_new2(size);
 	if (r==GL_TRUE) { /* all are resident */
@@ -162,7 +162,7 @@ VALUE obj,arg1,arg2,arg3,arg4;
 	stride = (GLsizei)NUM2UINT(arg3);
 	if (CheckBufferBinding(GL_ARRAY_BUFFER_BINDING)) {
 		g_SecondaryColor_ptr = arg4;
-		fptr_glSecondaryColorPointerEXT(size,type, stride, (const GLvoid*)NUM2LONG(arg4));
+		fptr_glSecondaryColorPointerEXT(size,type, stride, (const GLvoid*)NUM2SIZET(arg4));
 	} else {
 		VALUE data;
 		data = pack_array_or_pass_string(type,arg4);
@@ -196,7 +196,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
 	count = (GLsizei)NUM2UINT(arg4);
 	type = (GLenum)NUM2INT(arg5);
 	if (CheckBufferBinding(GL_ELEMENT_ARRAY_BUFFER_BINDING)) {
-		fptr_glDrawRangeElementsEXT(mode, start, end, count, type, (GLvoid *)NUM2LONG(arg6));
+		fptr_glDrawRangeElementsEXT(mode, start, end, count, type, (GLvoid *)NUM2SIZET(arg6));
 	} else {
 		VALUE data;
 		data = pack_array_or_pass_string(type,arg6);
@@ -287,7 +287,7 @@ VALUE obj;
 			indices = ALLOC_N(GLvoid*,size);
 			for (i=0;i<size;i++) {
 				counts[i] = NUM2INT(rb_ary_entry(args[2],i));
-				indices[i] = (GLvoid *)NUM2LONG(rb_ary_entry(args[3],i));
+				indices[i] = (GLvoid *)NUM2SIZET(rb_ary_entry(args[3],i));
 			}
 			fptr_glMultiDrawElementsEXT(mode,counts,type,indices,size);
 			xfree(counts);
@@ -331,7 +331,7 @@ VALUE obj,arg1,arg2,arg3;
 	stride = (GLsizei)NUM2UINT(arg2);
 	if (CheckBufferBinding(GL_ARRAY_BUFFER_BINDING)) {
 		g_FogCoord_ptr = arg3;
-		fptr_glFogCoordPointerEXT(type, stride, (const GLvoid*)NUM2LONG(arg3));
+		fptr_glFogCoordPointerEXT(type, stride, (const GLvoid*)NUM2SIZET(arg3));
 	} else {
 		VALUE data;
 		data = pack_array_or_pass_string(type,arg3);
@@ -451,14 +451,14 @@ PROGRAMPARAM_MULTI_FUNC_V(ProgramLocalParameters4fvEXT,GLfloat,ary2cflt,"GL_EXT_
 GL_FUNC_LOAD_3(ProgramParameteriEXT,GLvoid, GLuint,GLenum,GLint, "GL_EXT_geometry_shader4")
 
 /* #326 - GL_EXT_gpu_shader4 */
-GL_FUNC_LOAD_2(VertexAttribI1iEXT,GLvoid, GLuint,GLint, "GL_ARB_shader_objects")
-GL_FUNC_LOAD_3(VertexAttribI2iEXT,GLvoid, GLuint,GLint,GLint, "GL_ARB_shader_objects")
-GL_FUNC_LOAD_4(VertexAttribI3iEXT,GLvoid, GLuint,GLint,GLint,GLint, "GL_ARB_shader_objects")
-GL_FUNC_LOAD_5(VertexAttribI4iEXT,GLvoid, GLuint,GLint,GLint,GLint,GLint, "GL_ARB_shader_objects")
-GL_FUNC_LOAD_2(VertexAttribI1uiEXT,GLvoid, GLuint,GLuint, "GL_ARB_shader_objects")
-GL_FUNC_LOAD_3(VertexAttribI2uiEXT,GLvoid, GLuint,GLuint,GLuint, "GL_ARB_shader_objects")
-GL_FUNC_LOAD_4(VertexAttribI3uiEXT,GLvoid, GLuint,GLuint,GLuint,GLuint, "GL_ARB_shader_objects")
-GL_FUNC_LOAD_5(VertexAttribI4uiEXT,GLvoid, GLuint,GLuint,GLuint,GLuint,GLuint, "GL_ARB_shader_objects")
+GL_FUNC_LOAD_2(VertexAttribI1iEXT,GLvoid, GLuint,GLint, "GL_EXT_gpu_shader4")
+GL_FUNC_LOAD_3(VertexAttribI2iEXT,GLvoid, GLuint,GLint,GLint, "GL_EXT_gpu_shader4")
+GL_FUNC_LOAD_4(VertexAttribI3iEXT,GLvoid, GLuint,GLint,GLint,GLint, "GL_EXT_gpu_shader4")
+GL_FUNC_LOAD_5(VertexAttribI4iEXT,GLvoid, GLuint,GLint,GLint,GLint,GLint, "GL_EXT_gpu_shader4")
+GL_FUNC_LOAD_2(VertexAttribI1uiEXT,GLvoid, GLuint,GLuint, "GL_EXT_gpu_shader4")
+GL_FUNC_LOAD_3(VertexAttribI2uiEXT,GLvoid, GLuint,GLuint,GLuint, "GL_EXT_gpu_shader4")
+GL_FUNC_LOAD_4(VertexAttribI3uiEXT,GLvoid, GLuint,GLuint,GLuint,GLuint, "GL_EXT_gpu_shader4")
+GL_FUNC_LOAD_5(VertexAttribI4uiEXT,GLvoid, GLuint,GLuint,GLuint,GLuint,GLuint, "GL_EXT_gpu_shader4")
 
 #define GLVERTEXATTRIB_VFUNC(_name_,_type_,_conv_,_size_) \
 static void (APIENTRY * fptr_gl##_name_)(GLuint,const _type_ *); \
@@ -467,7 +467,7 @@ gl_##_name_(obj,arg1,arg2) \
 VALUE obj,arg1,arg2; \
 { \
 	_type_ value[_size_]; \
-	LOAD_GL_FUNC(gl##_name_, "GL_ARB_shader_objects"); \
+	LOAD_GL_FUNC(gl##_name_, "GL_EXT_gpu_shader4"); \
 	_conv_(arg2,value,_size_); \
 	fptr_gl##_name_(NUM2UINT(arg1),value); \
 	CHECK_GLERROR_FROM("gl" #_name_); \
@@ -534,7 +534,7 @@ static VALUE gl_VertexAttribIPointerEXT(VALUE obj,VALUE arg1,VALUE arg2,VALUE ar
 
 	if (CheckBufferBinding(GL_ARRAY_BUFFER_BINDING)) {
 		g_VertexAttrib_ptr[index] = arg5;
-		fptr_glVertexAttribIPointerEXT(index,size,type,stride,(GLvoid *)NUM2LONG(arg5));
+		fptr_glVertexAttribIPointerEXT(index,size,type,stride,(GLvoid *)NUM2SIZET(arg5));
 	} else {
 		VALUE data;
 		data = pack_array_or_pass_string(type,arg5);
@@ -653,7 +653,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5;
 	type = (GLenum)NUM2INT(arg3);
 	primcount = (GLsizei)NUM2INT(arg5);
 	if (CheckBufferBinding(GL_ELEMENT_ARRAY_BUFFER_BINDING)) {
-		fptr_glDrawElementsInstancedEXT(mode, count, type, (const GLvoid*)NUM2LONG(arg4), primcount);
+		fptr_glDrawElementsInstancedEXT(mode, count, type, (const GLvoid*)NUM2SIZET(arg4), primcount);
 	} else {
 		VALUE data;
 		data = pack_array_or_pass_string(type,arg4);

data/ext/opengl/gl-ext-nv.c

@@ -70,7 +70,7 @@ static VALUE gl_GetProgramStringNV(VALUE obj,VALUE arg1,VALUE arg2)
 	CHECK_GLERROR_FROM("glGetProgramivNV");
 	if (len<=0)
 		return rb_str_new2("");
-	
+
 	buffer = ALLOC_N(GLchar,len+1);
 	memset(buffer,0,sizeof(GLchar) * (len+1));
 		fptr_glGetProgramStringNV(NUM2INT(arg1),NUM2INT(arg2),buffer);
@@ -118,7 +118,7 @@ static VALUE gl_VertexAttribPointerNV(VALUE obj,VALUE arg1,VALUE arg2,VALUE arg3
 
 	if (CheckBufferBinding(GL_ARRAY_BUFFER_BINDING)) {
 		g_VertexAttrib_ptr[index] = arg5;
-		fptr_glVertexAttribPointerNV(index,size,type,stride,(GLvoid *)NUM2LONG(arg5));
+		fptr_glVertexAttribPointerNV(index,size,type,stride,(GLvoid *)NUM2SIZET(arg5));
 	} else {
 		VALUE data;
 		data = pack_array_or_pass_string(type,arg5);
@@ -355,7 +355,7 @@ static VALUE gl_RequestResidentProgramsNV(VALUE obj,VALUE arg1)
 		GLuint *programs;
 		n = (GLsizei)RARRAY_LENINT(arg1);
 		programs = ALLOC_N(GLuint,n);
-		ary2cuint(arg1,programs,n); 
+		ary2cuint(arg1,programs,n);
 		fptr_glRequestResidentProgramsNV( n, programs);
 		xfree(programs);
 	} else {
@@ -382,7 +382,7 @@ static VALUE gl_AreProgramsResidentNV(VALUE obj,VALUE arg1)
 	size = (GLsizei)RARRAY_LENINT(ary);
 	programs = ALLOC_N(GLuint,size);
 	residences = ALLOC_N(GLboolean,size);
-	ary2cuint(ary,programs,size);	
+	ary2cuint(ary,programs,size);
 	r = fptr_glAreProgramsResidentNV(size,programs,residences);
 	retary = rb_ary_new2(size);
 	if (r==GL_TRUE) { /* all are resident */
@@ -530,7 +530,7 @@ GETPROGRAMPARAM_FUNC_2(GetProgramEnvParameterIuivNV,GLuint,"GL_NV_gpu_program4")
 #undef GETPROGRAMPARAM_FUNC_2
 
 /* #323 GL_NV_geometry_program4 */
-GL_FUNC_LOAD_2(ProgramVertexLimitNV,GLvoid, GLenum,GLint, "GL_NV_gpu_program4")
+GL_FUNC_LOAD_2(ProgramVertexLimitNV,GLvoid, GLenum,GLint, "GL_EXT_geometry_shader4")
 GL_FUNC_LOAD_4(FramebufferTextureEXT,GLvoid, GLenum,GLenum,GLuint,GLuint, "GL_EXT_geometry_shader4")
 GL_FUNC_LOAD_5(FramebufferTextureLayerEXT,GLvoid, GLenum,GLenum,GLuint,GLint,GLint, "GL_EXT_geometry_shader4")
 GL_FUNC_LOAD_5(FramebufferTextureFaceEXT,GLvoid, GLenum,GLenum,GLuint,GLint,GLenum, "GL_EXT_geometry_shader4")
@@ -545,7 +545,7 @@ GL_FUNC_LOAD_6(RenderbufferStorageMultisampleCoverageNV,GLvoid, GLenum,GLsizei,G
 
 void gl_init_functions_ext_nv(VALUE module)
 {
-/* #222 GL_NV_fence */
+	/* #222 GL_NV_fence */
 	rb_define_module_function(module, "glGenFencesNV", gl_GenFencesNV, 1);
 	rb_define_module_function(module, "glDeleteFencesNV", gl_DeleteFencesNV, 1);
 	rb_define_module_function(module, "glSetFenceNV", gl_SetFenceNV, 2);
@@ -554,7 +554,7 @@ void gl_init_functions_ext_nv(VALUE module)
 	rb_define_module_function(module, "glIsFenceNV", gl_IsFenceNV, 1);
 	rb_define_module_function(module, "glGetFenceivNV", gl_GetFenceivNV, 2);
 
-/* #233 GL_NV_vertex_program */
+	/* #233 GL_NV_vertex_program */
 	rb_define_module_function(module, "glLoadProgramNV", gl_LoadProgramNV, 3);
 	rb_define_module_function(module, "glGetProgramStringNV", gl_GetProgramStringNV, 2);
 	rb_define_module_function(module, "glGetProgramivNV", gl_GetProgramivNV, 2);
@@ -620,7 +620,7 @@ void gl_init_functions_ext_nv(VALUE module)
 	rb_define_module_function(module, "glRequestResidentProgramsNV", gl_RequestResidentProgramsNV, 1);
 	rb_define_module_function(module, "glAreProgramsResidentNV", gl_AreProgramsResidentNV, 1);
 
-/* #261 GL_NV_occlusion_query */
+	/* #261 GL_NV_occlusion_query */
 	rb_define_module_function(module, "glGenOcclusionQueriesNV", gl_GenOcclusionQueriesNV, 1);
 	rb_define_module_function(module, "glDeleteOcclusionQueriesNV", gl_DeleteOcclusionQueriesNV, 1);
 	rb_define_module_function(module, "glIsOcclusionQueryNV", gl_IsOcclusionQueryNV, 1);
@@ -629,11 +629,11 @@ void gl_init_functions_ext_nv(VALUE module)
 	rb_define_module_function(module, "glGetOcclusionQueryivNV", gl_GetOcclusionQueryivNV, 2);
 	rb_define_module_function(module, "glGetOcclusionQueryuivNV", gl_GetOcclusionQueryuivNV, 2);
 
-/* #262 GL_NV_point_sprite */
+	/* #262 GL_NV_point_sprite */
 	rb_define_module_function(module, "glPointParameteriNV", gl_PointParameteriNV, 2);
 	rb_define_module_function(module, "glPointParameterivNV", gl_PointParameterivNV, 2);
 
-/* #282 GL_NV_fragment_program */
+	/* #282 GL_NV_fragment_program */
 	rb_define_module_function(module, "glProgramNamedParameter4fNV", gl_ProgramNamedParameter4fNV, 6);
 	rb_define_module_function(module, "glProgramNamedParameter4dNV", gl_ProgramNamedParameter4dNV, 6);
 	rb_define_module_function(module, "glProgramNamedParameter4fvNV", gl_ProgramNamedParameter4fvNV, 3);
@@ -641,11 +641,11 @@ void gl_init_functions_ext_nv(VALUE module)
 	rb_define_module_function(module, "glGetProgramNamedParameterdvNV", gl_GetProgramNamedParameterdvNV, 2);
 	rb_define_module_function(module, "glGetProgramNamedParameterfvNV", gl_GetProgramNamedParameterfvNV, 2);
 
-/* #285 GL_NV_primitive_restart */
+	/* #285 GL_NV_primitive_restart */
 	rb_define_module_function(module, "glPrimitiveRestartNV", gl_PrimitiveRestartNV, 0);
 	rb_define_module_function(module, "glPrimitiveRestartIndexNV", gl_PrimitiveRestartIndexNV, 1);
 
-/* #322 GL_NV_gpu_program4 */
+	/* #322 GL_NV_gpu_program4 */
 	rb_define_module_function(module, "glProgramLocalParameterI4iNV", gl_ProgramLocalParameterI4iNV, 6);
 	rb_define_module_function(module, "glProgramLocalParameterI4uiNV", gl_ProgramLocalParameterI4uiNV, 6);
 	rb_define_module_function(module, "glProgramLocalParameterI4ivNV", gl_ProgramLocalParameterI4ivNV, 3);
@@ -663,18 +663,18 @@ void gl_init_functions_ext_nv(VALUE module)
 	rb_define_module_function(module, "glGetProgramEnvParameterIivNV", gl_GetProgramEnvParameterIivNV, 2);
 	rb_define_module_function(module, "glGetProgramEnvParameterIuivNV", gl_GetProgramEnvParameterIuivNV, 2);
 
-/* #323 GL_NV_geometry_program4 */
+	/* #323 GL_NV_geometry_program4 */
 	rb_define_module_function(module, "glProgramVertexLimitNV", gl_ProgramVertexLimitNV, 2);
 	rb_define_module_function(module, "glFramebufferTextureEXT", gl_FramebufferTextureEXT, 4);
 	rb_define_module_function(module, "glFramebufferTextureLayerEXT", gl_FramebufferTextureLayerEXT, 5);
 	rb_define_module_function(module, "glFramebufferTextureFaceEXT", gl_FramebufferTextureFaceEXT, 5);
 
-/* #334 GL_NV_depth_buffer_float */
+	/* #334 GL_NV_depth_buffer_float */
 	rb_define_module_function(module, "glDepthRangedNV", gl_DepthRangedNV, 2);
 	rb_define_module_function(module, "glClearDepthdNV", gl_ClearDepthdNV, 1);
 	rb_define_module_function(module, "glDepthBoundsdNV", gl_DepthBoundsdNV, 2);
 
-/* #336 GL_NV_framebuffer_multisample_coverage */
+	/* #336 GL_NV_framebuffer_multisample_coverage */
 	rb_define_module_function(module, "glRenderbufferStorageMultisampleCoverageNV", gl_RenderbufferStorageMultisampleCoverageNV, 6);
 
 }

data/ext/opengl/gl.c

@@ -27,6 +27,7 @@ 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);
@@ -202,6 +203,7 @@ DLLEXPORT void Init_gl()
 	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);

data/ext/opengl/gl_buffer.c

@@ -4,174 +4,174 @@ static GLvoid * (APIENTRY * fptr_glMapBuffer)(GLenum,GLenum);
 static GLboolean (APIENTRY * fptr_glUnmapBuffer)(GLenum);
 
 struct buffer {
-  GLenum target;
-  void *ptr;
-  GLsizeiptr len;
+	GLenum target;
+	void *ptr;
+	GLsizeiptr len;
 };
 
 static void
 buffer_free(void *ptr) {
-  struct buffer *buf = ptr;
-  LOAD_GL_FUNC(glUnmapBuffer, "1.5");
+	struct buffer *buf = ptr;
+	LOAD_GL_FUNC(glUnmapBuffer, "1.5");
 
-  if (buf->ptr != NULL)
-    fptr_glUnmapBuffer(buf->target);
+	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;
+	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, },
+	"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");
+	struct buffer *buf = ALLOC(struct buffer);
+	LOAD_GL_FUNC(glMapBuffer, "1.5");
 
-  buf->target = RUBY2GLENUM(_target);
-  buf->len    = 0;
+	buf->target = RUBY2GLENUM(_target);
+	buf->len		= 0;
 
-  buf->ptr = fptr_glMapBuffer(buf->target, RUBY2GLENUM(_access));
+	buf->ptr = fptr_glMapBuffer(buf->target, RUBY2GLENUM(_access));
 
-  if (buf->ptr == NULL) {
-    xfree(buf);
-    CHECK_GLERROR_FROM("glMapBuffer");
-  }
+	if (buf->ptr == NULL) {
+		xfree(buf);
+		CHECK_GLERROR_FROM("glMapBuffer");
+	}
 
-  return TypedData_Wrap_Struct(klass, &buffer_type, buf);
+	return TypedData_Wrap_Struct(klass, &buffer_type, buf);
 }
 
 static VALUE
 rb_gl_buffer_addr(VALUE self) {
-  struct buffer *buf;
+	struct buffer *buf;
 
-  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
 
-  return ULONG2NUM((unsigned long)buf->ptr);
+	return SIZET2NUM((size_t)buf->ptr);
 }
 
 static VALUE
 rb_gl_buffer_length(VALUE self) {
-  struct buffer *buf;
+	struct buffer *buf;
 
-  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
 
-  return RETCONV_GLsizeiptr(buf->len);
+	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;
+	struct buffer *buf;
+	VALUE _length, _offset;
+	GLsizeiptr offset, length;
 
-  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
 
-  rb_scan_args(argc, argv, "02", &_length, &_offset);
+	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");
+	if (buf->len == 0 && NIL_P(_length))
+		rb_raise(rb_eArgError, "length must be provided for unbounded buffer");
 
-  length = NUM2ULONG(_length);
+	length = NUM2SIZET(_length);
 
-  if (NIL_P(_offset)) {
-    offset = 0;
-  } else {
-    offset = NUM2ULONG(_offset);
-  }
+	if (NIL_P(_offset)) {
+		offset = 0;
+	} else {
+		offset = NUM2SIZET(_offset);
+	}
 
-  if (buf->len != 0 && length + offset > buf->len)
-    rb_raise(rb_eArgError, "read to %ld past end of buffer %ld",
-        length + offset, buf->len);
+	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);
+	return rb_str_new((char *)buf->ptr + offset, length);
 }
 
 static VALUE
 rb_gl_buffer_target(VALUE self) {
-  struct buffer *buf;
+	struct buffer *buf;
 
-  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
 
-  return RETCONV_GLenum(buf->target);
+	return RETCONV_GLenum(buf->target);
 }
 
 static VALUE
 rb_gl_buffer_unmap(VALUE self) {
-  struct buffer *buf;
-  LOAD_GL_FUNC(glUnmapBuffer, "1.5");
+	struct buffer *buf;
+	LOAD_GL_FUNC(glUnmapBuffer, "1.5");
 
-  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
 
-  if (!buf->ptr)
-    return self;
+	if (!buf->ptr)
+		return self;
 
-  fptr_glUnmapBuffer(buf->target);
+	fptr_glUnmapBuffer(buf->target);
 
-  CHECK_GLERROR_FROM("glUnmapBuffer");
+	CHECK_GLERROR_FROM("glUnmapBuffer");
 
-  buf->ptr = NULL;
-  buf->len = 0;
-  buf->target = 0;
+	buf->ptr = NULL;
+	buf->len = 0;
+	buf->target = 0;
 
-  return self;
+	return self;
 }
 
 static VALUE
 rb_gl_buffer_write(int argc, VALUE *argv, VALUE self) {
-  struct buffer *buf;
-  VALUE _data, _offset;
-  GLsizeiptr offset;
-  long length;
+	struct buffer *buf;
+	VALUE _data, _offset;
+	GLsizeiptr offset;
+	long length;
 
-  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
 
-  if (!buf->ptr)
-    rb_raise(rb_eArgError, "write to unmapped buffer");
+	if (!buf->ptr)
+		rb_raise(rb_eArgError, "write to unmapped buffer");
 
-  rb_scan_args(argc, argv, "11", &_data, &_offset);
+	rb_scan_args(argc, argv, "11", &_data, &_offset);
 
-  if (NIL_P(_data))
-    rb_raise(rb_eArgError, "cannot write nil to buffer");
+	if (NIL_P(_data))
+		rb_raise(rb_eArgError, "cannot write nil to buffer");
 
-  _data = rb_String(_data);
+	_data = rb_String(_data);
 
-  length = RSTRING_LEN(_data);
+	length = RSTRING_LEN(_data);
 
-  if (NIL_P(_offset)) {
-    offset = 0;
-  } else {
-    offset = NUM2ULONG(_offset);
-  }
+	if (NIL_P(_offset)) {
+		offset = 0;
+	} else {
+		offset = NUM2SIZET(_offset);
+	}
 
-  if (buf->len != 0 && length + offset > buf->len)
-    rb_raise(rb_eArgError, "write to %ld past end of buffer %ld",
-        length + offset, buf->len);
+	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));
+	memcpy((char *)buf->ptr + offset, RSTRING_PTR(_data), RSTRING_LEN(_data));
 
-  return self;
+	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);
+	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);
 }