clray: 0f174fd60f19 src/dbgray.cc

clray

view src/dbgray.cc @ 61:0f174fd60f19

added readme file and license

author	John Tsiombikas <nuclear@member.fsf.org>
date	Mon, 28 Dec 2015 10:27:23 +0200
parents	6a30f27fa1e6
children

line source

1 #include <string.h>

2 #include <assert.h>

3 #include <limits.h>

4 #include "rt.h"

5 #include "ogl.h"

6 #include "vector.h"

7 #include "timer.h"

9 struct SurfPoint {

10 float t;

11 Vector3 pos, norm;

12 const Face *face;

13 };

15 static void trace_ray(float *pixel, const Ray &ray, int iter, float energy = 1.0f);

16 static void shade(float *pixel, const Ray &ray, const SurfPoint &sp, int iter, float energy = 1.0f);

17 static bool find_intersection(const Ray &ray, const Scene *scn, const KDNode *kd, SurfPoint *spret);

18 static bool ray_aabb_test(const Ray &ray, const AABBox &aabb);

19 static bool ray_triangle_test(const Ray &ray, const Face *face, SurfPoint *sp);

20 static Vector3 calc_bary(const Vector3 &pt, const Face *face, const Vector3 &norm);

21 static void transform(float *res, const float *v, const float *xform);

22 static void transform_ray(Ray *ray, const float *xform, const float *invtrans_xform);

24 static int xsz, ysz;

25 static float *fb;

26 static unsigned int tex;

27 static Scene *scn;

28 static const Ray *prim_rays;

29 static int max_iter;

31 static RenderStats *rstat;

32 static int cur_ray_aabb_tests, cur_ray_triangle_tests;

34 bool init_dbg_renderer(int width, int height, Scene *scene, unsigned int texid)

35 {

36 try {

37 fb = new float[3 * width * height];

38 }

39 catch(...) {

40 return false;

41 }

43 xsz = width;

44 ysz = height;

45 tex = texid;

46 scn = scene;

48 rstat = (RenderStats*)get_render_stats();

50 return true;

51 }

53 void destroy_dbg_renderer()

54 {

55 delete [] fb;

56 delete [] prim_rays;

57 }

59 void dbg_set_primary_rays(const Ray *rays)

60 {

61 prim_rays = rays;

62 }

64 void dbg_render(const float *xform, const float *invtrans_xform, int num_threads)

65 {

66 unsigned long t0 = get_msec();

68 max_iter = get_render_option_int(ROPT_ITER);

70 // initialize render-stats

71 memset(rstat, 0, sizeof *rstat);

72 rstat->min_aabb_tests = rstat->min_triangle_tests = INT_MAX;

73 rstat->max_aabb_tests = rstat->max_triangle_tests = 0;

75 int offs = 0;

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

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

78 Ray ray = prim_rays[offs];

79 transform_ray(&ray, xform, invtrans_xform);

81 cur_ray_aabb_tests = cur_ray_triangle_tests = 0;

83 trace_ray(fb + offs * 3, ray, max_iter, 1.0);

84 offs++;

86 // update stats as needed

87 if(cur_ray_aabb_tests < rstat->min_aabb_tests) {

88 rstat->min_aabb_tests = cur_ray_aabb_tests;

89 }

90 if(cur_ray_aabb_tests > rstat->max_aabb_tests) {

91 rstat->max_aabb_tests = cur_ray_aabb_tests;

92 }

93 if(cur_ray_triangle_tests < rstat->min_triangle_tests) {

94 rstat->min_triangle_tests = cur_ray_triangle_tests;

95 }

96 if(cur_ray_triangle_tests > rstat->max_triangle_tests) {

97 rstat->max_triangle_tests = cur_ray_triangle_tests;

98 }

99 rstat->prim_rays++;

100 rstat->aabb_tests += cur_ray_aabb_tests;

101 rstat->triangle_tests += cur_ray_triangle_tests;

102 }

103 }

104

105 unsigned long t1 = get_msec();

106

107 glPushAttrib(GL_TEXTURE_BIT);

108 glBindTexture(GL_TEXTURE_2D, tex);

109 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, xsz, ysz, GL_RGB, GL_FLOAT, fb);

110 glPopAttrib();

111 glFinish();

112

113 rstat->render_time = t1 - t0;

114 rstat->tex_update_time = get_msec() - t1;

115

116 rstat->rays_cast = rstat->prim_rays + rstat->refl_rays + rstat->shadow_rays;

117 rstat->rays_per_sec = 1000 * rstat->rays_cast / rstat->render_time;

118 rstat->avg_aabb_tests = (float)rstat->aabb_tests / (float)rstat->rays_cast;

119 rstat->avg_triangle_tests = (float)rstat->triangle_tests / (float)rstat->rays_cast;

120 }

121

122 static void trace_ray(float *pixel, const Ray &ray, int iter, float energy)

123 {

124 SurfPoint sp;

125

126 if(find_intersection(ray, scn, scn->kdtree, &sp)) {

127 shade(pixel, ray, sp, iter, energy);

128 } else {

129 pixel[0] = pixel[1] = pixel[2] = 0.05f;

130 }

131 }

132

133 #define MAX(a, b) ((a) > (b) ? (a) : (b))

134

135 static void shade(float *pixel, const Ray &ray, const SurfPoint &sp, int iter, float energy)

136 {

137 const Material *mat = scn->get_materials() + sp.face->matid;

138

139 bool cast_shadows = get_render_option_bool(ROPT_SHAD);

140 Vector3 raydir(ray.dir);

141 Vector3 norm = sp.norm;

142

143 if(dot(raydir, norm) >= 0.0) {

144 norm = -norm;

145 }

146

147 float dcol[3] = {0, 0, 0};

148 float scol[3] = {0, 0, 0};

149

150 for(int i=0; i<scn->get_num_lights(); i++) {

151 Vector3 lpos(scn->lights[i].pos);

152 Vector3 ldir = lpos - sp.pos;

153

154 Ray shadowray;

155 shadowray.origin[0] = sp.pos.x;

156 shadowray.origin[1] = sp.pos.y;

157 shadowray.origin[2] = sp.pos.z;

158 shadowray.dir[0] = ldir.x;

159 shadowray.dir[1] = ldir.y;

160 shadowray.dir[2] = ldir.z;

161

162 if(!cast_shadows || !find_intersection(shadowray, scn, scn->kdtree, 0)) {

163 rstat->brdf_evals++;

164

165 ldir.normalize();

166

167 Vector3 vdir = -raydir / RAY_MAG;

168 Vector3 vref = reflect(vdir, norm);

169

170 float ndotl = dot(ldir, norm);

171 float diff = MAX(ndotl, 0.0f);

172

173 dcol[0] += mat->kd[0] * diff;

174 dcol[1] += mat->kd[1] * diff;

175 dcol[2] += mat->kd[2] * diff;

176

177 float ldotvr = dot(ldir, vref);

178 float spec = pow(MAX(ldotvr, 0.0f), mat->spow);

179

180 scol[0] += mat->ks[0] * spec;

181 scol[1] += mat->ks[1] * spec;

182 scol[2] += mat->ks[2] * spec;

183 }

184

185 if(cast_shadows) {

186 rstat->shadow_rays++;

187 }

188 }

189

190 float refl_color[3];

191 refl_color[0] = mat->ks[0] * mat->kr;

192 refl_color[1] = mat->ks[1] * mat->kr;

193 refl_color[2] = mat->ks[2] * mat->kr;

194

195 energy *= (refl_color[0] + refl_color[1] + refl_color[2]) / 3.0;

196 if(iter >= 0 && energy > MIN_ENERGY) {

197 Vector3 rdir = reflect(-raydir, norm);

198

199 Ray refl;

200 refl.origin[0] = sp.pos.x;

201 refl.origin[1] = sp.pos.y;

202 refl.origin[2] = sp.pos.z;

203 refl.dir[0] = rdir.x;

204 refl.dir[1] = rdir.y;

205 refl.dir[2] = rdir.z;

206

207 float rcol[3];

208 trace_ray(rcol, refl, iter - 1, energy);

209 scol[0] += rcol[0] * mat->ks[0] * mat->kr;

210 scol[1] += rcol[1] * mat->ks[1] * mat->kr;

211 scol[2] += rcol[2] * mat->ks[2] * mat->kr;

212

213 rstat->refl_rays++;

214 }

215

216 pixel[0] = dcol[0] + scol[0];

217 pixel[1] = dcol[1] + scol[1];

218 pixel[2] = dcol[2] + scol[2];

219 }

220

221 static bool find_intersection(const Ray &ray, const Scene *scn, const KDNode *kd, SurfPoint *spret)

222 {

223 if(!ray_aabb_test(ray, kd->aabb)) {

224 return false;

225 }

226

227 SurfPoint sp, sptmp;

228 if(!spret) {

229 spret = &sptmp;

230 }

231

232 spret->t = RAY_MAG;

233 spret->face = 0;

234

235 if(kd->left) {

236 assert(kd->right);

237

238 bool found = find_intersection(ray, scn, kd->left, spret);

239 if(find_intersection(ray, scn, kd->right, &sp)) {

240 if(!found || sp.t < spret->t) {

241 *spret = sp;

242 }

243 found = true;

244 }

245 return found;

246 }

247

248 const Face *faces = scn->get_face_buffer();

249

250 for(size_t i=0; i<kd->face_idx.size(); i++) {

251 if(ray_triangle_test(ray, faces + kd->face_idx[i], &sp) && sp.t < spret->t) {

252 *spret = sp;

253 }

254 }

255 return spret->face != 0;

256 }

257

258 static bool ray_aabb_test(const Ray &ray, const AABBox &aabb)

259 {

260 cur_ray_aabb_tests++;

261

262 if(ray.origin[0] >= aabb.min[0] && ray.origin[1] >= aabb.min[1] && ray.origin[2] >= aabb.min[2] &&

263 ray.origin[0] < aabb.max[0] && ray.origin[1] < aabb.max[1] && ray.origin[2] < aabb.max[2]) {

264 return true;

265 }

266

267 float bbox[][3] = {

268 {aabb.min[0], aabb.min[1], aabb.min[2]},

269 {aabb.max[0], aabb.max[1], aabb.max[2]}

270 };

271

272 int xsign = (int)(ray.dir[0] < 0.0);

273 float invdirx = 1.0 / ray.dir[0];

274 float tmin = (bbox[xsign][0] - ray.origin[0]) * invdirx;

275 float tmax = (bbox[1 - xsign][0] - ray.origin[0]) * invdirx;

276

277 int ysign = (int)(ray.dir[1] < 0.0);

278 float invdiry = 1.0 / ray.dir[1];

279 float tymin = (bbox[ysign][1] - ray.origin[1]) * invdiry;

280 float tymax = (bbox[1 - ysign][1] - ray.origin[1]) * invdiry;

281

282 if(tmin > tymax || tymin > tmax) {

283 return false;

284 }

285

286 if(tymin > tmin) tmin = tymin;

287 if(tymax < tmax) tmax = tymax;

288

289 int zsign = (int)(ray.dir[2] < 0.0);

290 float invdirz = 1.0 / ray.dir[2];

291 float tzmin = (bbox[zsign][2] - ray.origin[2]) * invdirz;

292 float tzmax = (bbox[1 - zsign][2] - ray.origin[2]) * invdirz;

293

294 if(tmin > tzmax || tzmin > tmax) {

295 return false;

296 }

297

298 return tmin < 1.0 && tmax > 0.0;

299

300 }

301

302 static bool ray_triangle_test(const Ray &ray, const Face *face, SurfPoint *sp)

303 {

304 cur_ray_triangle_tests++;

305

306 Vector3 origin = ray.origin;

307 Vector3 dir = ray.dir;

308 Vector3 norm = face->normal;

309

310 float ndotdir = dot(dir, norm);

311

312 if(fabs(ndotdir) <= EPSILON) {

313 return false;

314 }

315

316 Vector3 pt = face->v[0].pos;

317 Vector3 vec = pt - origin;

318

319 float ndotvec = dot(norm, vec);

320 float t = ndotvec / ndotdir;

321

322 if(t < EPSILON || t > 1.0) {

323 return false;

324 }

325 pt = origin + dir * t;

326

327

328 Vector3 bc = calc_bary(pt, face, norm);

329 float bc_sum = bc.x + bc.y + bc.z;

330

331 if(bc_sum < 1.0 - EPSILON || bc_sum > 1.0 + EPSILON) {

332 return false;

333 }

334

335 Vector3 n0(face->v[0].normal);

336 Vector3 n1(face->v[1].normal);

337 Vector3 n2(face->v[2].normal);

338

339 sp->t = t;

340 sp->pos = pt;

341 sp->norm = n0 * bc.x + n1 * bc.y + n2 * bc.z;

342 sp->norm.normalize();

343 sp->face = face;

344 return true;

345 }

346

347 static Vector3 calc_bary(const Vector3 &pt, const Face *face, const Vector3 &norm)

348 {

349 Vector3 bc(0.0f, 0.0f, 0.0f);

350

351 Vector3 v1 = Vector3(face->v[1].pos) - Vector3(face->v[0].pos);

352 Vector3 v2 = Vector3(face->v[2].pos) - Vector3(face->v[0].pos);

353 Vector3 xv1v2 = cross(v1, v2);

354

355 float area = fabs(dot(xv1v2, norm)) * 0.5;

356 if(area < EPSILON) {

357 return bc;

358 }

359

360 Vector3 pv0 = face->v[0].pos - pt;

361 Vector3 pv1 = face->v[1].pos - pt;

362 Vector3 pv2 = face->v[2].pos - pt;

363

364 // calculate the area of each sub-triangle

365 Vector3 x12 = cross(pv1, pv2);

366 Vector3 x20 = cross(pv2, pv0);

367 Vector3 x01 = cross(pv0, pv1);

368

369 float a0 = fabs(dot(x12, norm)) * 0.5;

370 float a1 = fabs(dot(x20, norm)) * 0.5;

371 float a2 = fabs(dot(x01, norm)) * 0.5;

372

373 bc.x = a0 / area;

374 bc.y = a1 / area;

375 bc.z = a2 / area;

376 return bc;

377

378 }

379

380 static void transform(float *res, const float *v, const float *xform)

381 {

382 float tmp[3];

383 tmp[0] = v[0] * xform[0] + v[1] * xform[4] + v[2] * xform[8] + xform[12];

384 tmp[1] = v[0] * xform[1] + v[1] * xform[5] + v[2] * xform[9] + xform[13];

385 tmp[2] = v[0] * xform[2] + v[1] * xform[6] + v[2] * xform[10] + xform[14];

386 memcpy(res, tmp, sizeof tmp);

387 }

388

389 static void transform_ray(Ray *ray, const float *xform, const float *invtrans_xform)

390 {

391 transform(ray->origin, ray->origin, xform);

392 transform(ray->dir, ray->dir, invtrans_xform);

393 }