1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
|
/**
* @file llwind.cpp
* @brief LLWind class implementation
*
* Copyright (c) 2000-$CurrentYear$, Linden Research, Inc.
* $License$
*/
// Wind is a lattice. It is computed on the simulator, and transmitted to the viewer.
// It drives special effects like smoke blowing, trees bending, and grass wiggling.
//
// Currently wind lattice does not interpolate correctly to neighbors. This will need
// work.
#include "llviewerprecompiledheaders.h"
#include "indra_constants.h"
#include "llwind.h"
// linden libraries
#include "llgl.h"
#include "patch_dct.h"
#include "patch_code.h"
// viewer
#include "noise.h"
#include "v4color.h"
#include "viewer.h"
#include "llagent.h"
#include "llworld.h"
const F32 CLOUD_DIVERGENCE_COEF = 0.5f;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
LLWind::LLWind()
: mSize(16),
mCloudDensityp(NULL)
{
init();
}
LLWind::~LLWind()
{
delete [] mVelX;
delete [] mVelY;
delete [] mCloudVelX;
delete [] mCloudVelY;
}
//////////////////////////////////////////////////////////////////////
// Public Methods
//////////////////////////////////////////////////////////////////////
void LLWind::init()
{
// Initialize vector data
mVelX = new F32[mSize*mSize];
mVelY = new F32[mSize*mSize];
mCloudVelX = new F32[mSize*mSize];
mCloudVelY = new F32[mSize*mSize];
S32 i;
for (i = 0; i < mSize*mSize; i++)
{
mVelX[i] = 0.5f;
mVelY[i] = 0.5f;
mCloudVelX[i] = 0.0f;
mCloudVelY[i] = 0.0f;
}
}
void LLWind::decompress(LLBitPack &bitpack, LLGroupHeader *group_headerp)
{
if (!mCloudDensityp)
{
return;
}
LLPatchHeader patch_header;
S32 buffer[16*16];
init_patch_decompressor(group_headerp->patch_size);
// Don't use the packed group_header stride because the strides used on
// simulator and viewer are not equal.
group_headerp->stride = group_headerp->patch_size;
set_group_of_patch_header(group_headerp);
// X component
decode_patch_header(bitpack, &patch_header);
decode_patch(bitpack, buffer);
decompress_patch(mVelX, buffer, &patch_header);
// Y component
decode_patch_header(bitpack, &patch_header);
decode_patch(bitpack, buffer);
decompress_patch(mVelY, buffer, &patch_header);
S32 i, j, k;
// HACK -- mCloudVelXY is the same as mVelXY, except we add a divergence
// that is proportional to the gradient of the cloud density
// ==> this helps to clump clouds together
// NOTE ASSUMPTION: cloud density has the same dimensions as the wind field
// This needs to be fixed... causes discrepency at region boundaries
for (j=1; j<mSize-1; j++)
{
for (i=1; i<mSize-1; i++)
{
k = i + j * mSize;
*(mCloudVelX + k) = *(mVelX + k) + CLOUD_DIVERGENCE_COEF * (*(mCloudDensityp + k + 1) - *(mCloudDensityp + k - 1));
*(mCloudVelY + k) = *(mVelY + k) + CLOUD_DIVERGENCE_COEF * (*(mCloudDensityp + k + mSize) - *(mCloudDensityp + k - mSize));
}
}
i = mSize - 1;
for (j=1; j<mSize-1; j++)
{
k = i + j * mSize;
*(mCloudVelX + k) = *(mVelX + k) + CLOUD_DIVERGENCE_COEF * (*(mCloudDensityp + k) - *(mCloudDensityp + k - 2));
*(mCloudVelY + k) = *(mVelY + k) + CLOUD_DIVERGENCE_COEF * (*(mCloudDensityp + k + mSize) - *(mCloudDensityp + k - mSize));
}
i = 0;
for (j=1; j<mSize-1; j++)
{
k = i + j * mSize;
*(mCloudVelX + k) = *(mVelX + k) + CLOUD_DIVERGENCE_COEF * (*(mCloudDensityp + k + 2) - *(mCloudDensityp + k));
*(mCloudVelY + k) = *(mVelY + k) + CLOUD_DIVERGENCE_COEF * (*(mCloudDensityp + k + mSize) - *(mCloudDensityp + k + mSize));
}
j = mSize - 1;
for (i=1; i<mSize-1; i++)
{
k = i + j * mSize;
*(mCloudVelX + k) = *(mVelX + k) + CLOUD_DIVERGENCE_COEF * (*(mCloudDensityp + k + 1) - *(mCloudDensityp + k - 1));
*(mCloudVelY + k) = *(mVelY + k) + CLOUD_DIVERGENCE_COEF * (*(mCloudDensityp + k) - *(mCloudDensityp + k - 2*mSize));
}
j = 0;
for (i=1; i<mSize-1; i++)
{
k = i + j * mSize;
*(mCloudVelX + k) = *(mVelX + k) + CLOUD_DIVERGENCE_COEF * (*(mCloudDensityp + k + 1) - *(mCloudDensityp + k -1));
*(mCloudVelY + k) = *(mVelY + k) + CLOUD_DIVERGENCE_COEF * (*(mCloudDensityp + k + 2*mSize) - *(mCloudDensityp + k));
}
}
LLVector3 LLWind::getAverage()
{
// Returns in average_wind the average wind velocity
LLVector3 average(0.0f, 0.0f, 0.0f);
S32 i, grid_count;
grid_count = mSize * mSize;
for (i = 0; i < grid_count; i++)
{
average.mV[VX] += mVelX[i];
average.mV[VY] += mVelY[i];
}
average *= 1.f/((F32)(grid_count)) * WIND_SCALE_HACK;
return average;
}
LLVector3 LLWind::getVelocityNoisy(const LLVector3 &pos_region, const F32 dim)
{
// Resolve a value, using fractal summing to perturb the returned value
LLVector3 r_val(0,0,0);
F32 norm = 1.0f;
if (dim == 8)
{
norm = 1.875;
}
else if (dim == 4)
{
norm = 1.75;
}
else if (dim == 2)
{
norm = 1.5;
}
F32 temp_dim = dim;
while (temp_dim >= 1.0)
{
LLVector3 pos_region_scaled(pos_region * temp_dim);
r_val += getVelocity(pos_region_scaled) * (1.0f/temp_dim);
temp_dim /= 2.0;
}
return r_val * (1.0f/norm) * WIND_SCALE_HACK;
}
LLVector3 LLWind::getVelocity(const LLVector3 &pos_region)
{
llassert(mSize == 16);
// Resolves value of wind at a location relative to SW corner of region
//
// Returns wind magnitude in X,Y components of vector3
LLVector3 r_val;
F32 dx,dy;
S32 k;
LLVector3 pos_clamped_region(pos_region);
F32 region_width_meters = gWorldPointer->getRegionWidthInMeters();
if (pos_clamped_region.mV[VX] < 0.f)
{
pos_clamped_region.mV[VX] = 0.f;
}
else if (pos_clamped_region.mV[VX] >= region_width_meters)
{
pos_clamped_region.mV[VX] = (F32) fmod(pos_clamped_region.mV[VX], region_width_meters);
}
if (pos_clamped_region.mV[VY] < 0.f)
{
pos_clamped_region.mV[VY] = 0.f;
}
else if (pos_clamped_region.mV[VY] >= region_width_meters)
{
pos_clamped_region.mV[VY] = (F32) fmod(pos_clamped_region.mV[VY], region_width_meters);
}
S32 i = llfloor(pos_clamped_region.mV[VX] * mSize / region_width_meters);
S32 j = llfloor(pos_clamped_region.mV[VY] * mSize / region_width_meters);
k = i + j*mSize;
dx = ((pos_clamped_region.mV[VX] * mSize / region_width_meters) - (F32) i);
dy = ((pos_clamped_region.mV[VY] * mSize / region_width_meters) - (F32) j);
if ((i < mSize-1) && (j < mSize-1))
{
// Interior points, no edges
r_val.mV[VX] = mVelX[k]*(1.0f - dx)*(1.0f - dy) +
mVelX[k + 1]*dx*(1.0f - dy) +
mVelX[k + mSize]*dy*(1.0f - dx) +
mVelX[k + mSize + 1]*dx*dy;
r_val.mV[VY] = mVelY[k]*(1.0f - dx)*(1.0f - dy) +
mVelY[k + 1]*dx*(1.0f - dy) +
mVelY[k + mSize]*dy*(1.0f - dx) +
mVelY[k + mSize + 1]*dx*dy;
}
else
{
r_val.mV[VX] = mVelX[k];
r_val.mV[VY] = mVelY[k];
}
r_val.mV[VZ] = 0.f;
return r_val * WIND_SCALE_HACK;
}
LLVector3 LLWind::getCloudVelocity(const LLVector3 &pos_region)
{
llassert(mSize == 16);
// Resolves value of wind at a location relative to SW corner of region
//
// Returns wind magnitude in X,Y components of vector3
LLVector3 r_val;
F32 dx,dy;
S32 k;
LLVector3 pos_clamped_region(pos_region);
F32 region_width_meters = gWorldPointer->getRegionWidthInMeters();
if (pos_clamped_region.mV[VX] < 0.f)
{
pos_clamped_region.mV[VX] = 0.f;
}
else if (pos_clamped_region.mV[VX] >= region_width_meters)
{
pos_clamped_region.mV[VX] = (F32) fmod(pos_clamped_region.mV[VX], region_width_meters);
}
if (pos_clamped_region.mV[VY] < 0.f)
{
pos_clamped_region.mV[VY] = 0.f;
}
else if (pos_clamped_region.mV[VY] >= region_width_meters)
{
pos_clamped_region.mV[VY] = (F32) fmod(pos_clamped_region.mV[VY], region_width_meters);
}
S32 i = llfloor(pos_clamped_region.mV[VX] * mSize / region_width_meters);
S32 j = llfloor(pos_clamped_region.mV[VY] * mSize / region_width_meters);
k = i + j*mSize;
dx = ((pos_clamped_region.mV[VX] * mSize / region_width_meters) - (F32) i);
dy = ((pos_clamped_region.mV[VY] * mSize / region_width_meters) - (F32) j);
if ((i < mSize-1) && (j < mSize-1))
{
// Interior points, no edges
r_val.mV[VX] = mCloudVelX[k]*(1.0f - dx)*(1.0f - dy) +
mCloudVelX[k + 1]*dx*(1.0f - dy) +
mCloudVelX[k + mSize]*dy*(1.0f - dx) +
mCloudVelX[k + mSize + 1]*dx*dy;
r_val.mV[VY] = mCloudVelY[k]*(1.0f - dx)*(1.0f - dy) +
mCloudVelY[k + 1]*dx*(1.0f - dy) +
mCloudVelY[k + mSize]*dy*(1.0f - dx) +
mCloudVelY[k + mSize + 1]*dx*dy;
}
else
{
r_val.mV[VX] = mCloudVelX[k];
r_val.mV[VY] = mCloudVelY[k];
}
r_val.mV[VZ] = 0.f;
return r_val * WIND_SCALE_HACK;
}
void LLWind::setCloudDensityPointer(F32 *densityp)
{
mCloudDensityp = densityp;
}
void LLWind::setOriginGlobal(const LLVector3d &origin_global)
{
mOriginGlobal = origin_global;
}
|
