LCOV - code coverage report
Current view: top level - source/renderer - TexturedLineRData.h (source / functions) Hit Total Coverage
Test: 0 A.D. test coverage report Lines: 0 5 0.0 %
Date: 2022-03-08 13:03:03 Functions: 0 4 0.0 %

          Line data    Source code
       1             : /* Copyright (C) 2022 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/ShaderProgramPtr.h"
      24             : #include "graphics/TextureManager.h"
      25             : #include "maths/BoundingBoxAligned.h"
      26             : #include "renderer/backend/gl/DeviceCommandContext.h"
      27             : #include "renderer/VertexBufferManager.h"
      28             : 
      29             : class CFrustum;
      30             : 
      31             : /**
      32             :  * Rendering data for an STexturedOverlayLine.
      33             :  *
      34             :  * Note that instances may be shared amongst multiple copies of the same STexturedOverlayLine instance.
      35             :  * The reason is that this rendering data is non-copyable, but we do wish to maintain copyability of
      36             :  * SOverlayTexturedLineData to not limit its usage patterns too much (particularly the practice of storing
      37             :  * them into containers).
      38             :  *
      39             :  * For this reason, instead of storing a reverse pointer back to any single SOverlayTexturedLine, the methods
      40             :  * in this class accept references to STexturedOverlayLines to work with. It is up to client code to pass in
      41             :  * SOverlayTexturedLines to all methods that are consistently the same instance or non-modified copies of it.
      42             :  */
      43             : class CTexturedLineRData : public CRenderData
      44             : {
      45             :     // we hold raw pointers to vertex buffer chunks that are handed out by the vertex buffer manager
      46             :     // and can not be safely duplicated by us.
      47             :     NONCOPYABLE(CTexturedLineRData);
      48             : 
      49             : public:
      50             : 
      51           0 :     CTexturedLineRData() = default;
      52           0 :     ~CTexturedLineRData() = default;
      53             : 
      54             :     void Update(const SOverlayTexturedLine& line);
      55             :     void Render(Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext,
      56             :         const SOverlayTexturedLine& line, const CShaderProgramPtr& shader);
      57             : 
      58             :     bool IsVisibleInFrustum(const CFrustum& frustum) const;
      59             : 
      60             : protected:
      61             : 
      62             :     struct SVertex
      63             :     {
      64           0 :         SVertex(CVector3D pos, float u, float v) : m_Position(pos) { m_UVs[0] = u; m_UVs[1] = v; }
      65             :         CVector3D m_Position;
      66             :         GLfloat m_UVs[2];
      67             :         float padding[3]; // get a pow2 struct size
      68             :     };
      69             :     cassert(sizeof(SVertex) == 32);
      70             : 
      71             :     /**
      72             :      * Creates a line cap of the specified type @p endCapType at the end of the segment going in direction @p normal, and appends
      73             :      * the vertices to @p verticesOut in GL_TRIANGLES order.
      74             :      *
      75             :      * @param corner1 One of the two butt-end corner points of the line to which the cap should be attached.
      76             :      * @param corner2 One of the two butt-end corner points of the line to which the cap should be attached.
      77             :      * @param normal Normal vector indicating the direction of the segment to which the cap should be attached.
      78             :      * @param endCapType The type of end cap to produce.
      79             :      * @param verticesOut Output vector of vertices for passing to the renderer.
      80             :      * @param indicesOut Output vector of vertex indices for passing to the renderer.
      81             :      */
      82             :     void CreateLineCap(const SOverlayTexturedLine& line, const CVector3D& corner1, const CVector3D& corner2, const CVector3D& normal,
      83             :                        SOverlayTexturedLine::LineCapType endCapType, std::vector<SVertex>& verticesOut, std::vector<u16>& indicesOut);
      84             : 
      85             :     /// Small utility function; grabs the centroid of the positions of two vertices
      86           0 :     inline CVector3D Centroid(const SVertex& v1, const SVertex& v2)
      87             :     {
      88           0 :         return (v1.m_Position + v2.m_Position) * 0.5;
      89             :     }
      90             : 
      91             :     CVertexBufferManager::Handle m_VB;
      92             :     CVertexBufferManager::Handle m_VBIndices;
      93             :     CBoundingBoxAligned m_BoundingBox;
      94             : };
      95             : 
      96             : #endif // INCLUDED_TEXTUREDLINERDATA

Generated by: LCOV version 1.13