ld33_umonster

view src/dragon.cc @ 7:92d662deb66e

find changesets by author, revision, files, or words in the commit message
capsule distance seems broken
author John Tsiombikas <nuclear@member.fsf.org>
date Tue, 25 Aug 2015 00:38:00 +0300
parents 3b4460b34d43
children bed39534d471
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 "shadow.h"
8
9 #define VOXEL_PAD 1.0f
10 #define DYN_FCOUNT 64
11 #define DYN_VCOUNT (DYN_FCOUNT * 3)
12
13 #define NUM_NECK_SEG 8
14 static const float nseg_sizes[NUM_NECK_SEG][2] = {
15 {1.0, 3.0}, {1.0, 1.5}, {1.5, 2.0}, {2.0, 2.5}, {2.5, 3.0}, {3.0, 3.5}
16 };
17
18 static Vector3 bezier(const Vector3 &a, const Vector3 &b, const Vector3 &c, const Vector3 &d, float t);
19 static float mseval(struct metasurface *ms, float x, float y, float z);
20 static void msvertex(struct metasurface *ms, float x, float y, float z);
21
22
23 Dragon::Dragon()
24 : pos(0, 0, 0), dir(0, 0, -1), head_pos(0, 0, -1), target(0, 0, -2)
25 {
26 set_head_limits(-1, 1, -1, 1);
27
28 glGenBuffers(1, &dyn_vbo);
29 glBindBuffer(GL_ARRAY_BUFFER, dyn_vbo);
30 glBufferData(GL_ARRAY_BUFFER, DYN_VCOUNT * sizeof(DynVertex), 0, GL_STREAM_DRAW);
31 glBindBuffer(GL_ARRAY_BUFFER, 0);
32
33 dyn_varr = new DynVertex[DYN_VCOUNT];
34
35 neck_seg_count = NUM_NECK_SEG;
36 neck_seg = new Capsule[neck_seg_count];
37
38 for(int i=0; i<neck_seg_count; i++) {
39 neck_seg[i].w[0] = nseg_sizes[i][0];
40 neck_seg[i].w[1] = nseg_sizes[i][1];
41 }
42
43 msurf = msurf_create();
44 msurf_set_user_data(msurf, this);
45 msurf_set_resolution(msurf, 36, 36, 36);
46 msurf_set_threshold(msurf, 1.0);
47 msurf_eval_func(msurf, mseval);
48 msurf_vertex_func(msurf, msvertex);
49 }
50
51 Dragon::~Dragon()
52 {
53 delete [] neck_seg;
54 msurf_free(msurf);
55
56 delete [] dyn_varr;
57 glDeleteBuffers(1, &dyn_vbo);
58 }
59
60 void Dragon::set_position(const Vector3 &p)
61 {
62 pos = p;
63 }
64
65 void Dragon::set_direction(const Vector3 &dir)
66 {
67 this->dir = dir.normalized();
68 }
69
70 void Dragon::set_target(const Vector3 &p)
71 {
72 target = p;
73 }
74
75 void Dragon::set_head_limits(float xmin, float xmax, float ymin, float ymax)
76 {
77 head_xlim[0] = std::min(xmin, xmax);
78 head_xlim[1] = std::max(xmin, xmax);
79 head_ylim[0] = std::min(ymin, ymax);
80 head_ylim[1] = std::max(ymin, ymax);
81 }
82
83 void Dragon::move_head(const Vector3 &p)
84 {
85 head_pos = p;
86 }
87
88 static float clamp(float x, float low, float high)
89 {
90 return x < low ? low : (x > high ? high : x);
91 }
92
93 void Dragon::move_head(float dx, float dy)
94 {
95 float newx = clamp(head_pos.x + dx, head_xlim[0], head_xlim[1]);
96 float newy = clamp(head_pos.y + dy, head_ylim[0], head_ylim[1]);
97
98 dx = newx - head_pos.x;
99 dy = newy - head_pos.y;
100 head_pos.x = newx;
101 head_pos.y = newy;
102
103 target.x += dx * 0.7;
104 target.y += dy * 0.5;
105 }
106
107 const Vector3 &Dragon::head_position() const
108 {
109 return head_pos;
110 }
111
112 Vector3 Dragon::breath_dir() const
113 {
114 return (target - head_pos).normalized();
115 }
116
117 void Dragon::update()
118 {
119 Vector3 bdir = breath_dir();
120 Vector3 bezcp[] = { pos, pos + dir * 6.0, head_pos - bdir * 8.0, head_pos };
121
122 float t = 0.0, dt = 1.0 / (float)(neck_seg_count + 1);
123 Vector3 p = bezier(bezcp[0], bezcp[1], bezcp[2], bezcp[3], t);
124
125 for(int i=0; i<neck_seg_count; i++) {
126 t += dt;
127 Vector3 pnext = bezier(bezcp[0], bezcp[1], bezcp[2], bezcp[3], t);
128
129 neck_seg[i].p[0] = p;
130 neck_seg[i].p[1] = pnext;
131
132 p = pnext;
133 }
134 }
135
136 void Dragon::draw() const
137 {
138 static float bmin[] = { head_xlim[0] - VOXEL_PAD * 0.9, head_ylim[0] - VOXEL_PAD, head_pos.z };
139 static float bmax[] = { head_xlim[1] + VOXEL_PAD * 0.9, head_ylim[1] + VOXEL_PAD * 2.1f, pos.z + VOXEL_PAD };
140 msurf_set_bounds(msurf, bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2]);
141
142
143 if(!shadow_pass) {
144
145 if(dbg_wireframe) {
146 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
147 }
148
149 dyn_vidx = 0;
150 msurf_polygonize(msurf);
151 flush_dynvbo();
152
153 if(dbg_wireframe) {
154 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
155 }
156
157 int cur_sdr;
158 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
159 glUseProgram(0);
160
161 glPushAttrib(GL_ENABLE_BIT);
162 glDisable(GL_LIGHTING);
163
164 // bounds
165 glColor3f(1, 0, 0);
166 glBegin(GL_LINE_LOOP);
167 glVertex3f(bmin[0], bmin[1], bmin[2]);
168 glVertex3f(bmax[0], bmin[1], bmin[2]);
169 glVertex3f(bmax[0], bmax[1], bmin[2]);
170 glVertex3f(bmin[0], bmax[1], bmin[2]);
171 glEnd();
172 glBegin(GL_LINE_LOOP);
173 glVertex3f(bmin[0], bmin[1], bmax[2]);
174 glVertex3f(bmax[0], bmin[1], bmax[2]);
175 glVertex3f(bmax[0], bmax[1], bmax[2]);
176 glVertex3f(bmin[0], bmax[1], bmax[2]);
177 glEnd();
178 glBegin(GL_LINE_LOOP);
179 glVertex3f(bmin[0], bmax[1], bmin[2]);
180 glVertex3f(bmax[0], bmax[1], bmin[2]);
181 glVertex3f(bmax[0], bmax[1], bmax[2]);
182 glVertex3f(bmin[0], bmax[1], bmax[2]);
183 glEnd();
184 glBegin(GL_LINE_LOOP);
185 glVertex3f(bmin[0], bmin[1], bmin[2]);
186 glVertex3f(bmax[0], bmin[1], bmin[2]);
187 glVertex3f(bmax[0], bmin[1], bmax[2]);
188 glVertex3f(bmin[0], bmin[1], bmax[2]);
189 glEnd();
190
191 // foo
192 glDisable(GL_DEPTH_TEST);
193 glEnable(GL_BLEND);
194 glBlendFunc(GL_ONE, GL_ONE);
195 glLineWidth(2.0);
196 glColor3f(0, 0, 1);
197
198 glBegin(GL_LINES);
199 for(int i=0; i<neck_seg_count; i++) {
200 glVertex3f(neck_seg[i].p[0].x, neck_seg[i].p[0].y, neck_seg[i].p[0].z);
201 glVertex3f(neck_seg[i].p[1].x, neck_seg[i].p[1].y, neck_seg[i].p[1].z);
202 }
203 glEnd();
204 glLineWidth(1);
205
206 // done debug drawing
207 glPopAttrib();
208 if(cur_sdr) glUseProgram(cur_sdr);
209 }
210 }
211
212 void Dragon::flush_dynvbo() const
213 {
214 if(!dyn_vidx) return;
215
216 glBindBuffer(GL_ARRAY_BUFFER, dyn_vbo);
217 glBufferSubData(GL_ARRAY_BUFFER, 0, dyn_vidx * sizeof(DynVertex), dyn_varr);
218
219 glEnableClientState(GL_VERTEX_ARRAY);
220 glVertexPointer(3, GL_FLOAT, sizeof(DynVertex), (void*)offsetof(DynVertex, x));
221 glEnableClientState(GL_NORMAL_ARRAY);
222 glNormalPointer(GL_FLOAT, sizeof(DynVertex), (void*)offsetof(DynVertex, nx));
223 glBindBuffer(GL_ARRAY_BUFFER, 0);
224
225 glDrawArrays(GL_TRIANGLES, 0, dyn_vidx);
226
227 glDisableClientState(GL_VERTEX_ARRAY);
228 glDisableClientState(GL_NORMAL_ARRAY);
229 dyn_vidx = 0;
230 }
231
232
233 static Vector3 bezier(const Vector3 &a, const Vector3 &b, const Vector3 &c, const Vector3 &d, float t)
234 {
235 float x = bezier(a.x, b.x, c.x, d.x, t);
236 float y = bezier(a.y, b.y, c.y, d.y, t);
237 float z = bezier(a.z, b.z, c.z, d.z, t);
238 return Vector3(x, y, z);
239 }
240
241 static float mseval(struct metasurface *ms, float x, float y, float z)
242 {
243 Dragon *dragon = (Dragon*)msurf_get_user_data(ms);
244
245 Vector3 pt = Vector3(x, y, z);
246 Capsule *seg = dragon->neck_seg;
247
248 //printf("eval(%g %g %g)\n", x, y, z);
249
250 float sum = 0.0f;
251 for(int i=0; i<dragon->neck_seg_count; i++) {
252 float dist = capsule_distance(seg[i].p[0], seg[i].w[0], seg[i].p[1], seg[i].w[1], pt);
253 //float dist = sphere_distance(seg[i].p[0], 1.0, pt);
254 if(dist < 1e-4) dist = 1e-4;
255 float energy = 0.0001 / (dist * dist);
256 /*float dx = x - seg[i].p[0].x;
257 float dy = y - seg[i].p[0].y;
258 float dz = z - seg[i].p[0].z;
259 float energy = 0.5 / (dx * dx + dy * dy + dz * dz);*/
260 sum += energy;
261 }
262 return sum;
263 }
264
265 static void msvertex(struct metasurface *ms, float x, float y, float z)
266 {
267 Dragon *dragon = (Dragon*)msurf_get_user_data(ms);
268
269 const float dt = 0.001;
270 float dfdx = mseval(ms, x - dt, y, z) - mseval(ms, x + dt, y, z);
271 float dfdy = mseval(ms, x, y - dt, z) - mseval(ms, x, y + dt, z);
272 float dfdz = mseval(ms, x, y, z - dt) - mseval(ms, x, y, z + dt);
273
274 DynVertex *vptr = dragon->dyn_varr + dragon->dyn_vidx++;
275 vptr->x = x;
276 vptr->y = y;
277 vptr->z = z;
278 vptr->nx = dfdx;
279 vptr->ny = dfdy;
280 vptr->nz = dfdz;
281
282 if(dragon->dyn_vidx >= DYN_VCOUNT) {
283 dragon->flush_dynvbo();
284 }
285 }