Module: Engine::GL

Defined in:
lib/engine/gl.rb

Constant Summary collapse

ALWAYS =

Constants (hardcoded OpenGL values)

0x0207
ARRAY_BUFFER = 
0x8892
BACK = 
0x0405
BLEND = 
0x0BE2
CLAMP_TO_BORDER = 
0x812D
CLAMP_TO_EDGE = 
0x812F
COLOR_ATTACHMENT0 = 
0x8CE0
COLOR_ATTACHMENT1 = 
0x8CE1
COLOR_BUFFER_BIT = 
0x4000
COMPUTE_SHADER = 
0x91B9
CULL_FACE = 
0x0B44
DEPTH24_STENCIL8 = 
0x88F0
DEPTH_ATTACHMENT = 
0x8D00
DEPTH_BUFFER_BIT = 
0x0100
DEPTH_COMPONENT = 
0x1902
DEPTH_COMPONENT32F = 
0x8CAC
DEPTH_STENCIL = 
0x84F9
DEPTH_STENCIL_ATTACHMENT = 
0x821A
DEPTH_STENCIL_TEXTURE_MODE = 
0x90EA
DEPTH_TEST = 
0x0B71
DRAW_FRAMEBUFFER = 
0x8CA9
DYNAMIC_DRAW = 
0x88E8
ELEMENT_ARRAY_BUFFER = 
0x8893
EQUAL = 
0x0202
FALSE = 
0
FLOAT = 
0x1406
FRAGMENT_SHADER = 
0x8B30
FRAMEBUFFER = 
0x8D40
FRAMEBUFFER_COMPLETE = 
0x8CD5
INCR = 
0x1E02
INT = 
0x1404
KEEP = 
0x1E00
LESS = 
0x0201
LINEAR = 
0x2601

0x8B82
NEAREST = 
0x2600
NONE = 
0
ONE_MINUS_SRC_ALPHA = 
0x0303
QUERY_RESULT = 
0x8866
READ_FRAMEBUFFER = 
0x8CA8
READ_WRITE = 
0x88BA
REPEAT = 
0x2901
REPLACE = 
0x1E01
RGB = 
0x1907
RGB16F = 
0x881B
RGBA = 
0x1908
RGBA16F = 
0x881A
RGBA32F = 
0x8814
SHADER_IMAGE_ACCESS_BARRIER_BIT = 
0x00000020
SHADING_LANGUAGE_VERSION = 
0x8B8C
SRC_ALPHA = 
0x0302
STATIC_DRAW = 
0x88E4
STENCIL_BUFFER_BIT = 
0x0400
STENCIL_TEST = 
0x0B90
TEXTURE_2D = 
0x0DE1
TEXTURE_2D_ARRAY = 
0x8C1A
TEXTURE_BORDER_COLOR = 
0x1004
TEXTURE_COMPARE_MODE = 
0x884C
TEXTURE_CUBE_MAP = 
0x8513
TEXTURE_CUBE_MAP_ARRAY = 
0x9009
TEXTURE_CUBE_MAP_POSITIVE_X = 
0x8515
TEXTURE_MAG_FILTER = 
0x2800
TEXTURE_MIN_FILTER = 
0x2801
TEXTURE_RECTANGLE = 
0x84F5
TEXTURE_WRAP_R = 
0x8072
TEXTURE_WRAP_S = 
0x2802
TEXTURE_WRAP_T = 
0x2803
TIME_ELAPSED = 
0x88BF
TRIANGLES = 
0x0004
TRUE = 
1
UNSIGNED_BYTE = 
0x1401
UNSIGNED_INT = 
0x1405
UNSIGNED_INT_24_8 = 
0x84FA
VERTEX_SHADER = 
0x8B31
VERSION = 
0x1F02
TEXTURE0 =

Texture units

0x84C0
TEXTURE1 = 
0x84C1
TEXTURE2 = 
0x84C2
TEXTURE3 = 
0x84C3
TEXTURE4 = 
0x84C4
TEXTURE5 = 
0x84C5
TEXTURE6 = 
0x84C6
TEXTURE7 = 
0x84C7
TEXTURE8 = 
0x84C8
TEXTURE9 = 
0x84C9
TEXTURE10 = 
0x84CA
TEXTURE11 = 
0x84CB
TEXTURE12 = 
0x84CC
TEXTURE13 = 
0x84CD
TEXTURE14 = 
0x84CE
TEXTURE15 = 
0x84CF
TEXTURE16 = 
0x84D0
TEXTURE17 = 
0x84D1
TEXTURE18 = 
0x84D2
TEXTURE19 = 
0x84D3
TEXTURE20 = 
0x84D4
TEXTURE21 = 
0x84D5
TEXTURE22 = 
0x84D6
TEXTURE23 = 
0x84D7
TEXTURE24 = 
0x84D8
TEXTURE25 = 
0x84D9
TEXTURE26 = 
0x84DA
TEXTURE27 = 
0x84DB
TEXTURE28 = 
0x84DC
TEXTURE29 = 
0x84DD
TEXTURE30 = 
0x84DE
TEXTURE31 = 
0x84DF

Class Method Summary collapse

Class Method Details

.ActiveTexture(texture_unit) ⇒ Object 



32
33
34
35
36
37
 
# File 'lib/engine/gl.rb', line 32

def self.ActiveTexture(texture_unit)
  return if @current_texture_unit == texture_unit

  @current_texture_unit = texture_unit
  GLNative.active_texture(texture_unit)
end

.AttachShader(program, shader) ⇒ Object

Pass-through methods



53
54
55
 
# File 'lib/engine/gl.rb', line 53

def self.AttachShader(program, shader)
  GLNative.attach_shader(program, shader)
end

.BeginQuery(target, id) ⇒ Object 



57
58
59
 
# File 'lib/engine/gl.rb', line 57

def self.BeginQuery(target, id)
  GLNative.begin_query(target, id)
end

.BindBuffer(target, buffer) ⇒ Object 



61
62
63
64
65
66
 
# File 'lib/engine/gl.rb', line 61

def self.BindBuffer(target, buffer)
  return if bound_buffers[target] == buffer

  bound_buffers[target] = buffer
  GLNative.bind_buffer(target, buffer)
end

.BindFramebuffer(target, framebuffer) ⇒ Object 



72
73
74
 
# File 'lib/engine/gl.rb', line 72

def self.BindFramebuffer(target, framebuffer)
  GLNative.bind_framebuffer(target, framebuffer)
end

.BindImageTexture(unit, texture, level, layered, layer, access, format) ⇒ Object 



76
77
78
 
# File 'lib/engine/gl.rb', line 76

def self.BindImageTexture(unit, texture, level, layered, layer, access, format)
  GLNative.bind_image_texture(unit, texture, level, layered, layer, access, format)
end

.BindTexture(target, texture_id) ⇒ Object 



39
40
41
42
43
44
45
 
# File 'lib/engine/gl.rb', line 39

def self.BindTexture(target, texture_id)
  cache_key = [@current_texture_unit, target]
  return if bound_textures[cache_key] == texture_id

  bound_textures[cache_key] = texture_id
  GLNative.bind_texture(target, texture_id)
end

.BindVertexArray(array) ⇒ Object 



80
81
82
83
84
85
 
# File 'lib/engine/gl.rb', line 80

def self.BindVertexArray(array)
  return if @current_vertex_array == array

  @current_vertex_array = array
  GLNative.bind_vertex_array(array)
end

.BlendFunc(sfactor, dfactor) ⇒ Object 



87
88
89
 
# File 'lib/engine/gl.rb', line 87

def self.BlendFunc(sfactor, dfactor)
  GLNative.blend_func(sfactor, dfactor)
end

.BlitFramebuffer(src_x0, src_y0, src_x1, src_y1, dst_x0, dst_y0, dst_x1, dst_y1, mask, filter) ⇒ Object 



91
92
93
 
# File 'lib/engine/gl.rb', line 91

def self.BlitFramebuffer(src_x0, src_y0, src_x1, src_y1, dst_x0, dst_y0, dst_x1, dst_y1, mask, filter)
  GLNative.blit_framebuffer(src_x0, src_y0, src_x1, src_y1, dst_x0, dst_y0, dst_x1, dst_y1, mask, filter)
end

.bound_buffers ⇒ Object 



68
69
70
 
# File 'lib/engine/gl.rb', line 68

def self.bound_buffers
  @bound_buffers ||= {}
end

.bound_textures ⇒ Object 



47
48
49
 
# File 'lib/engine/gl.rb', line 47

def self.bound_textures
  @bound_textures ||= {}
end

.BufferData(target, size, data, usage) ⇒ Object 



95
96
97
 
# File 'lib/engine/gl.rb', line 95

def self.BufferData(target, size, data, usage)
  GLNative.buffer_data(target, size, data, usage)
end

.BufferSubData(target, offset, size, data) ⇒ Object 



99
100
101
 
# File 'lib/engine/gl.rb', line 99

def self.BufferSubData(target, offset, size, data)
  GLNative.buffer_sub_data(target, offset, size, data)
end

.CheckFramebufferStatus(target) ⇒ Object 



103
104
105
 
# File 'lib/engine/gl.rb', line 103

def self.CheckFramebufferStatus(target)
  GLNative.check_framebuffer_status(target)
end

.Clear(mask) ⇒ Object 



107
108
109
 
# File 'lib/engine/gl.rb', line 107

def self.Clear(mask)
  GLNative.clear(mask)
end

.ClearColor(red, green, blue, alpha) ⇒ Object 



111
112
113
 
# File 'lib/engine/gl.rb', line 111

def self.ClearColor(red, green, blue, alpha)
  GLNative.clear_color(red, green, blue, alpha)
end

.ColorMask(red, green, blue, alpha) ⇒ Object 



115
116
117
 
# File 'lib/engine/gl.rb', line 115

def self.ColorMask(red, green, blue, alpha)
  GLNative.color_mask(red, green, blue, alpha)
end

.CompileShader(shader) ⇒ Object 



119
120
121
 
# File 'lib/engine/gl.rb', line 119

def self.CompileShader(shader)
  GLNative.compile_shader(shader)
end

.CreateProgram ⇒ Object 



123
124
125
 
# File 'lib/engine/gl.rb', line 123

def self.CreateProgram
  GLNative.create_program
end

.CreateShader(type) ⇒ Object 



127
128
129
 
# File 'lib/engine/gl.rb', line 127

def self.CreateShader(type)
  GLNative.create_shader(type)
end

.CullFace(mode) ⇒ Object 



131
132
133
 
# File 'lib/engine/gl.rb', line 131

def self.CullFace(mode)
  GLNative.cull_face(mode)
end

.DepthFunc(func) ⇒ Object 



135
136
137
 
# File 'lib/engine/gl.rb', line 135

def self.DepthFunc(func)
  GLNative.depth_func(func)
end

.Disable(flag) ⇒ Object 



14
15
16
17
18
19
 
# File 'lib/engine/gl.rb', line 14

def self.Disable(flag)
  return if enable_flag_cache[flag] == false

  enable_flag_cache[flag] = false
  GLNative.disable(flag)
end

.DispatchCompute(num_groups_x, num_groups_y, num_groups_z) ⇒ Object 



139
140
141
 
# File 'lib/engine/gl.rb', line 139

def self.DispatchCompute(num_groups_x, num_groups_y, num_groups_z)
  GLNative.dispatch_compute(num_groups_x, num_groups_y, num_groups_z)
end

.DrawArrays(mode, first, count) ⇒ Object 



143
144
145
 
# File 'lib/engine/gl.rb', line 143

def self.DrawArrays(mode, first, count)
  GLNative.draw_arrays(mode, first, count)
end

.DrawBuffer(mode) ⇒ Object 



147
148
149
 
# File 'lib/engine/gl.rb', line 147

def self.DrawBuffer(mode)
  GLNative.draw_buffer(mode)
end

.DrawBuffers(n, bufs) ⇒ Object 



151
152
153
 
# File 'lib/engine/gl.rb', line 151

def self.DrawBuffers(n, bufs)
  GLNative.draw_buffers(n, bufs)
end

.DrawElements(mode, count, type, indices) ⇒ Object 



155
156
157
 
# File 'lib/engine/gl.rb', line 155

def self.DrawElements(mode, count, type, indices)
  GLNative.draw_elements(mode, count, type, indices)
end

.DrawElementsInstanced(mode, count, type, indices, instance_count) ⇒ Object 



159
160
161
 
# File 'lib/engine/gl.rb', line 159

def self.DrawElementsInstanced(mode, count, type, indices, instance_count)
  GLNative.draw_elements_instanced(mode, count, type, indices, instance_count)
end

.Enable(flag) ⇒ Object

Cached methods - avoid redundant GL state changes



7
8
9
10
11
12
 
# File 'lib/engine/gl.rb', line 7

def self.Enable(flag)
  return if enable_flag_cache[flag] == true

  enable_flag_cache[flag] = true
  GLNative.enable(flag)
end

.enable_flag_cache ⇒ Object 



21
22
23
 
# File 'lib/engine/gl.rb', line 21

def self.enable_flag_cache
  @enable_flag_cache ||= {}
end

.EnableVertexAttribArray(index) ⇒ Object 



163
164
165
 
# File 'lib/engine/gl.rb', line 163

def self.EnableVertexAttribArray(index)
  GLNative.enable_vertex_attrib_array(index)
end

.EndQuery(target) ⇒ Object 



167
168
169
 
# File 'lib/engine/gl.rb', line 167

def self.EndQuery(target)
  GLNative.end_query(target)
end

.Finish ⇒ Object 



171
172
173
 
# File 'lib/engine/gl.rb', line 171

def self.Finish
  GLNative.finish
end

.FramebufferTexture2D(target, attachment, textarget, texture, level) ⇒ Object 



175
176
177
 
# File 'lib/engine/gl.rb', line 175

def self.FramebufferTexture2D(target, attachment, textarget, texture, level)
  GLNative.framebuffer_texture_2d(target, attachment, textarget, texture, level)
end

.FramebufferTextureLayer(target, attachment, texture, level, layer) ⇒ Object 



179
180
181
 
# File 'lib/engine/gl.rb', line 179

def self.FramebufferTextureLayer(target, attachment, texture, level, layer)
  GLNative.framebuffer_texture_layer(target, attachment, texture, level, layer)
end

.GenBuffers(n, buffers) ⇒ Object 



183
184
185
 
# File 'lib/engine/gl.rb', line 183

def self.GenBuffers(n, buffers)
  GLNative.gen_buffers(n, buffers)
end

.GenerateMipmap(target) ⇒ Object 



187
188
189
 
# File 'lib/engine/gl.rb', line 187

def self.GenerateMipmap(target)
  GLNative.generate_mipmap(target)
end

.GenFramebuffers(n, framebuffers) ⇒ Object 



191
192
193
 
# File 'lib/engine/gl.rb', line 191

def self.GenFramebuffers(n, framebuffers)
  GLNative.gen_framebuffers(n, framebuffers)
end

.GenQueries(n, ids) ⇒ Object 



195
196
197
 
# File 'lib/engine/gl.rb', line 195

def self.GenQueries(n, ids)
  GLNative.gen_queries(n, ids)
end

.GenTextures(n, textures) ⇒ Object 



199
200
201
 
# File 'lib/engine/gl.rb', line 199

def self.GenTextures(n, textures)
  GLNative.gen_textures(n, textures)
end

.GenVertexArrays(n, arrays) ⇒ Object 



203
204
205
 
# File 'lib/engine/gl.rb', line 203

def self.GenVertexArrays(n, arrays)
  GLNative.gen_vertex_arrays(n, arrays)
end

.GetError ⇒ Object 



207
208
209
 
# File 'lib/engine/gl.rb', line 207

def self.GetError
  GLNative.get_error
end

.GetProgramInfoLog(program, max_length, length, info_log) ⇒ Object 



211
212
213
 
# File 'lib/engine/gl.rb', line 211

def self.GetProgramInfoLog(program, max_length, length, info_log)
  GLNative.get_program_info_log(program, max_length, length, info_log)
end

.GetProgramiv(program, pname, params) ⇒ Object 



215
216
217
 
# File 'lib/engine/gl.rb', line 215

def self.GetProgramiv(program, pname, params)
  GLNative.get_programiv(program, pname, params)
end

.GetQueryObjectui64v(id, pname, params) ⇒ Object 



219
220
221
 
# File 'lib/engine/gl.rb', line 219

def self.GetQueryObjectui64v(id, pname, params)
  GLNative.get_query_objectui64v(id, pname, params)
end

.GetShaderInfoLog(shader, max_length, length, info_log) ⇒ Object 



223
224
225
 
# File 'lib/engine/gl.rb', line 223

def self.GetShaderInfoLog(shader, max_length, length, info_log)
  GLNative.get_shader_info_log(shader, max_length, length, info_log)
end

.GetString(name) ⇒ Object 



227
228
229
 
# File 'lib/engine/gl.rb', line 227

def self.GetString(name)
  GLNative.get_string(name)
end

.GetUniformLocation(program, name) ⇒ Object 



231
232
233
 
# File 'lib/engine/gl.rb', line 231

def self.GetUniformLocation(program, name)
  GLNative.get_uniform_location(program, name)
end

.LinkProgram(program) ⇒ Object 



235
236
237
 
# File 'lib/engine/gl.rb', line 235

def self.LinkProgram(program)
  GLNative.link_program(program)
end

.MemoryBarrier(barriers) ⇒ Object 



239
240
241
 
# File 'lib/engine/gl.rb', line 239

def self.MemoryBarrier(barriers)
  GLNative.memory_barrier(barriers)
end

.ReadBuffer(mode) ⇒ Object 



243
244
245
 
# File 'lib/engine/gl.rb', line 243

def self.ReadBuffer(mode)
  GLNative.read_buffer(mode)
end

.ReadPixels(x, y, width, height, format, type, data) ⇒ Object 



247
248
249
 
# File 'lib/engine/gl.rb', line 247

def self.ReadPixels(x, y, width, height, format, type, data)
  GLNative.read_pixels(x, y, width, height, format, type, data)
end

.ShaderSource(shader, count, string, length) ⇒ Object 



251
252
253
 
# File 'lib/engine/gl.rb', line 251

def self.ShaderSource(shader, count, string, length)
  GLNative.shader_source(shader, count, string, length)
end

.StencilFunc(func, ref, mask) ⇒ Object 



255
256
257
 
# File 'lib/engine/gl.rb', line 255

def self.StencilFunc(func, ref, mask)
  GLNative.stencil_func(func, ref, mask)
end

.StencilMask(mask) ⇒ Object 



259
260
261
 
# File 'lib/engine/gl.rb', line 259

def self.StencilMask(mask)
  GLNative.stencil_mask(mask)
end

.StencilOp(sfail, dpfail, dppass) ⇒ Object 



263
264
265
 
# File 'lib/engine/gl.rb', line 263

def self.StencilOp(sfail, dpfail, dppass)
  GLNative.stencil_op(sfail, dpfail, dppass)
end

.TexImage2D(target, level, internalformat, width, height, border, format, type, data) ⇒ Object 



267
268
269
 
# File 'lib/engine/gl.rb', line 267

def self.TexImage2D(target, level, internalformat, width, height, border, format, type, data)
  GLNative.tex_image_2d(target, level, internalformat, width, height, border, format, type, data)
end

.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, data) ⇒ Object 



271
272
273
 
# File 'lib/engine/gl.rb', line 271

def self.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, data)
  GLNative.tex_image_3d(target, level, internalformat, width, height, depth, border, format, type, data)
end

.TexParameterfv(target, pname, params) ⇒ Object 



275
276
277
 
# File 'lib/engine/gl.rb', line 275

def self.TexParameterfv(target, pname, params)
  GLNative.tex_parameterfv(target, pname, params)
end

.TexParameteri(target, pname, param) ⇒ Object 



279
280
281
 
# File 'lib/engine/gl.rb', line 279

def self.TexParameteri(target, pname, param)
  GLNative.tex_parameteri(target, pname, param)
end

.Uniform1f(location, v0) ⇒ Object 



283
284
285
 
# File 'lib/engine/gl.rb', line 283

def self.Uniform1f(location, v0)
  GLNative.uniform1f(location, v0)
end

.Uniform1i(location, v0) ⇒ Object 



287
288
289
 
# File 'lib/engine/gl.rb', line 287

def self.Uniform1i(location, v0)
  GLNative.uniform1i(location, v0)
end

.Uniform2f(location, v0, v1) ⇒ Object 



291
292
293
 
# File 'lib/engine/gl.rb', line 291

def self.Uniform2f(location, v0, v1)
  GLNative.uniform2f(location, v0, v1)
end

.Uniform3f(location, v0, v1, v2) ⇒ Object 



295
296
297
 
# File 'lib/engine/gl.rb', line 295

def self.Uniform3f(location, v0, v1, v2)
  GLNative.uniform3f(location, v0, v1, v2)
end

.Uniform4f(location, v0, v1, v2, v3) ⇒ Object 



299
300
301
 
# File 'lib/engine/gl.rb', line 299

def self.Uniform4f(location, v0, v1, v2, v3)
  GLNative.uniform4f(location, v0, v1, v2, v3)
end

.UniformMatrix4fv(location, count, transpose, value) ⇒ Object 



303
304
305
 
# File 'lib/engine/gl.rb', line 303

def self.UniformMatrix4fv(location, count, transpose, value)
  GLNative.uniform_matrix4fv(location, count, transpose, value)
end

.UseProgram(program) ⇒ Object 



25
26
27
28
29
30
 
# File 'lib/engine/gl.rb', line 25

def self.UseProgram(program)
  return if @current_program == program

  @current_program = program
  GLNative.use_program(program)
end

.VertexAttribDivisor(index, divisor) ⇒ Object 



307
308
309
 
# File 'lib/engine/gl.rb', line 307

def self.VertexAttribDivisor(index, divisor)
  GLNative.vertex_attrib_divisor(index, divisor)
end

.VertexAttribIPointer(index, size, type, stride, pointer) ⇒ Object 



311
312
313
 
# File 'lib/engine/gl.rb', line 311

def self.VertexAttribIPointer(index, size, type, stride, pointer)
  GLNative.vertex_attrib_ipointer(index, size, type, stride, pointer)
end

.VertexAttribPointer(index, size, type, normalized, stride, pointer) ⇒ Object 



315
316
317
 
# File 'lib/engine/gl.rb', line 315

def self.VertexAttribPointer(index, size, type, normalized, stride, pointer)
  GLNative.vertex_attrib_pointer(index, size, type, normalized, stride, pointer)
end

.Viewport(x, y, width, height) ⇒ Object 



319
320
321
322
323
324
325
 
# File 'lib/engine/gl.rb', line 319

def self.Viewport(x, y, width, height)
  viewport = [x, y, width, height]
  return if @current_viewport == viewport

  @current_viewport = viewport
  GLNative.viewport(x, y, width, height)
end