clray: e7f79c6ad246 src/rt.cc

clray

view src/rt.cc @ 44:e7f79c6ad246

added maximum node face limit by default

author	John Tsiombikas <nuclear@member.fsf.org>
date	Sat, 28 Aug 2010 21:50:17 +0100
parents	057b8575a1c1
children	8047637961a2

line source

1 #include <stdio.h>

2 #include <string.h>

3 #include <math.h>

4 #include <assert.h>

5 #include "ogl.h"

6 #include "ocl.h"

7 #include "scene.h"

8 #include "timer.h"

10 // kernel arguments

11 enum {

12 KARG_FRAMEBUFFER,

13 KARG_RENDER_INFO,

14 KARG_FACES,

15 KARG_MATLIB,

16 KARG_LIGHTS,

17 KARG_PRIM_RAYS,

18 KARG_XFORM,

19 KARG_INVTRANS_XFORM,

20 KARG_KDTREE,

22 NUM_KERNEL_ARGS

23 };

25 struct RendInfo {

26 float ambient[4];

27 int xsz, ysz;

28 int num_faces, num_lights;

29 int max_iter;

30 int kd_depth;

31 };

33 struct Ray {

34 float origin[4], dir[4];

35 };

37 struct Light {

38 float pos[4], color[4];

39 };

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

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

44 static Face *faces;

45 static Ray *prim_rays;

46 static CLProgram *prog;

47 static int global_size;

49 static Light lightlist[] = {

50 {{-8, 15, 18, 0}, {1, 1, 1, 1}}

51 };

54 static RendInfo rinf;

56 static long timing_sample_sum;

57 static long num_timing_samples;

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

61 {

62 // render info

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

64 rinf.ambient[3] = 0.0;

66 rinf.xsz = xsz;

67 rinf.ysz = ysz;

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

69 rinf.num_lights = sizeof lightlist / sizeof *lightlist;

70 rinf.max_iter = 6;

71 rinf.kd_depth = kdtree_depth(scn->kdtree);

73 /* calculate primary rays */

74 prim_rays = new Ray[xsz * ysz];

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

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

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

79 }

80 }

82 /* setup opencl */

83 prog = new CLProgram("render");

84 if(!prog->load("rt.cl")) {

85 return false;

86 }

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

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

90 return false;

91 }

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

94 if(!kdbuf) {

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

96 return false;

97 }

99 int kdimg_xsz, kdimg_ysz;

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

101

102 /* setup argument buffers */

103 #ifdef CLGL_INTEROP

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

105 #else

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

107 #endif

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

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

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

111 prog->set_arg_buffer(KARG_LIGHTS, ARG_RD, sizeof lightlist, lightlist);

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

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

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

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

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

117

118 delete [] kdimg_pixels;

119

120

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

122 return false;

123 }

124

125 if(!prog->build()) {

126 return false;

127 }

128

129 delete [] prim_rays;

130

131 global_size = xsz * ysz;

132 return true;

133 }

134

135 void destroy_renderer()

136 {

137 delete prog;

138

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

140 }

141

142 bool render()

143 {

144 // XXX do we need to call glFinish ?

145

146 long tm0 = get_msec();

147

148 #ifdef CLGL_INTEROP

149 cl_event ev;

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

151

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

153 return false;

154 }

155

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

157 prog->set_wait_event(ev);

158 #endif

159

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

161 return false;

162 }

163

164 #ifdef CLGL_INTEROP

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

166 return false;

167 }

168 clWaitForEvents(1, &ev);

169 #endif

170

171 #ifndef CLGL_INTEROP

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

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

174 * the image.

175 */

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

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

178 if(!fb) {

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

180 return false;

181 }

182

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

184 unmap_mem_buffer(mbuf);

185 #endif

186

187 long msec = get_msec() - tm0;

188 timing_sample_sum += msec;

189 num_timing_samples++;

190

191 printf("rendered in %ld msec\n", msec);

192 return true;

193 }

194

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

196 static void dbg_set_gl_material(Material *mat)

197 {

198 static Material def_mat = {{0.7, 0.7, 0.7, 1}, {0, 0, 0, 0}, 0, 0, 0};

199

200 if(!mat) mat = &def_mat;

201

202 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat->kd);

203 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat->ks);

204 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, MIN(mat->spow, 128.0f));

205 }

206

207 void dbg_render_gl(Scene *scn, bool show_tree, bool show_obj)

208 {

209 glPushAttrib(GL_ENABLE_BIT | GL_TRANSFORM_BIT | GL_LIGHTING_BIT);

210

211 for(int i=0; i<rinf.num_lights; i++) {

212 float lpos[4];

213

214 memcpy(lpos, lightlist[i].pos, sizeof lpos);

215 lpos[3] = 1.0;

216

217 glLightfv(GL_LIGHT0 + i, GL_POSITION, lpos);

218 glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, lightlist[i].color);

219 glEnable(GL_LIGHT0 + i);

220 }

221

222 glDisable(GL_TEXTURE_2D);

223 glEnable(GL_DEPTH_TEST);

224 glEnable(GL_LIGHTING);

225

226 glMatrixMode(GL_PROJECTION);

227 glPushMatrix();

228 glLoadIdentity();

229 gluPerspective(45.0, (float)rinf.xsz / (float)rinf.ysz, 0.5, 1000.0);

230

231 if(show_obj) {

232 Material *materials = scn->get_materials();

233

234 int num_faces = scn->get_num_faces();

235 int cur_mat = -1;

236

237 for(int i=0; i<num_faces; i++) {

238 if(faces[i].matid != cur_mat) {

239 if(cur_mat != -1) {

240 glEnd();

241 }

242 dbg_set_gl_material(materials ? materials + faces[i].matid : 0);

243 cur_mat = faces[i].matid;

244 glBegin(GL_TRIANGLES);

245 }

246

247 for(int j=0; j<3; j++) {

248 glNormal3fv(faces[i].v[j].normal);

249 glVertex3fv(faces[i].v[j].pos);

250 }

251 }

252 glEnd();

253 }

254

255 if(show_tree) {

256 scn->draw_kdtree();

257 }

258

259 glPopMatrix();

260 glPopAttrib();

261

262 assert(glGetError() == GL_NO_ERROR);

263 }

264

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

266 {

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

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

269 assert(mbuf_xform && mbuf_invtrans);

270

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

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

273 unmap_mem_buffer(mbuf_xform);

274

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

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

277 unmap_mem_buffer(mbuf_invtrans);

278 }

279

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

281 {

282 float vfov = M_PI * vfov_deg / 180.0;

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

284

285 float ysz = 2.0;

286 float xsz = aspect * ysz;

287

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

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

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

291

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

293

294 px = px * 500.0 / mag;

295 py = py * 500.0 / mag;

296 pz = pz * 500.0 / mag;

297

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

299 return ray;

300 }

301

302 static int next_pow2(int x)

303 {

304 x--;

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

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

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

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

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

310 return x + 1;

311 }

312

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

314 {

315 int xsz = 16;

316 int ysz = next_pow2(num_nodes);

317

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

319

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

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

322

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

324 float *ptr = img + i * 4 * xsz;

325

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

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

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

329 *ptr++ = 0.0;

330

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

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

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

334 *ptr++ = 0.0;

335

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

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

338 }

339

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

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

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

343 *ptr++ = 0.0;

344 }

345

346 if(xsz_ret) *xsz_ret = xsz;

347 if(ysz_ret) *ysz_ret = ysz;

348 return img;

349 }