Line data    Source code

       1             : /* Copyright (C) 2023 Wildfire Games.
       2             :  * This file is part of 0 A.D.
       3             :  *
       4             :  * 0 A.D. is free software: you can redistribute it and/or modify
       5             :  * it under the terms of the GNU General Public License as published by
       6             :  * the Free Software Foundation, either version 2 of the License, or
       7             :  * (at your option) any later version.
       8             :  *
       9             :  * 0 A.D. is distributed in the hope that it will be useful,
      10             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12             :  * GNU General Public License for more details.
      13             :  *
      14             :  * You should have received a copy of the GNU General Public License
      15             :  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
      16             :  */
      17             : 
      18             : #ifndef INCLUDED_TEXTUREDLINERDATA
      19             : #define INCLUDED_TEXTUREDLINERDATA
      20             : 
      21             : #include "graphics/Overlay.h"
      22             : #include "graphics/RenderableObject.h"
      23             : #include "graphics/ShaderProgram.h"
      24             : #include "graphics/TextureManager.h"
      25             : #include "maths/BoundingBoxAligned.h"
      26             : #include "renderer/backend/IDeviceCommandContext.h"
      27             : #include "renderer/backend/IShaderProgram.h"
      28             : #include "renderer/VertexBufferManager.h"
      29             : 
      30             : class CFrustum;
      31             : 
      32             : /**
      33             :  * Rendering data for an STexturedOverlayLine.
      34             :  *
      35             :  * Note that instances may be shared amongst multiple copies of the same STexturedOverlayLine instance.
      36             :  * The reason is that this rendering data is non-copyable, but we do wish to maintain copyability of
      37             :  * SOverlayTexturedLineData to not limit its usage patterns too much (particularly the practice of storing
      38             :  * them into containers).
      39             :  *
      40             :  * For this reason, instead of storing a reverse pointer back to any single SOverlayTexturedLine, the methods
      41             :  * in this class accept references to STexturedOverlayLines to work with. It is up to client code to pass in
      42             :  * SOverlayTexturedLines to all methods that are consistently the same instance or non-modified copies of it.
      43             :  */
      44             : class CTexturedLineRData : public CRenderData
      45             : {
      46             :     // we hold raw pointers to vertex buffer chunks that are handed out by the vertex buffer manager
      47             :     // and can not be safely duplicated by us.
      48             :     NONCOPYABLE(CTexturedLineRData);
      49             : 
      50             : public:
      51           0 :     CTexturedLineRData() = default;
      52           0 :     ~CTexturedLineRData() = default;
      53             : 
      54             :     static Renderer::Backend::IVertexInputLayout* GetVertexInputLayout();
      55             : 
      56             :     void Update(const SOverlayTexturedLine& line);
      57             :     void Render(Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
      58             :         Renderer::Backend::IVertexInputLayout* vertexInputLayout,
      59             :         const SOverlayTexturedLine& line, Renderer::Backend::IShaderProgram* shader);
      60             : 
      61             :     bool IsVisibleInFrustum(const CFrustum& frustum) const;
      62             : 
      63             : protected:
      64             : 
      65             :     struct SVertex
      66             :     {
      67           0 :         SVertex(const CVector3D& pos, const CVector2D& uv) : m_Position(pos), m_UV(uv) { }
      68             :         CVector3D m_Position;
      69             :         CVector2D m_UV;
      70             :         float padding[3]; // get a pow2 struct size
      71             :     };
      72             :     cassert(sizeof(SVertex) == 32);
      73             : 
      74             :     /**
      75             :      * Creates a line cap of the specified type @p endCapType at the end of the segment going in direction @p normal, and appends
      76             :      * the vertices to @p verticesOut in GL_TRIANGLES order.
      77             :      *
      78             :      * @param corner1 One of the two butt-end corner points of the line to which the cap should be attached.
      79             :      * @param corner2 One of the two butt-end corner points of the line to which the cap should be attached.
      80             :      * @param normal Normal vector indicating the direction of the segment to which the cap should be attached.
      81             :      * @param endCapType The type of end cap to produce.
      82             :      * @param verticesOut Output vector of vertices for passing to the renderer.
      83             :      * @param indicesOut Output vector of vertex indices for passing to the renderer.
      84             :      */
      85             :     void CreateLineCap(const SOverlayTexturedLine& line, const CVector3D& corner1, const CVector3D& corner2, const CVector3D& normal,
      86             :                        SOverlayTexturedLine::LineCapType endCapType, std::vector<SVertex>& verticesOut, std::vector<u16>& indicesOut);
      87             : 
      88             :     /// Small utility function; grabs the centroid of the positions of two vertices
      89           0 :     inline CVector3D Centroid(const SVertex& v1, const SVertex& v2)
      90             :     {
      91           0 :         return (v1.m_Position + v2.m_Position) * 0.5;
      92             :     }
      93             : 
      94             :     CVertexBufferManager::Handle m_VB;
      95             :     CVertexBufferManager::Handle m_VBIndices;
      96             :     CBoundingBoxAligned m_BoundingBox;
      97             : };
      98             : 
      99             : #endif // INCLUDED_TEXTUREDLINERDATA