Merge branch 'develop' into maxim/lua-nearby-avatars

1 files changed, 128 insertions, 0 deletions

diff --git a/indra/newview/llterrainpaintmap.h b/indra/newview/llterrainpaintmap.h
index 66827862c5..d4859b747b 100644
--- a/indra/newview/llterrainpaintmap.h
+++ b/indra/newview/llterrainpaintmap.h
@@ -26,9 +26,20 @@
 
 #pragma once
 
+#include <memory>
+#include <vector>
+
+#include "stdtypes.h"
+#include "v2math.h"
+
+class LLTexture;
 class LLViewerRegion;
 class LLViewerTexture;
+class LLTerrainPaintQueue;
+class LLTerrainBrushQueue;
 
+// TODO: Terrain painting across regions. Assuming painting is confined to one
+// region for now.
 class LLTerrainPaintMap
 {
 public:
@@ -39,4 +50,121 @@ public:
     // to type TERRAIN_PAINT_TYPE_PBR_PAINTMAP.
     // Returns true if successful
     static bool bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion& region, LLViewerTexture& tex);
+
+    // This operation clears the queue
+    // TODO: Decide if clearing the queue is needed - seems inconsistent
+    static void applyPaintQueueRGB(LLViewerTexture& tex, LLTerrainPaintQueue& queue);
+
+    static LLTerrainPaintQueue convertPaintQueueRGBAToRGB(LLViewerTexture& tex, LLTerrainPaintQueue& queue_in);
+    // TODO: Implement (it's similar to convertPaintQueueRGBAToRGB but different shader + need to calculate the dimensions + need a different vertex buffer for each brush stroke)
+    static LLTerrainPaintQueue convertBrushQueueToPaintRGB(const LLViewerRegion& region, LLViewerTexture& tex, LLTerrainBrushQueue& queue_in);
+};
+
+template<typename T>
+class LLTerrainQueue
+{
+public:
+    LLTerrainQueue() = default;
+    LLTerrainQueue(LLTerrainQueue<T>& other);
+    LLTerrainQueue& operator=(LLTerrainQueue<T>& other);
+
+    bool enqueue(std::shared_ptr<T>& t, bool dry_run = false);
+    size_t size() const;
+    bool empty() const;
+    void clear();
+
+    const std::vector<std::shared_ptr<T>>& get() const { return mList; }
+
+protected:
+    bool enqueue(std::vector<std::shared_ptr<T>>& list);
+
+    std::vector<std::shared_ptr<T>> mList;
+};
+
+// Enqueued paint operations, in texture coordinates.
+// mData is always RGB or RGBA (determined by mComponents), with each U8
+// storing one color with a max value of (1 >> mBitDepth) - 1
+struct LLTerrainPaint
+{
+    using ptr_t = std::shared_ptr<LLTerrainPaint>;
+
+    U16 mStartX;
+    U16 mStartY;
+    U16 mWidthX;
+    U16 mWidthY;
+    U8 mBitDepth;
+    U8 mComponents;
+    static constexpr U8 RGB = 3;
+    static constexpr U8 RGBA = 4;
+    std::vector<U8> mData;
+
+    // Asserts that this paint's start/width fit within the bounds of the
+    // provided texture dimensions.
+    void assert_confined_to(const LLTexture& tex) const;
+    // Confines this paint's start/width so it fits within the bounds of the
+    // provided texture dimensions.
+    // Does not allocate mData.
+    void confine_to(const LLTexture& tex);
+};
+
+class LLTerrainPaintQueue : public LLTerrainQueue<LLTerrainPaint>
+{
+public:
+    LLTerrainPaintQueue() = delete;
+    // components determines what type of LLTerrainPaint is allowed. Must be 3 (RGB) or 4 (RGBA)
+    LLTerrainPaintQueue(U8 components);
+    LLTerrainPaintQueue(LLTerrainPaintQueue& other);
+    LLTerrainPaintQueue& operator=(LLTerrainPaintQueue& other);
+
+    bool enqueue(LLTerrainPaint::ptr_t& paint, bool dry_run = false);
+    bool enqueue(LLTerrainPaintQueue& queue);
+
+    U8 getComponents() const { return mComponents; }
+    // Convert mBitDepth for the LLTerrainPaint in the queue at index
+    // If mBitDepth is already equal to target_bit_depth, no conversion takes
+    // place.
+    // It is currently the responsibility of the paint queue to convert
+    // incoming bits to the right bit depth for the paintmap (this could
+    // change in the future).
+    void convertBitDepths(size_t index, U8 target_bit_depth);
+
+private:
+    U8 mComponents;
+};
+
+struct LLTerrainBrush
+{
+    using ptr_t = std::shared_ptr<LLTerrainBrush>;
+
+    // Width of the brush in region space. The brush is a square texture with
+    // alpha.
+    F32 mBrushSize;
+    // Brush path points in region space, excluding the vertical axis, which
+    // does not contribute to the paint map.
+    std::vector<LLVector2> mPath;
+    // Offset of the brush path to actually start drawing at. An offset of 0
+    // indicates that a brush stroke has just started (i.e. the user just
+    // pressed down the mouse button). An offset greater than 0 indicates the
+    // continuation of a brush stroke. Skipped entries in mPath are not drawn
+    // directly, but are used for stroke orientation and path interpolation.
+    // TODO: For the initial implementation, mPathOffset will be 0 and mPath
+    // will be of length of at most 1, leading to discontinuous paint paths.
+    // Then, mPathOffset may be 1 or 0, 1 indicating the continuation of a
+    // stroke with linear interpolation. It is unlikely that we will implement
+    // anything more sophisticated than that for now.
+    U8 mPathOffset;
+    // Indicates if this is the end of the brush stroke. Can occur if the mouse
+    // button is lifted, or if the mouse temporarily stops while held down.
+    bool mPathEnd;
+};
+
+class LLTerrainBrushQueue : public LLTerrainQueue<LLTerrainBrush>
+{
+public:
+    LLTerrainBrushQueue();
+    LLTerrainBrushQueue(LLTerrainBrushQueue& other);
+    LLTerrainBrushQueue& operator=(LLTerrainBrushQueue& other);
+
+    bool enqueue(LLTerrainBrush::ptr_t& brush, bool dry_run = false);
+    bool enqueue(LLTerrainBrushQueue& queue);
 };