source/renderer/TexturedLineRData.h

   1 /* Copyright (C) 2012 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 "renderer/VertexBufferManager.h"
  26
  27 /**
  28  * Rendering data for an STexturedOverlayLine.
  29  *
  30  * Note that instances may be shared amongst multiple copies of the same STexturedOverlayLine instance.
  31  * The reason is that this rendering data is non-copyable, but we do wish to maintain copyability of
  32  * SOverlayTexturedLineData to not limit its usage patterns too much (particularly the practice of storing
  33  * them into containers).
  34  *
  35  * For this reason, instead of storing a reverse pointer back to any single SOverlayTexturedLine, the methods
  36  * in this class accept references to STexturedOverlayLines to work with. It is up to client code to pass in
  37  * SOverlayTexturedLines to all methods that are consistently the same instance or non-modified copies of it.
  38  */
  39 class CTexturedLineRData : public CRenderData
  40 {
  41         // we hold raw pointers to vertex buffer chunks that are handed out by the vertex buffer manager
  42         // and can not be safely duplicated by us.
  43         NONCOPYABLE(CTexturedLineRData);
  44
  45 public:
  46
  47         CTexturedLineRData() : m_VB(NULL), m_VBIndices(NULL) { }
  48
  49         ~CTexturedLineRData()
  50         {
  51                 if (m_VB)
  52                         g_VBMan.Release(m_VB);
  53                 if (m_VBIndices)
  54                         g_VBMan.Release(m_VBIndices);
  55         }
  56
  57         void Update(const SOverlayTexturedLine& line);
  58         void Render(const SOverlayTexturedLine& line, const CShaderProgramPtr& shader);
  59
  60 protected:
  61
  62         struct SVertex
  63         {
  64                 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         inline CVector3D Centroid(const SVertex& v1, const SVertex& v2)
  87         {
  88                 return (v1.m_Position + v2.m_Position) * 0.5;
  89         }
  90
  91         CVertexBuffer::VBChunk* m_VB;
  92         CVertexBuffer::VBChunk* m_VBIndices;
  93 };
  94
  95 #endif // INCLUDED_TEXTUREDLINERDATA