dungeon_crawler: aa86119e3295 prototype/src/renderer

dungeon_crawler

view prototype/src/renderer_deferred.cc @ 60:aa86119e3295

added multipass deferred

author	John Tsiombikas <nuclear@member.fsf.org>
date	Tue, 25 Sep 2012 06:19:37 +0300
parents	acfe0c0110fc
children	f71381c9e245

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 into the MRT buffers

136 glUseProgram(mrt_prog);

137 curr_prog = mrt_prog;

138

139 glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);

140

141 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

142 level->draw();

143 glBindFramebufferEXT(GL_FRAMEBUFFER, 0);

144

145 // post-process lighting

146 light_pass(level);

147

148 glUseProgram(0);

149 curr_prog = 0;

150 }

151

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

153 {

154 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);

155

156 glEnable(GL_BLEND);

157 glBlendFunc(GL_ONE, GL_ONE);

158

159 glDisable(GL_LIGHTING);

160 glDisable(GL_DEPTH_TEST);

161 glCullFace(GL_FRONT);

162

163 glUseProgram(deferred_omni);

164 curr_prog = deferred_omni;

165

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

167 glActiveTexture(GL_TEXTURE0 + i);

168 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

169 glEnable(GL_TEXTURE_2D);

170 }

171

172 glDepthMask(0);

173 level->draw_lights();

174 glDepthMask(1);

175

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

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

178 glDisable(GL_TEXTURE_2D);

179 }

180

181 glPopAttrib();

182 }

183

184 static const char *fbstname[] = {

185 "GL_FRAMEBUFFER_COMPLETE",

186 "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT",

187 "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",

188 "no such fbo error",

189 "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS",

190 "GL_FRAMEBUFFER_INCOMPLETE_FORMATS",

191 "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER",

192 "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER",

193 "GL_FRAMEBUFFER_UNSUPPORTED"

194 };

195

196 bool DeferredRenderer::create_fbo()

197 {

198 unsigned int clamp = GLEW_ARB_texture_border_clamp ? GL_CLAMP_TO_EDGE : GL_CLAMP;

199

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

201 tex_xsz = round_pow2(width);

202 tex_ysz = round_pow2(height);

203

204 if(!glGenFramebuffersEXT) {

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

206 return false;

207 }

208 glGenFramebuffersEXT(1, &fbo);

209 glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);

210

211 glGenTextures(MRT_COUNT, mrt_tex);

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

213 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

214 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp);

215 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp);

216 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

217 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

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

219

220 // attach to fbo

221 GLenum color_att = num_draw_bufs >= MRT_COUNT ? GL_COLOR_ATTACHMENT0 + i : GL_COLOR_ATTACHMENT0;

222 glFramebufferTexture2DEXT(GL_FRAMEBUFFER, color_att, GL_TEXTURE_2D,

223 mrt_tex[i], 0);

224 CHECKGLERR;

225 }

226

227 if(num_draw_bufs >= MRT_COUNT) {

228 static GLenum draw_bufs[] = {

229 GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT,

230 GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT,

231 GL_COLOR_ATTACHMENT4_EXT, GL_COLOR_ATTACHMENT5_EXT,

232 GL_COLOR_ATTACHMENT6_EXT, GL_COLOR_ATTACHMENT7_EXT

233 };

234 glDrawBuffersARB(num_draw_bufs, draw_bufs);

235 }

236

237 glGenRenderbuffersEXT(1, &rbuf_depth);

238 glBindRenderbufferEXT(GL_RENDERBUFFER, rbuf_depth);

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

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

241

242 int fbst = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);

243 if(fbst != GL_FRAMEBUFFER_COMPLETE) {

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

245 return false;

246 }

247 CHECKGLERR;

248

249 glBindFramebufferEXT(GL_FRAMEBUFFER, 0);

250 return true;

251 }

252

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

254 {

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

256 const char *fname;

257 unsigned int prog;

258

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

260 strcpy(vsfile, fname);

261 } else {

262 vsfile[0] = 0;

263 }

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

265 strcpy(psfile, fname);

266 } else {

267 psfile[0] = 0;

268 }

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

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

271 return 0;

272 }

273 return prog;

274 }

275

276 static int round_pow2(int x)

277 {

278 x--;

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

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

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

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

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

284 return x + 1;

285 }

286

287 #ifdef DBG_VIS_MRT

288 // visualize the MRT buffers

289 static void draw_deferred_debug()

290 {

291 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);

292 glUseProgram(deferred_debug);

293 glDisable(GL_DEPTH_TEST);

294

295 glMatrixMode(GL_PROJECTION);

296 glPushMatrix();

297 glLoadIdentity();

298 glMatrixMode(GL_MODELVIEW);

299 glPushMatrix();

300 glLoadIdentity();

301

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

303 glActiveTexture(GL_TEXTURE0 + i);

304 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

305 glEnable(GL_TEXTURE_2D);

306 }

307

308 glBegin(GL_QUADS);

309 glTexCoord2f(0, 0);

310 glVertex2f(-1, -1);

311 glTexCoord2f(1, 0);

312 glVertex2f(1, -1);

313 glTexCoord2f(1, 1);

314 glVertex2f(1, 1);

315 glTexCoord2f(0, 1);

316 glVertex2f(-1, 1);

317 glEnd();

318

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

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

321 glDisable(GL_TEXTURE_2D);

322 }

323

324 glMatrixMode(GL_PROJECTION);

325 glPopMatrix();

326 glMatrixMode(GL_MODELVIEW);

327 glPopMatrix();

328

329 glUseProgram(0);

330 glPopAttrib();

331 }

332 #endif