dungeon_crawler: 0cd55268eaf4 prototype/src/renderer.cc

dungeon_crawler

view prototype/src/renderer.cc @ 32:0cd55268eaf4

AAAAaaaarghhhh... forgot to request floating point pixel format for MRT textures...

author	John Tsiombikas <nuclear@member.fsf.org>
date	Tue, 28 Aug 2012 02:18:19 +0300
parents	938a6a155c94
children	0357994effe2

line source

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <string.h>

4 #include <limits.h>

5 #include <assert.h>

6 #include "opengl.h"

7 #include "renderer.h"

8 #include "level.h"

9 #include "sdr.h"

10 #include "datapath.h"

13 static bool create_fbo(int xsz, int ysz);

14 static unsigned int load_sdr(const char *vfname, const char *pfname);

15 static int round_pow2(int x);

18 #define MRT_COUNT 4

19 static unsigned int mrt_tex[MRT_COUNT];

21 static unsigned int mrt_prog;

22 static unsigned int deferred_omni, deferred_debug;

24 static unsigned int fbo, rbuf_depth;

25 static const char *fbstname[] = {

26 "GL_FRAMEBUFFER_COMPLETE",

27 "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT",

28 "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",

29 "no such fbo error",

30 "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS",

31 "GL_FRAMEBUFFER_INCOMPLETE_FORMATS",

32 "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER",

33 "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER",

34 "GL_FRAMEBUFFER_UNSUPPORTED"

35 };

37 static int fb_xsz, fb_ysz, tex_xsz, tex_ysz;

41 bool init_renderer(int xsz, int ysz)

42 {

43 if(!GLEW_ARB_texture_float) {

44 fprintf(stderr, "Error: OpenGL implementation doesn't support floating point textures\n");

45 return false;

46 }

47 if(!GLEW_ARB_draw_buffers) {

48 fprintf(stderr, "Error: OpenGL implementation doesn't support multiple render targets\n");

49 return false;

50 }

52 int max_draw_buf;

53 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_draw_buf);

54 printf("max draw buffers: %d\n", max_draw_buf);

55 if(max_draw_buf < MRT_COUNT) {

56 fprintf(stderr, "OpenGL implementation doesn't support enough draw buffers\n");

57 return false;

58 }

60 if(!create_fbo(xsz, ysz)) {

61 return false;

62 }

63 CHECKGLERR;

65 if(!(mrt_prog = load_sdr("mrt.v.glsl", "mrt.p.glsl"))) {

66 return false;

67 }

68 set_uniform_int(mrt_prog, "tex_dif", 0);

69 set_uniform_int(mrt_prog, "tex_norm", 1);

71 if(!(deferred_debug = load_sdr("deferred.v.glsl", "deferred.p.glsl"))) {

72 return false;

73 }

74 for(int i=0; i<MRT_COUNT; i++) {

75 char uname[32];

76 sprintf(uname, "mrt%d", i);

77 set_uniform_int(deferred_debug, uname, i);

78 }

80 if(!(deferred_omni = load_sdr("deferred_omni.v.glsl", "deferred_omni.p.glsl"))) {

81 return false;

82 }

83 for(int i=0; i<MRT_COUNT; i++) {

84 char uname[32];

85 sprintf(uname, "mrt%d", i);

86 set_uniform_int(deferred_omni, uname, i);

87 }

88 return true;

89 }

91 void destroy_renderer()

92 {

93 free_program(mrt_prog);

94 free_program(deferred_omni);

96 glDeleteTextures(MRT_COUNT, mrt_tex);

97 glDeleteFramebuffersEXT(1, &fbo);

98 }

100 void resize_renderer(int xsz, int ysz)

101 {

102 fb_xsz = xsz;

103 fb_ysz = ysz;

104

105 // if we need a bigger rendertarget resize all colorbuffer textures and the depth buffer

106 if(xsz > tex_xsz || ysz > tex_ysz) {

107 tex_xsz = round_pow2(xsz);

108 tex_ysz = round_pow2(ysz);

109

110 for(int i=0; i<MRT_COUNT; i++) {

111 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

112 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, tex_xsz, tex_ysz, 0, GL_RGBA, GL_FLOAT, 0);

113 }

114

115 glBindRenderbufferEXT(GL_RENDERBUFFER, rbuf_depth);

116 glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, tex_xsz, tex_ysz);

117 }

118

119

120 // update the texture coordinate scaling factors

121 float tex_scale_x = (float)fb_xsz / tex_xsz;

122 float tex_scale_y = (float)fb_ysz / tex_ysz;

123

124 set_uniform_float2(deferred_omni, "tex_scale", tex_scale_x, tex_scale_y);

125 set_uniform_float2(deferred_omni, "fb_size", fb_xsz, fb_ysz);

126

127 set_uniform_float2(deferred_debug, "tex_scale", tex_scale_x, tex_scale_y);

128 }

129

130 void render_deferred(const Level *level)

131 {

132 // render into the MRT buffers

133 glUseProgram(mrt_prog);

134 glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);

135

136 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

137 level->draw();

138

139 glBindFramebufferEXT(GL_FRAMEBUFFER, 0);

140

141

142 // post-process lighting

143 glPushAttrib(GL_ENABLE_BIT);

144

145 glEnable(GL_BLEND);

146 glBlendFunc(GL_ONE, GL_ONE);

147

148 glDisable(GL_LIGHTING);

149 glDisable(GL_CULL_FACE);

150 glDisable(GL_DEPTH_TEST);

151

152 glUseProgram(deferred_omni);

153 for(int i=0; i<MRT_COUNT; i++) {

154 glActiveTexture(GL_TEXTURE0 + i);

155 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

156 glEnable(GL_TEXTURE_2D);

157 }

158

159 glDepthMask(0);

160 level->draw_lights();

161 glDepthMask(1);

162

163 for(int i=0; i<MRT_COUNT; i++) {

164 glActiveTexture(GL_TEXTURE0 + MRT_COUNT - i - 1);

165 glDisable(GL_TEXTURE_2D);

166 }

167

168 glUseProgram(0);

169 glPopAttrib();

170 }

171

172 static bool create_fbo(int xsz, int ysz)

173 {

174 unsigned int clamp = GL_ARB_texture_border_clamp ? GL_CLAMP_TO_EDGE : GL_CLAMP;

175

176 tex_xsz = round_pow2(xsz);

177 tex_ysz = round_pow2(ysz);

178 fb_xsz = xsz;

179 fb_ysz = ysz;

180

181 if(!glGenFramebuffersEXT) {

182 fprintf(stderr, "FBO support missing\n");

183 return false;

184 }

185 glGenFramebuffersEXT(1, &fbo);

186 glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);

187

188 glGenTextures(MRT_COUNT, mrt_tex);

189 for(int i=0; i<MRT_COUNT; i++) {

190 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

191 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp);

192 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp);

193 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

194 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

195 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, tex_xsz, tex_ysz, 0, GL_RGBA, GL_FLOAT, 0);

196

197 // attach to fbo

198 glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,

199 GL_TEXTURE_2D, mrt_tex[i], 0);

200 CHECKGLERR;

201 }

202

203 static GLenum draw_bufs[] = {

204 GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT,

205 GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT,

206 GL_COLOR_ATTACHMENT4_EXT, GL_COLOR_ATTACHMENT5_EXT,

207 GL_COLOR_ATTACHMENT6_EXT, GL_COLOR_ATTACHMENT7_EXT

208 };

209 glDrawBuffersARB(MRT_COUNT, draw_bufs);

210

211 glGenRenderbuffersEXT(1, &rbuf_depth);

212 glBindRenderbufferEXT(GL_RENDERBUFFER, rbuf_depth);

213 glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, tex_xsz, tex_ysz);

214 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rbuf_depth);

215

216 int fbst = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);

217 if(fbst != GL_FRAMEBUFFER_COMPLETE) {

218 fprintf(stderr, "incomplete fbo: %u (%s)\n", fbo, fbstname[fbst - GL_FRAMEBUFFER_COMPLETE]);

219 return false;

220 }

221 CHECKGLERR;

222

223 glBindFramebufferEXT(GL_FRAMEBUFFER, 0);

224 return true;

225 }

226

227 static unsigned int load_sdr(const char *vfname, const char *pfname)

228 {

229 char vsfile[PATH_MAX], psfile[PATH_MAX];

230 const char *fname;

231 unsigned int prog;

232

233 if((fname = datafile_path(vfname))) {

234 strcpy(vsfile, fname);

235 } else {

236 vsfile[0] = 0;

237 }

238 if((fname = datafile_path(pfname))) {

239 strcpy(psfile, fname);

240 } else {

241 psfile[0] = 0;

242 }

243 if(!(prog = create_program_load(vsfile, psfile))) {

244 fprintf(stderr, "failed to load shader program (%s, %s)\n", vsfile, psfile);

245 return 0;

246 }

247 return prog;

248 }

249

250 static int round_pow2(int x)

251 {

252 x--;

253 x = (x >> 1) | x;

254 x = (x >> 2) | x;

255 x = (x >> 4) | x;

256 x = (x >> 8) | x;

257 x = (x >> 16) | x;

258 return x + 1;

259 }