/** * @file llvosky.h * @brief LLVOSky class header file * * $LicenseInfo:firstyear=2001&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #ifndef LL_LLVOSKY_H #define LL_LLVOSKY_H #include "stdtypes.h" #include "v3color.h" #include "v4coloru.h" #include "llquaternion.h" #include "llviewertexture.h" #include "llviewerobject.h" #include "llframetimer.h" #include "v3colorutil.h" #include "llsettingssky.h" #include "lllegacyatmospherics.h" const F32 SKY_BOX_MULT = 16.0f; const F32 HEAVENLY_BODY_DIST = HORIZON_DIST - 20.f; const F32 HEAVENLY_BODY_FACTOR = 0.1f; const F32 HEAVENLY_BODY_SCALE = HEAVENLY_BODY_DIST * HEAVENLY_BODY_FACTOR; const F32 SKYTEX_COMPONENTS = 4; const F32 SKYTEX_RESOLUTION = 64; class LLFace; class LLHaze; class LLSkyTex { friend class LLVOSky; private: LLPointer<LLViewerTexture> mTexture[2]; LLPointer<LLImageRaw> mImageRaw[2]; LLColor4 *mSkyData; LLVector3 *mSkyDirs; // Cache of sky direction vectors static S32 sCurrent; public: void bindTexture(bool curr = true); protected: LLSkyTex(); void init(bool isShiny); void cleanupGL(); void restoreGL(); ~LLSkyTex(); static S32 getResolution(); static S32 getCurrent(); static S32 stepCurrent(); static S32 getNext(); static S32 getWhich(const bool curr); void initEmpty(const S32 tex); void create(); void setDir(const LLVector3 &dir, const S32 i, const S32 j) { S32 offset = (S32)(i * SKYTEX_RESOLUTION + j); mSkyDirs[offset] = dir; } const LLVector3 &getDir(const S32 i, const S32 j) const { S32 offset = (S32)(i * SKYTEX_RESOLUTION + j); return mSkyDirs[offset]; } void setPixel(const LLColor4 &col, const S32 i, const S32 j) { S32 offset = (S32)(i * SKYTEX_RESOLUTION + j); mSkyData[offset] = col; } void setPixel(const LLColor4U &col, const S32 i, const S32 j) { LLImageDataSharedLock lock(mImageRaw[sCurrent]); S32 offset = (S32)((i * SKYTEX_RESOLUTION + j) * SKYTEX_COMPONENTS); U32* pix = (U32*) &(mImageRaw[sCurrent]->getData()[offset]); *pix = col.asRGBA(); } LLColor4U getPixel(const S32 i, const S32 j) { LLColor4U col; LLImageDataSharedLock lock(mImageRaw[sCurrent]); S32 offset = (S32)((i * SKYTEX_RESOLUTION + j) * SKYTEX_COMPONENTS); U32* pix = (U32*) &(mImageRaw[sCurrent]->getData()[offset]); col.fromRGBA( *pix ); return col; } LLImageRaw* getImageRaw(bool curr=true); void createGLImage(S32 which); bool mIsShiny; }; /// TODO Move into the stars draw pool (and rename them appropriately). class LLHeavenBody { protected: LLVector3 mDirectionCached; // hack for events that shouldn't happen every frame LLColor3 mColor; LLColor3 mColorCached; F32 mIntensity; LLVector3 mDirection; // direction of the local heavenly body LLQuaternion mRotation; LLVector3 mAngularVelocity; // velocity of the local heavenly body F32 mDiskRadius; bool mDraw; // false - do not draw. F32 mHorizonVisibility; // number [0, 1] due to how horizon F32 mVisibility; // same but due to other objects being in throng. bool mVisible; static F32 sInterpVal; LLVector3 mQuadCorner[4]; LLVector3 mO; public: LLHeavenBody(const F32 rad); ~LLHeavenBody() {} const LLQuaternion& getRotation() const; void setRotation(const LLQuaternion& rot); const LLVector3& getDirection() const; void setDirection(const LLVector3 &direction); void setAngularVelocity(const LLVector3 &ang_vel); const LLVector3& getAngularVelocity() const; const LLVector3& getDirectionCached() const; void renewDirection(); const LLColor3& getColorCached() const; void setColorCached(const LLColor3& c); const LLColor3& getColor() const; void setColor(const LLColor3& c); void renewColor(); static F32 interpVal(); static void setInterpVal(const F32 v); LLColor3 getInterpColor() const; const F32& getVisibility() const; void setVisibility(const F32 c = 1); bool isVisible() const; void setVisible(const bool v); const F32& getIntensity() const; void setIntensity(const F32 c); void setDiskRadius(const F32 radius); F32 getDiskRadius() const; void setDraw(const bool draw); bool getDraw() const; const LLVector3& corner(const S32 n) const; LLVector3& corner(const S32 n); const LLVector3* corners() const; }; class LLCubeMap; class LLVOSky : public LLStaticViewerObject { public: enum { FACE_SIDE0, FACE_SIDE1, FACE_SIDE2, FACE_SIDE3, FACE_SIDE4, FACE_SIDE5, FACE_SUN, // was 6 FACE_MOON, // was 7 FACE_BLOOM, // was 8 FACE_REFLECTION, // was 10 FACE_COUNT }; LLVOSky(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp); // Initialize/delete data that's only inited once per class. void init(); void initCubeMap(); void cleanupGL(); void restoreGL(); void calc(); void cacheEnvironment(LLSettingsSky::ptr_t psky, AtmosphericsVars& atmosphericsVars); /*virtual*/ void idleUpdate(LLAgent &agent, const F64 &time); bool updateSky(); // Graphical stuff for objects - maybe broken out into render class // later? /*virtual*/ void updateTextures(); /*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline); /*virtual*/ bool updateGeometry(LLDrawable *drawable); const LLHeavenBody& getSun() const { return mSun; } const LLHeavenBody& getMoon() const { return mMoon; } bool isSameFace(S32 idx, const LLFace* face) const { return mFace[idx] == face; } // directions provided should already be in CFR coord sys (+x at, +z up, +y right) void setSunAndMoonDirectionsCFR(const LLVector3 &sun_dir, const LLVector3 &moon_dir); void setSunDirectionCFR(const LLVector3 &sun_direction); void setMoonDirectionCFR(const LLVector3 &moon_direction); bool updateHeavenlyBodyGeometry(LLDrawable *drawable, F32 scale, const S32 side, LLHeavenBody& hb, const LLVector3 &up, const LLVector3 &right); void updateReflectionGeometry(LLDrawable *drawable, F32 H, const LLHeavenBody& HB); F32 getWorldScale() const { return mWorldScale; } void setWorldScale(const F32 s) { mWorldScale = s; } void updateFog(const F32 distance); void setFogRatio(const F32 fog_ratio) { m_legacyAtmospherics.setFogRatio(fog_ratio); } F32 getFogRatio() const { return m_legacyAtmospherics.getFogRatio(); } LLColor4 getSkyFogColor() const { return m_legacyAtmospherics.getFogColor(); } LLColor4 getGLFogColor() const { return m_legacyAtmospherics.getGLFogColor(); } void setCloudDensity(F32 cloud_density) { mCloudDensity = cloud_density; } void setWind ( const LLVector3& wind ) { mWind = wind.length(); } const LLVector3 &getCameraPosAgent() const { return mCameraPosAgent; } LLVector3 getEarthCenter() const { return mEarthCenter; } LLCubeMap *getCubeMap() const { return mCubeMap; } S32 getDrawRefl() const { return mDrawRefl; } void setDrawRefl(const S32 r) { mDrawRefl = r; } bool isReflFace(const LLFace* face) const { return face == mFace[FACE_REFLECTION]; } LLFace* getReflFace() const { return mFace[FACE_REFLECTION]; } LLViewerTexture* getSunTex() const { return mSunTexturep[0]; } LLViewerTexture* getMoonTex() const { return mMoonTexturep[0]; } LLViewerTexture* getBloomTex() const { return mBloomTexturep[0]; } LLViewerTexture* getCloudNoiseTex() const { return mCloudNoiseTexturep[0]; } LLViewerTexture* getRainbowTex() const { return mRainbowMap; } LLViewerTexture* getHaloTex() const { return mHaloMap; } LLViewerTexture* getSunTexNext() const { return mSunTexturep[1]; } LLViewerTexture* getMoonTexNext() const { return mMoonTexturep[1]; } LLViewerTexture* getBloomTexNext() const { return mBloomTexturep[1]; } LLViewerTexture* getCloudNoiseTexNext() const { return mCloudNoiseTexturep[1]; } void setSunTextures(const LLUUID& sun_texture, const LLUUID& sun_texture_next); void setMoonTextures(const LLUUID& moon_texture, const LLUUID& moon_texture_next); void setCloudNoiseTextures(const LLUUID& cloud_noise_texture, const LLUUID& cloud_noise_texture_next); void setBloomTextures(const LLUUID& bloom_texture, const LLUUID& bloom_texture_next); void setSunScale(F32 sun_scale); void setMoonScale(F32 sun_scale); void forceSkyUpdate(void); public: LLFace *mFace[FACE_COUNT]; LLVector3 mBumpSunDir; F32 getInterpVal() const { return mInterpVal; } protected: ~LLVOSky(); void updateDirections(LLSettingsSky::ptr_t psky); void initSkyTextureDirs(const S32 side, const S32 tile); void createSkyTexture(const LLSettingsSky::ptr_t &psky, AtmosphericsVars& vars, const S32 side, const S32 tile); LLPointer<LLViewerFetchedTexture> mSunTexturep[2]; LLPointer<LLViewerFetchedTexture> mMoonTexturep[2]; LLPointer<LLViewerFetchedTexture> mCloudNoiseTexturep[2]; LLPointer<LLViewerFetchedTexture> mBloomTexturep[2]; LLPointer<LLViewerFetchedTexture> mRainbowMap; LLPointer<LLViewerFetchedTexture> mHaloMap; F32 mSunScale = 1.0f; F32 mMoonScale = 1.0f; static S32 sResolution; static S32 sTileResX; static S32 sTileResY; LLSkyTex mSkyTex[6]; LLSkyTex mShinyTex[6]; LLHeavenBody mSun; LLHeavenBody mMoon; LLVector3 mSunDefaultPosition; LLVector3 mSunAngVel; F32 mAtmHeight; LLVector3 mEarthCenter; LLVector3 mCameraPosAgent; F32 mBrightnessScale; LLColor3 mBrightestPoint; F32 mBrightnessScaleNew; LLColor3 mBrightestPointNew; F32 mBrightnessScaleGuess; LLColor3 mBrightestPointGuess; bool mWeatherChange; F32 mCloudDensity; F32 mWind; bool mInitialized; bool mForceUpdate; bool mNeedUpdate; // flag to force update of cubemap S32 mCubeMapUpdateStage; // state of cubemap uodate: -1 idle; 0-5 per-face updates; 6 finalizing F32 mAmbientScale; LLColor3 mNightColorShift; F32 mInterpVal; F32 mWorldScale; LLPointer<LLCubeMap> mCubeMap; // Cube map for the environment S32 mDrawRefl; LLFrameTimer mUpdateTimer; LLTimer mForceUpdateThrottle; bool mHeavenlyBodyUpdated ; AtmosphericsVars m_atmosphericsVars; AtmosphericsVars m_lastAtmosphericsVars; LLAtmospherics m_legacyAtmospherics; }; #endif