dungeon_crawler: a27528035e20 prototype/src/renderer

dungeon_crawler

view prototype/src/renderer_deferred.cc @ 72:a27528035e20

- re-organized the renderer classes a bit wrt final render-target - implemented identity color-grading palette for now - broke particle systems.... - removed multipass renderer

author	John Tsiombikas <nuclear@member.fsf.org>
date	Fri, 19 Oct 2012 02:45:57 +0300
parents	45172d087ebe
children

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 void attach_color_buffer(unsigned int fbo, int count, const unsigned int *tex);

14 DeferredRenderer::DeferredRenderer()

15 {

16 fbo = 0;

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

18 mrt_tex[i] = 0;

19 }

20 mrt_prog = deferred_debug = deferred_omni = 0;

22 curr_prog = 0;

23 num_draw_bufs = 1;

24 }

26 DeferredRenderer::~DeferredRenderer()

27 {

28 if(mrt_prog) {

29 free_program(mrt_prog);

30 }

31 if(deferred_omni) {

32 free_program(deferred_omni);

33 }

34 if(deferred_debug) {

35 free_program(deferred_debug);

36 }

38 if(mrt_tex[0]) {

39 glDeleteTextures(MRT_COUNT, mrt_tex);

40 }

41 }

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

44 {

45 if(!Renderer::init(xsz, ysz)) {

46 return false;

47 }

49 if(!GLEW_ARB_texture_float) {

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

51 return false;

52 }

53 if(!GLEW_ARB_draw_buffers) {

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

55 return false;

56 }

58 int max_draw_buf;

59 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_draw_buf);

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

61 if(max_draw_buf < MRT_COUNT) {

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

63 return false;

64 }

65 num_draw_bufs = MRT_COUNT;

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

68 return false;

69 }

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

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

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

74 return false;

75 }

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

77 char uname[32];

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

79 set_uniform_int(deferred_omni, uname, i);

80 }

82 return true;

83 }

85 int DeferredRenderer::get_tangent_location() const

86 {

87 return get_attrib_loc(mrt_prog, "attr_tangent");

88 }

90 unsigned int DeferredRenderer::get_current_program() const

91 {

92 return curr_prog;

93 }

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

96 {

97 // keep a copy of the previous texture size because Renderer::resize may change it

99 int prev_tex_xsz = tex_xsz;

100 int prev_tex_ysz = tex_ysz;

101

102 Renderer::resize(xsz, ysz);

103

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

105 if(xsz > prev_tex_xsz || ysz > prev_tex_ysz) {

106 // ... resize all the color buffers

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

108 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

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

110 }

111 }

112

113 // update the texture coordinate scaling factors

114 float tex_scale_x = (float)width / tex_xsz;

115 float tex_scale_y = (float)height / tex_ysz;

116

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

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

119 }

120

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

122 {

123 render_pre(level);

124

125 // render into the MRT buffers

126 glUseProgram(mrt_prog);

127 curr_prog = mrt_prog;

128

129 glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);

130 attach_color_buffer(fbo, num_draw_bufs, mrt_tex);

131

132 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

133 level->draw();

134

135 attach_color_buffer(fbo, 1, &rend_tex);

136 glClear(GL_COLOR_BUFFER_BIT);

137

138 // post-process lighting

139 light_pass(level);

140

141 glUseProgram(0);

142 curr_prog = 0;

143

144 render_post(level);

145

146 glBindFramebufferEXT(GL_FRAMEBUFFER, 0);

147 }

148

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

150 {

151 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT | GL_TEXTURE_BIT);

152

153 glEnable(GL_BLEND);

154 glBlendFunc(GL_ONE, GL_ONE);

155

156 glDisable(GL_LIGHTING);

157 glDisable(GL_DEPTH_TEST);

158 glCullFace(GL_FRONT);

159

160 glUseProgram(deferred_omni);

161 curr_prog = deferred_omni;

162

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

164 glActiveTexture(GL_TEXTURE0 + i);

165 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

166 glEnable(GL_TEXTURE_2D);

167 }

168

169 glDepthMask(0);

170 level->draw_lights();

171 glDepthMask(1);

172

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

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

175 glDisable(GL_TEXTURE_2D);

176 }

177

178 glPopAttrib();

179 }

180

181 static const char *fbstname[] = {

182 "GL_FRAMEBUFFER_COMPLETE",

183 "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT",

184 "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",

185 "no such fbo error",

186 "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS",

187 "GL_FRAMEBUFFER_INCOMPLETE_FORMATS",

188 "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER",

189 "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER",

190 "GL_FRAMEBUFFER_UNSUPPORTED"

191 };

192

193 bool DeferredRenderer::create_rtarg()

194 {

195 if(!Renderer::create_rtarg()) {

196 return false;

197 }

198

199 unsigned int clamp = GLEW_ARB_texture_border_clamp ? GL_CLAMP_TO_EDGE : GL_CLAMP;

200

201 glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);

202

203 glGenTextures(MRT_COUNT, mrt_tex);

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

205 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

206 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp);

207 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp);

208 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

209 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

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

211

212 // attach to fbo

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

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

215 CHECKGLERR;

216 }

217

218 int fbst = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);

219 if(fbst != GL_FRAMEBUFFER_COMPLETE) {

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

221 return false;

222 }

223 CHECKGLERR;

224

225 glBindFramebufferEXT(GL_FRAMEBUFFER, 0);

226 return true;

227 }

228

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

230 {

231 unsigned int prog;

232

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

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

235

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

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

238

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

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

241 return 0;

242 }

243 return prog;

244 }

245

246 static void attach_color_buffer(unsigned int fbo, int count, const unsigned int *tex)

247 {

248 glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);

249

250 for(int i=0; i<count; i++) {

251 GLenum color_att = GL_COLOR_ATTACHMENT0 + i;

252 glFramebufferTexture2DEXT(GL_FRAMEBUFFER, color_att, GL_TEXTURE_2D, tex[i], 0);

253 CHECKGLERR;

254 }

255

256 static GLenum draw_bufs[] = {

257 GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT,

258 GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT,

259 GL_COLOR_ATTACHMENT4_EXT, GL_COLOR_ATTACHMENT5_EXT,

260 GL_COLOR_ATTACHMENT6_EXT, GL_COLOR_ATTACHMENT7_EXT

261 };

262 glDrawBuffersARB(count, draw_bufs);

263 }

264

265 #ifdef DBG_VIS_MRT

266 // visualize the MRT buffers

267 static void draw_deferred_debug()

268 {

269 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);

270 glUseProgram(deferred_debug);

271 glDisable(GL_DEPTH_TEST);

272

273 glMatrixMode(GL_PROJECTION);

274 glPushMatrix();

275 glLoadIdentity();

276 glMatrixMode(GL_MODELVIEW);

277 glPushMatrix();

278 glLoadIdentity();

279

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

281 glActiveTexture(GL_TEXTURE0 + i);

282 glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);

283 glEnable(GL_TEXTURE_2D);

284 }

285

286 glBegin(GL_QUADS);

287 glTexCoord2f(0, 0);

288 glVertex2f(-1, -1);

289 glTexCoord2f(1, 0);

290 glVertex2f(1, -1);

291 glTexCoord2f(1, 1);

292 glVertex2f(1, 1);

293 glTexCoord2f(0, 1);

294 glVertex2f(-1, 1);

295 glEnd();

296

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

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

299 glDisable(GL_TEXTURE_2D);

300 }

301

302 glMatrixMode(GL_PROJECTION);

303 glPopMatrix();

304 glMatrixMode(GL_MODELVIEW);

305 glPopMatrix();

306

307 glUseProgram(0);

308 glPopAttrib();

309 }

310 #endif