metasurf: 9ab057fba0c5 examples/metaballs/src/metaballs.c

metasurf

view examples/metaballs/src/metaballs.c @ 2:9ab057fba0c5

added copyright statements, added comments, yada yada

author	John Tsiombikas <nuclear@member.fsf.org>
date	Tue, 25 Oct 2011 08:59:07 +0300
parents	dc0e882ec3f9
children	52664d3451ad

line source

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <math.h>

4 #include <assert.h>

6 #ifndef NO_SHADERS

7 #include <GL/glew.h>

8 #include "sdr.h"

9 #endif

11 #ifndef __APPLE__

12 #include <GL/glut.h>

13 #else

14 #include <GLUT/glut.h>

15 #endif

17 #include "cam.h"

18 #include "metasurf.h"

20 #define RES 38

22 struct metaball {

23 float energy;

24 float x, y, z;

25 } mball[] = {

26 {1.0, 0, 0, 0},

27 {0.25, 0.45, 0, 0.25},

28 {0.15, -0.3, 0.2, 0.1}

29 };

31 int num_mballs = sizeof mball / sizeof *mball;

33 float eval(float x, float y, float z);

34 float eval_cached(float x, float y, float z);

35 void vertex(float x, float y, float z);

36 void render(void);

37 void disp(void);

38 void reshape(int x, int y);

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

40 void mouse(int bn, int state, int x, int y);

41 void motion(int x, int y);

42 void sball_button(int bn, int state);

43 void sball_motion(int x, int y, int z);

44 int parse_args(int argc, char **argv);

46 int stereo, fullscreen;

47 int orig_xsz, orig_ysz;

49 struct metasurface *msurf;

50 float threshold = 12;

51 #ifndef NO_SHADERS

52 unsigned int sdr;

53 #endif

54 int bidx = 1;

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

57 {

58 float amb[] = {0, 0, 0, 0};

59 float lpos[] = {-0.2, 0.2, 1, 0};

61 glutInitWindowSize(1280, 720);

62 glutInit(&argc, argv);

64 if(parse_args(argc, argv) == -1) {

65 return 1;

66 }

67 glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE | (stereo ? GLUT_STEREO : 0));

68 glutCreateWindow("metasurf");

70 orig_xsz = glutGet(GLUT_WINDOW_WIDTH);

71 orig_ysz = glutGet(GLUT_WINDOW_HEIGHT);

73 if(fullscreen) {

74 glutFullScreen();

75 }

77 glutDisplayFunc(disp);

78 glutReshapeFunc(reshape);

79 glutKeyboardFunc(keyb);

80 glutMouseFunc(mouse);

81 glutMotionFunc(motion);

82 glutSpaceballButtonFunc(sball_button);

83 glutSpaceballMotionFunc(sball_motion);

85 #ifndef NO_SHADERS

86 glewInit();

87 if(!(sdr = create_program_load("sdr/vert.glsl", "sdr/frag.glsl"))) {

88 return 1;

89 }

90 #endif

92 glEnable(GL_CULL_FACE);

93 glEnable(GL_DEPTH_TEST);

95 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, amb);

97 glEnable(GL_LIGHTING);

98 glEnable(GL_LIGHT0);

99 glLightfv(GL_LIGHT0, GL_POSITION, lpos);

100

101 glEnable(GL_NORMALIZE);

102

103 cam_focus_dist(2.0);

104 cam_clip(0.1, 200.0);

105 cam_rotate(0, 0);

106 cam_dolly(2);

107

108 msurf = msurf_create();

109 msurf_eval_func(msurf, eval);

110 msurf_vertex_func(msurf, vertex);

111 msurf_threshold(msurf, threshold);

112 msurf_resolution(msurf, RES, RES, RES);

113 msurf_bounds(msurf, -1, -1, -1, 1, 1, 1);

114

115 glClearColor(0.8, 0.8, 0.8, 1.0);

116

117 glutMainLoop();

118 return 0;

119 }

120

121 float eval(float x, float y, float z)

122 {

123 int i;

124 float val = 0.0f;

125

126 for(i=0; i<num_mballs; i++) {

127 float dx = mball[i].x - x;

128 float dy = mball[i].y - y;

129 float dz = mball[i].z - z;

130 float dist_sq = dx * dx + dy * dy + dz * dz;

131

132 if(dist_sq < 1e-6) {

133 val += 100.0;

134 } else {

135 val += mball[i].energy / dist_sq;

136 }

137 }

138 return val;

139 }

140

141 void vertex(float x, float y, float z)

142 {

143 const float dt = 0.001;

144 float dfdx = eval(x - dt, y, z) - eval(x + dt, y, z);

145 float dfdy = eval(x, y - dt, z) - eval(x, y + dt, z);

146 float dfdz = eval(x, y, z - dt) - eval(x, y, z + dt);

147

148 glNormal3f(dfdx, dfdy, dfdz);

149 glVertex3f(x, y, z);

150 }

151

152 void render(void)

153 {

154 float kd[] = {0.7, 0.28, 0.2, 1.0};

155 float ks[] = {0.9, 0.9, 0.9, 1.0};

156

157 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, kd);

158 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, ks);

159 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60.0);

160

161 #ifndef NO_SHADERS

162 bind_program(sdr);

163 #endif

164

165 glBegin(GL_TRIANGLES);

166 msurf_polygonize(msurf);

167 glEnd();

168

169 assert(glGetError() == GL_NO_ERROR);

170 }

171

172 void disp(void)

173 {

174 if(stereo) {

175 glDrawBuffer(GL_BACK_LEFT);

176 }

177

178 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

179

180 glMatrixMode(GL_PROJECTION);

181 glLoadIdentity();

182 cam_stereo_proj_matrix(stereo ? CAM_LEFT : CAM_CENTER);

183

184 glMatrixMode(GL_MODELVIEW);

185 glLoadIdentity();

186 cam_stereo_view_matrix(stereo ? CAM_LEFT : CAM_CENTER);

187

188 render();

189

190 if(stereo) {

191 glDrawBuffer(GL_BACK_RIGHT);

192 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

193

194 glMatrixMode(GL_PROJECTION);

195 glLoadIdentity();

196 cam_stereo_proj_matrix(CAM_RIGHT);

197

198 glMatrixMode(GL_MODELVIEW);

199 glLoadIdentity();

200 cam_stereo_view_matrix(CAM_RIGHT);

201

202 render();

203 }

204 glutSwapBuffers();

205 }

206

207 void reshape(int x, int y)

208 {

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

210 cam_aspect((float)x / (float)y);

211 }

212

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

214 {

215 static int wire;

216

217 switch(key) {

218 case 27:

219 exit(0);

220

221 case 'f':

222 fullscreen = !fullscreen;

223 if(fullscreen) {

224 glutFullScreen();

225 } else {

226 glutReshapeWindow(orig_xsz, orig_ysz);

227 }

228 break;

229

230 case 's':

231 stereo = !stereo;

232 glutPostRedisplay();

233 break;

234

235 case 'w':

236 wire = !wire;

237 glPolygonMode(GL_FRONT_AND_BACK, wire ? GL_LINE : GL_FILL);

238 glutPostRedisplay();

239 break;

240

241 case '=':

242 threshold += 0.05;

243 msurf_threshold(msurf, threshold);

244 printf("threshold: %f\n", threshold);

245 glutPostRedisplay();

246 break;

247

248 case '-':

249 threshold -= 0.05;

250 msurf_threshold(msurf, threshold);

251 printf("threshold: %f\n", threshold);

252 glutPostRedisplay();

253 break;

254

255 case ' ':

256 bidx = (bidx + 1) % num_mballs;

257 break;

258

259 default:

260 break;

261 }

262 }

263

264 int bnstate[32];

265 int prev_x, prev_y;

266

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

268 {

269 bnstate[bn] = state == GLUT_DOWN;

270 prev_x = x;

271 prev_y = y;

272 }

273

274 void motion(int x, int y)

275 {

276 int dx, dy;

277

278 dx = x - prev_x;

279 dy = y - prev_y;

280 prev_x = x;

281 prev_y = y;

282

283 if(glutGetModifiers()) {

284 if(bnstate[GLUT_LEFT_BUTTON]) {

285 cam_inp_rotate(dx, dy);

286 }

287 if(bnstate[GLUT_RIGHT_BUTTON]) {

288 cam_inp_zoom(dy);

289 }

290 } else {

291 mball[bidx].x += (float)dx * 0.005;

292 mball[bidx].y -= (float)dy * 0.005;

293 }

294 glutPostRedisplay();

295 }

296

297 void sball_button(int bn, int state)

298 {

299 if(state) return;

300

301 if(bn < num_mballs) {

302 bidx = bn;

303 } else {

304 bidx = (bidx + 1) % num_mballs;

305 }

306 }

307

308 void sball_motion(int x, int y, int z)

309 {

310 mball[bidx].x += (float)x / 16384.0;

311 mball[bidx].y += (float)y / 16384.0;

312 mball[bidx].z -= (float)z / 16384.0;

313 glutPostRedisplay();

314 }

315

316 int parse_args(int argc, char **argv)

317 {

318 int i;

319

320 for(i=1; i<argc; i++) {

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

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

323 case 'f':

324 fullscreen = !fullscreen;

325 break;

326

327 case 's':

328 stereo = !stereo;

329 break;

330

331 case 'h':

332 printf("usage: %s [opt]\n", argv[0]);

333 printf("options:\n");

334 printf(" -f start in fullscreen\n");

335 printf(" -s enable stereoscopic rendering\n");

336 printf(" -h print usage and exit\n");

337 exit(0);

338

339 default:

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

341 return -1;

342 }

343 } else {

344 fprintf(stderr, "unexpected argument: %s\n", argv[i]);

345 return -1;

346 }

347 }

348 return 0;

349 }