refmod_test: b469e6a72636 sdr.c

refmod_test

view sdr.c @ 0:b469e6a72636

initial commit

author	John Tsiombikas <nuclear@member.fsf.org>
date	Thu, 18 Feb 2016 23:15:43 +0200
parents
children	7e911c994ef2

line source

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <string.h>

4 #include <errno.h>

5 #include <assert.h>

7 #if defined(unix) || defined(__unix__)

8 #include <unistd.h>

9 #include <sys/stat.h>

10 #include <GL/glx.h>

11 #endif /* unix */

13 #if defined(WIN32) || defined(__WIN32__)

14 #include <windows.h>

16 #define glXGetProcAddress wglGetProcAddress

17 #endif /* windows */

19 #define GL_GLEXT_LEGACY

20 #include <GL/gl.h>

22 #include "sdr.h"

24 #ifndef GL_VERSION_2_0

26 #define GL_FRAGMENT_SHADER 0x8B30

27 #define GL_VERTEX_SHADER 0x8B31

28 #define GL_COMPILE_STATUS 0x8B81

29 #define GL_LINK_STATUS 0x8B82

30 #define GL_INFO_LOG_LENGTH 0x8B84

31 #define GL_CURRENT_PROGRAM 0x8B8D

33 typedef char GLchar;

35 GLuint (*glCreateProgram)(void);

36 GLuint (*glCreateShader)(GLenum);

37 void (*glDeleteProgram)(GLuint);

38 void (*glDeleteShader)(GLuint);

39 void (*glCompileShader)(GLuint);

40 void (*glAttachShader)(GLuint, GLuint);

41 void (*glGetShaderiv)(GLuint, GLenum, GLint *);

42 void (*glGetShaderInfoLog)(GLuint, GLsizei, GLsizei *, GLchar *);

43 void (*glGetProgramiv)(GLuint, GLenum, GLint *);

44 void (*glGetProgramInfoLog)(GLuint, GLsizei, GLsizei *, GLchar *);

45 void (*glLinkProgram)(GLuint);

46 void (*glShaderSource)(GLuint, GLsizei, const GLchar* *, const GLint *);

47 void (*glUseProgram)(GLuint);

48 GLint (*glGetUniformLocation)(GLuint, const GLchar *);

49 void (*glUniform1f)(GLint, GLfloat);

50 void (*glUniform2f)(GLint, GLfloat, GLfloat);

51 void (*glUniform3f)(GLint, GLfloat, GLfloat, GLfloat);

52 void (*glUniform4f)(GLint, GLfloat, GLfloat, GLfloat, GLfloat);

53 void (*glUniform1i)(GLint, GLint);

54 void (*glUniformMatrix4fv)(GLint, GLsizei, GLboolean, const GLfloat *);

55 GLint (*glGetAttribLocation)(GLuint, const GLchar *);

56 void (*glVertexAttrib3f)(GLint, GLfloat, GLfloat, GLfloat);

58 void init_sdr(void)

59 {

60 glCreateProgram = glXGetProcAddress("glCreateProgramObjectARB");

61 glCreateShader = glXGetProcAddress("glCreateShaderObjectARB");

62 glDeleteProgram = glXGetProcAddress("glDeleteObjectARB");

63 glDeleteShader = glXGetProcAddress("glDeleteObjectARB");

64 glCompileShader = glXGetProcAddress("glCompileShaderARB");

65 glAttachShader = glXGetProcAddress("glAttachObjectARB");

66 glGetShaderiv = glXGetProcAddress("glGetObjectParameterivARB");

67 glGetShaderInfoLog = glXGetProcAddress("glGetInfoLogARB");

68 glGetProgramiv = glXGetProcAddress("glGetObjectParameterivARB");

69 glGetProgramInfoLog = glXGetProcAddress("glGetInfoLogARB");

70 glLinkProgram = glXGetProcAddress("glLinkProgramARB");

71 glShaderSource = glXGetProcAddress("glShaderSourceARB");

72 glUseProgram = glXGetProcAddress("glUseProgramObjectARB");

73 glGetUniformLocation = glXGetProcAddress("glGetUniformLocationARB");

74 glUniform1f = glXGetProcAddress("glUniform1fARB");

75 glUniform2f = glXGetProcAddress("glUniform2fARB");

76 glUniform3f = glXGetProcAddress("glUniform3fARB");

77 glUniform4f = glXGetProcAddress("glUniform4fARB");

78 glUniform1i = glXGetProcAddress("glUniform1iARB");

79 glUniformMatrix4fv = glXGetProcAddress("glUniformMatrix4fvARB");

80 glGetAttribLocation = glXGetProcAddress("glGetAttribLocationARB");

81 glVertexAttrib3f = glXGetProcAddress("glVertexAttrib3fARB");

82 }

83 #else

84 void init_sdr(void) {}

85 #endif

87 unsigned int create_vertex_shader(const char *src)

88 {

89 return create_shader(src, GL_VERTEX_SHADER);

90 }

92 unsigned int create_pixel_shader(const char *src)

93 {

94 return create_shader(src, GL_FRAGMENT_SHADER);

95 }

97 unsigned int create_shader(const char *src, unsigned int sdr_type)

98 {

99 unsigned int sdr;

100 int success, info_len;

101 char *info_str = 0;

102 GLenum err;

103

104 sdr = glCreateShader(sdr_type);

105 assert(glGetError() == GL_NO_ERROR);

106 glShaderSource(sdr, 1, &src, 0);

107 err = glGetError();

108 assert(err == GL_NO_ERROR);

109 glCompileShader(sdr);

110 assert(glGetError() == GL_NO_ERROR);

111

112 glGetShaderiv(sdr, GL_COMPILE_STATUS, &success);

113 assert(glGetError() == GL_NO_ERROR);

114 glGetShaderiv(sdr, GL_INFO_LOG_LENGTH, &info_len);

115 assert(glGetError() == GL_NO_ERROR);

116

117 if(info_len) {

118 if((info_str = malloc(info_len + 1))) {

119 glGetShaderInfoLog(sdr, info_len, 0, info_str);

120 assert(glGetError() == GL_NO_ERROR);

121 }

122 }

123

124 if(success) {

125 fprintf(stderr, info_str ? "done: %s\n" : "done\n", info_str);

126 } else {

127 fprintf(stderr, info_str ? "failed: %s\n" : "failed\n", info_str);

128 glDeleteShader(sdr);

129 sdr = 0;

130 }

131

132 free(info_str);

133 return sdr;

134 }

135

136 void free_shader(unsigned int sdr)

137 {

138 glDeleteShader(sdr);

139 }

140

141 unsigned int load_vertex_shader(const char *fname)

142 {

143 return load_shader(fname, GL_VERTEX_SHADER);

144 }

145

146 unsigned int load_pixel_shader(const char *fname)

147 {

148 return load_shader(fname, GL_FRAGMENT_SHADER);

149 }

150

151 unsigned int load_shader(const char *fname, unsigned int sdr_type)

152 {

153 #if defined(unix) || defined(__unix__)

154 struct stat st;

155 #endif

156 unsigned int sdr;

157 size_t filesize;

158 FILE *fp;

159 char *src;

160

161 if(!(fp = fopen(fname, "r"))) {

162 fprintf(stderr, "failed to open shader %s: %s\n", fname, strerror(errno));

163 return 0;

164 }

165

166 #if defined(unix) || defined(__unix__)

167 fstat(fileno(fp), &st);

168 filesize = st.st_size;

169 #else

170 fseek(fp, 0, SEEK_END);

171 filesize = ftell(fp);

172 fseek(fp, 0, SEEK_SET);

173 #endif /* unix */

174

175 if(!(src = malloc(filesize + 1))) {

176 fclose(fp);

177 return 0;

178 }

179 fread(src, 1, filesize, fp);

180 src[filesize] = 0;

181 fclose(fp);

182

183 fprintf(stderr, "compiling %s shader: %s... ", (sdr_type == GL_VERTEX_SHADER ? "vertex" : "pixel"), fname);

184 sdr = create_shader(src, sdr_type);

185

186 free(src);

187 return sdr;

188 }

189

190

191 unsigned int get_vertex_shader(const char *fname)

192 {

193 return get_shader(fname, GL_VERTEX_SHADER);

194 }

195

196 unsigned int get_pixel_shader(const char *fname)

197 {

198 return get_shader(fname, GL_FRAGMENT_SHADER);

199 }

200

201 unsigned int get_shader(const char *fname, unsigned int sdr_type)

202 {

203 unsigned int sdr;

204 #if 0

205 if((res = get_resource(sdrman, fname))) {

206 /* TODO: validate that the shader matches sdr_type? */

207 return (uintptr_t)res;

208 }

209 #endif

210

211 if(!(sdr = load_shader(fname, sdr_type))) {

212 return 0;

213 }

214 add_shader(fname, sdr);

215 return sdr;

216 }

217

218 int add_shader(const char *fname, unsigned int sdr)

219 {

220 return 0;/*add_resource(sdrman, fname, (void*)(uintptr_t)sdr);*/

221 }

222

223 int remove_shader(const char *fname)

224 {

225 return 0;/*remove_resource(sdrman, fname);*/

226 }

227

228

229 /* ---- gpu programs ---- */

230

231 unsigned int create_program(void)

232 {

233 unsigned int prog = glCreateProgram();

234 assert(glGetError() == GL_NO_ERROR);

235 return prog;

236 }

237

238 unsigned int create_program_link(unsigned int vs, unsigned int ps)

239 {

240 unsigned int prog;

241

242 if(!(prog = create_program())) {

243 return 0;

244 }

245

246 attach_shader(prog, vs);

247 assert(glGetError() == GL_NO_ERROR);

248 attach_shader(prog, ps);

249 assert(glGetError() == GL_NO_ERROR);

250

251 if(link_program(prog) == -1) {

252 free_program(prog);

253 return 0;

254 }

255 return prog;

256 }

257

258 unsigned int create_program_load(const char *vfile, const char *pfile)

259 {

260 unsigned int vs, ps;

261

262 if(!(vs = get_vertex_shader(vfile)) || !(ps = get_pixel_shader(pfile))) {

263 return 0;

264 }

265 return create_program_link(vs, ps);

266 }

267

268 void free_program(unsigned int sdr)

269 {

270 glDeleteProgram(sdr);

271 }

272

273 void attach_shader(unsigned int prog, unsigned int sdr)

274 {

275 glAttachShader(prog, sdr);

276 assert(glGetError() == GL_NO_ERROR);

277 }

278

279 int link_program(unsigned int prog)

280 {

281 int linked, info_len, retval = 0;

282 char *info_str = 0;

283

284 glLinkProgram(prog);

285 assert(glGetError() == GL_NO_ERROR);

286 glGetProgramiv(prog, GL_LINK_STATUS, &linked);

287 assert(glGetError() == GL_NO_ERROR);

288 glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &info_len);

289 assert(glGetError() == GL_NO_ERROR);

290

291 if(info_len) {

292 if((info_str = malloc(info_len + 1))) {

293 glGetProgramInfoLog(prog, info_len, 0, info_str);

294 assert(glGetError() == GL_NO_ERROR);

295 }

296 }

297

298 if(linked) {

299 fprintf(stderr, info_str ? "linking done: %s\n" : "linking done\n", info_str);

300 } else {

301 fprintf(stderr, info_str ? "linking failed: %s\n" : "linking failed\n", info_str);

302 retval = -1;

303 }

304

305 free(info_str);

306 return retval;

307 }

308

309 int bind_program(unsigned int prog)

310 {

311 GLenum err;

312

313 glUseProgram(prog);

314 if(prog && (err = glGetError()) != GL_NO_ERROR) {

315 /* maybe the program is not linked, try to link first */

316 if(err == GL_INVALID_OPERATION) {

317 if(link_program(prog) == -1) {

318 return -1;

319 }

320 glUseProgram(prog);

321 return glGetError() == GL_NO_ERROR ? 0 : -1;

322 }

323 return -1;

324 }

325 return 0;

326 }

327

328 /* ugly but I'm not going to write the same bloody code over and over */

329 #define BEGIN_UNIFORM_CODE \

330 int loc, curr_prog; \

331 glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog); \

332 if(curr_prog != prog && bind_program(prog) == -1) { \

333 return -1; \

334 } \

335 if((loc = glGetUniformLocation(prog, name)) != -1)

336

337 #define END_UNIFORM_CODE \

338 if(curr_prog != prog) { \

339 bind_program(curr_prog); \

340 } \

341 return loc == -1 ? -1 : 0

342

343 int set_uniform_int(unsigned int prog, const char *name, int val)

344 {

345 BEGIN_UNIFORM_CODE {

346 glUniform1i(loc, val);

347 }

348 END_UNIFORM_CODE;

349 }

350

351 int set_uniform_float(unsigned int prog, const char *name, float val)

352 {

353 BEGIN_UNIFORM_CODE {

354 glUniform1f(loc, val);

355 }

356 END_UNIFORM_CODE;

357 }

358

359 int set_uniform_vec2(unsigned int prog, const char *name, vec2_t val)

360 {

361 BEGIN_UNIFORM_CODE {

362 glUniform2f(loc, val.x, val.y);

363 }

364 END_UNIFORM_CODE;

365 }

366

367 int set_uniform_vec3(unsigned int prog, const char *name, vec3_t val)

368 {

369 BEGIN_UNIFORM_CODE {

370 glUniform3f(loc, val.x, val.y, val.z);

371 }

372 END_UNIFORM_CODE;

373 }

374

375 int set_uniform_vec4(unsigned int prog, const char *name, vec4_t val)

376 {

377 BEGIN_UNIFORM_CODE {

378 glUniform4f(loc, val.x, val.y, val.z, val.w);

379 }

380 END_UNIFORM_CODE;

381 }

382

383 int set_uniform_mat4(unsigned int prog, const char *name, mat4_t val)

384 {

385 BEGIN_UNIFORM_CODE {

386 glUniformMatrix4fv(loc, 1, 1, (float*)val);

387 }

388 END_UNIFORM_CODE;

389 }

390

391

392 int get_attrib_loc(unsigned int prog, const char *name)

393 {

394 int loc, curr_prog;

395

396 glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog);

397 if(curr_prog != prog && bind_program(prog) == -1) {

398 return -1;

399 }

400

401 loc = glGetAttribLocation(prog, (char*)name);

402

403 if(curr_prog != prog) {

404 bind_program(curr_prog);

405 }

406 return loc;

407 }

408

409 void set_attrib_vec3(int attr_loc, vec3_t val)

410 {

411 glVertexAttrib3f(attr_loc, val.x, val.y, val.z);

412 }

413

414 void set_attrib_float3(int attr_loc, float x, float y, float z)

415 {

416 glVertexAttrib3f(attr_loc, x, y, z);

417 }