diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 01e094e786..a33b4898b6 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -3357,7 +3357,7 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs auto skyStage = DependencyManager::get()->getSkyStage(); DependencyManager::get()->setGlobalLight(skyStage->getSunLight()->getDirection(), skyStage->getSunLight()->getColor(), skyStage->getSunLight()->getIntensity(), skyStage->getSunLight()->getAmbientIntensity()); DependencyManager::get()->setGlobalAtmosphere(skyStage->getAtmosphere()); - // NOt yet DependencyManager::get()->setGlobalSkybox(skybox); + DependencyManager::get()->setGlobalSkybox(skybox); PROFILE_RANGE("DeferredLighting"); PerformanceTimer perfTimer("lighting"); diff --git a/libraries/gpu/src/gpu/Texture.h b/libraries/gpu/src/gpu/Texture.h index e4f66c94e6..5d094ddbb4 100755 --- a/libraries/gpu/src/gpu/Texture.h +++ b/libraries/gpu/src/gpu/Texture.h @@ -127,7 +127,7 @@ public: CUBE_FACE_LEFT_NEG_X, CUBE_FACE_TOP_POS_Y, CUBE_FACE_BOTTOM_NEG_Y, - CUBE_FACE_BACK_POS_X, + CUBE_FACE_BACK_POS_Z, CUBE_FACE_FRONT_NEG_Z, NUM_CUBE_FACES, // Not a valid vace index diff --git a/libraries/model/src/model/Light.cpp b/libraries/model/src/model/Light.cpp index 6460e0b316..9a2af11664 100755 --- a/libraries/model/src/model/Light.cpp +++ b/libraries/model/src/model/Light.cpp @@ -99,3 +99,6 @@ void Light::setShowContour(float show) { } editSchema()._control.w = show; } + + + diff --git a/libraries/model/src/model/Light.h b/libraries/model/src/model/Light.h index 18d8cc5001..abcb06181f 100755 --- a/libraries/model/src/model/Light.h +++ b/libraries/model/src/model/Light.h @@ -180,6 +180,7 @@ public: } } }; +typedef std::shared_ptr< SphericalHarmonics > SHPointer; class Light { public: diff --git a/libraries/model/src/model/Skybox.cpp b/libraries/model/src/model/Skybox.cpp index 1a54ebd955..7ec15eb008 100755 --- a/libraries/model/src/model/Skybox.cpp +++ b/libraries/model/src/model/Skybox.cpp @@ -49,6 +49,9 @@ void Skybox::clearCubemap() { void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Skybox& skybox) { if (skybox.getCubemap() && skybox.getCubemap()->isDefined()) { + + skybox.getAmbientSH(); + static gpu::PipelinePointer thePipeline; static gpu::BufferPointer theBuffer; static gpu::Stream::FormatPointer theFormat; @@ -113,3 +116,252 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky batch.clearFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, glm::vec4(skybox.getColor(),1.0f), 0.f, 0); } } + + + +void sphericalHarmonicsAdd(float * result, int order, + const float * inputA, const float * inputB) +{ + const int numCoeff = order * order; + for(int i=0; i < numCoeff; i++) + { + result[i] = inputA[i] + inputB[i]; + } +} + +void sphericalHarmonicsScale(float * result, int order, + const float * input, float scale) +{ + const int numCoeff = order * order; + for(int i=0; i < numCoeff; i++) + { + result[i] = input[i] * scale; + } +} + +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); +} + +void sphericalHarmonicsFromTexture(const gpu::Texture& cubeTexture, + std::vector & output, const uint order) +{ + const uint sqOrder = order*order; + + // allocate memory for calculations + output.resize(sqOrder); + std::vector resultR(sqOrder); + std::vector resultG(sqOrder); + std::vector 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 shBuff(sqOrder); + std::vector 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); + + width = height = cubeTexture.getWidth(); + if(width != height) + { + return; + } + + + numComponents = cubeTexture.accessStoredMipFace(0,face)->_format.getDimensionCount(); + + auto data = cubeTexture.accessStoredMipFace(0,face)->_sysmem.readData(); + + // 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 y=0; y < width; y++) + { + // texture coordinate V in range [-1 to 1] + const float fV = negativeBound + float(y) * invWidthBy2; + + 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]) / 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()) / 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, 2); + + _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; +} diff --git a/libraries/model/src/model/Skybox.h b/libraries/model/src/model/Skybox.h index b739032f39..c66cbfb627 100755 --- a/libraries/model/src/model/Skybox.h +++ b/libraries/model/src/model/Skybox.h @@ -13,6 +13,8 @@ #include "gpu/Texture.h" +#include "Light.h" + class ViewFrustum; //class Transform; namespace gpu { class Batch; } @@ -34,11 +36,16 @@ public: const gpu::TexturePointer& getCubemap() const { return _cubemap; } void clearCubemap(); + const SphericalHarmonics& getAmbientSH() const; + static void render(gpu::Batch& batch, const ViewFrustum& frustum, const Skybox& skybox); protected: gpu::TexturePointer _cubemap; + mutable SphericalHarmonics _ambientSH; + mutable bool _isSHValid = false; + Color _color{1.0f, 1.0f, 1.0f}; }; typedef std::shared_ptr< Skybox > SkyboxPointer;