forked from vlang/v
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathgl.v
More file actions
210 lines (167 loc) · 4.33 KB
/
Copy pathgl.v
File metadata and controls
210 lines (167 loc) · 4.33 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module gl
import const (
GL_TEXTURE_2D
GL_TEXTURE0
GL_FLOAT
GL_VERTEX_SHADER
GL_ELEMENT_ARRAY_BUFFER
GL_DEPTH_TEST
)
// TODO: windows support
#flag linux -I$HOME/code/v/thirdparty/glad
#flag darwin -I$HOME/code/v/thirdparty/glad
#include "glad.h"
#include "glad.c"
fn init_glad() {
ok := C.gladLoadGL()
if !ok {
println('Failed to initialize glad OpenGL context')
exit(1)
}
}
pub fn viewport(a int, b int, c int, d int) {
C.glViewport(a, b, c, d)
}
pub fn clear_color(r, g, b, a int) {
# glClearColor(((float)r)/255.0,((float)g)/255.0,b/255.0, a/255.0);
}
pub fn clear() {
# glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
}
pub fn create_shader(typ int) int {
return C.glCreateShader(typ)
}
pub fn create_program() int {
return C.glCreateProgram()
}
pub fn shader_source(shader int, a int, source string, b int) {
C.glShaderSource(shader, a, &source.str, b)
}
pub fn compile_shader(shader int) {
C.glCompileShader(shader)
}
pub fn shader_compile_status(shader int) int {
success := 0
# glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
return success
}
pub fn attach_shader(program int, shader int) {
// fn (s Shader) attach(program int) {
C.glAttachShader(program, shader)
}
pub fn link_program(program int) {
C.glLinkProgram(program)
}
pub fn get_program_link_status(program int) int {
success := 0
# glGetProgramiv(program, GL_LINK_STATUS, &success);
return success
}
pub fn delete_shader(shader int) {
C.glDeleteShader(shader)
}
pub fn shader_info_log(shader int) string {
# printf("GET info log\n");
# char infoLog[512];
# glGetShaderInfoLog(shader, 512, NULL, infoLog);
# printf("log=%s\n", infoLog);
# return tos_no_len(infoLog);
return ''
}
pub fn get_program_info_log(program int) string {
# char infoLog[512];
# glGetProgramInfoLog(program, 1024, NULL, infoLog);
# return tos_no_len(infoLog);
return ''
}
pub fn bind_vao(vao u32) {
C.glBindVertexArray(vao)
}
pub fn bind_buffer(typ int, vbo u32) {
C.glBindBuffer(typ, vbo)
}
pub fn gen_texture() u32 {
res := u32(0)
C.glGenTextures(1, &res)
return res
}
pub fn active_texture(t int) {
C.glActiveTexture(t)
}
pub fn bind_2d_texture(texture u32) {
C.glBindTexture(GL_TEXTURE_2D, texture)
}
pub fn delete_texture(texture u32) {
C.glDeleteTextures(1, &texture)
}
pub fn buffer_data(typ int, size int, arr voidptr, draw_typ int) {
C.glBufferData(typ, size, arr, draw_typ)
}
pub fn buffer_data_int(typ int, vertices[]int, draw_typ int) {
size := sizeof(int) * vertices.len
C.glBufferData(typ, size, vertices.data, draw_typ)
}
pub fn buffer_data_float(typ int, vertices[]float, draw_typ int) {
size := sizeof(float) * vertices.len
C.glBufferData(typ, size, vertices.data, draw_typ)
}
pub fn set_vbo(vbo u32, vertices[]float, draw_typ int) {
gl.bind_buffer(GL_ARRAY_BUFFER, vbo)
gl.buffer_data_float(GL_ARRAY_BUFFER, vertices, draw_typ)
}
pub fn set_ebo(ebo u32, indices[]int, draw_typ int) {
gl.bind_buffer(GL_ELEMENT_ARRAY_BUFFER, ebo)
// gl.buffer_data_int(GL_ELEMENT_ARRAY_BUFFER, indices, draw_typ)
gl.buffer_data_int(GL_ELEMENT_ARRAY_BUFFER, indices, draw_typ)
}
// /////////////////////
// fn gen_vertex_arrays(a int, vao uint) {
// # glGenVertexArrays(a, &VAO);
// }
pub fn draw_arrays(typ, start, len int) {
C.glDrawArrays(typ, start, len)
}
pub fn draw_elements(mode, count, typ, indices int) {
C.glDrawElements(mode, count, typ, indices)
}
pub fn use_program(program int) {
C.glUseProgram(program)
}
pub fn gen_vertex_array() u32 {
VAO := u32(0)
# glGenVertexArrays(1, &VAO);
return VAO
}
pub fn enable_vertex_attrib_array(n int) {
C.glEnableVertexAttribArray(n)
}
pub fn gen_buffer() u32 {
VBO := u32(0)
# glGenBuffers(1, &VBO);
return VBO
}
pub fn vertex_attrib_pointer(index, size int, typ int, normalized bool, stride int, ptr int) {
if typ == GL_FLOAT {
stride *= sizeof(float)
ptr *= sizeof(float)
}
C.glVertexAttribPointer(index, size, typ, normalized, stride, ptr)
}
pub fn tex_param(key, val int) {
C.glTexParameteri(GL_TEXTURE_2D, key, val)
}
pub fn enable(val int) {
C.glEnable(val)
}
pub fn disable(val int) {
C.glDisable(val)
}
pub fn scissor(a, b, c, d int) {
C.glScissor(a, b, c, d)
}
pub fn generate_mipmap(typ int) {
C.glGenerateMipmap(typ)
}