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 } } } }