1 files changed, 80 insertions, 10 deletions

diff --git a/indra/newview/llterrainpaintmap.h b/indra/newview/llterrainpaintmap.h
index b4d706b107..cffdad80a2 100644
--- a/indra/newview/llterrainpaintmap.h
+++ b/indra/newview/llterrainpaintmap.h
@@ -28,10 +28,14 @@
 
 #include "llviewerprecompiledheaders.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:
@@ -43,8 +47,34 @@ public:
     // 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.
@@ -63,23 +93,27 @@ struct LLTerrainPaint
     const static U8 RGB = 3;
     const static 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
+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(const LLTerrainPaintQueue& other);
-    LLTerrainPaintQueue& operator=(const LLTerrainPaintQueue& other);
+    LLTerrainPaintQueue(LLTerrainPaintQueue& other);
+    LLTerrainPaintQueue& operator=(LLTerrainPaintQueue& other);
 
     bool enqueue(LLTerrainPaint::ptr_t& paint, bool dry_run = false);
-    bool enqueue(LLTerrainPaintQueue& paint_queue);
-    size_t size() const;
-    bool empty() const;
-    void clear();
-
-    const std::vector<LLTerrainPaint::ptr_t>& get() const { return mList; }
+    bool enqueue(LLTerrainPaintQueue& queue);
 
     U8 getComponents() const { return mComponents; }
     // Convert mBitDepth for the LLTerrainPaint in the queue at index
@@ -92,5 +126,41 @@ public:
 
 private:
     U8 mComponents;
-    std::vector<LLTerrainPaint::ptr_t> mList;
+};
+
+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);
 };