static void applyForces(struct particle_system *ps, struct particle *p)
{
int i = 0;
vec3 force;
vec3 dir;
float m, d, s;
vec3Copy(p->dir, p->acc);
do {
switch(ps->forces[i].type) {
case PARTICLE_FORCE_DIRECTIONAL:
vec3Copy(ps->forces[i].dir, force);
break;
case PARTICLE_FORCE_FLUID:
s = vec3Mag(p->acc);
vec3Copy(p->acc, force);
vec3Normalize(force, force);
vec3Mul(force, -ps->forces[i].value*s*s, force);
break;
case PARTICLE_FORCE_ATTRACTION:
vec3Sub(ps->forces[i].loc, p->loc, dir);
d = vec3Mag(dir);
vec3Normalize(dir, dir);
m = 0.00001*ps->forces[i].value*p->mass / (d*d);
vec3Mul(dir, m, force);
break;
}
vec3Add(p->acc, force, p->acc);
} while(++i < ps->nbforces);
vec3Div(p->acc, p->mass, p->acc);
vec3Add(p->vel, p->acc, p->vel);
vec3Add(p->loc, p->vel, p->loc);
}
void update(float _deltaTime)
{
if (m_mouseDown)
{
int32_t deltaX = m_mouseNow.m_mx - m_mouseLast.m_mx;
int32_t deltaY = m_mouseNow.m_my - m_mouseLast.m_my;
m_horizontalAngle += m_mouseSpeed * float(deltaX);
m_verticalAngle -= m_mouseSpeed * float(deltaY);
m_mouseLast.m_mx = m_mouseNow.m_mx;
m_mouseLast.m_my = m_mouseNow.m_my;
}
float direction[3] =
{
cosf(m_verticalAngle) * sinf(m_horizontalAngle),
sinf(m_verticalAngle),
cosf(m_verticalAngle) * cosf(m_horizontalAngle),
};
float right[3] =
{
sinf(m_horizontalAngle - float(M_PI)/2.0f),
0,
cosf(m_horizontalAngle - float(M_PI)/2.0f),
};
if (m_keys & CAMERA_KEY_UP)
{
// m_eye += direction * _deltaTime * m_moveSpeed
float tmpRhs[3];
float tmpPos[3];
memcpy(tmpPos, m_eye, sizeof(float)*3);
vec3Mul(tmpRhs, direction, _deltaTime * m_moveSpeed);
vec3Add(m_eye, tmpPos, tmpRhs);
setKeyState(CAMERA_KEY_UP, false);
}
if (m_keys & CAMERA_KEY_DOWN)
{
// m_eye -= direction * _deltaTime * m_moveSpeed
float tmpRhs[3];
float tmpPos[3];
memcpy(tmpPos, m_eye, sizeof(float)*3);
vec3Mul(tmpRhs, direction, _deltaTime * m_moveSpeed);
vec3Sub(m_eye, tmpPos, tmpRhs);
setKeyState(CAMERA_KEY_DOWN, false);
}
if (m_keys & CAMERA_KEY_LEFT)
{
// m_eye += right * _deltaTime * m_moveSpeed
float tmpRhs[3];
float tmpPos[3];
memcpy(tmpPos, m_eye, sizeof(float)*3);
vec3Mul(tmpRhs, right, _deltaTime * m_moveSpeed);
vec3Add(m_eye, tmpPos, tmpRhs);
setKeyState(CAMERA_KEY_LEFT, false);
}
if (m_keys & CAMERA_KEY_RIGHT)
{
// m_eye -= right * _deltaTime * m_moveSpeed
float tmpRhs[3];
float tmpPos[3];
memcpy(tmpPos, m_eye, sizeof(float)*3);
vec3Mul(tmpRhs, right, _deltaTime * m_moveSpeed);
vec3Sub(m_eye, tmpPos, tmpRhs);
setKeyState(CAMERA_KEY_RIGHT, false);
}
vec3Add(m_at, m_eye, direction);
vec3Cross(m_up, right, direction);
}
void splitFacesFromEquilateral(T *_data, unsigned int _width, unsigned int _height, Face<T> **_faces ) {
// Alloc data.
const uint32_t faceWidth = (_height + 1)/2;
const uint32_t faceHeight = faceWidth;
// Get source parameters.
const float srcWidthMinusOne = float(int(_width-1));
const float srcHeightMinusOne = float(int(_height-1));
const float invfaceWidthf = 1.0f/float(faceWidth);
for (int i = 0; i < 6; i++) {
_faces[i] = new Face<T>();
_faces[i]->id = i;
_faces[i]->data = new T[3 * faceWidth * faceHeight];
_faces[i]->width = faceWidth;
_faces[i]->height = faceHeight;
_faces[i]->currentOffset = 0;
for (uint32_t yy = 0; yy < faceHeight; ++yy) {
T* dstRowData = &_faces[i]->data[yy * faceWidth * 3];
for (uint32_t xx = 0; xx < faceWidth; ++xx) {
T* dstColumnData = &dstRowData[xx * 3];
// Cubemap (u,v) on current face.
const float uu = 2.0f*xx*invfaceWidthf-1.0f;
const float vv = 2.0f*yy*invfaceWidthf-1.0f;
// Get cubemap vector (x,y,z) from (u,v,faceIdx).
float vec[3];
texelCoordToVec(vec, uu, vv, i);
// Convert cubemap vector (x,y,z) to latlong (u,v).
float xSrcf;
float ySrcf;
latLongFromVec(xSrcf, ySrcf, vec);
// Convert from [0..1] to [0..(size-1)] range.
xSrcf *= srcWidthMinusOne;
ySrcf *= srcHeightMinusOne;
// Sample from latlong (u,v).
#ifdef USE_BILINEAR_INTERPOLATION
const uint32_t x0 = ftou(xSrcf);
const uint32_t y0 = ftou(ySrcf);
const uint32_t x1 = M_MIN(x0+1, _width-1);
const uint32_t y1 = M_MIN(y0+1, _height-1);
const T *src0 = &_data[y0 * _width * 3 + x0 * 3];
const T *src1 = &_data[y0 * _width * 3 + x1 * 3];
const T *src2 = &_data[y1 * _width * 3 + x0 * 3];
const T *src3 = &_data[y1 * _width * 3 + x1 * 3];
const float tx = xSrcf - float(int(x0));
const float ty = ySrcf - float(int(y0));
const float invTx = 1.0f - tx;
const float invTy = 1.0f - ty;
T p0[3];
T p1[3];
T p2[3];
T p3[3];
vec3Mul(p0, src0, invTx*invTy);
vec3Mul(p1, src1, tx*invTy);
vec3Mul(p2, src2, invTx* ty);
vec3Mul(p3, src3, tx* ty);
const T rr = p0[0] + p1[0] + p2[0] + p3[0];
const T gg = p0[1] + p1[1] + p2[1] + p3[1];
const T bb = p0[2] + p1[2] + p2[2] + p3[2];
dstColumnData[0] = rr;
dstColumnData[1] = gg;
dstColumnData[2] = bb;
#else
const uint32_t xSrc = ftou(xSrcf);
const uint32_t ySrc = ftou(ySrcf);
dstColumnData[0] = _data[ySrc * _width * 3 + xSrc * 3 + 0];
dstColumnData[1] = _data[ySrc * _width * 3 + xSrc * 3 + 1];
dstColumnData[2] = _data[ySrc * _width * 3 + xSrc * 3 + 2];
#endif
}
}
}
}
