void
noise_ff(float *ret, float f)
{
float r;
r = noise1(f);
(*ret) = r;
}
int main(int argc, char **argv){
time_t t;
srand((unsigned) time(&t));
float seed = rand()%1000/100.0;
strcat(path, filename);
FILE *file = fopen(path, "w");
// HEADER
fprintf(file, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
fprintf(file, "<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" ");
fprintf(file, "x=\"0px\" y=\"0px\" width=\"%dpx\" height=\"%dpx\" ", width, height);
fprintf(file, "viewBox=\"0 0 %d %d\">\n", width, height);
// BODY
fprintf(file, "<g>\n");
fprintf(file, "<polyline fill=\"none\" stroke=\"#000000\" points=\""); // hanging open polyline
float x, y;
unsigned char newPolyline = 0;
for(int i = START_RADIUS; i < REVOLUTIONS; i++){
float circleResolution = i * 20; // how many points in one full circle
for(float a = 0; a < TWOPI; a += TWOPI/circleResolution){
float revolution = a/TWOPI; // 0-1, progress of one revolution
float bend1 = noise1(seed + a*3)*(i-3)*.7;
float bend2 = noise1(seed + 8+a*10) * powf(i-20,2)*.1;
if(i < 20) bend2 = 0;
float bend3 = noise1(-seed - a*40) * (i-40)*1.2;
if(i < 40) bend3 = 0;
float radius1 = (i + revolution + bend1) * SPACING;
x = width*.5 + cosf(a) * radius1 + cos(a) * bend2 - sin(a) * bend3;
y = height*.5 + sinf(a) * radius1 + sin(a) * bend2 - cos(a) * bend3;
fprintf(file, "%.2f,%.2f ", x, y);
}
}
fprintf(file, "\"/>\n"); // closing polyline
fprintf(file, "</g>\n");
fprintf(file, "</svg>");
fclose(file);
return 0;
}
scalar_t turbulence1(scalar_t x, int octaves)
{
int i;
scalar_t res = 0.0f, freq = 1.0f;
for(i=0; i<octaves; i++) {
res += fabs(noise1(x * freq) / freq);
freq *= 2.0f;
}
return res;
}
scalar_t fbm1(scalar_t x, int octaves)
{
int i;
scalar_t res = 0.0f, freq = 1.0f;
for(i=0; i<octaves; i++) {
res += noise1(x * freq) / freq;
freq *= 2.0f;
}
return res;
}
void noise1D::init()
{
int i;
for (i=0; i<MAXKNOTS; i++)
{
knots1[i]=noise1(i);
knots1[i]=(knots1[i]*SHINESS);
}
return;
}
double PerlinGenerator::PerlinNoise1D( double x, double divisionFactor, double freqMult, int numFreqs )
{
double sum = 0;
double scale = 1;
for( int i = 0 ; i < numFreqs ; i++ )
{
sum += noise1(x) / scale ; // get noise, reduce magnitude by scale (so "higher freq" noise has less effect)
scale *= divisionFactor ; // increase division factor, for next iteration
x *= freqMult ; // "up the frequency" of next noise value.
}
return sum ;
}
static PyObject *
py_noise1(PyObject *self, PyObject *args, PyObject *kwargs)
{
float x;
int octaves = 1;
float persistence = 0.5f;
float lacunarity = 2.0f;
int repeat = 1024; // arbitrary
int base = 0;
static char *kwlist[] = {"x", "octaves", "persistence", "lacunarity", "repeat", "base", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "f|iffii:noise1", kwlist,
&x, &octaves, &persistence, &lacunarity, &repeat, &base))
return NULL;
if (octaves == 1) {
// Single octave, return simple noise
return (PyObject *) PyFloat_FromDouble((double) noise1(x, repeat, base));
} else if (octaves > 1) {
int i;
float freq = 1.0f;
float amp = 1.0f;
float max = 0.0f;
float total = 0.0f;
for (i = 0; i < octaves; i++) {
total += noise1(x * freq, (const int)(repeat * freq), base) * amp;
max += amp;
freq *= lacunarity;
amp *= persistence;
}
return (PyObject *) PyFloat_FromDouble((double) (total / max));
} else {
PyErr_SetString(PyExc_ValueError, "Expected octaves value > 0");
return NULL;
}
}
double PerlinNoise1D(double x,double alpha,double beta,int n)
{
int i;
double val,sum = 0;
double p,scale = 1;
p = x;
for (i=0;i<n;i++) {
val = noise1(p);
sum += val / scale;
scale *= alpha;
p *= beta;
}
return(sum);
}
double Perlin::perlin_noise_1D(double vec)
{
int terms = mOctaves;
double freq = mFrequency;
double result = 0.0f;
double amp = mAmplitude;
vec*=mFrequency;
for( int i=0; i<terms; i++ ) {
result += noise1(vec)*amp;
vec*=2.0f;
amp*=0.5f;
}
return result;
}
T
noise_1D (
T val)
{
T amp = mAmplitude;
T result = 0.0;
val *= mFrequency;
for( int i = 0; i < mOctaves; i++ )
{
result += noise1(val) * amp;
val *= 2.0;
amp *= 0.5;
}
return result;
}
void MapGenerator::make_cells(Cell *cells)
{
SimplexNoise noise1(random);
SimplexNoise noise2(random);
unsigned int x = 0;
while (x < cells_x)
{
unsigned int y = 0;
while (y < cells_y)
{
float fx = x * 0.1f;
float fy = y * 0.1f;
bool wall;
wall = noise1.raw_noise_2d(fx, fy) > 0.0;
wall &= noise2.raw_noise_2d(fx, fy) > 0.0;
wall &= x != 1;
wall &= x != cells_x - 2;
wall &= y != 1;
wall &= y != cells_y - 2;
wall |= x == 0;
wall |= x == cells_x - 1;
wall |= y == 0;
wall |= y == cells_y - 1;
cells[x + y * cells_x].type = wall ? Cell::steel : Cell::empty;
y++;
}
x++;
}
unsigned int base_x = cells_x / 16;
unsigned int base_y = cells_y / 16;
cells[base_x + cells_y / 2 * cells_x].type = Cell::base;
cells[(cells_x - base_x - 1) + cells_y / 2 * cells_x].type = Cell::base;
cells[cells_x / 2 + base_y * cells_x].type = Cell::base;
cells[cells_x / 2 + (cells_y - base_y - 1) * cells_x].type = Cell::base;
}
real shPerlin::Noise1D(const real& v)const{
real val = v;
return noise1(val);
}
void ViBenchMarker3::process2()
{
int time = mTime.elapsed();
QObject::disconnect(mCurrentObject.data(), SIGNAL(noiseGenerated()), this, SLOT(process2()));
/*QObject::connect(mCurrentObject.data(), SIGNAL(encoded()), this, SLOT(quit()));
mCurrentObject->encode(ViAudio::Noise);
return;*/
qreal maxMAT = 0;
qint64 maxTP = 0, maxTN = 0, maxFP = 0, maxFN = 0;
qint64 i, lengthIndex, offset1 = 0, offset2 = 0;
int noChange = 0;
ViAudioReadData corrupted(mCurrentObject->buffer(ViAudio::Noise));
ViAudioReadData realMask(mCurrentObject->buffer(ViAudio::CustomMask));
ViAudioReadData length(mCurrentObject->buffer(ViAudio::Custom));
corrupted.setSampleCount(WINDOW_SIZE);
realMask.setSampleCount(WINDOW_SIZE);
length.setSampleCount(WINDOW_SIZE);
ViSampleChunk *nData1 = new ViSampleChunk(corrupted.bufferSamples() / 2);
ViSampleChunk *nData2 = new ViSampleChunk(corrupted.bufferSamples() / 2);
ViSampleChunk *nMask1 = new ViSampleChunk(corrupted.bufferSamples() / 2);
ViSampleChunk *nMask2 = new ViSampleChunk(corrupted.bufferSamples() / 2);
ViSampleChunk *nRealMask1 = new ViSampleChunk(realMask.bufferSamples() / 2);
ViSampleChunk *nRealMask2 = new ViSampleChunk(realMask.bufferSamples() / 2);
ViSampleChunk *nLength1 = new ViSampleChunk(corrupted.bufferSamples() / 2);
ViSampleChunk *nLength2 = new ViSampleChunk(corrupted.bufferSamples() / 2);
while(corrupted.hasData() && realMask.hasData())
{
corrupted.read();
ViSampleChunk &corrupted1 = corrupted.splitSamples(0);
ViSampleChunk &corrupted2 = corrupted.splitSamples(1);
realMask.read();
ViSampleChunk &realMask1 = realMask.splitSamples(0);
ViSampleChunk &realMask2 = realMask.splitSamples(1);
length.read();
ViSampleChunk &length1 = length.splitSamples(0);
ViSampleChunk &length2 = length.splitSamples(1);
for(i = 0; i < corrupted1.size(); ++i)
{
(*nData1)[i + offset1] = corrupted1[i];
(*nRealMask1)[i + offset1] = realMask1[i];
(*nLength1)[i + offset1] = length1[i];
}
offset1 += corrupted1.size();
for(i = 0; i < corrupted2.size(); ++i)
{
(*nData2)[i + offset2] = corrupted2[i];
(*nRealMask2)[i + offset2] = realMask2[i];
(*nLength2)[i + offset2] = length2[i];
}
offset2 += corrupted2.size();
}
mCurrentObject->clearBuffer(ViAudio::Target);
mCurrentObject->clearBuffer(ViAudio::Noise);
mCurrentObject->clearBuffer(ViAudio::NoiseMask);
ViNoise noise1(nData1, nMask1, mCurrentThreshold);
ViNoise noise2(nData2, nMask2, mCurrentThreshold);
QVector<qreal> lengthTP(ViNoiseCreator::noiseSizeCount());
QVector<qreal> lengthFN(ViNoiseCreator::noiseSizeCount());
lengthTP.fill(0);
lengthFN.fill(0);
QVector<qreal> maxLengthTP, maxLengthFN;
for(mCurrentThreshold = MASK_START; mCurrentThreshold <= MASK_END; mCurrentThreshold += MASK_INTERVAL)
{
noise1.setThreshold(mCurrentThreshold);
noise1.generateMask(ViNoise::NOISE_TYPE);
noise2.setThreshold(mCurrentThreshold);
noise2.generateMask(ViNoise::NOISE_TYPE);
qint64 truePositives = 0, falsePositives = 0, trueNegatives = 0, falseNegatives = 0;
for(i = 0; i < nRealMask1->size(); ++i)
{
if((*nRealMask1)[i] == 1)
{
lengthIndex = ViNoiseCreator::fromSizeMask((*nLength1)[i]) - 1;
if((*nMask1)[i] == 1)
{
++truePositives;
lengthTP[lengthIndex] += 1;
}
else
{
++falseNegatives;
lengthFN[lengthIndex] += 1;
}
}
else if((*nRealMask1)[i] == 0)
{
if((*nMask1)[i] == 1) ++falsePositives;
else ++trueNegatives;
}
}
for(i = 0; i < nRealMask2->size(); ++i)
{
if((*nRealMask2)[i] == 1)
{
lengthIndex = ViNoiseCreator::fromSizeMask((*nLength2)[i]) - 1;
if((*nMask2)[i] == 1)
{
++truePositives;
lengthTP[lengthIndex] += 1;
}
else
{
++falseNegatives;
lengthFN[lengthIndex] += 1;
}
}
else if((*nRealMask2)[i] == 0)
{
if((*nMask2)[i] == 1) ++falsePositives;
else ++trueNegatives;
}
}
qreal math = matthews(truePositives, trueNegatives, falsePositives, falseNegatives);
if(math > maxMAT)
{
maxMAT = math;
maxTP = truePositives;
maxTN = trueNegatives;
maxFP = falsePositives;
maxFN = falseNegatives;
maxLengthTP = lengthTP;
maxLengthFN = lengthFN;
noChange = 0;
}
++noChange;
if(noChange > NO_CHANGE) break;
}
delete nRealMask1;
delete nRealMask2;
delete nLength1;
delete nLength2;
++mDoneParamIterations;
if(maxMAT > mBestMatthews) mBestMatthews = maxMAT;
printFileData(time, maxTP, maxTN, maxFP, maxFN, maxLengthTP, maxLengthFN);
printTerminal(time, maxTP, maxTN, maxFP, maxFN, mBestMatthews);
if(nextParam()) process1(false);
else nextFile();
}
void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
{
if (pass == -1)
{
for (S32 i = 1; i < getNumPasses(); i++)
{ //skip foot shadows
prerender();
beginRenderPass(i);
renderAvatars(single_avatar, i);
endRenderPass(i);
}
return;
}
if (mDrawFace.empty() && !single_avatar)
{
return;
}
LLVOAvatar *avatarp;
if (single_avatar)
{
avatarp = single_avatar;
}
else
{
const LLFace *facep = mDrawFace[0];
if (!facep->getDrawable())
{
return;
}
avatarp = (LLVOAvatar *)facep->getDrawable()->getVObj().get();
}
if (avatarp->isDead() || avatarp->mDrawable.isNull())
{
return;
}
if (!single_avatar && !avatarp->isFullyLoaded())
{
if (pass == 0 && (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES) || LLViewerPartSim::getMaxPartCount() <= 0))
{
// debug code to draw a sphere in place of avatar
gGL.getTexUnit(0)->bind(LLViewerFetchedTexture::sWhiteImagep);
gGL.setColorMask(true, true);
LLVector3 pos = avatarp->getPositionAgent();
gGL.color4f(1.0f, 1.0f, 1.0f, 0.7f);
gGL.pushMatrix();
gGL.translatef((F32)(pos.mV[VX]), (F32)(pos.mV[VY]), (F32)(pos.mV[VZ]));
gGL.scalef(0.15f, 0.15f, 0.3f);
gSphere.renderGGL();
gGL.popMatrix();
gGL.setColorMask(true, false);
}
// don't render please
return;
}
BOOL impostor = avatarp->isImpostor() && !single_avatar;
if (impostor && pass != 0)
{ //don't draw anything but the impostor for impostored avatars
return;
}
if (pass == 0 && !impostor && LLPipeline::sUnderWaterRender)
{ //don't draw foot shadows under water
return;
}
if (pass == 0)
{
if (!LLPipeline::sReflectionRender)
{
LLVOAvatar::sNumVisibleAvatars++;
}
if (impostor)
{
if (LLPipeline::sRenderDeferred && !LLPipeline::sReflectionRender &&
avatarp->mImpostor.isComplete())
{
if (normal_channel > -1)
{
avatarp->mImpostor.bindTexture(2, normal_channel);
}
if (specular_channel > -1)
{
avatarp->mImpostor.bindTexture(1, specular_channel);
}
}
avatarp->renderImpostor(LLColor4U(255,255,255,255), sDiffuseChannel);
}
return;
}
if (single_avatar && avatarp->mSpecialRenderMode >= 1) // 1=anim preview, 2=image preview, 3=morph view
{
gPipeline.enableLightsAvatarEdit(LLColor4(.5f, .5f, .5f, 1.f));
}
if (pass == 1)
{
// render rigid meshes (eyeballs) first
avatarp->renderRigid();
return;
}
if (pass == 3)
{
if (is_deferred_render)
{
renderDeferredRiggedSimple(avatarp);
}
else
{
renderRiggedSimple(avatarp);
}
return;
}
if (pass == 4)
{
if (is_deferred_render)
{
renderDeferredRiggedBump(avatarp);
}
else
{
renderRiggedFullbright(avatarp);
}
return;
}
if (pass == 5)
{
renderRiggedShinySimple(avatarp);
return;
}
if (pass == 6)
{
renderRiggedFullbrightShiny(avatarp);
return;
}
if (pass >= 7 && pass < 9)
{
LLGLEnable blend(GL_BLEND);
gGL.setColorMask(true, true);
gGL.blendFunc(LLRender::BF_SOURCE_ALPHA,
LLRender::BF_ONE_MINUS_SOURCE_ALPHA,
LLRender::BF_ZERO,
LLRender::BF_ONE_MINUS_SOURCE_ALPHA);
if (pass == 7)
{
renderRiggedAlpha(avatarp);
return;
}
if (pass == 8)
{
renderRiggedFullbrightAlpha(avatarp);
return;
}
}
if (pass == 9)
{
LLGLEnable blend(GL_BLEND);
LLGLDisable test(GL_ALPHA_TEST);
gGL.flush();
LLGLEnable polyOffset(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(-1.0f, -1.0f);
gGL.setSceneBlendType(LLRender::BT_ADD);
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
gGL.setColorMask(false, true);
renderRiggedGlow(avatarp);
gGL.setColorMask(true, false);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
return;
}
if (sShaderLevel > 0)
{
gAvatarMatrixParam = sVertexProgram->mUniform[LLViewerShaderMgr::AVATAR_MATRIX];
}
if (sShaderLevel >= SHADER_LEVEL_CLOTH)
{
LLMatrix4 rot_mat;
LLViewerCamera::getInstance()->getMatrixToLocal(rot_mat);
LLMatrix4 cfr(OGL_TO_CFR_ROTATION);
rot_mat *= cfr;
LLVector4 wind;
wind.setVec(avatarp->mWindVec);
wind.mV[VW] = 0;
wind = wind * rot_mat;
wind.mV[VW] = avatarp->mWindVec.mV[VW];
sVertexProgram->vertexAttrib4fv(LLViewerShaderMgr::AVATAR_WIND, wind.mV);
F32 phase = -1.f * (avatarp->mRipplePhase);
F32 freq = 7.f + (noise1(avatarp->mRipplePhase) * 2.f);
LLVector4 sin_params(freq, freq, freq, phase);
sVertexProgram->vertexAttrib4fv(LLViewerShaderMgr::AVATAR_SINWAVE, sin_params.mV);
LLVector4 gravity(0.f, 0.f, -CLOTHING_GRAVITY_EFFECT, 0.f);
gravity = gravity * rot_mat;
sVertexProgram->vertexAttrib4fv(LLViewerShaderMgr::AVATAR_GRAVITY, gravity.mV);
}
if (!single_avatar || avatarp == single_avatar)
{
avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE);
}
}
void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
{
LLFastTimer t(FTM_RENDER_AVATARS);
if (pass == -1)
{
for (S32 i = 1; i < getNumPasses(); i++)
{ //skip foot shadows
prerender();
beginRenderPass(i);
renderAvatars(single_avatar, i);
endRenderPass(i);
}
return;
}
if (mDrawFace.empty() && !single_avatar)
{
return;
}
LLVOAvatar *avatarp;
if (single_avatar)
{
avatarp = single_avatar;
}
else
{
const LLFace *facep = mDrawFace[0];
if (!facep->getDrawable())
{
return;
}
avatarp = (LLVOAvatar *)facep->getDrawable()->getVObj().get();
}
if (avatarp->isDead() || avatarp->mDrawable.isNull())
{
return;
}
if (!single_avatar && !avatarp->isFullyLoaded() )
{
if (pass==0 && (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES) || LLViewerPartSim::getMaxPartCount() <= 0))
{
// debug code to draw a sphere in place of avatar
gGL.getTexUnit(0)->bind(LLViewerFetchedTexture::sWhiteImagep);
gGL.setColorMask(true, true);
LLVector3 pos = avatarp->getPositionAgent();
gGL.color4f(1.0f, 1.0f, 1.0f, 0.7f);
gGL.pushMatrix();
gGL.translatef((F32)(pos.mV[VX]),
(F32)(pos.mV[VY]),
(F32)(pos.mV[VZ]));
gGL.scalef(0.15f, 0.15f, 0.3f);
gSphere.renderGGL();
gGL.popMatrix();
gGL.setColorMask(true, false);
}
// don't render please
return;
}
BOOL impostor = avatarp->isImpostor() && !single_avatar;
if (impostor && pass != 0)
{ //don't draw anything but the impostor for impostored avatars
return;
}
if (pass == 0 && !impostor && LLPipeline::sUnderWaterRender)
{ //don't draw foot shadows under water
return;
}
if (pass == 0)
{
if (!LLPipeline::sReflectionRender)
{
LLVOAvatar::sNumVisibleAvatars++;
}
if (impostor)
{
if (LLPipeline::sRenderDeferred && !LLPipeline::sReflectionRender && avatarp->mImpostor.isComplete())
{
if (normal_channel > -1)
{
avatarp->mImpostor.bindTexture(2, normal_channel);
}
if (specular_channel > -1)
{
avatarp->mImpostor.bindTexture(1, specular_channel);
}
}
avatarp->renderImpostor(LLColor4U(255,255,255,255), sDiffuseChannel);
}
//else if (gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_FOOT_SHADOWS) && !LLPipeline::sRenderDeferred)
//{
// avatarp->renderFootShadows();
//}
return;
}
llassert(LLPipeline::sImpostorRender || !avatarp->isVisuallyMuted());
/*if (single_avatar && avatarp->mSpecialRenderMode >= 1) // 1=anim preview, 2=image preview, 3=morph view
{
gPipeline.enableLightsAvatarEdit(LLColor4(.5f, .5f, .5f, 1.f));
}*/
if (pass == 1)
{
// render rigid meshes (eyeballs) first
avatarp->renderRigid();
return;
}
if (pass == 3)
{
if (is_deferred_render)
{
renderDeferredRiggedSimple(avatarp);
}
else
{
renderRiggedSimple(avatarp);
if (LLPipeline::sRenderDeferred)
{ //render "simple" materials
renderRigged(avatarp, RIGGED_MATERIAL);
renderRigged(avatarp, RIGGED_MATERIAL_ALPHA_MASK);
renderRigged(avatarp, RIGGED_MATERIAL_ALPHA_EMISSIVE);
renderRigged(avatarp, RIGGED_NORMMAP);
renderRigged(avatarp, RIGGED_NORMMAP_MASK);
renderRigged(avatarp, RIGGED_NORMMAP_EMISSIVE);
renderRigged(avatarp, RIGGED_SPECMAP);
renderRigged(avatarp, RIGGED_SPECMAP_MASK);
renderRigged(avatarp, RIGGED_SPECMAP_EMISSIVE);
renderRigged(avatarp, RIGGED_NORMSPEC);
renderRigged(avatarp, RIGGED_NORMSPEC_MASK);
renderRigged(avatarp, RIGGED_NORMSPEC_EMISSIVE);
}
}
return;
}
if (pass == 4)
{
if (is_deferred_render)
{
renderDeferredRiggedBump(avatarp);
}
else
{
renderRiggedFullbright(avatarp);
}
return;
}
if (is_deferred_render && pass >= 5 && pass <= 21)
{
S32 p = pass-5;
if (p != 1 &&
p != 5 &&
p != 9 &&
p != 13)
{
renderDeferredRiggedMaterial(avatarp, p);
}
return;
}
if (pass == 5)
{
renderRiggedShinySimple(avatarp);
return;
}
if (pass == 6)
{
renderRiggedFullbrightShiny(avatarp);
return;
}
if (pass >= 7 && pass < 13)
{
if (pass == 7)
{
renderRiggedAlpha(avatarp);
if (LLPipeline::sRenderDeferred && !is_post_deferred_render)
{ //render transparent materials under water
LLGLEnable blend(GL_BLEND);
gGL.setColorMask(true, true);
gGL.blendFunc(LLRender::BF_SOURCE_ALPHA,
LLRender::BF_ONE_MINUS_SOURCE_ALPHA,
LLRender::BF_ZERO,
LLRender::BF_ONE_MINUS_SOURCE_ALPHA);
renderRigged(avatarp, RIGGED_MATERIAL_ALPHA);
renderRigged(avatarp, RIGGED_SPECMAP_BLEND);
renderRigged(avatarp, RIGGED_NORMMAP_BLEND);
renderRigged(avatarp, RIGGED_NORMSPEC_BLEND);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
gGL.setColorMask(true, false);
}
return;
}
if (pass == 8)
{
renderRiggedFullbrightAlpha(avatarp);
return;
}
if (LLPipeline::sRenderDeferred && is_post_deferred_render)
{
S32 p = 0;
switch (pass)
{
case 9: p = 1; break;
case 10: p = 5; break;
case 11: p = 9; break;
case 12: p = 13; break;
}
{
LLGLEnable blend(GL_BLEND);
renderDeferredRiggedMaterial(avatarp, p);
}
return;
}
else if (pass == 9)
{
renderRiggedGlow(avatarp);
return;
}
}
if (pass == 13)
{
renderRiggedGlow(avatarp);
return;
}
if ((sShaderLevel >= SHADER_LEVEL_CLOTH))
{
LLMatrix4 rot_mat;
LLViewerCamera::getInstance()->getMatrixToLocal(rot_mat);
LLMatrix4 cfr(OGL_TO_CFR_ROTATION.getF32ptr());
rot_mat *= cfr;
LLVector4 wind;
wind.setVec(avatarp->mWindVec);
wind.mV[VW] = 0;
wind = wind * rot_mat;
wind.mV[VW] = avatarp->mWindVec.mV[VW];
sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_WIND, 1, wind.mV);
F32 phase = -1.f * (avatarp->mRipplePhase);
F32 freq = 7.f + (noise1(avatarp->mRipplePhase) * 2.f);
LLVector4 sin_params(freq, freq, freq, phase);
sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_SINWAVE, 1, sin_params.mV);
LLVector4 gravity(0.f, 0.f, -CLOTHING_GRAVITY_EFFECT, 0.f);
gravity = gravity * rot_mat;
sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_GRAVITY, 1, gravity.mV);
}
if( !single_avatar || (avatarp == single_avatar) )
{
avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE);
}
}
float tileableNoise1(const float x, const float w){
return (noise1(x) * (w - x) +
noise1(x - w) * x) / w;
}
/*
* 1D noise
*/
float Noise::Noise1D(float x)
{
return noise1(x);
}
