void consumeOrbit(float _amount)
{
float consume[2];
consume[0] = m_orbit[0]*_amount;
consume[1] = m_orbit[1]*_amount;
m_orbit[0] -= consume[0];
m_orbit[1] -= consume[1];
const float toPos[3] =
{
m_pos.curr[0] - m_target.curr[0],
m_pos.curr[1] - m_target.curr[1],
m_pos.curr[2] - m_target.curr[2],
};
const float toPosLen = bx::vec3Length(toPos);
const float invToPosLen = 1.0f/(toPosLen+FLT_MIN);
const float toPosNorm[3] =
{
toPos[0]*invToPosLen,
toPos[1]*invToPosLen,
toPos[2]*invToPosLen,
};
float ll[2];
latLongFromVec(ll[0], ll[1], toPosNorm);
ll[0] += consume[0];
ll[1] -= consume[1];
ll[1] = bx::fclamp(ll[1], 0.02f, 0.98f);
float tmp[3];
vecFromLatLong(tmp, ll[0], ll[1]);
float diff[3];
diff[0] = (tmp[0]-toPosNorm[0])*toPosLen;
diff[1] = (tmp[1]-toPosNorm[1])*toPosLen;
diff[2] = (tmp[2]-toPosNorm[2])*toPosLen;
m_pos.curr[0] += diff[0];
m_pos.curr[1] += diff[1];
m_pos.curr[2] += diff[2];
m_pos.dest[0] += diff[0];
m_pos.dest[1] += diff[1];
m_pos.dest[2] += diff[2];
}
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
}
}
}
}
