dungeon_crawler: 7f52d6310317 prototype/src/renderer

dungeon_crawler

view prototype/src/renderer_deferred.cc @ 63:7f52d6310317

fixed design issue with datafile_path

author	John Tsiombikas <nuclear@member.fsf.org>
date	Tue, 02 Oct 2012 04:52:59 +0300
parents	f71381c9e245
children	fc2b3d06d07c

line source

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <string.h>

4 #include <limits.h>

5 #include "opengl.h"

6 #include "renderer_deferred.h"

7 #include "level.h"

8 #include "sdr.h"

9 #include "datapath.h"

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

12 static int round_pow2(int x);

14 DeferredRenderer::DeferredRenderer()

15 {

16 fbo = rbuf_depth = 0;

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

18 mrt_tex[i] = 0;

19 }

20 tex_xsz = tex_ysz = 0;

22 mrt_prog = deferred_debug = deferred_omni = 0;

24 curr_prog = 0;

25 num_draw_bufs = 1;

26 }

28 DeferredRenderer::~DeferredRenderer()

29 {

30 if(mrt_prog) {

31 free_program(mrt_prog);

32 }

33 if(deferred_omni) {

34 free_program(deferred_omni);

35 }

36 if(deferred_debug) {

37 free_program(deferred_debug);

38 }

40 if(mrt_tex[0]) {

41 glDeleteTextures(MRT_COUNT, mrt_tex);

42 }

43 if(fbo) {

44 glDeleteFramebuffersEXT(1, &fbo);

45 }

46 }

48 bool DeferredRenderer::init(int xsz, int ysz)

49 {

50 width = xsz;

51 height = ysz;

53 if(!GLEW_ARB_texture_float) {

54 fprintf(stderr, "%s: error: no floating point texture support\n", __func__);

55 return false;

56 }

57 if(!GLEW_ARB_draw_buffers) {

58 fprintf(stderr, "%s: error: no multiple render target support\n", __func__);

59 return false;

60 }

62 int max_draw_buf;

63 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_draw_buf);

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

65 if(max_draw_buf < MRT_COUNT) {

66 fprintf(stderr, "%s: error: not enough draw buffers (%d), %d required\n", __func__, max_draw_buf, MRT_COUNT);

67 return false;

68 }

69 num_draw_bufs = MRT_COUNT;

71 if(!create_fbo()) {

72 return false;

73 }

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

76 return false;

77 }

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

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

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

82 return false;

83 }

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

85 char uname[32];

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

87 set_uniform_int(deferred_omni, uname, i);

88 }

90 rend = this;

91 return true;

92 }

94 int DeferredRenderer::get_tangent_location() const

95 {

96 return get_attrib_loc(mrt_prog, "attr_tangent");

97 }

99 unsigned int DeferredRenderer::get_current_program() const

100 {

101 return curr_prog;

102 }

103

104 void DeferredRenderer::resize(int xsz, int ysz)

105 {

106 width = xsz;

107 height = ysz;

108

109 // if we need a bigger rendertarget ...

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

111 tex_xsz = round_pow2(xsz);

112 tex_ysz = round_pow2(ysz);

113

114 // ... resize all the color buffers

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

116 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

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

118 }

119

120 // ... resize the depth buffer

121 glBindRenderbufferEXT(GL_RENDERBUFFER, rbuf_depth);

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

123 }

124

125 // update the texture coordinate scaling factors

126 float tex_scale_x = (float)width / tex_xsz;

127 float tex_scale_y = (float)height / tex_ysz;

128

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

130 set_uniform_float2(deferred_omni, "fb_size", width, height);

131 }

132

133 void DeferredRenderer::render(const Level *level) const

134 {

135 render_pre(level);

136

137 // render into the MRT buffers

138 glUseProgram(mrt_prog);

139 curr_prog = mrt_prog;

140

141 glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);

142

143 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

144 level->draw();

145 glBindFramebufferEXT(GL_FRAMEBUFFER, 0);

146

147 // post-process lighting

148 light_pass(level);

149

150 glUseProgram(0);

151 curr_prog = 0;

152

153 render_post(level);

154 }

155

156 void DeferredRenderer::light_pass(const Level *level) const

157 {

158 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);

159

160 glEnable(GL_BLEND);

161 glBlendFunc(GL_ONE, GL_ONE);

162

163 glDisable(GL_LIGHTING);

164 glDisable(GL_DEPTH_TEST);

165 glCullFace(GL_FRONT);

166

167 glUseProgram(deferred_omni);

168 curr_prog = deferred_omni;

169

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

171 glActiveTexture(GL_TEXTURE0 + i);

172 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

173 glEnable(GL_TEXTURE_2D);

174 }

175

176 glDepthMask(0);

177 level->draw_lights();

178 glDepthMask(1);

179

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

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

182 glDisable(GL_TEXTURE_2D);

183 }

184

185 glPopAttrib();

186 }

187

188 static const char *fbstname[] = {

189 "GL_FRAMEBUFFER_COMPLETE",

190 "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT",

191 "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",

192 "no such fbo error",

193 "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS",

194 "GL_FRAMEBUFFER_INCOMPLETE_FORMATS",

195 "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER",

196 "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER",

197 "GL_FRAMEBUFFER_UNSUPPORTED"

198 };

199

200 bool DeferredRenderer::create_fbo()

201 {

202 unsigned int clamp = GLEW_ARB_texture_border_clamp ? GL_CLAMP_TO_EDGE : GL_CLAMP;

203

204 // round the texture size up to the next power of 2

205 tex_xsz = round_pow2(width);

206 tex_ysz = round_pow2(height);

207

208 if(!glGenFramebuffersEXT) {

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

210 return false;

211 }

212 glGenFramebuffersEXT(1, &fbo);

213 glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);

214

215 glGenTextures(MRT_COUNT, mrt_tex);

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

217 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

218 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp);

219 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp);

220 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

221 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

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

223

224 // attach to fbo

225 GLenum color_att = GL_COLOR_ATTACHMENT0 + (num_draw_bufs == MRT_COUNT ? i : 0);

226 glFramebufferTexture2DEXT(GL_FRAMEBUFFER, color_att, GL_TEXTURE_2D, mrt_tex[i], 0);

227 CHECKGLERR;

228 }

229

230 if(num_draw_bufs == MRT_COUNT) {

231 static GLenum draw_bufs[] = {

232 GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT,

233 GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT,

234 GL_COLOR_ATTACHMENT4_EXT, GL_COLOR_ATTACHMENT5_EXT,

235 GL_COLOR_ATTACHMENT6_EXT, GL_COLOR_ATTACHMENT7_EXT

236 };

237 glDrawBuffersARB(num_draw_bufs, draw_bufs);

238 }

239

240 glGenRenderbuffersEXT(1, &rbuf_depth);

241 glBindRenderbufferEXT(GL_RENDERBUFFER, rbuf_depth);

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

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

244

245 int fbst = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);

246 if(fbst != GL_FRAMEBUFFER_COMPLETE) {

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

248 return false;

249 }

250 CHECKGLERR;

251

252 glBindFramebufferEXT(GL_FRAMEBUFFER, 0);

253 return true;

254 }

255

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

257 {

258 unsigned int prog;

259

260 std::string vsfile = datafile_path(vfname);

261 std::string psfile = datafile_path(pfname);

262

263 const char *vs = vsfile.empty() ? 0 : vsfile.c_str();

264 const char *ps = psfile.empty() ? 0 : psfile.c_str();

265

266 if(!(prog = create_program_load(vs, ps))) {

267 fprintf(stderr, "failed to load shader program (%s, %s)\n", vs, ps);

268 return 0;

269 }

270 return prog;

271 }

272

273 static int round_pow2(int x)

274 {

275 x--;

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

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

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

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

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

281 return x + 1;

282 }

283

284 #ifdef DBG_VIS_MRT

285 // visualize the MRT buffers

286 static void draw_deferred_debug()

287 {

288 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);

289 glUseProgram(deferred_debug);

290 glDisable(GL_DEPTH_TEST);

291

292 glMatrixMode(GL_PROJECTION);

293 glPushMatrix();

294 glLoadIdentity();

295 glMatrixMode(GL_MODELVIEW);

296 glPushMatrix();

297 glLoadIdentity();

298

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

300 glActiveTexture(GL_TEXTURE0 + i);

301 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

302 glEnable(GL_TEXTURE_2D);

303 }

304

305 glBegin(GL_QUADS);

306 glTexCoord2f(0, 0);

307 glVertex2f(-1, -1);

308 glTexCoord2f(1, 0);

309 glVertex2f(1, -1);

310 glTexCoord2f(1, 1);

311 glVertex2f(1, 1);

312 glTexCoord2f(0, 1);

313 glVertex2f(-1, 1);

314 glEnd();

315

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

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

318 glDisable(GL_TEXTURE_2D);

319 }

320

321 glMatrixMode(GL_PROJECTION);

322 glPopMatrix();

323 glMatrixMode(GL_MODELVIEW);

324 glPopMatrix();

325

326 glUseProgram(0);

327 glPopAttrib();

328 }

329 #endif