--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Copyright 2014 Alexis Laferrière <alexis.laf@xymus.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# OpenGL graphics rendering library for embedded systems, version 2.0.
+#
+# Most services of this module are a direct wrapper of the underlying
+# C library. If a method or class is not documented in Nit, refer to
+# the official documentation by the Khronos Group at:
+# http://www.khronos.org/opengles/sdk/docs/man/
+module glesv2 is pkgconfig("glesv2")
+
+in "C Header" `{
+ #include <GLES2/gl2.h>
+`}
+
+# Opengl ES program to which we attach shaders
+extern class GLProgram `{GLuint`}
+ new `{ return glCreateProgram(); `}
+
+ fun is_ok: Bool `{ return glIsProgram(recv); `}
+
+ fun attach_shader(shader: GLShader) `{ glAttachShader(recv, shader); `}
+
+ fun bind_attrib_location(index: Int, name: String) import String.to_cstring `{
+ GLchar *c_name = String_to_cstring(name);
+ glBindAttribLocation(recv, index, c_name);
+ `}
+
+ fun attrib_location(name: String): Int import String.to_cstring `{
+ GLchar *c_name = String_to_cstring(name);
+ return glGetAttribLocation(recv, c_name);
+ `}
+
+ fun query(pname: Int): Int `{
+ int val;
+ glGetProgramiv(recv, pname, &val);
+ return val;
+ `}
+
+ fun link `{ glLinkProgram(recv); `}
+ fun is_linked: Bool do return query("8B82".to_hex) != 0
+
+ fun use `{ glUseProgram(recv); `}
+
+ fun delete `{ glDeleteProgram(recv); `}
+ fun is_deleted: Bool do return query("8B80".to_hex) != 0
+
+ fun validate `{ glValidateProgram(recv); `}
+ fun is_validated: Bool do return query("8B83".to_hex) != 0
+
+ fun info_log: String import NativeString.to_s `{
+ int size;
+ glGetProgramiv(recv, GL_INFO_LOG_LENGTH, &size);
+ GLchar *msg = malloc(size);
+ glGetProgramInfoLog(recv, size, NULL, msg);
+ return NativeString_to_s(msg);
+ `}
+end
+
+# Abstract OpenGL ES shader object, implemented by `GLFragmentShader` and `GLVertexShader`
+extern class GLShader `{GLuint`}
+ fun source=(code: String) import String.to_cstring, String.length `{
+ GLchar *c_code = String_to_cstring(code);
+ glShaderSource(recv, 1, (const GLchar * const*)&c_code, NULL);
+ `}
+ fun source: nullable String import NativeString.to_s `{
+ int size;
+ glGetShaderiv(recv, GL_SHADER_SOURCE_LENGTH, &size);
+ if (size == 0) return NULL;
+ GLchar *code = malloc(size);
+ glGetShaderSource(recv, size, NULL, code);
+ return NativeString_to_s(code);
+ `}
+
+ protected fun query(pname: Int): Int `{
+ int val;
+ glGetShaderiv(recv, pname, &val);
+ return val;
+ `}
+
+ fun compile `{ glCompileShader(recv); `}
+ fun is_compiled: Bool do return query("8B81".to_hex) != 0
+
+ fun delete `{ glDeleteShader(recv); `}
+ fun is_deleted: Bool do return query("8B80".to_hex) != 0
+
+ fun is_ok: Bool `{ return glIsShader(recv); `}
+
+ fun info_log: String import NativeString.to_s `{
+ int size;
+ glGetShaderiv(recv, GL_INFO_LOG_LENGTH, &size);
+ GLchar *msg = malloc(size);
+ glGetShaderInfoLog(recv, size, NULL, msg);
+ return NativeString_to_s(msg);
+ `}
+
+end
+
+extern class GLFragmentShader
+ super GLShader
+
+ new `{ return glCreateShader(GL_FRAGMENT_SHADER); `}
+end
+
+extern class GLVertexShader
+ super GLShader
+
+ new `{ return glCreateShader(GL_VERTEX_SHADER); `}
+end
+
+# An array of `Float` associated to a program variable
+class VertexArray
+ var index: Int
+ var count: Int
+ protected var glfloat_array: GLfloatArray
+
+ init(index, count: Int, array: Array[Float])
+ do
+ self.index = index
+ self.count = count
+ self.glfloat_array = new GLfloatArray(array)
+ end
+
+ fun attrib_pointer do attrib_pointer_intern(index, count, glfloat_array)
+ private fun attrib_pointer_intern(index, count: Int, array: GLfloatArray) `{
+ glVertexAttribPointer(index, count, GL_FLOAT, GL_FALSE, 0, array);
+ `}
+
+ fun enable do enable_intern(index)
+ private fun enable_intern(index: Int) `{ glEnableVertexAttribArray(index); `}
+
+ fun draw_arrays_triangles do draw_arrays_triangles_intern(index, count)
+ private fun draw_arrays_triangles_intern(index, count: Int) `{
+ glDrawArrays(GL_TRIANGLES, index, count);
+ `}
+end
+
+# Low level array of `Float`
+extern class GLfloatArray `{GLfloat *`}
+ new (array: Array[Float]) import Array[Float].length, Array[Float].[] `{
+ int i;
+ int len = Array_of_Float_length(array);
+ GLfloat *vertex_array = malloc(sizeof(GLfloat)*len);
+ for (i = 0; i < len; i ++) vertex_array[i] = Array_of_Float__index(array, i);
+ return vertex_array;
+ `}
+end
+
+extern class GLError `{ GLenum `}
+ fun is_ok: Bool do return is_no_error
+ fun is_no_error: Bool `{ return recv == GL_NO_ERROR; `}
+ fun is_invalid_enum: Bool `{ return recv == GL_INVALID_ENUM; `}
+ fun is_invalid_value: Bool `{ return recv == GL_INVALID_VALUE; `}
+ fun is_invalid_operation: Bool `{ return recv == GL_INVALID_OPERATION; `}
+ fun is_invalid_framebuffer_operation: Bool `{ return recv == GL_INVALID_FRAMEBUFFER_OPERATION; `}
+ fun is_out_of_memory: Bool `{ return recv == GL_OUT_OF_MEMORY; `}
+
+ redef fun to_s
+ do
+ if is_no_error then return "No error"
+ if is_invalid_enum then return "Invalid enum"
+ if is_invalid_value then return "Invalid value"
+ if is_invalid_operation then return "Invalid operation"
+ if is_invalid_framebuffer_operation then return "invalid framebuffer operation"
+ if is_out_of_memory then return "Out of memory"
+ return "Truely unknown error"
+ end
+end
+
+protected fun gl_clear_color(r, g, b, a: Float) `{ glClearColor(r, g, b, a); `}
+protected fun gl_viewport(x, y, width, height: Int) `{ glViewport(x, y, width, height); `}
+protected fun gl_vertex_attrib_pointer_int(index, length: Int, normalize: Bool, stride: Int, vertex: Array[Int]) import Array[Int].length, Array[Int].intern_items `{
+ int* c_vertex = Array_of_Int_intern_items(vertex);
+ glVertexAttribPointer(index, length, GL_INT, normalize, stride, c_vertex);
+`}
+protected fun gl_vertex_attrib_pointer_float(index, length: Int, normalize: Bool, stride: Int, vertex: Array[Float]) import Array[Float].length, Array[Float].intern_items `{
+ int* c_vertex = Array_of_Float_intern_items(vertex);
+ glVertexAttribPointer(index, length, GL_FLOAT, normalize, stride, c_vertex);
+`}
+
+# Direct call to `glClear`, call with a combinaison of `gl_clear_color_buffer`,
+# `gl_stencil_buffer_bit` and `gl_color_buffer_bit`.
+private fun gl_clear(flag: Int) `{ glClear(flag); `}
+
+protected fun gl_depth_buffer_bit: Int do return once "0100".to_hex
+protected fun gl_stencil_buffer_bit: Int do return once "0400".to_hex
+protected fun gl_color_buffer_bit: Int do return once "4000".to_hex
+
+protected fun gl_clear_color_buffer do gl_clear(gl_color_buffer_bit)
+protected fun gl_clear_depth_buffer do gl_clear(gl_depth_buffer_bit)
+protected fun gl_clear_stencil_buffer do gl_clear(gl_stencil_buffer_bit)
+
+protected fun gl_error: GLError `{ return glGetError(); `}
+protected fun assert_no_gl_error
+do
+ var error = gl_error
+ if not error.is_ok then
+ print "GL error: {error}"
+ abort
+ end
+end
+
+private fun gl_get_bool(key: Int): Bool `{
+ GLboolean val;
+ glGetBooleanv(GL_SHADER_COMPILER, &val);
+ return val == GL_TRUE;
+`}
+private fun gl_get_float(key: Int): Float `{
+ GLfloat val;
+ glGetFloatv(key, &val);
+ return val;
+`}
+private fun gl_get_int(key: Int): Int `{
+ GLint val;
+ glGetIntegerv(key, &val);
+ return val;
+`}
+
+fun gl_shader_compiler: Bool do return gl_get_bool("8DFA".to_hex)
nitlanguage / nit.git / commitdiff