Line data Source code
1 : /* grass.cpp: billboarded grass generation atop cube geometry
2 : *
3 : * grass can be rendered on the top side of geometry, in an "X" shape atop cubes
4 : * grass is billboarded, and faces the camera, and can be modified as to its draw
5 : * distance
6 : */
7 : #include "../libprimis-headers/cube.h"
8 : #include "../../shared/geomexts.h"
9 : #include "../../shared/glemu.h"
10 : #include "../../shared/glexts.h"
11 :
12 : #include "grass.h"
13 : #include "octarender.h"
14 : #include "rendergl.h"
15 : #include "renderva.h"
16 : #include "shader.h"
17 : #include "shaderparam.h"
18 : #include "texture.h"
19 :
20 : #include "interface/control.h"
21 :
22 : #include "world/octaworld.h"
23 :
24 : namespace //internal functionality not seen by other files
25 : {
26 : VARP(grass, 0, 1, 1); //toggles rendering of grass
27 : VARP(grassdist, 0, 256, 10000); //maximum distance to render grass
28 : FVARP(grasstaper, 0, 0.2, 1);
29 : FVARP(grassstep, 0.5, 2, 8);
30 : VARP(grassheight, 1, 4, 64); //height of grass in cube units
31 :
32 : constexpr int numgrasswedges = 8;
33 :
34 : struct grasswedge
35 : {
36 : vec dir, across, edge1, edge2;
37 : plane bound1, bound2;
38 :
39 8 : grasswedge(int i) :
40 8 : dir(2*M_PI*(i+0.5f)/static_cast<float>(numgrasswedges), 0),
41 8 : across(2*M_PI*((i+0.5f)/static_cast<float>(numgrasswedges) + 0.25f), 0),
42 8 : edge1(vec(2*M_PI*i/static_cast<float>(numgrasswedges), 0).div(std::cos(M_PI/numgrasswedges))),
43 8 : edge2(vec(2*M_PI*(i+1)/static_cast<float>(numgrasswedges), 0).div(std::cos(M_PI/numgrasswedges))),
44 8 : bound1(vec(2*M_PI*(i/static_cast<float>(numgrasswedges) - 0.25f), 0), 0),
45 8 : bound2(vec(2*M_PI*((i+1)/static_cast<float>(numgrasswedges) + 0.25f), 0), 0)
46 : {
47 8 : across.div(-across.dot(bound1));
48 8 : }
49 : } grasswedges[numgrasswedges] = { 0, 1, 2, 3, 4, 5, 6, 7 };
50 :
51 : struct grassvert
52 : {
53 : vec pos;
54 : vec4<uchar> color;
55 : vec2 tc;
56 : };
57 :
58 : std::vector<grassvert> grassverts;
59 : GLuint grassvbo = 0;
60 : int grassvbosize = 0;
61 :
62 : VAR(maxgrass, 10, 10000, 10000); //number of grass squares allowed to be rendered at a time
63 :
64 : struct grassgroup
65 : {
66 : const grasstri *tri;
67 : int tex, offset, numquads;
68 : };
69 :
70 : std::vector<grassgroup> grassgroups;
71 :
72 : constexpr int numgrassoffsets = 32;
73 :
74 : float grassoffsets[numgrassoffsets] = { -1 },
75 : grassanimoffsets[numgrassoffsets];
76 : int lastgrassanim = -1;
77 :
78 : VARR(grassanimmillis, 0, 3000, 60000); //sets the characteristic rate of grass animation change
79 : FVARR(grassanimscale, 0, 0.03f, 1); //sets the intensity of the animation (size of waviness)
80 :
81 : //updates the grass animation offset values based on the current time
82 0 : void animategrass()
83 : {
84 0 : for(int i = 0; i < numgrassoffsets; ++i)
85 : {
86 0 : grassanimoffsets[i] = grassanimscale*std::sin(2*M_PI*(grassoffsets[i] + lastmillis/static_cast<float>(grassanimmillis)));
87 : }
88 0 : lastgrassanim = lastmillis;
89 0 : }
90 :
91 : VARR(grassscale, 1, 2, 64); //scale factor for grass texture
92 0 : CVAR0R(grasscolor, 0xFFFFFF);//tint color for grass
93 : FVARR(grasstest, 0, 0.6f, 1);
94 :
95 : //generate the grass geometry placed above cubes
96 : //grass always faces the camera (billboarded)
97 : //and therefore grass geom is calculated realtime to face the cam
98 0 : void gengrassquads(grassgroup *&group, const grasswedge &w, const grasstri &g, const Texture *tex)
99 : {
100 0 : float t = camera1->o.dot(w.dir);
101 0 : int tstep = static_cast<int>(std::ceil(t/grassstep));
102 0 : float tstart = tstep*grassstep,
103 0 : t0 = w.dir.dot(g.v[0]),
104 0 : t1 = w.dir.dot(g.v[1]),
105 0 : t2 = w.dir.dot(g.v[2]),
106 0 : t3 = w.dir.dot(g.v[3]),
107 0 : tmin = std::min(std::min(t0, t1), std::min(t2, t3)),
108 0 : tmax = std::max(std::max(t0, t1), std::max(t2, t3));
109 0 : if(tmax < tstart || tmin > t + grassdist)
110 : {
111 0 : return;
112 : }
113 0 : int minstep = std::max(static_cast<int>(std::ceil(tmin/grassstep)) - tstep, 1),
114 0 : maxstep = static_cast<int>(std::floor(std::min(tmax, t + grassdist)/grassstep)) - tstep,
115 0 : numsteps = maxstep - minstep + 1;
116 :
117 0 : float texscale = (grassscale*tex->ys)/static_cast<float>(grassheight*tex->xs),
118 0 : animscale = grassheight*texscale;
119 0 : vec tc;
120 0 : tc.cross(g.surface, w.dir).mul(texscale);
121 :
122 0 : int offset = tstep + maxstep;
123 0 : if(offset < 0)
124 : {
125 0 : offset = numgrassoffsets - (-offset)%numgrassoffsets;
126 : }
127 0 : offset += numsteps + numgrassoffsets - numsteps%numgrassoffsets;
128 :
129 0 : float leftdist = t0;
130 0 : const vec *leftv = &g.v[0];
131 0 : if(t1 > leftdist)
132 : {
133 0 : leftv = &g.v[1];
134 0 : leftdist = t1;
135 : }
136 0 : if(t2 > leftdist)
137 : {
138 0 : leftv = &g.v[2];
139 0 : leftdist = t2;
140 : }
141 0 : if(t3 > leftdist)
142 : {
143 0 : leftv = &g.v[3];
144 0 : leftdist = t3;
145 : }
146 0 : float rightdist = leftdist;
147 0 : const vec *rightv = leftv;
148 :
149 0 : vec across(w.across.x, w.across.y, g.surface.zdelta(w.across)),
150 0 : leftdir(0, 0, 0),
151 0 : rightdir(0, 0, 0),
152 0 : leftp = *leftv,
153 0 : rightp = *rightv;
154 0 : float taperdist = grassdist*grasstaper,
155 0 : taperscale = 1.0f / (grassdist - taperdist),
156 0 : dist = maxstep*grassstep + tstart,
157 0 : leftb = 0,
158 0 : rightb = 0,
159 0 : leftdb = 0,
160 0 : rightdb = 0;
161 0 : for(int i = maxstep; i >= minstep; i--, offset--, leftp.add(leftdir), rightp.add(rightdir), leftb += leftdb, rightb += rightdb, dist -= grassstep)
162 : {
163 0 : if(dist <= leftdist)
164 : {
165 0 : const vec *prev = leftv;
166 0 : float prevdist = leftdist;
167 0 : if(--leftv < &g.v[0])
168 : {
169 0 : leftv += g.numv;
170 : }
171 0 : leftdist = leftv->dot(w.dir);
172 0 : if(dist <= leftdist)
173 : {
174 0 : prev = leftv;
175 0 : prevdist = leftdist;
176 0 : if(--leftv < &g.v[0])
177 : {
178 0 : leftv += g.numv;
179 : }
180 0 : leftdist = leftv->dot(w.dir);
181 : }
182 0 : leftdir = vec(*leftv).sub(*prev);
183 0 : leftdir.mul(grassstep/-w.dir.dot(leftdir));
184 0 : leftp = vec(leftdir).mul((prevdist - dist)/grassstep).add(*prev);
185 0 : leftb = w.bound1.dist(leftp);
186 0 : leftdb = w.bound1.dot(leftdir);
187 : }
188 0 : if(dist <= rightdist)
189 : {
190 0 : const vec *prev = rightv;
191 0 : float prevdist = rightdist;
192 0 : if(++rightv >= &g.v[g.numv])
193 : {
194 0 : rightv = &g.v[0];
195 : }
196 0 : rightdist = rightv->dot(w.dir);
197 0 : if(dist <= rightdist)
198 : {
199 0 : prev = rightv;
200 0 : prevdist = rightdist;
201 0 : if(++rightv >= &g.v[g.numv])
202 : {
203 0 : rightv = &g.v[0];
204 : }
205 0 : rightdist = rightv->dot(w.dir);
206 : }
207 0 : rightdir = vec(*rightv).sub(*prev);
208 0 : rightdir.mul(grassstep/-w.dir.dot(rightdir));
209 0 : rightp = vec(rightdir).mul((prevdist - dist)/grassstep).add(*prev);
210 0 : rightb = w.bound2.dist(rightp);
211 0 : rightdb = w.bound2.dot(rightdir);
212 : }
213 0 : vec p1 = leftp,
214 0 : p2 = rightp;
215 0 : if(leftb > 0)
216 : {
217 0 : if(w.bound1.dist(p2) >= 0)
218 : {
219 0 : continue;
220 : }
221 0 : p1.add(vec(across).mul(leftb));
222 : }
223 0 : if(rightb > 0)
224 : {
225 0 : if(w.bound2.dist(p1) >= 0)
226 : {
227 0 : continue;
228 : }
229 0 : p2.sub(vec(across).mul(rightb));
230 : }
231 :
232 0 : if(static_cast<int>(grassverts.size()) >= 4*maxgrass)
233 : {
234 0 : break;
235 : }
236 :
237 0 : if(!group)
238 : {
239 : grassgroup group;
240 0 : group.tri = &g;
241 0 : group.tex = tex->id;
242 0 : group.offset = grassverts.size()/4;
243 0 : group.numquads = 0;
244 0 : grassgroups.push_back(group);
245 0 : if(lastgrassanim!=lastmillis)
246 : {
247 0 : animategrass();
248 : }
249 : }
250 :
251 0 : group->numquads++;
252 :
253 0 : float tcoffset = grassoffsets[offset%numgrassoffsets],
254 0 : animoffset = animscale*grassanimoffsets[offset%numgrassoffsets],
255 0 : tc1 = tc.dot(p1) + tcoffset,
256 0 : tc2 = tc.dot(p2) + tcoffset,
257 0 : fade = dist - t > taperdist ? (grassdist - (dist - t))*taperscale : 1,
258 0 : height = grassheight * fade;
259 0 : vec4<uchar> color(grasscolor, 255);
260 : //=====================================================================GRASSVERT
261 : #define GRASSVERT(n, tcv, modify) { \
262 : grassvert gv; \
263 : gv.pos = p##n; \
264 : gv.color = color; \
265 : gv.tc = vec2(tc##n, tcv); \
266 : grassverts.push_back(gv); \
267 : modify; \
268 : }
269 :
270 0 : GRASSVERT(2, 0, { gv.pos.z += height; gv.tc.x += animoffset; });
271 0 : GRASSVERT(1, 0, { gv.pos.z += height; gv.tc.x += animoffset; });
272 0 : GRASSVERT(1, 1, );
273 0 : GRASSVERT(2, 1, );
274 :
275 : #undef GRASSVERT
276 : //==============================================================================
277 : }
278 : }
279 :
280 : // generates grass geometry for a given vertex array
281 0 : void gengrassquads(const vtxarray &va)
282 : {
283 0 : for(const grasstri &g : va.grasstris)
284 : {
285 0 : if(view.isfoggedsphere(g.radius, g.center))
286 : {
287 0 : continue;
288 : }
289 0 : float dist = g.center.dist(camera1->o);
290 0 : if(dist - g.radius > grassdist)
291 : {
292 0 : continue;
293 : }
294 0 : Slot &s = *lookupvslot(g.texture, false).slot;
295 0 : if(!s.grasstex)
296 : {
297 0 : if(!s.grass)
298 : {
299 0 : continue;
300 : }
301 0 : s.grasstex = textureload(s.grass, 2);
302 : }
303 0 : grassgroup *group = nullptr;
304 0 : for(const grasswedge &w : grasswedges)
305 : {
306 0 : if(w.bound1.dist(g.center) > g.radius || w.bound2.dist(g.center) > g.radius)
307 : {
308 0 : continue;
309 : }
310 0 : gengrassquads(group, w, g, s.grasstex);
311 : }
312 : }
313 0 : }
314 :
315 : bool hasgrassshader = false;
316 :
317 0 : void cleargrassshaders()
318 : {
319 0 : hasgrassshader = false;
320 0 : }
321 :
322 0 : Shader *loadgrassshader()
323 : {
324 0 : std::string name = "grass";
325 0 : return generateshader(name.c_str(), "grassshader ");
326 :
327 0 : }
328 : }
329 :
330 : /* externally relevant functions */
331 : ///////////////////////////////////
332 :
333 0 : void generategrass()
334 : {
335 0 : if(!grass || !grassdist)
336 : {
337 0 : return;
338 : }
339 0 : grassgroups.clear();
340 0 : grassverts.clear();
341 :
342 0 : if(grassoffsets[0] < 0)
343 : {
344 0 : for(int i = 0; i < numgrassoffsets; ++i)
345 : {
346 0 : grassoffsets[i] = randomint(0x1000000)/static_cast<float>(0x1000000);
347 : }
348 : }
349 :
350 0 : for(grasswedge &w : grasswedges)
351 : {
352 0 : w.bound1.offset = -camera1->o.dot(w.bound1);
353 0 : w.bound2.offset = -camera1->o.dot(w.bound2);
354 : }
355 :
356 0 : for(vtxarray *va = visibleva; va; va = va->next)
357 : {
358 0 : if(va->grasstris.empty() || va->occluded >= Occlude_Geom)
359 : {
360 0 : continue;
361 : }
362 0 : if(va->distance > grassdist)
363 : {
364 0 : continue;
365 : }
366 0 : gengrassquads(*va);
367 : }
368 :
369 0 : if(grassgroups.empty())
370 : {
371 0 : return;
372 : }
373 0 : if(!grassvbo)
374 : {
375 0 : glGenBuffers(1, &grassvbo);
376 : }
377 0 : gle::bindvbo(grassvbo);
378 0 : int size = grassverts.size()*sizeof(grassvert);
379 0 : grassvbosize = std::max(grassvbosize, size);
380 0 : glBufferData(GL_ARRAY_BUFFER, grassvbosize, size == grassvbosize ? grassverts.data() : nullptr, GL_STREAM_DRAW);
381 0 : if(size != grassvbosize)
382 : {
383 0 : glBufferSubData(GL_ARRAY_BUFFER, 0, size, grassverts.data());
384 : }
385 0 : gle::clearvbo();
386 : }
387 :
388 0 : void loadgrassshaders()
389 : {
390 0 : hasgrassshader = (loadgrassshader() != nullptr);
391 0 : }
392 :
393 0 : void rendergrass()
394 : {
395 0 : if(!grass || !grassdist || grassgroups.empty() || !hasgrassshader)
396 : {
397 0 : return;
398 : }
399 0 : glDisable(GL_CULL_FACE);
400 :
401 0 : gle::bindvbo(grassvbo);
402 :
403 0 : const grassvert *ptr = nullptr;
404 0 : gle::vertexpointer(sizeof(grassvert), ptr->pos.v);
405 0 : gle::colorpointer(sizeof(grassvert), ptr->color.v);
406 0 : gle::texcoord0pointer(sizeof(grassvert), ptr->tc.v);
407 0 : gle::enablevertex();
408 0 : gle::enablecolor();
409 0 : gle::enabletexcoord0();
410 0 : gle::enablequads();
411 :
412 0 : GLOBALPARAMF(grasstest, grasstest); //toggles use of grass (depth) test shader
413 :
414 0 : int texid = -1;
415 0 : for(const grassgroup &g : grassgroups)
416 : {
417 0 : if(texid != g.tex)
418 : {
419 0 : glBindTexture(GL_TEXTURE_2D, g.tex);
420 0 : texid = g.tex;
421 : }
422 :
423 0 : gle::drawquads(g.offset, g.numquads);
424 0 : xtravertsva += 4*g.numquads;
425 : }
426 :
427 0 : gle::disablequads();
428 0 : gle::disablevertex();
429 0 : gle::disablecolor();
430 0 : gle::disabletexcoord0();
431 :
432 0 : gle::clearvbo();
433 :
434 0 : glEnable(GL_CULL_FACE);
435 : }
436 :
437 0 : void cleanupgrass()
438 : {
439 0 : if(grassvbo)
440 : {
441 0 : glDeleteBuffers(1, &grassvbo);
442 0 : grassvbo = 0;
443 : }
444 0 : grassvbosize = 0;
445 :
446 0 : cleargrassshaders();
447 0 : }
|
