summaryrefslogtreecommitdiff
path: root/indra/newview/llheroprobemanager.h
blob: 68cfdbfd991d867c14085b023f7a4d735ec88020 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/**
 * @file llheroprobemanager.h
 * @brief LLHeroProbeManager class declaration
 *
 * $LicenseInfo:firstyear=2022&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2022, 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$
 */

#pragma once

#include "llreflectionmap.h"
#include "llrendertarget.h"
#include "llcubemaparray.h"
#include "llcubemap.h"
#include "lldrawable.h"

class LLSpatialGroup;
class LLViewerObject;

// number of reflection probes to keep in vram
#define LL_MAX_HERO_PROBE_COUNT 2

class alignas(16) LLHeroProbeManager
{
    LL_ALIGN_NEW
public:
    enum class DetailLevel 
    {
        STATIC_ONLY = 0,
        STATIC_AND_DYNAMIC,
        REALTIME = 2
    };

    // allocate an environment map of the given resolution 
    LLHeroProbeManager();

    // release any GL state 
    void cleanup();

    // maintain reflection probes
    void update();

    // debug display, called from llspatialpartition if reflection
    // probe debug display is active
    void renderDebug();

    // call once at startup to allocate cubemap arrays
    void initReflectionMaps();

    // perform occlusion culling on all active reflection probes
    void doOcclusion();

    void registerHeroDrawable(LLVOVolume* drawablep);
    void unregisterHeroDrawable(LLVOVolume* drawablep);

    bool isViableMirror(LLFace* face) const;

    bool isMirrorPass() const { return mRenderingMirror; }

    LLPlane currentMirrorClip() const { return mCurrentClipPlane; }
    
private:
    friend class LLPipeline;
    
    // update UBO used for rendering (call only once per render pipe flush)
    void updateUniforms();

    // bind UBO used for rendering
    void setUniforms();

    // render target for cube snapshots
    // used to generate mipmaps without doing a copy-to-texture
    LLRenderTarget mRenderTarget;
    
    LLRenderTarget mHeroRenderTarget;

    std::vector<LLRenderTarget> mMipChain;

    // storage for reflection probe radiance maps (plus two scratch space cubemaps)
    LLPointer<LLCubeMapArray> mTexture;

    // vertex buffer for pushing verts to filter shaders
    LLPointer<LLVertexBuffer> mVertexBuffer;

    LLPlane mCurrentClipPlane;

    // update the specified face of the specified probe
    void updateProbeFace(LLReflectionMap* probe, U32 face, F32 near_clip);
    
    // list of active reflection maps
    std::vector<LLPointer<LLReflectionMap> > mProbes;

    // handle to UBO
    U32 mUBO = 0;

    // list of maps being used for rendering
    std::vector<LLReflectionMap*> mReflectionMaps;

    LLReflectionMap* mUpdatingProbe = nullptr;

    LLPointer<LLReflectionMap> mDefaultProbe;  // default reflection probe to fall back to for pixels with no probe influences (should always be at cube index 0)

    // number of reflection probes to use for rendering
    U32 mReflectionProbeCount;

    // resolution of reflection probes
    U32 mProbeResolution = 1024;
    
    // maximum LoD of reflection probes (mip levels - 1)
    F32 mMaxProbeLOD = 6.f;
    
    F32 mHeroProbeStrength = 1.f;
    bool mIsInTransition = false;

    // if true, reset all probe render state on the next update (for teleports and sky changes)
    bool mReset = false;

    bool mRenderingMirror = false;
    
    std::set<LLVOVolume*>               mHeroVOList;
    LLVOVolume*                         mNearestHero;
    LLFace*                             mCurrentFace;
};