ld33_umonster: 1b30bd381667 src/dragon.cc

ld33_umonster

view src/dragon.cc @ 10:1b30bd381667

sweep curve mesh gen and dragon horns

author	John Tsiombikas <nuclear@member.fsf.org>
date	Thu, 27 Aug 2015 05:25:04 +0300
parents	4f6168f3ca82
children

line source

1 #include <algorithm>

2 #include "opengl.h"

3 #include "dragon.h"

4 #include "metasurf.h"

5 #include "geom.h"

6 #include "game.h"

7 #include "object.h"

8 #include "shadow.h"

9 #include "meshgen.h"

11 #define VOXEL_PAD 1.0f

12 #define DYN_FCOUNT 64

13 #define DYN_VCOUNT (DYN_FCOUNT * 3)

15 #define NUM_NECK_SEG 10

16 static const float nseg_sizes[NUM_NECK_SEG][2] = {

17 {2.0, 2.0}, {1.0, 1.0}, {1.0, 1.0}, {1.25, 1.25}, {1.3, 1.3}, {1.5, 1.5}, {1.6, 1.6}, {1.75, 1.75}, {2.0, 2.0}, {2.1, 2.1}

18 };

19 #define NSEG_SZ_SCALE 0.5f

21 static Vector3 bezier(const Vector3 &a, const Vector3 &b, const Vector3 &c, const Vector3 &d, float t);

22 static float mseval(struct metasurface *ms, float x, float y, float z);

23 static void msvertex(struct metasurface *ms, float x, float y, float z);

24 static void gen_detail_meshes();

26 static std::vector<Object*> detail_obj;

29 Dragon::Dragon()

30 : pos(0, 0, 0), dir(0, 0, -1), head_pos(0, 0, -1), target(0, 0, -2)

31 {

32 set_head_limits(-1, 1, -1, 1);

34 glGenBuffers(1, &dyn_vbo);

35 glBindBuffer(GL_ARRAY_BUFFER, dyn_vbo);

36 glBufferData(GL_ARRAY_BUFFER, DYN_VCOUNT * sizeof(DynVertex), 0, GL_STREAM_DRAW);

37 glBindBuffer(GL_ARRAY_BUFFER, 0);

39 dyn_varr = new DynVertex[DYN_VCOUNT];

41 neck_seg_count = NUM_NECK_SEG;

42 neck_seg = new Capsule[neck_seg_count];

44 for(int i=0; i<neck_seg_count; i++) {

45 int idx = neck_seg_count - i - 1;

46 neck_seg[i].w[0] = nseg_sizes[idx][0] * NSEG_SZ_SCALE;

47 neck_seg[i].w[1] = nseg_sizes[idx][1] * NSEG_SZ_SCALE;

48 }

50 msurf = msurf_create();

51 msurf_set_user_data(msurf, this);

52 msurf_set_resolution(msurf, 28, 28, 35);

53 msurf_set_threshold(msurf, 1.0);

54 msurf_eval_func(msurf, mseval);

55 msurf_vertex_func(msurf, msvertex);

57 if(detail_obj.empty()) {

58 gen_detail_meshes();

59 }

60 }

62 Dragon::~Dragon()

63 {

64 delete [] neck_seg;

65 msurf_free(msurf);

67 delete [] dyn_varr;

68 glDeleteBuffers(1, &dyn_vbo);

69 }

71 void Dragon::set_position(const Vector3 &p)

72 {

73 pos = p;

74 }

76 void Dragon::set_direction(const Vector3 &dir)

77 {

78 this->dir = dir.normalized();

79 }

81 void Dragon::set_target(const Vector3 &p)

82 {

83 target = p;

84 }

86 void Dragon::set_head_limits(float xmin, float xmax, float ymin, float ymax)

87 {

88 head_xlim[0] = std::min(xmin, xmax);

89 head_xlim[1] = std::max(xmin, xmax);

90 head_ylim[0] = std::min(ymin, ymax);

91 head_ylim[1] = std::max(ymin, ymax);

92 }

94 void Dragon::move_head(const Vector3 &p)

95 {

96 head_pos = p;

97 }

99 static float clamp(float x, float low, float high)

100 {

101 return x < low ? low : (x > high ? high : x);

102 }

103

104 void Dragon::move_head(float dx, float dy)

105 {

106 float newx = clamp(head_pos.x + dx, head_xlim[0], head_xlim[1]);

107 float newy = clamp(head_pos.y + dy, head_ylim[0], head_ylim[1]);

108

109 dx = newx - head_pos.x;

110 dy = newy - head_pos.y;

111 head_pos.x = newx;

112 head_pos.y = newy;

113

114 target.x += dx * 0.7;

115 target.y += dy * 0.5;

116 }

117

118 const Vector3 &Dragon::head_position() const

119 {

120 return head_pos;

121 }

122

123 Vector3 Dragon::breath_dir() const

124 {

125 return (target - head_pos).normalized();

126 }

127

128 void Dragon::update()

129 {

130 Vector3 bdir = breath_dir();

131 Vector3 bezcp[] = { pos, pos + dir * 6.0, head_pos - bdir * 8.0, head_pos };

132

133 float t = 0.0, dt = 1.0 / (float)(neck_seg_count + 1);

134 Vector3 p = bezier(bezcp[0], bezcp[1], bezcp[2], bezcp[3], t);

135

136 for(int i=0; i<neck_seg_count; i++) {

137 t += dt;

138 Vector3 pnext = bezier(bezcp[0], bezcp[1], bezcp[2], bezcp[3], t);

139

140 neck_seg[i].p[0] = p;

141 neck_seg[i].p[1] = pnext;

142

143 p = pnext;

144 }

145 }

146

147 void Dragon::draw() const

148 {

149 float xmin = std::min(head_pos.x, pos.x);

150 float xmax = std::max(head_pos.x, pos.x);

151 float ymin = std::min(head_pos.y, pos.y);

152 float ymax = std::max(head_pos.y, pos.y);

153

154 float bmin[] = { xmin - VOXEL_PAD * 1.2f, ymin - VOXEL_PAD, head_pos.z };

155 float bmax[] = { xmax + VOXEL_PAD * 1.2f, ymax + VOXEL_PAD * 2.1f, pos.z + VOXEL_PAD };

156 msurf_set_bounds(msurf, bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2]);

157

158

159 if(!shadow_pass) {

160

161 if(dbg_wireframe) {

162 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

163 }

164

165 dyn_vidx = 0;

166 msurf_polygonize(msurf);

167 flush_dynvbo();

168

169 if(dbg_wireframe) {

170 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

171 }

172

173 int cur_sdr;

174 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);

175 glUseProgram(0);

176

177 glPushAttrib(GL_ENABLE_BIT);

178 glDisable(GL_LIGHTING);

179

180 // bounds

181 glColor3f(1, 0, 0);

182 glBegin(GL_LINE_LOOP);

183 glVertex3f(bmin[0], bmin[1], bmin[2]);

184 glVertex3f(bmax[0], bmin[1], bmin[2]);

185 glVertex3f(bmax[0], bmax[1], bmin[2]);

186 glVertex3f(bmin[0], bmax[1], bmin[2]);

187 glEnd();

188 glBegin(GL_LINE_LOOP);

189 glVertex3f(bmin[0], bmin[1], bmax[2]);

190 glVertex3f(bmax[0], bmin[1], bmax[2]);

191 glVertex3f(bmax[0], bmax[1], bmax[2]);

192 glVertex3f(bmin[0], bmax[1], bmax[2]);

193 glEnd();

194 glBegin(GL_LINE_LOOP);

195 glVertex3f(bmin[0], bmax[1], bmin[2]);

196 glVertex3f(bmax[0], bmax[1], bmin[2]);

197 glVertex3f(bmax[0], bmax[1], bmax[2]);

198 glVertex3f(bmin[0], bmax[1], bmax[2]);

199 glEnd();

200 glBegin(GL_LINE_LOOP);

201 glVertex3f(bmin[0], bmin[1], bmin[2]);

202 glVertex3f(bmax[0], bmin[1], bmin[2]);

203 glVertex3f(bmax[0], bmin[1], bmax[2]);

204 glVertex3f(bmin[0], bmin[1], bmax[2]);

205 glEnd();

206

207 // foo

208 glDisable(GL_DEPTH_TEST);

209 glEnable(GL_BLEND);

210 glBlendFunc(GL_ONE, GL_ONE);

211 glLineWidth(2.0);

212 glColor3f(0, 0, 1);

213

214 glBegin(GL_LINES);

215 for(int i=0; i<neck_seg_count; i++) {

216 glVertex3f(neck_seg[i].p[0].x, neck_seg[i].p[0].y, neck_seg[i].p[0].z);

217 glVertex3f(neck_seg[i].p[1].x, neck_seg[i].p[1].y, neck_seg[i].p[1].z);

218 }

219 glEnd();

220 glLineWidth(1);

221

222 // done debug drawing

223 glPopAttrib();

224 if(cur_sdr) glUseProgram(cur_sdr);

225 }

226

227 // draw detail objects

228 for(size_t i=0; i<detail_obj.size(); i++) {

229 detail_obj[i]->xform().set_translation(head_pos);

230

231 if(dbg_wireframe) {

232 detail_obj[i]->draw_wire();

233 } else {

234 detail_obj[i]->draw();

235 }

236 }

237 }

238

239 void Dragon::flush_dynvbo() const

240 {

241 if(!dyn_vidx) return;

242

243 glBindBuffer(GL_ARRAY_BUFFER, dyn_vbo);

244 glBufferSubData(GL_ARRAY_BUFFER, 0, dyn_vidx * sizeof(DynVertex), dyn_varr);

245

246 glEnableClientState(GL_VERTEX_ARRAY);

247 glVertexPointer(3, GL_FLOAT, sizeof(DynVertex), (void*)offsetof(DynVertex, x));

248 glEnableClientState(GL_NORMAL_ARRAY);

249 glNormalPointer(GL_FLOAT, sizeof(DynVertex), (void*)offsetof(DynVertex, nx));

250 glBindBuffer(GL_ARRAY_BUFFER, 0);

251

252 glDrawArrays(GL_TRIANGLES, 0, dyn_vidx);

253

254 glDisableClientState(GL_VERTEX_ARRAY);

255 glDisableClientState(GL_NORMAL_ARRAY);

256 dyn_vidx = 0;

257 }

258

259

260 static Vector3 bezier(const Vector3 &a, const Vector3 &b, const Vector3 &c, const Vector3 &d, float t)

261 {

262 float x = bezier(a.x, b.x, c.x, d.x, t);

263 float y = bezier(a.y, b.y, c.y, d.y, t);

264 float z = bezier(a.z, b.z, c.z, d.z, t);

265 return Vector3(x, y, z);

266 }

267

268 static float mseval(struct metasurface *ms, float x, float y, float z)

269 {

270 Dragon *dragon = (Dragon*)msurf_get_user_data(ms);

271

272 Vector3 pt = Vector3(x, y, z);

273 Capsule *seg = dragon->neck_seg;

274

275 //printf("eval(%g %g %g)\n", x, y, z);

276

277 float sum = 0.0f;

278 for(int i=0; i<dragon->neck_seg_count; i++) {

279 float dist = capsule_distance(seg[i].p[0], seg[i].w[0], seg[i].p[1], seg[i].w[1], pt);

280 //float dist = sphere_distance(seg[i].p[0], 1.0, pt);

281 if(dist < 1e-4) dist = 1e-4;

282 float energy = 0.0001 / (dist * dist);

283 /*float dx = x - seg[i].p[0].x;

284 float dy = y - seg[i].p[0].y;

285 float dz = z - seg[i].p[0].z;

286 float energy = 0.5 / (dx * dx + dy * dy + dz * dz);*/

287 sum += energy;

288 }

289 return sum;

290 }

291

292 static void msvertex(struct metasurface *ms, float x, float y, float z)

293 {

294 Dragon *dragon = (Dragon*)msurf_get_user_data(ms);

295

296 const float dt = 0.001;

297 float dfdx = mseval(ms, x - dt, y, z) - mseval(ms, x + dt, y, z);

298 float dfdy = mseval(ms, x, y - dt, z) - mseval(ms, x, y + dt, z);

299 float dfdz = mseval(ms, x, y, z - dt) - mseval(ms, x, y, z + dt);

300

301 DynVertex *vptr = dragon->dyn_varr + dragon->dyn_vidx++;

302 vptr->x = x;

303 vptr->y = y;

304 vptr->z = z;

305 vptr->nx = dfdx;

306 vptr->ny = dfdy;

307 vptr->nz = dfdz;

308

309 if(dragon->dyn_vidx >= DYN_VCOUNT) {

310 dragon->flush_dynvbo();

311 }

312 }

313

314

315 #define HORN_RAD 0.15f

316 static Vector2 horn_sweep(float u, float v, void *cls)

317 {

318 float t = 1.0f - v;

319 float angle = u * 2.0 * M_PI;

320 float x = sin(angle) * t * HORN_RAD;

321 float y = cos(angle) * t * HORN_RAD;

322 return Vector2(x, y + smoothstep(0.3, 1.0, v) * 0.5);

323 }

324

325 static void gen_detail_meshes()

326 {

327 Mesh *mesh;

328 Object *obj;

329 Matrix4x4 xform;

330

331 for(int i=0; i<2; i++) {

332 float sign = i ? 1.0f : -1.0f;

333

334 mesh = new Mesh;

335 gen_sweep(mesh, 2, 6, 6, horn_sweep, 0);

336 xform.set_translation(Vector3(0.5 * sign, 1.5, 3));

337 xform.rotate(Vector3(DEG_TO_RAD(25), 0, 0));

338 xform.rotate(Vector3(0, 0, DEG_TO_RAD(15) * -sign));

339 mesh->apply_xform(xform, Matrix4x4::identity);

340

341 obj = new Object;

342 obj->set_mesh(mesh);

343 obj->mtl.diffuse = Vector3(1.0, 0.85, 0.8);

344 obj->mtl.specular = Vector3(1, 1, 1);

345 obj->mtl.shininess = 60.0;

346

347 detail_obj.push_back(obj);

348 }

349 }