clray: b5eb404af481 src/clray.cc

clray

view src/clray.cc @ 46:b5eb404af481

- added -d switch to start in OpenGL rendering mode

author	John Tsiombikas <nuclear@member.fsf.org>
date	Sun, 29 Aug 2010 14:02:37 +0100
parents	f9eec11e5acc
children	30bf84881553

line source

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <string.h>

4 #include <ctype.h>

5 #include <errno.h>

6 #ifndef __APPLE__

7 #include <GL/glut.h>

8 #else

9 #include <GLUT/glut.h>

10 #endif

11 #include "rt.h"

12 #include "matrix.h"

13 #include "scene.h"

14 #include "ocl.h"

16 void cleanup();

17 void disp();

18 void reshape(int x, int y);

19 void keyb(unsigned char key, int x, int y);

20 void mouse(int bn, int status, int x, int y);

21 void motion(int x, int y);

22 bool write_ppm(const char *fname, float *fb, int xsz, int ysz);

24 static int xsz, ysz;

25 static bool need_update = true;

27 static float cam_theta, cam_phi = 25.0;

28 static float cam_dist = 10.0;

30 static bool dbg_glrender = false;

31 static bool dbg_show_kdtree = false;

32 static bool dbg_show_obj = true;

34 static Scene scn;

35 static unsigned int tex;

38 int main(int argc, char **argv)

39 {

40 glutInitWindowSize(800, 600);

41 glutInit(&argc, argv);

43 int loaded = 0;

44 for(int i=1; i<argc; i++) {

45 if(argv[i][0] == '-' && argv[i][2] == 0) {

46 switch(argv[i][1]) {

47 case 'i':

48 if(!argv[++i] || !isdigit(argv[i][0])) {

49 fprintf(stderr, "-i must be followed by the intersection cost\n");

50 return 1;

51 }

53 set_accel_param(ACCEL_PARAM_COST_INTERSECT, atoi(argv[i]));

54 break;

56 case 't':

57 if(!argv[++i] || !isdigit(argv[i][0])) {

58 fprintf(stderr, "-t must be followed by the traversal cost\n");

59 return 1;

60 }

62 set_accel_param(ACCEL_PARAM_COST_TRAVERSE, atoi(argv[i]));

63 break;

65 case 'c':

66 if(!argv[++i] || !isdigit(argv[i][0])) {

67 fprintf(stderr, "-c must be followed by the max number of items per leaf node\n");

68 return 1;

69 }

71 set_accel_param(ACCEL_PARAM_MAX_NODE_ITEMS, atoi(argv[i]));

72 break;

74 case 'd':

75 dbg_glrender = true;

76 break;

78 default:

79 fprintf(stderr, "unrecognized option: %s\n", argv[i]);

80 return 1;

81 }

82 } else {

83 if(!scn.load(argv[i])) {

84 fprintf(stderr, "failed to load scene: %s\n", argv[i]);

85 return false;

86 }

87 loaded++;

88 }

89 }

91 if(!loaded) {

92 fprintf(stderr, "you must specify a scene file to load\n");

93 return false;

94 }

95 if(!scn.get_num_faces()) {

96 fprintf(stderr, "didn't load any polygons\n");

97 return false;

98 }

100 glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);

101 glutCreateWindow("OpenCL Raytracer");

102

103 xsz = glutGet(GLUT_WINDOW_WIDTH);

104 ysz = glutGet(GLUT_WINDOW_HEIGHT);

105

106 glutDisplayFunc(disp);

107 glutReshapeFunc(reshape);

108 glutKeyboardFunc(keyb);

109 glutMouseFunc(mouse);

110 glutMotionFunc(motion);

111

112 unsigned int *test_pattern = new unsigned int[xsz * ysz];

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

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

115 test_pattern[i * xsz + j] = ((i >> 4) & 1) == ((j >> 4) & 1) ? 0xff0000 : 0xff00;

116 }

117 }

118

119 glGenTextures(1, &tex);

120 glBindTexture(GL_TEXTURE_2D, tex);

121 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);

122 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

123 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

124 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

125 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, xsz, ysz, 0, GL_RGBA, GL_UNSIGNED_BYTE, test_pattern);

126 delete [] test_pattern;

127

128 if(!init_opencl()) {

129 return 1;

130 }

131

132 if(!init_renderer(xsz, ysz, &scn, tex)) {

133 return 1;

134 }

135 atexit(cleanup);

136

137 glutMainLoop();

138 return 0;

139 }

140

141 void cleanup()

142 {

143 printf("destroying renderer ...\n");

144 destroy_renderer();

145

146 printf("shutting down OpenCL ...\n");

147 destroy_opencl();

148

149 printf("cleaning up OpenGL resources ...\n");

150 glDeleteTextures(1, &tex);

151 }

152

153 static Matrix4x4 mat, inv_mat, inv_trans;

154

155 void disp()

156 {

157 glMatrixMode(GL_MODELVIEW);

158 glLoadIdentity();

159

160 if(need_update) {

161 glPushMatrix();

162 glRotatef(-cam_theta, 0, 1, 0);

163 glRotatef(-cam_phi, 1, 0, 0);

164 glTranslatef(0, 0, cam_dist);

165

166 glGetFloatv(GL_MODELVIEW_MATRIX, mat.m);

167

168 inv_mat = mat;

169 inv_mat.invert();

170

171 /*inv_trans = inv_mat;

172 inv_trans.transpose();*/

173 inv_trans = mat;

174 inv_trans.m[3] = inv_trans.m[7] = inv_trans.m[11] = 0.0;

175 inv_trans.m[12] = inv_trans.m[13] = inv_trans.m[14] = 0.0;

176 inv_trans.m[15] = 1.0;

177

178 set_xform(mat.m, inv_trans.m);

179 glPopMatrix();

180

181 if(!dbg_glrender) {

182 if(!render()) {

183 exit(1);

184 }

185 need_update = false;

186 }

187 }

188

189 if(dbg_glrender) {

190 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

191 glLoadMatrixf(inv_mat.m);

192 dbg_render_gl(&scn, dbg_show_kdtree, dbg_show_obj);

193 } else {

194 glEnable(GL_TEXTURE_2D);

195 glDisable(GL_LIGHTING);

196

197 glBegin(GL_QUADS);

198 glColor3f(1, 1, 1);

199 glTexCoord2f(0, 1); glVertex2f(-1, -1);

200 glTexCoord2f(1, 1); glVertex2f(1, -1);

201 glTexCoord2f(1, 0); glVertex2f(1, 1);

202 glTexCoord2f(0, 0); glVertex2f(-1, 1);

203 glEnd();

204

205 glDisable(GL_TEXTURE_2D);

206 }

207

208 glutSwapBuffers();

209 }

210

211 void reshape(int x, int y)

212 {

213 glViewport(0, 0, x, y);

214

215 /* reallocate the framebuffer */

216 /*delete [] fb;

217 fb = new float[x * y * 4];

218 set_framebuffer(fb, x, y);*/

219 }

220

221 void keyb(unsigned char key, int x, int y)

222 {

223 switch(key) {

224 case 27:

225 exit(0);

226

227 case 'r':

228 need_update = true;

229 glutPostRedisplay();

230 break;

231

232 case 'd':

233 dbg_glrender = !dbg_glrender;

234 if(dbg_glrender) {

235 printf("Debug OpenGL rendering\n");

236 } else {

237 printf("Raytracing\n");

238 }

239 glutPostRedisplay();

240 break;

241

242 case 'k':

243 dbg_show_kdtree = !dbg_show_kdtree;

244 if(dbg_glrender) {

245 glutPostRedisplay();

246 }

247 break;

248

249 case 'o':

250 dbg_show_obj = !dbg_show_obj;

251 if(dbg_glrender) {

252 glutPostRedisplay();

253 }

254 break;

255

256 default:

257 break;

258 }

259 }

260

261 static bool bnstate[32];

262 static int prev_x, prev_y;

263

264 void mouse(int bn, int state, int x, int y)

265 {

266 if(state == GLUT_DOWN) {

267 prev_x = x;

268 prev_y = y;

269 bnstate[bn] = true;

270 } else {

271 bnstate[bn] = false;

272 }

273 }

274

275 #define ROT_SCALE 0.5

276 #define PAN_SCALE 0.1

277

278 void motion(int x, int y)

279 {

280 int dx = x - prev_x;

281 int dy = y - prev_y;

282 prev_x = x;

283 prev_y = y;

284

285 if(bnstate[0]) {

286 cam_theta += dx * ROT_SCALE;

287 cam_phi += dy * ROT_SCALE;

288

289 if(cam_phi < -89) cam_phi = -89;

290 if(cam_phi > 89) cam_phi = 89;

291

292 need_update = true;

293 glutPostRedisplay();

294 }

295 if(bnstate[2]) {

296 cam_dist += dy * PAN_SCALE;

297 if(cam_dist < 0) cam_dist = 0;

298

299 need_update = true;

300 glutPostRedisplay();

301 }

302 }

303

304 bool write_ppm(const char *fname, float *fb, int xsz, int ysz)

305 {

306 FILE *fp;

307

308 if(!(fp = fopen(fname, "wb"))) {

309 fprintf(stderr, "write_ppm: failed to open file %s for writing: %s\n", fname, strerror(errno));

310 return false;

311 }

312 fprintf(fp, "P6\n%d %d\n255\n", xsz, ysz);

313

314 for(int i=0; i<xsz * ysz * 4; i++) {

315 if(i % 4 == 3) continue;

316

317 unsigned char c = (unsigned char)(fb[i] * 255.0);

318 fputc(c, fp);

319 }

320 fclose(fp);

321 return true;

322 }