mirror of
https://github.com/overte-org/overte.git
synced 2025-04-15 19:39:20 +02:00
cleaning up the SH generation
This commit is contained in:
Sam Cake
parent
8324268ec8
commit
238d3751c5
4 changed files with 233 additions and 223 deletions
|
|
@ -53,7 +53,7 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky
|
|||
|
||||
if (skybox.getCubemap() && skybox.getCubemap()->isDefined()) {
|
||||
|
||||
skybox.getAmbientSH();
|
||||
skybox.getIrradianceSH();
|
||||
|
||||
static gpu::PipelinePointer thePipeline;
|
||||
static gpu::BufferPointer theBuffer;
|
||||
|
|
@ -121,250 +121,221 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky
|
|||
}
|
||||
|
||||
|
||||
glm::vec3 sRGBToLinear(glm::vec3& color) {
|
||||
const float GAMMA_CORRECTION = 2.2f;
|
||||
return glm::pow(color, glm::vec3(GAMMA_CORRECTION));
|
||||
}
|
||||
|
||||
void sphericalHarmonicsAdd(float * result, int order,
|
||||
const float * inputA, const float * inputB)
|
||||
{
|
||||
glm::vec3 linearTosRGB(glm::vec3& color) {
|
||||
const float GAMMA_CORRECTION_INV = 1.0f / 2.2f;
|
||||
return glm::pow(color, glm::vec3(GAMMA_CORRECTION_INV));
|
||||
}
|
||||
|
||||
// Originial code for the Spherical Harmonics taken from "Sun and Black Cat- Igor Dykhta (igor dykhta email) © 2007-2014 "
|
||||
void sphericalHarmonicsAdd(float * result, int order, const float * inputA, const float * inputB) {
|
||||
const int numCoeff = order * order;
|
||||
for(int i=0; i < numCoeff; i++)
|
||||
{
|
||||
for(int i=0; i < numCoeff; i++) {
|
||||
result[i] = inputA[i] + inputB[i];
|
||||
}
|
||||
}
|
||||
|
||||
void sphericalHarmonicsScale(float * result, int order,
|
||||
const float * input, float scale)
|
||||
{
|
||||
void sphericalHarmonicsScale(float * result, int order, const float * input, float scale) {
|
||||
const int numCoeff = order * order;
|
||||
for(int i=0; i < numCoeff; i++)
|
||||
{
|
||||
for(int i=0; i < numCoeff; i++) {
|
||||
result[i] = input[i] * scale;
|
||||
}
|
||||
}
|
||||
|
||||
void sphericalHarmonicsEvaluateDirection(float * result, int order,
|
||||
const glm::vec3 & dir)
|
||||
{
|
||||
void sphericalHarmonicsEvaluateDirection(float * result, int order, const glm::vec3 & dir) {
|
||||
// calculate coefficients for first 3 bands of spherical harmonics
|
||||
double p_0_0 = 0.282094791773878140;
|
||||
double p_1_0 = 0.488602511902919920 * dir.z;
|
||||
double p_1_1 = -0.488602511902919920;
|
||||
double p_2_0 = 0.946174695757560080 * dir.z * dir.z - 0.315391565252520050;
|
||||
double p_2_1 = -1.092548430592079200 * dir.z;
|
||||
double p_2_2 = 0.546274215296039590;
|
||||
result[0] = p_0_0;
|
||||
result[1] = p_1_1 * dir.y;
|
||||
result[2] = p_1_0;
|
||||
result[3] = p_1_1 * dir.x;
|
||||
result[4] = p_2_2 * (dir.x * dir.y + dir.y * dir.x);
|
||||
result[5] = p_2_1 * dir.y;
|
||||
result[6] = p_2_0;
|
||||
result[7] = p_2_1 * dir.x;
|
||||
result[8] = p_2_2 * (dir.x * dir.x - dir.y * dir.y);
|
||||
double P_0_0 = 0.282094791773878140;
|
||||
double P_1_0 = 0.488602511902919920 * dir.z;
|
||||
double P_1_1 = -0.488602511902919920;
|
||||
double P_2_0 = 0.946174695757560080 * dir.z * dir.z - 0.315391565252520050;
|
||||
double P_2_1 = -1.092548430592079200 * dir.z;
|
||||
double P_2_2 = 0.546274215296039590;
|
||||
result[0] = P_0_0;
|
||||
result[1] = P_1_1 * dir.y;
|
||||
result[2] = P_1_0;
|
||||
result[3] = P_1_1 * dir.x;
|
||||
result[4] = P_2_2 * (dir.x * dir.y + dir.y * dir.x);
|
||||
result[5] = P_2_1 * dir.y;
|
||||
result[6] = P_2_0;
|
||||
result[7] = P_2_1 * dir.x;
|
||||
result[8] = P_2_2 * (dir.x * dir.x - dir.y * dir.y);
|
||||
}
|
||||
|
||||
void sphericalHarmonicsFromTexture(const gpu::Texture& cubeTexture,
|
||||
std::vector<glm::vec3> & output, const uint order)
|
||||
{
|
||||
const uint sqOrder = order*order;
|
||||
void sphericalHarmonicsFromTexture(const gpu::Texture& cubeTexture, std::vector<glm::vec3> & output, const uint order) {
|
||||
const uint sqOrder = order*order;
|
||||
|
||||
// allocate memory for calculations
|
||||
output.resize(sqOrder);
|
||||
std::vector<float> resultR(sqOrder);
|
||||
std::vector<float> resultG(sqOrder);
|
||||
std::vector<float> resultB(sqOrder);
|
||||
// allocate memory for calculations
|
||||
output.resize(sqOrder);
|
||||
std::vector<float> resultR(sqOrder);
|
||||
std::vector<float> resultG(sqOrder);
|
||||
std::vector<float> resultB(sqOrder);
|
||||
|
||||
// variables that describe current face of cube texture
|
||||
//std::unique_ptr data;
|
||||
GLint width, height;
|
||||
GLint internalFormat;
|
||||
GLint numComponents;
|
||||
|
||||
// initialize values
|
||||
float fWt = 0.0f;
|
||||
for(uint i=0; i < sqOrder; i++)
|
||||
{
|
||||
output[i].x = 0;
|
||||
output[i].y = 0;
|
||||
output[i].z = 0;
|
||||
resultR[i] = 0;
|
||||
resultG[i] = 0;
|
||||
resultB[i] = 0;
|
||||
}
|
||||
std::vector<float> shBuff(sqOrder);
|
||||
std::vector<float> shBuffB(sqOrder);
|
||||
|
||||
// bind current texture
|
||||
// glBindTexture(GL_TEXTURE_CUBE_MAP, cubeTexture->texture());
|
||||
// for each face of cube texture
|
||||
for(int face=0; face < 6; face++)
|
||||
{
|
||||
// get width and height
|
||||
// glGetTexLevelParameteriv(cubeSides[face], 0, GL_TEXTURE_WIDTH, &width);
|
||||
// glGetTexLevelParameteriv(cubeSides[face], 0, GL_TEXTURE_HEIGHT, &height);
|
||||
int width, height;
|
||||
|
||||
// initialize values
|
||||
float fWt = 0.0f;
|
||||
for(uint i=0; i < sqOrder; i++) {
|
||||
output[i] = glm::vec3(0.0f);
|
||||
resultR[i] = 0.0f;
|
||||
resultG[i] = 0;
|
||||
resultB[i] = 0;
|
||||
}
|
||||
std::vector<float> shBuff(sqOrder);
|
||||
std::vector<float> shBuffB(sqOrder);
|
||||
// get width and height
|
||||
width = height = cubeTexture.getWidth();
|
||||
if(width != height)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if(width != height) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
numComponents = cubeTexture.accessStoredMipFace(0,face)->_format.getDimensionCount();
|
||||
const float UCHAR_TO_FLOAT = 1.0f / float(std::numeric_limits<unsigned char>::max());
|
||||
|
||||
auto data = cubeTexture.accessStoredMipFace(0,face)->_sysmem.readData();
|
||||
// for each face of cube texture
|
||||
for(int face=0; face < gpu::Texture::NUM_CUBE_FACES; face++) {
|
||||
|
||||
// step between two texels for range [0, 1]
|
||||
float invWidth = 1.0f / float(width);
|
||||
// initial negative bound for range [-1, 1]
|
||||
float negativeBound = -1.0f + invWidth;
|
||||
// step between two texels for range [-1, 1]
|
||||
float invWidthBy2 = 2.0f / float(width);
|
||||
auto numComponents = cubeTexture.accessStoredMipFace(0,face)->_format.getDimensionCount();
|
||||
auto data = cubeTexture.accessStoredMipFace(0,face)->_sysmem.readData();
|
||||
if (data == nullptr) {
|
||||
continue;
|
||||
}
|
||||
|
||||
for(int y=0; y < width; y++)
|
||||
{
|
||||
// texture coordinate V in range [-1 to 1]
|
||||
const float fV = negativeBound + float(y) * invWidthBy2;
|
||||
// step between two texels for range [0, 1]
|
||||
float invWidth = 1.0f / float(width);
|
||||
// initial negative bound for range [-1, 1]
|
||||
float negativeBound = -1.0f + invWidth;
|
||||
// step between two texels for range [-1, 1]
|
||||
float invWidthBy2 = 2.0f / float(width);
|
||||
|
||||
for(int x=0; x < width; x++)
|
||||
{
|
||||
// texture coordinate U in range [-1 to 1]
|
||||
const float fU = negativeBound + float(x) * invWidthBy2;
|
||||
for(int y=0; y < width; y++) {
|
||||
// texture coordinate V in range [-1 to 1]
|
||||
const float fV = negativeBound + float(y) * invWidthBy2;
|
||||
|
||||
// determine direction from center of cube texture to current texel
|
||||
glm::vec3 dir;
|
||||
switch(face)
|
||||
{
|
||||
case gpu::Texture::CUBE_FACE_RIGHT_POS_X:
|
||||
dir.x = 1.0f;
|
||||
dir.y = 1.0f - (invWidthBy2 * float(y) + invWidth);
|
||||
dir.z = 1.0f - (invWidthBy2 * float(x) + invWidth);
|
||||
dir = -dir;
|
||||
break;
|
||||
case gpu::Texture::CUBE_FACE_LEFT_NEG_X:
|
||||
dir.x = -1.0f;
|
||||
dir.y = 1.0f - (invWidthBy2 * float(y) + invWidth);
|
||||
dir.z = -1.0f + (invWidthBy2 * float(x) + invWidth);
|
||||
dir = -dir;
|
||||
break;
|
||||
case gpu::Texture::CUBE_FACE_TOP_POS_Y:
|
||||
dir.x = - 1.0f + (invWidthBy2 * float(x) + invWidth);
|
||||
dir.y = 1.0f;
|
||||
dir.z = - 1.0f + (invWidthBy2 * float(y) + invWidth);
|
||||
dir = -dir;
|
||||
break;
|
||||
case gpu::Texture::CUBE_FACE_BOTTOM_NEG_Y:
|
||||
dir.x = - 1.0f + (invWidthBy2 * float(x) + invWidth);
|
||||
dir.y = - 1.0f;
|
||||
dir.z = 1.0f - (invWidthBy2 * float(y) + invWidth);
|
||||
dir = -dir;
|
||||
break;
|
||||
case gpu::Texture::CUBE_FACE_BACK_POS_Z:
|
||||
dir.x = - 1.0f + (invWidthBy2 * float(x) + invWidth);
|
||||
dir.y = 1.0f - (invWidthBy2 * float(y) + invWidth);
|
||||
dir.z = 1.0f;
|
||||
break;
|
||||
case gpu::Texture::CUBE_FACE_FRONT_NEG_Z:
|
||||
dir.x = 1.0f - (invWidthBy2 * float(x) + invWidth);
|
||||
dir.y = 1.0f - (invWidthBy2 * float(y) + invWidth);
|
||||
dir.z = - 1.0f;
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
for(int x=0; x < width; x++) {
|
||||
// texture coordinate U in range [-1 to 1]
|
||||
const float fU = negativeBound + float(x) * invWidthBy2;
|
||||
|
||||
// determine direction from center of cube texture to current texel
|
||||
glm::vec3 dir;
|
||||
switch(face) {
|
||||
case gpu::Texture::CUBE_FACE_RIGHT_POS_X: {
|
||||
dir.x = 1.0f;
|
||||
dir.y = 1.0f - (invWidthBy2 * float(y) + invWidth);
|
||||
dir.z = 1.0f - (invWidthBy2 * float(x) + invWidth);
|
||||
dir = -dir;
|
||||
break;
|
||||
}
|
||||
case gpu::Texture::CUBE_FACE_LEFT_NEG_X: {
|
||||
dir.x = -1.0f;
|
||||
dir.y = 1.0f - (invWidthBy2 * float(y) + invWidth);
|
||||
dir.z = -1.0f + (invWidthBy2 * float(x) + invWidth);
|
||||
dir = -dir;
|
||||
break;
|
||||
}
|
||||
case gpu::Texture::CUBE_FACE_TOP_POS_Y: {
|
||||
dir.x = - 1.0f + (invWidthBy2 * float(x) + invWidth);
|
||||
dir.y = 1.0f;
|
||||
dir.z = - 1.0f + (invWidthBy2 * float(y) + invWidth);
|
||||
dir = -dir;
|
||||
break;
|
||||
}
|
||||
case gpu::Texture::CUBE_FACE_BOTTOM_NEG_Y: {
|
||||
dir.x = - 1.0f + (invWidthBy2 * float(x) + invWidth);
|
||||
dir.y = - 1.0f;
|
||||
dir.z = 1.0f - (invWidthBy2 * float(y) + invWidth);
|
||||
dir = -dir;
|
||||
break;
|
||||
}
|
||||
case gpu::Texture::CUBE_FACE_BACK_POS_Z: {
|
||||
dir.x = - 1.0f + (invWidthBy2 * float(x) + invWidth);
|
||||
dir.y = 1.0f - (invWidthBy2 * float(y) + invWidth);
|
||||
dir.z = 1.0f;
|
||||
break;
|
||||
}
|
||||
case gpu::Texture::CUBE_FACE_FRONT_NEG_Z: {
|
||||
dir.x = 1.0f - (invWidthBy2 * float(x) + invWidth);
|
||||
dir.y = 1.0f - (invWidthBy2 * float(y) + invWidth);
|
||||
dir.z = - 1.0f;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
||||
// normalize direction
|
||||
dir = glm::normalize(dir);
|
||||
|
||||
// scale factor depending on distance from center of the face
|
||||
const float fDiffSolid = 4.0f / ((1.0f + fU*fU + fV*fV) *
|
||||
sqrtf(1.0f + fU*fU + fV*fV));
|
||||
fWt += fDiffSolid;
|
||||
|
||||
// calculate coefficients of spherical harmonics for current direction
|
||||
sphericalHarmonicsEvaluateDirection(shBuff.data(), order, dir);
|
||||
|
||||
// index of texel in texture
|
||||
uint pixOffsetIndex = (x + y * width) * numComponents;
|
||||
|
||||
// get color from texture and map to range [0, 1]
|
||||
glm::vec3 clr(float(data[pixOffsetIndex]) * UCHAR_TO_FLOAT,
|
||||
float(data[pixOffsetIndex+1]) * UCHAR_TO_FLOAT,
|
||||
float(data[pixOffsetIndex+2]) * UCHAR_TO_FLOAT);
|
||||
|
||||
// Gamma correct
|
||||
clr = sRGBToLinear(clr);
|
||||
|
||||
// scale color and add to previously accumulated coefficients
|
||||
sphericalHarmonicsScale(shBuffB.data(), order,
|
||||
shBuff.data(), clr.r * fDiffSolid);
|
||||
sphericalHarmonicsAdd(resultR.data(), order,
|
||||
resultR.data(), shBuffB.data());
|
||||
sphericalHarmonicsScale(shBuffB.data(), order,
|
||||
shBuff.data(), clr.g * fDiffSolid);
|
||||
sphericalHarmonicsAdd(resultG.data(), order,
|
||||
resultG.data(), shBuffB.data());
|
||||
sphericalHarmonicsScale(shBuffB.data(), order,
|
||||
shBuff.data(), clr.b * fDiffSolid);
|
||||
sphericalHarmonicsAdd(resultB.data(), order,
|
||||
resultB.data(), shBuffB.data());
|
||||
}
|
||||
|
||||
// normalize direction
|
||||
dir = glm::normalize(dir);
|
||||
|
||||
// scale factor depending on distance from center of the face
|
||||
const float fDiffSolid = 4.0f / ((1.0f + fU*fU + fV*fV) *
|
||||
sqrtf(1.0f + fU*fU + fV*fV));
|
||||
fWt += fDiffSolid;
|
||||
|
||||
// calculate coefficients of spherical harmonics for current direction
|
||||
sphericalHarmonicsEvaluateDirection(shBuff.data(), order, dir);
|
||||
|
||||
// index of texel in texture
|
||||
uint pixOffsetIndex = (x + y * width) * numComponents;
|
||||
// get color from texture and map to range [0, 1]
|
||||
glm::vec3 clr(
|
||||
float(data[pixOffsetIndex]) / 255,
|
||||
float(data[pixOffsetIndex+1]) / 255,
|
||||
float(data[pixOffsetIndex+2]) / 255
|
||||
);
|
||||
|
||||
// scale color and add to previously accumulated coefficients
|
||||
sphericalHarmonicsScale(shBuffB.data(), order,
|
||||
shBuff.data(), clr.r * fDiffSolid);
|
||||
sphericalHarmonicsAdd(resultR.data(), order,
|
||||
resultR.data(), shBuffB.data());
|
||||
sphericalHarmonicsScale(shBuffB.data(), order,
|
||||
shBuff.data(), clr.g * fDiffSolid);
|
||||
sphericalHarmonicsAdd(resultG.data(), order,
|
||||
resultG.data(), shBuffB.data());
|
||||
sphericalHarmonicsScale(shBuffB.data(), order,
|
||||
shBuff.data(), clr.b * fDiffSolid);
|
||||
sphericalHarmonicsAdd(resultB.data(), order,
|
||||
resultB.data(), shBuffB.data());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// final scale for coefficients
|
||||
const float fNormProj = (4.0f * glm::pi<float>()) / fWt;
|
||||
sphericalHarmonicsScale(resultR.data(), order, resultR.data(), fNormProj);
|
||||
sphericalHarmonicsScale(resultG.data(), order, resultG.data(), fNormProj);
|
||||
sphericalHarmonicsScale(resultB.data(), order, resultB.data(), fNormProj);
|
||||
|
||||
// save result
|
||||
for(uint i=0; i < sqOrder; i++)
|
||||
{
|
||||
output[i].r = resultR[i];
|
||||
output[i].g = resultG[i];
|
||||
output[i].b = resultB[i];
|
||||
}
|
||||
}
|
||||
/*
|
||||
glm::vec3 sphericalHarmonicsFromTexture(glm::vec3 & N, std::vector & coef)
|
||||
{
|
||||
return
|
||||
|
||||
// constant term, lowest frequency //////
|
||||
C4 * coef[0] +
|
||||
|
||||
// axis aligned terms ///////////////////
|
||||
2.0 * C2 * coef[1] * N.y +
|
||||
2.0 * C2 * coef[2] * N.z +
|
||||
2.0 * C2 * coef[3] * N.x +
|
||||
|
||||
// band 2 terms /////////////////////////
|
||||
2.0 * C1 * coef[4] * N.x * N.y +
|
||||
2.0 * C1 * coef[5] * N.y * N.z +
|
||||
C3 * coef[6] * N.z * N.z - C5 * coef[6] +
|
||||
2.0 * C1 * coef[7] * N.x * N.z +
|
||||
C1 * coef[8] * (N.x * N.x - N.y * N.y);
|
||||
}
|
||||
*/
|
||||
|
||||
const SphericalHarmonics& Skybox::getAmbientSH() const {
|
||||
if (!_isSHValid) {
|
||||
if (_cubemap && _cubemap->isDefined()) {
|
||||
|
||||
std::vector< glm::vec3 > coefs(10, glm::vec3(0.0f));
|
||||
sphericalHarmonicsFromTexture(*_cubemap, coefs, 3);
|
||||
|
||||
_ambientSH.L00 = coefs[0];
|
||||
_ambientSH.L1m1 = coefs[1];
|
||||
_ambientSH.L10 = coefs[2];
|
||||
_ambientSH.L11 = coefs[3];
|
||||
_ambientSH.L2m2 = coefs[4];
|
||||
_ambientSH.L2m1 = coefs[5];
|
||||
_ambientSH.L20 = coefs[6];
|
||||
_ambientSH.L21 = coefs[7];
|
||||
_ambientSH.L22 = coefs[8];
|
||||
|
||||
_isSHValid = true;
|
||||
}
|
||||
}
|
||||
return _ambientSH;
|
||||
|
||||
// final scale for coefficients
|
||||
const float fNormProj = (4.0f * glm::pi<float>()) / fWt;
|
||||
sphericalHarmonicsScale(resultR.data(), order, resultR.data(), fNormProj);
|
||||
sphericalHarmonicsScale(resultG.data(), order, resultG.data(), fNormProj);
|
||||
sphericalHarmonicsScale(resultB.data(), order, resultB.data(), fNormProj);
|
||||
|
||||
// save result
|
||||
for(uint i=0; i < sqOrder; i++) {
|
||||
// gamma Correct
|
||||
// output[i] = linearTosRGB(glm::vec3(resultR[i], resultG[i], resultB[i]));
|
||||
output[i] = glm::vec3(resultR[i], resultG[i], resultB[i]);
|
||||
}
|
||||
}
|
||||
|
||||
const SphericalHarmonics& Skybox::getIrradianceSH() const {
|
||||
if (!_isSHValid) {
|
||||
if (_cubemap && _cubemap->isDefined()) {
|
||||
std::vector< glm::vec3 > coefs;
|
||||
sphericalHarmonicsFromTexture(*_cubemap, coefs, 3);
|
||||
|
||||
_irradianceSH.L00 = coefs[0];
|
||||
_irradianceSH.L1m1 = coefs[1];
|
||||
_irradianceSH.L10 = coefs[2];
|
||||
_irradianceSH.L11 = coefs[3];
|
||||
_irradianceSH.L2m2 = coefs[4];
|
||||
_irradianceSH.L2m1 = coefs[5];
|
||||
_irradianceSH.L20 = coefs[6];
|
||||
_irradianceSH.L21 = coefs[7];
|
||||
_irradianceSH.L22 = coefs[8];
|
||||
|
||||
_isSHValid = true;
|
||||
}
|
||||
}
|
||||
return _irradianceSH;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,14 +36,14 @@ public:
|
|||
const gpu::TexturePointer& getCubemap() const { return _cubemap; }
|
||||
void clearCubemap();
|
||||
|
||||
const SphericalHarmonics& getAmbientSH() const;
|
||||
const SphericalHarmonics& getIrradianceSH() const;
|
||||
|
||||
static void render(gpu::Batch& batch, const ViewFrustum& frustum, const Skybox& skybox);
|
||||
|
||||
protected:
|
||||
gpu::TexturePointer _cubemap;
|
||||
|
||||
mutable SphericalHarmonics _ambientSH;
|
||||
mutable SphericalHarmonics _irradianceSH;
|
||||
mutable bool _isSHValid = false;
|
||||
|
||||
Color _color{1.0f, 1.0f, 1.0f};
|
||||
|
|
|
|||
|
|
@ -293,7 +293,7 @@ void DeferredLightingEffect::render() {
|
|||
if (locations->ambientSphere >= 0) {
|
||||
model::SphericalHarmonics sh;
|
||||
if (useSkyboxCubemap) {
|
||||
sh = _skybox->getAmbientSH();
|
||||
sh = _skybox->getIrradianceSH();
|
||||
} else {
|
||||
sh = globalLight->getAmbientSphere();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -603,6 +603,45 @@ void NetworkTexture::setImage(const QImage& image, bool translucent, const QColo
|
|||
faces.push_back(image.copy(QRect(3 * faceWidth, faceWidth, faceWidth, faceWidth)).mirrored(true, false));
|
||||
// Front = -Z
|
||||
faces.push_back(image.copy(QRect(1 * faceWidth, faceWidth, faceWidth, faceWidth)).mirrored(true, false));
|
||||
|
||||
} else if ((_height / 4) == (_width / 3)) {
|
||||
int faceWidth = _height / 4;
|
||||
|
||||
// Here is the expected layout for the faces in an image with the 4/3 aspect ratio:
|
||||
//
|
||||
// <-------WIDTH-------->
|
||||
// ^ +------+------+------+
|
||||
// | | | | |
|
||||
// | | | +Y | |
|
||||
// | | | | |
|
||||
// H +------+------+------+
|
||||
// E | | | |
|
||||
// I | -X | -Z | +X |
|
||||
// G | | | |
|
||||
// H +------+------+------+
|
||||
// T | | | |
|
||||
// | | | -Y | |
|
||||
// | | | | |
|
||||
// | +------+------+------+
|
||||
// | | | | |
|
||||
// | | | +Z! | | <+Z is upside down!
|
||||
// | | | | |
|
||||
// V +------+------+------+
|
||||
//
|
||||
// FaceWidth = width / 3 = height / 4
|
||||
|
||||
// Right = +X
|
||||
faces.push_back(image.copy(QRect(2 * faceWidth, faceWidth, faceWidth, faceWidth)).mirrored(true, false));
|
||||
// Left = -X
|
||||
faces.push_back(image.copy(QRect(0 * faceWidth, faceWidth, faceWidth, faceWidth)).mirrored(true, false));
|
||||
// Top = +Y
|
||||
faces.push_back(image.copy(QRect(1 * faceWidth, 0, faceWidth, faceWidth)).mirrored(false, true));
|
||||
// Bottom = -Y
|
||||
faces.push_back(image.copy(QRect(1 * faceWidth, 2 * faceWidth, faceWidth, faceWidth)).mirrored(false, true));
|
||||
// Back = +Z
|
||||
faces.push_back(image.copy(QRect(1 * faceWidth, 3 * faceWidth, faceWidth, faceWidth)).mirrored(false, true));
|
||||
// Front = -Z
|
||||
faces.push_back(image.copy(QRect(1 * faceWidth, faceWidth, faceWidth, faceWidth)).mirrored(true, false));
|
||||
}
|
||||
|
||||
if (faces.size() == gpu::Texture::NUM_FACES_PER_TYPE[gpu::Texture::TEX_CUBE]) {
|
||||
|
|
|
|||
Loading…
Reference in a new issue