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