phoenix-firestorm/indra/newview/lldrawpoolbump.h

/**
 * @file lldrawpoolbump.h
 * @brief LLDrawPoolBump class definition
 *
 * $LicenseInfo:firstyear=2003&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_LLDRAWPOOLBUMP_H
#define LL_LLDRAWPOOLBUMP_H

#include "lldrawpool.h"
#include "llstring.h"
#include "lltextureentry.h"
#include "lluuid.h"

#include <unordered_map>

class LLImageRaw;
class LLSpatialGroup;
class LLDrawInfo;
class LLGLSLShader;
class LLViewerFetchedTexture;

class LLDrawPoolBump : public LLRenderPass
{
protected :
    LLDrawPoolBump(const U32 type):LLRenderPass(type) { mShiny = false; }
public:
    static U32 sVertexMask;
    bool mShiny;

    virtual U32 getVertexDataMask() override { return sVertexMask; }

    LLDrawPoolBump();

    /*virtual*/ void prerender() override;

    void pushBumpBatches(U32 type);
    void renderGroup(LLSpatialGroup* group, U32 type, bool texture) override;

    S32 numBumpPasses();

    void beginFullbrightShiny();
    void renderFullbrightShiny();
    void endFullbrightShiny();

    void beginBump();
    void renderBump(U32 pass = LLRenderPass::PASS_BUMP);
    void endBump(U32 pass = LLRenderPass::PASS_BUMP);

    static void bindCubeMap(LLGLSLShader* shader, S32 shader_level, S32& diffuse_channel, S32& cube_channel);
    static void unbindCubeMap(LLGLSLShader* shader, S32 shader_level, S32& diffuse_channel, S32& cube_channel);

    virtual S32 getNumDeferredPasses() override;
    /*virtual*/ void renderDeferred(S32 pass) override;

    virtual S32 getNumPostDeferredPasses() override { return 1; }
    /*virtual*/ void renderPostDeferred(S32 pass) override;

    static bool bindBumpMap(LLDrawInfo& params, S32 channel = -2);
    static bool bindBumpMap(LLFace* face, S32 channel = -2);

private:
    static bool bindBumpMap(U8 bump_code, LLViewerTexture* tex, S32 channel);
    bool mRigged = false; // if true, doing a rigged pass

};

enum EBumpEffect
{
    BE_NO_BUMP = 0,
    BE_BRIGHTNESS = 1,
    BE_DARKNESS = 2,
    BE_STANDARD_0 = 3,  // Standard must always be the last one
    BE_COUNT = 4
};

////////////////////////////////////////////////////////////////
// List of standard bumpmaps that are specificed by LLTextureEntry::mBump's lower bits

class LLStandardBumpmap
{
public:
    LLStandardBumpmap() : mLabel() {}
    LLStandardBumpmap( const std::string& label ) : mLabel(label) {}

    std::string mLabel;
    LLPointer<LLViewerFetchedTexture> mImage;

    static  U32 sStandardBumpmapCount;  // Number of valid values in gStandardBumpmapList[]

    static void clear();
    static void addstandard();

    static void shutdown();
    static void restoreGL();
    static void destroyGL();
};

extern LLStandardBumpmap gStandardBumpmapList[TEM_BUMPMAP_COUNT];

////////////////////////////////////////////////////////////////
// List of one-component bump-maps created from other texures.

struct LLBumpImageEntry;

class LLBumpImageList
{
public:
    LLBumpImageList() {}
    ~LLBumpImageList();

    void        init();
    void        shutdown();
    void            clear();
    void        destroyGL();
    void        restoreGL();
    void        updateImages();


    LLViewerTexture*    getBrightnessDarknessImage(LLViewerFetchedTexture* src_image, U8 bump_code);
    void        addTextureStats(U8 bump, const LLUUID& base_image_id, F32 virtual_size);

    static void onSourceStandardLoaded( bool success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, bool final, void* userdata );
    static void generateNormalMapFromAlpha(LLImageRaw* src, LLImageRaw* nrm_image);


private:
    // should be called whenever resolution of src_vi changes compared to the current entry
    static void onSourceUpdated( LLViewerTexture *src_vi, EBumpEffect bump );

private:
    typedef std::unordered_map<LLUUID, LLPointer<LLViewerTexture> > bump_image_map_t;
    bump_image_map_t mBrightnessEntries;
    bump_image_map_t mDarknessEntries;
    static LL::WorkQueue::weak_t sMainQueue;
    static LL::WorkQueue::weak_t sTexUpdateQueue;
    static LLRenderTarget sRenderTarget;
};

extern LLBumpImageList gBumpImageList;

#endif // LL_LLDRAWPOOLBUMP_H