clray: 3d13924b22e6 src/rt.cc

clray

view src/rt.cc @ 58:3d13924b22e6

implementing polygon split

author	John Tsiombikas <nuclear@member.fsf.org>
date	Sun, 12 Sep 2010 00:19:04 +0100
parents	df239a52a091
children	8c858e1a89e8

line source

1 #include <stdio.h>

2 #include <string.h>

3 #include <math.h>

4 #include <limits.h>

5 #include <assert.h>

6 #include "rt.h"

7 #include "ogl.h"

8 #include "ocl.h"

9 #include "scene.h"

10 #include "timer.h"

11 #include "common.h"

13 // kernel arguments

14 enum {

15 KARG_FRAMEBUFFER,

16 KARG_RENDER_INFO,

17 KARG_FACES,

18 KARG_MATLIB,

19 KARG_LIGHTS,

20 KARG_PRIM_RAYS,

21 KARG_XFORM,

22 KARG_INVTRANS_XFORM,

23 KARG_KDTREE,

25 NUM_KERNEL_ARGS

26 };

28 static void update_render_info();

29 static Ray get_primary_ray(int x, int y, int w, int h, float vfov_deg);

30 static float *create_kdimage(const KDNodeGPU *kdtree, int num_nodes, int *xsz_ret, int *ysz_ret);

32 static Face *faces;

33 static Ray *prim_rays;

34 static CLProgram *prog;

35 static int global_size;

38 static RendInfo rinf;

39 static RenderStats rstat;

40 static int saved_iter_val;

42 static long timing_sample_sum;

43 static long num_timing_samples;

46 bool init_renderer(int xsz, int ysz, Scene *scn, unsigned int tex)

47 {

48 // render info

49 rinf.ambient[0] = rinf.ambient[1] = rinf.ambient[2] = 0.0;

50 rinf.ambient[3] = 0.0;

52 rinf.xsz = xsz;

53 rinf.ysz = ysz;

54 rinf.num_faces = scn->get_num_faces();

55 rinf.num_lights = scn->get_num_lights();

56 rinf.max_iter = saved_iter_val = 6;

57 rinf.cast_shadows = true;

59 /* calculate primary rays */

60 prim_rays = new Ray[xsz * ysz];

62 for(int i=0; i<ysz; i++) {

63 for(int j=0; j<xsz; j++) {

64 prim_rays[i * xsz + j] = get_primary_ray(j, i, xsz, ysz, 45.0);

65 }

66 }

67 dbg_set_primary_rays(prim_rays); // give them to the debug renderer

69 /* setup opencl */

70 prog = new CLProgram("render");

71 if(!prog->load("src/rt.cl")) {

72 return false;

73 }

75 if(!(faces = (Face*)scn->get_face_buffer())) {

76 fprintf(stderr, "failed to create face buffer\n");

77 return false;

78 }

80 const KDNodeGPU *kdbuf = scn->get_kdtree_buffer();

81 if(!kdbuf) {

82 fprintf(stderr, "failed to create kdtree buffer\n");

83 return false;

84 }

86 int kdimg_xsz, kdimg_ysz;

87 float *kdimg_pixels = create_kdimage(kdbuf, scn->get_num_kdnodes(), &kdimg_xsz, &kdimg_ysz);

89 /* setup argument buffers */

90 #ifdef CLGL_INTEROP

91 prog->set_arg_texture(KARG_FRAMEBUFFER, ARG_WR, tex);

92 #else

93 prog->set_arg_image(KARG_FRAMEBUFFER, ARG_WR, xsz, ysz);

94 #endif

95 prog->set_arg_buffer(KARG_RENDER_INFO, ARG_RD, sizeof rinf, &rinf);

96 prog->set_arg_buffer(KARG_FACES, ARG_RD, rinf.num_faces * sizeof(Face), faces);

97 prog->set_arg_buffer(KARG_MATLIB, ARG_RD, scn->get_num_materials() * sizeof(Material), scn->get_materials());

98 prog->set_arg_buffer(KARG_LIGHTS, ARG_RD, scn->get_num_lights() * sizeof(Light), scn->get_lights());

99 prog->set_arg_buffer(KARG_PRIM_RAYS, ARG_RD, xsz * ysz * sizeof *prim_rays, prim_rays);

100 prog->set_arg_buffer(KARG_XFORM, ARG_RD, 16 * sizeof(float));

101 prog->set_arg_buffer(KARG_INVTRANS_XFORM, ARG_RD, 16 * sizeof(float));

102 //prog->set_arg_buffer(KARG_KDTREE, ARG_RD, scn->get_num_kdnodes() * sizeof *kdbuf, kdbuf);

103 prog->set_arg_image(KARG_KDTREE, ARG_RD, kdimg_xsz, kdimg_ysz, kdimg_pixels);

104

105 delete [] kdimg_pixels;

106

107

108 if(prog->get_num_args() < NUM_KERNEL_ARGS) {

109 return false;

110 }

111

112 const char *opt = "-Isrc -cl-mad-enable -cl-single-precision-constant -cl-fast-relaxed-math";

113 if(!prog->build(opt)) {

114 return false;

115 }

116

117 //delete [] prim_rays; now dbg_renderer handles them

118

119 global_size = xsz * ysz;

120

121

122 init_dbg_renderer(xsz, ysz, scn, tex);

123 return true;

124 }

125

126 void destroy_renderer()

127 {

128 delete prog;

129

130 destroy_dbg_renderer();

131

132 if(num_timing_samples) {

133 printf("rendertime mean: %ld msec\n", timing_sample_sum / num_timing_samples);

134 }

135 }

136

137 bool render()

138 {

139 long tm0 = get_msec();

140

141 // initialize render-stats

142 memset(&rstat, 0, sizeof rstat);

143 rstat.min_aabb_tests = rstat.min_triangle_tests = INT_MAX;

144 rstat.max_aabb_tests = rstat.max_triangle_tests = 0;

145

146 #ifdef CLGL_INTEROP

147 cl_event ev;

148 CLMemBuffer *texbuf = prog->get_arg_buffer(KARG_FRAMEBUFFER);

149

150 if(!acquire_gl_object(texbuf, &ev)) {

151 return false;

152 }

153

154 // make sure that we will wait for the acquire to finish before running

155 prog->set_wait_event(ev);

156 #endif

157

158 if(!prog->run(1, global_size)) {

159 return false;

160 }

161

162 #ifdef CLGL_INTEROP

163 if(!release_gl_object(texbuf, &ev)) {

164 return false;

165 }

166 clWaitForEvents(1, &ev);

167 #endif

168

169 #ifndef CLGL_INTEROP

170 /* if we don't compile in CL/GL interoperability support, we need

171 * to copy the output buffer to the OpenGL texture used to displaying

172 * the image.

173 */

174 CLMemBuffer *mbuf = prog->get_arg_buffer(KARG_FRAMEBUFFER);

175 void *fb = map_mem_buffer(mbuf, MAP_RD);

176 if(!fb) {

177 fprintf(stderr, "FAILED\n");

178 return false;

179 }

180

181 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, rinf.xsz, rinf.ysz, GL_RGBA, GL_FLOAT, fb);

182 unmap_mem_buffer(mbuf);

183 #endif

184

185 rstat.render_time = get_msec() - tm0;

186

187 timing_sample_sum += rstat.render_time;

188 num_timing_samples++;

189

190 return true;

191 }

192

193

194 void set_xform(float *matrix, float *invtrans)

195 {

196 CLMemBuffer *mbuf_xform = prog->get_arg_buffer(KARG_XFORM);

197 CLMemBuffer *mbuf_invtrans = prog->get_arg_buffer(KARG_INVTRANS_XFORM);

198 assert(mbuf_xform && mbuf_invtrans);

199

200 float *mem = (float*)map_mem_buffer(mbuf_xform, MAP_WR);

201 memcpy(mem, matrix, 16 * sizeof *mem);

202 unmap_mem_buffer(mbuf_xform);

203

204 mem = (float*)map_mem_buffer(mbuf_invtrans, MAP_WR);

205 memcpy(mem, invtrans, 16 * sizeof *mem);

206 unmap_mem_buffer(mbuf_invtrans);

207 }

208

209

210 const RendInfo *get_render_info()

211 {

212 return &rinf;

213 }

214

215 const RenderStats *get_render_stats()

216 {

217 return &rstat;

218 }

219

220 void print_render_stats(FILE *fp)

221 {

222 fprintf(fp, "-- render stats --\n");

223 fprintf(fp, "> timing\n");

224 fprintf(fp, " render time (msec): %lu\n", rstat.render_time);

225 fprintf(fp, " tex update time (msec): %lu\n", rstat.tex_update_time);

226 fprintf(fp, "> counters\n");

227 fprintf(fp, " AABB tests: %d\n", rstat.aabb_tests);

228 fprintf(fp, " AABB tests per ray (min/max/avg): %d/%d/%f\n",

229 rstat.min_aabb_tests, rstat.max_aabb_tests, rstat.avg_aabb_tests);

230 fprintf(fp, " triangle tests: %d\n", rstat.triangle_tests);

231 fprintf(fp, " triangle tests per ray (min/max/avg): %d/%d/%f\n",

232 rstat.min_triangle_tests, rstat.max_triangle_tests, rstat.avg_triangle_tests);

233 fprintf(fp, " rays cast: %dp %dr %ds (sum: %d)\n", rstat.prim_rays,

234 rstat.refl_rays, rstat.shadow_rays, rstat.rays_cast);

235 fprintf(fp, " rays per second: %d\n", rstat.rays_per_sec);

236 fprintf(fp, " BRDF evaluations: %d\n", rstat.brdf_evals);

237 fputc('\n', fp);

238 }

239

240 void set_render_option(int opt, bool val)

241 {

242 switch(opt) {

243 case ROPT_ITER:

244 case ROPT_REFL:

245 rinf.max_iter = val ? saved_iter_val : 0;

246 break;

247

248 case ROPT_SHAD:

249 rinf.cast_shadows = val;

250 break;

251

252 default:

253 return;

254 }

255

256 update_render_info();

257 }

258

259 void set_render_option(int opt, int val)

260 {

261 switch(opt) {

262 case ROPT_ITER:

263 rinf.max_iter = saved_iter_val = val;

264 break;

265

266 case ROPT_SHAD:

267 rinf.cast_shadows = val;

268 break;

269

270 case ROPT_REFL:

271 rinf.max_iter = val ? saved_iter_val : 0;

272 break;

273

274 default:

275 return;

276 }

277

278 update_render_info();

279 }

280

281 void set_render_option(int opt, float val)

282 {

283 set_render_option(opt, (int)val);

284 }

285

286 bool get_render_option_bool(int opt)

287 {

288 switch(opt) {

289 case ROPT_ITER:

290 return rinf.max_iter;

291 case ROPT_SHAD:

292 return rinf.cast_shadows;

293 case ROPT_REFL:

294 return rinf.max_iter == saved_iter_val;

295 default:

296 break;

297 }

298 return false;

299 }

300

301 int get_render_option_int(int opt)

302 {

303 switch(opt) {

304 case ROPT_ITER:

305 return rinf.max_iter;

306 case ROPT_SHAD:

307 return rinf.cast_shadows ? 1 : 0;

308 case ROPT_REFL:

309 return rinf.max_iter == saved_iter_val ? 1 : 0;

310 default:

311 break;

312 }

313 return -1;

314 }

315

316 float get_render_option_float(int opt)

317 {

318 return (float)get_render_option_int(opt);

319 }

320

321 static void update_render_info()

322 {

323 if(!prog) {

324 return;

325 }

326

327 CLMemBuffer *mbuf = prog->get_arg_buffer(KARG_RENDER_INFO);

328 assert(mbuf);

329

330 RendInfo *rinf_ptr = (RendInfo*)map_mem_buffer(mbuf, MAP_WR);

331 *rinf_ptr = rinf;

332 unmap_mem_buffer(mbuf);

333 }

334

335 static Ray get_primary_ray(int x, int y, int w, int h, float vfov_deg)

336 {

337 float vfov = M_PI * vfov_deg / 180.0;

338 float aspect = (float)w / (float)h;

339

340 float ysz = 2.0;

341 float xsz = aspect * ysz;

342

343 float px = ((float)x / (float)w) * xsz - xsz / 2.0;

344 float py = 1.0 - ((float)y / (float)h) * ysz;

345 float pz = 1.0 / tan(0.5 * vfov);

346

347 float mag = sqrt(px * px + py * py + pz * pz);

348

349 px = px * RAY_MAG / mag;

350 py = py * RAY_MAG / mag;

351 pz = pz * RAY_MAG / mag;

352

353 Ray ray = {{0, 0, 0, 1}, {px, py, -pz, 1}};

354 return ray;

355 }

356

357 #define MIN(a, b) ((a) < (b) ? (a) : (b))

358

359 static float *create_kdimage(const KDNodeGPU *kdtree, int num_nodes, int *xsz_ret, int *ysz_ret)

360 {

361 int ysz = MIN(num_nodes, KDIMG_MAX_HEIGHT);

362 int columns = (num_nodes - 1) / KDIMG_MAX_HEIGHT + 1;

363 int xsz = KDIMG_NODE_WIDTH * columns;

364

365 printf("creating kdtree image %dx%d (%d nodes)\n", xsz, ysz, num_nodes);

366

367 float *img = new float[4 * xsz * ysz];

368 memset(img, 0, 4 * xsz * ysz * sizeof *img);

369

370 for(int i=0; i<num_nodes; i++) {

371 int x = KDIMG_NODE_WIDTH * (i / KDIMG_MAX_HEIGHT);

372 int y = i % KDIMG_MAX_HEIGHT;

373

374 float *ptr = img + (y * xsz + x) * 4;

375

376 *ptr++ = kdtree[i].aabb.min[0];

377 *ptr++ = kdtree[i].aabb.min[1];

378 *ptr++ = kdtree[i].aabb.min[2];

379 *ptr++ = 0.0;

380

381 *ptr++ = kdtree[i].aabb.max[0];

382 *ptr++ = kdtree[i].aabb.max[1];

383 *ptr++ = kdtree[i].aabb.max[2];

384 *ptr++ = 0.0;

385

386 for(int j=0; j<MAX_NODE_FACES; j++) {

387 *ptr++ = j < kdtree[i].num_faces ? (float)kdtree[i].face_idx[j] : 0.0f;

388 }

389

390 *ptr++ = (float)kdtree[i].num_faces;

391 *ptr++ = (float)kdtree[i].left;

392 *ptr++ = (float)kdtree[i].right;

393 *ptr++ = 0.0;

394 }

395

396 if(xsz_ret) *xsz_ret = xsz;

397 if(ysz_ret) *ysz_ret = ysz;

398 return img;

399 }