refmod_test

view sdr.c @ 1:7e911c994ef2

find changesets by author, revision, files, or words in the commit message
should work on mac now
author John Tsiombikas <nuclear@member.fsf.org>
date Thu, 18 Feb 2016 23:21:49 +0200
parents b469e6a72636
children
line source
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <errno.h>
5 #include <assert.h>
6 #include <GL/glew.h>
7
8 #if defined(unix) || defined(__unix__)
9 #include <unistd.h>
10 #include <sys/stat.h>
11 #endif /* unix */
12
13 #include "sdr.h"
14
15 void init_sdr(void)
16 {
17 glewInit();
18 }
19
20 unsigned int create_vertex_shader(const char *src)
21 {
22 return create_shader(src, GL_VERTEX_SHADER);
23 }
24
25 unsigned int create_pixel_shader(const char *src)
26 {
27 return create_shader(src, GL_FRAGMENT_SHADER);
28 }
29
30 unsigned int create_shader(const char *src, unsigned int sdr_type)
31 {
32 unsigned int sdr;
33 int success, info_len;
34 char *info_str = 0;
35 GLenum err;
36
37 sdr = glCreateShader(sdr_type);
38 assert(glGetError() == GL_NO_ERROR);
39 glShaderSource(sdr, 1, &src, 0);
40 err = glGetError();
41 assert(err == GL_NO_ERROR);
42 glCompileShader(sdr);
43 assert(glGetError() == GL_NO_ERROR);
44
45 glGetShaderiv(sdr, GL_COMPILE_STATUS, &success);
46 assert(glGetError() == GL_NO_ERROR);
47 glGetShaderiv(sdr, GL_INFO_LOG_LENGTH, &info_len);
48 assert(glGetError() == GL_NO_ERROR);
49
50 if(info_len) {
51 if((info_str = malloc(info_len + 1))) {
52 glGetShaderInfoLog(sdr, info_len, 0, info_str);
53 assert(glGetError() == GL_NO_ERROR);
54 }
55 }
56
57 if(success) {
58 fprintf(stderr, info_str ? "done: %s\n" : "done\n", info_str);
59 } else {
60 fprintf(stderr, info_str ? "failed: %s\n" : "failed\n", info_str);
61 glDeleteShader(sdr);
62 sdr = 0;
63 }
64
65 free(info_str);
66 return sdr;
67 }
68
69 void free_shader(unsigned int sdr)
70 {
71 glDeleteShader(sdr);
72 }
73
74 unsigned int load_vertex_shader(const char *fname)
75 {
76 return load_shader(fname, GL_VERTEX_SHADER);
77 }
78
79 unsigned int load_pixel_shader(const char *fname)
80 {
81 return load_shader(fname, GL_FRAGMENT_SHADER);
82 }
83
84 unsigned int load_shader(const char *fname, unsigned int sdr_type)
85 {
86 #if defined(unix) || defined(__unix__)
87 struct stat st;
88 #endif
89 unsigned int sdr;
90 size_t filesize;
91 FILE *fp;
92 char *src;
93
94 if(!(fp = fopen(fname, "r"))) {
95 fprintf(stderr, "failed to open shader %s: %s\n", fname, strerror(errno));
96 return 0;
97 }
98
99 #if defined(unix) || defined(__unix__)
100 fstat(fileno(fp), &st);
101 filesize = st.st_size;
102 #else
103 fseek(fp, 0, SEEK_END);
104 filesize = ftell(fp);
105 fseek(fp, 0, SEEK_SET);
106 #endif /* unix */
107
108 if(!(src = malloc(filesize + 1))) {
109 fclose(fp);
110 return 0;
111 }
112 fread(src, 1, filesize, fp);
113 src[filesize] = 0;
114 fclose(fp);
115
116 fprintf(stderr, "compiling %s shader: %s... ", (sdr_type == GL_VERTEX_SHADER ? "vertex" : "pixel"), fname);
117 sdr = create_shader(src, sdr_type);
118
119 free(src);
120 return sdr;
121 }
122
123
124 unsigned int get_vertex_shader(const char *fname)
125 {
126 return get_shader(fname, GL_VERTEX_SHADER);
127 }
128
129 unsigned int get_pixel_shader(const char *fname)
130 {
131 return get_shader(fname, GL_FRAGMENT_SHADER);
132 }
133
134 unsigned int get_shader(const char *fname, unsigned int sdr_type)
135 {
136 unsigned int sdr;
137 #if 0
138 if((res = get_resource(sdrman, fname))) {
139 /* TODO: validate that the shader matches sdr_type? */
140 return (uintptr_t)res;
141 }
142 #endif
143
144 if(!(sdr = load_shader(fname, sdr_type))) {
145 return 0;
146 }
147 add_shader(fname, sdr);
148 return sdr;
149 }
150
151 int add_shader(const char *fname, unsigned int sdr)
152 {
153 return 0;/*add_resource(sdrman, fname, (void*)(uintptr_t)sdr);*/
154 }
155
156 int remove_shader(const char *fname)
157 {
158 return 0;/*remove_resource(sdrman, fname);*/
159 }
160
161
162 /* ---- gpu programs ---- */
163
164 unsigned int create_program(void)
165 {
166 unsigned int prog = glCreateProgram();
167 assert(glGetError() == GL_NO_ERROR);
168 return prog;
169 }
170
171 unsigned int create_program_link(unsigned int vs, unsigned int ps)
172 {
173 unsigned int prog;
174
175 if(!(prog = create_program())) {
176 return 0;
177 }
178
179 attach_shader(prog, vs);
180 assert(glGetError() == GL_NO_ERROR);
181 attach_shader(prog, ps);
182 assert(glGetError() == GL_NO_ERROR);
183
184 if(link_program(prog) == -1) {
185 free_program(prog);
186 return 0;
187 }
188 return prog;
189 }
190
191 unsigned int create_program_load(const char *vfile, const char *pfile)
192 {
193 unsigned int vs, ps;
194
195 if(!(vs = get_vertex_shader(vfile)) || !(ps = get_pixel_shader(pfile))) {
196 return 0;
197 }
198 return create_program_link(vs, ps);
199 }
200
201 void free_program(unsigned int sdr)
202 {
203 glDeleteProgram(sdr);
204 }
205
206 void attach_shader(unsigned int prog, unsigned int sdr)
207 {
208 glAttachShader(prog, sdr);
209 assert(glGetError() == GL_NO_ERROR);
210 }
211
212 int link_program(unsigned int prog)
213 {
214 int linked, info_len, retval = 0;
215 char *info_str = 0;
216
217 glLinkProgram(prog);
218 assert(glGetError() == GL_NO_ERROR);
219 glGetProgramiv(prog, GL_LINK_STATUS, &linked);
220 assert(glGetError() == GL_NO_ERROR);
221 glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &info_len);
222 assert(glGetError() == GL_NO_ERROR);
223
224 if(info_len) {
225 if((info_str = malloc(info_len + 1))) {
226 glGetProgramInfoLog(prog, info_len, 0, info_str);
227 assert(glGetError() == GL_NO_ERROR);
228 }
229 }
230
231 if(linked) {
232 fprintf(stderr, info_str ? "linking done: %s\n" : "linking done\n", info_str);
233 } else {
234 fprintf(stderr, info_str ? "linking failed: %s\n" : "linking failed\n", info_str);
235 retval = -1;
236 }
237
238 free(info_str);
239 return retval;
240 }
241
242 int bind_program(unsigned int prog)
243 {
244 GLenum err;
245
246 glUseProgram(prog);
247 if(prog && (err = glGetError()) != GL_NO_ERROR) {
248 /* maybe the program is not linked, try to link first */
249 if(err == GL_INVALID_OPERATION) {
250 if(link_program(prog) == -1) {
251 return -1;
252 }
253 glUseProgram(prog);
254 return glGetError() == GL_NO_ERROR ? 0 : -1;
255 }
256 return -1;
257 }
258 return 0;
259 }
260
261 /* ugly but I'm not going to write the same bloody code over and over */
262 #define BEGIN_UNIFORM_CODE \
263 int loc, curr_prog; \
264 glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog); \
265 if(curr_prog != prog && bind_program(prog) == -1) { \
266 return -1; \
267 } \
268 if((loc = glGetUniformLocation(prog, name)) != -1)
269
270 #define END_UNIFORM_CODE \
271 if(curr_prog != prog) { \
272 bind_program(curr_prog); \
273 } \
274 return loc == -1 ? -1 : 0
275
276 int set_uniform_int(unsigned int prog, const char *name, int val)
277 {
278 BEGIN_UNIFORM_CODE {
279 glUniform1i(loc, val);
280 }
281 END_UNIFORM_CODE;
282 }
283
284 int set_uniform_float(unsigned int prog, const char *name, float val)
285 {
286 BEGIN_UNIFORM_CODE {
287 glUniform1f(loc, val);
288 }
289 END_UNIFORM_CODE;
290 }
291
292 int set_uniform_vec2(unsigned int prog, const char *name, vec2_t val)
293 {
294 BEGIN_UNIFORM_CODE {
295 glUniform2f(loc, val.x, val.y);
296 }
297 END_UNIFORM_CODE;
298 }
299
300 int set_uniform_vec3(unsigned int prog, const char *name, vec3_t val)
301 {
302 BEGIN_UNIFORM_CODE {
303 glUniform3f(loc, val.x, val.y, val.z);
304 }
305 END_UNIFORM_CODE;
306 }
307
308 int set_uniform_vec4(unsigned int prog, const char *name, vec4_t val)
309 {
310 BEGIN_UNIFORM_CODE {
311 glUniform4f(loc, val.x, val.y, val.z, val.w);
312 }
313 END_UNIFORM_CODE;
314 }
315
316 int set_uniform_mat4(unsigned int prog, const char *name, mat4_t val)
317 {
318 BEGIN_UNIFORM_CODE {
319 glUniformMatrix4fv(loc, 1, 1, (float*)val);
320 }
321 END_UNIFORM_CODE;
322 }
323
324
325 int get_attrib_loc(unsigned int prog, const char *name)
326 {
327 int loc, curr_prog;
328
329 glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog);
330 if(curr_prog != prog && bind_program(prog) == -1) {
331 return -1;
332 }
333
334 loc = glGetAttribLocation(prog, (char*)name);
335
336 if(curr_prog != prog) {
337 bind_program(curr_prog);
338 }
339 return loc;
340 }
341
342 void set_attrib_vec3(int attr_loc, vec3_t val)
343 {
344 glVertexAttrib3f(attr_loc, val.x, val.y, val.z);
345 }
346
347 void set_attrib_float3(int attr_loc, float x, float y, float z)
348 {
349 glVertexAttrib3f(attr_loc, x, y, z);
350 }