RV_RenderUI.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        RV_RenderUI.h ( RV Library, C++)
 *
 */

#ifndef RV_RenderUI_h
#define RV_RenderUI_h

#include <UT/UT_Array.h>
#include <UT/UT_BoundingRect.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_Rect.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_ValArray.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector3Array.h>
#include <UT/UT_Vector4.h>
#include <UT/UT_VectorTypes.h>
#include <RE/RE_Render.h>
#include <RE/RE_RenderContext.h>

#include "RV_API.h"
#include "RV_TypePtrs.h"

class RV_Geometry;
class RV_Instance;
class RV_Render;
class RV_ShaderBlock;
class RV_ShaderProgram;
class RV_ShaderVariableSet;

class UT_Color;
class rv_RenderUIPolyConvex;


class RV_API RV_RenderUI : UT_NonCopyable
{
 public:

  RV_RenderUI();
  virtual ~RV_RenderUI();

  void prepare(fpreal xperpixel, fpreal yperpixel, fpreal xorigin,
               fpreal yorigin);

  /// Draw all buffered primitives
  virtual void draw(
          RV_Render* r,
          bool pickpass = false,
          int pick_depthpass = 0);

  /// Clear all buffered data. Also called at the end of draw.
  virtual void clearAllData();

  /// Change the rendering "layer". This just modifies the depth
  /// coordinate of the primitives.
  void bumpLayer(int delta);

  /// Z value for use as the base for another object.
  virtual void setZStart(fpreal32 zStart);
  fpreal32 getZStart() const;
  fpreal32 getZEnd() const;
  void incrementZEnd();

  /// Set the view and projection matrices for 3D rendering.
  /// These must be set before calling draw() for proper transformation.
  void setViewProjection(const UT_Matrix4F& view, const UT_Matrix4F& proj);

    /// Helper to copy view matrices from the current OpenGL state, and use
    /// provided projection matrix
    void copyViewFromGL(RE_RenderContext r, const UT_Matrix4F &proj);

  /// Helper to copy view/projection matrices from the current OpenGL state.
  void copyViewProjectionFromGL(RE_RenderContext r);

  /// Get x or y distance in current units that corresponds to 1 pixel.
  fpreal32 getXPerPixel() const { return myXPerPixel; }
  fpreal32 getYPerPixel() const { return myYPerPixel; }
  fpreal32 getXOrigin() const { return myXOrigin; }
  fpreal32 getYOrigin() const { return myYOrigin; }

  /// These are options that can change per-vertex.
  void pushColor();
  void pushColor(const UT_Color& c, fpreal32 a = 1.0f);
  void pushColor(fpreal32 r, fpreal32 g, fpreal32 b, fpreal32 a = 1.0f);
  void setColor(const UT_Color& c, fpreal32 a = 1.0f);
  void setColor(fpreal32 r, fpreal32 g, fpreal32 b, fpreal32 a = 1.0f);
  void setAlpha(fpreal32 a);
  void popColor();
  void getColor(UT_Color& c) const;
  fpreal32 getAlpha() const;

  void pushPointSize(fpreal32 size);
  void setPointSize(fpreal32 size);
  void popPointSize();

  /// Pick state used by Vulkan UI pick pass rendering.
  /// If high_priority is true, the pick will be treated as a high priority
  /// target
  void pushPick(UT_Vector3i pick_base_id, UT_Vector3i pick_component_id,
                bool high_priority = false);
  void setPickHighPriority(bool high_priority);
  void popPick();
  // High priority pick flag similar to DM_Handle
  static constexpr int PICK_HIGH_PRIORITY_FLAG = 0x80000000;

  void pushLineSmoothing(bool smooth_lines);
  void pushLineSmoothing();
  void setLineSmoothing(bool smooth_lines);
  void popLineSmoothing();

  void pushLineStyle(RE_LineStyle style);
  void pushLineStyle();
  void setLineStyle(RE_LineStyle style);
  void popLineStyle();

  void pushLineWidth(fpreal32 width);
  void pushLineWidth();
  void setLineWidth(fpreal32 width);
  void popLineWidth();

  // Deprecated. Should call addTriangles() instead. This only exists to support porting old OpenGL code.
  void beginTriangles();
  void endTriangles();

  void addTriangles(const UT_Vector2FArray &pts);
  void addTriangles(const UT_Vector3FArray &pts);

  // Deprecated. Should call addTriangleFan() instead. These only exist to support porting old OpenGL code.
  void beginTriangleFan();
  void endTriangleFan();

  void addTriangleFan(const UT_Vector2FArray &pts);
  void addTriangleFan(const UT_Vector3FArray &pts);

  // Deprecated. Should call addTriMesh() instead. These only exist to support porting old OpenGL code.
  void beginTriMesh();
  void endTriMesh();
  
  void addTriMesh(const UT_Vector2FArray &pts);
  void addTriMesh(const UT_Vector3FArray &pts);

  // Deprecated. Should call addQuads() instead. These only exist to support porting old OpenGL code.
  void beginQuads();
  void endQuads();

  // Quads are just converted to triangles internally
  void addQuads(const UT_Vector2FArray &pts);
  void addQuads(const UT_Vector3FArray &pts);

  // Deprecated. Should call addQuadStrip() instead. These only exist to support porting old OpenGL code.
  void beginQuadStrip();
  void endQuadStrip();

  void addQuadStrip(const UT_Vector2FArray &pts);
  void addQuadStrip(const UT_Vector3FArray &pts);

  // Deprecated. Should call addPolygon() instead. These only exist to support porting old OpenGL code.
  void beginPolygon(int concave);
  void endPolygon();

  void addPolygon(const UT_Vector2FArray &pts, int concave = 0);
  void addPolygon(const UT_Vector3FArray &pts, int concave = 0);

  // Deprecated. Should call addLine() instead. These only exist to support porting old OpenGL code.
  void beginLine();
  void beginClosedLine();
  void endLine();
  void beginLines();
  void endLines();

  /// Lines can be either a single strip or multiple segments. 
  /// If segments is true, each pair of vertices is a separate line segment. 
  /// If closed is true, the last vertex will be connected to the first.
  void addLine(const UT_Vector2FArray &pts,
               bool closed = false,
               bool segments = false);
  void addLine(const UT_Vector3FArray &pts,
               bool closed = false,
               bool segments = false);

  // Deprecated. Should call drawViewportPoint() instead.
  void beginPoint();
  void endPoint();

  void drawViewportPoint(const float vtx[3], fpreal32 size);
    void drawViewportPoint(const UT_Vector3F &vtx, fpreal32 size);

  /// Set vertex attributes.
  void c3DW(const fpreal32 clr[3]);
  void c4DW(const fpreal32 clr[4]);

  /// Create vertices for primitives.
  void v2DW(const fpreal32 vtx[2]);
  void v2DI(const int vtx[2]);
  void vertex2DW(fpreal32 x, fpreal32 y);
  void vertex2DI(int x, int y);
  void vertex2DS(int x, int y);

  // 3D Vertex creation
  void v3DW(const float vtx[3]);
  void vertex3DW(float x, float y, float z);

  /// Unfilled rectangles.
  void rect2DW(fpreal32 x1, fpreal32 y1, fpreal32 x2, fpreal32 y2);
  void rect2DS(int x1, int y1, int x2, int y2);
  void box2DS(int x1, int y1, int x2, int y2);

  /// Filled rectangles.
  void rectf2DW(fpreal32 x1, fpreal32 y1, fpreal32 x2, fpreal32 y2);
  void rectf2DS(int x1, int y1, int x2, int y2);
  void boxf2DS(int x1, int y1, int x2, int y2);

  /// Unfilled circles and arcs.
  void circleW(float x, float y, float r);
  void circleS(int x, int y, int r);
  void arcW(float x, float y, float r, int angle_start, int angle_end);
  void arcS(int x, int y, int r, int angle_start, int angle_end);

  
  /// Filled circles and arcs.
  void circlefW(float x, float y, float r);
  void circlefS(int x, int y, int r);
  void arcfW(float x, float y, float r, int angle_start, int angle_end);
  void arcfS(int x, int y, int r, int angle_start, int angle_end);

  // Rings and Sectors
  void ringfW(float x, float y, float inner_r, float outer_r);
  void ringfS(int x, int y, int inner_r, int outer_r);
  void sectorW(float x, float y, float inner_r, float outer_r,
               float angle_start, float angle_end);
  void sectorfW(float x, float y, float inner_r, float outer_r,
                float angle_start, float angle_end);


  static RV_ShaderProgram* getUIShader(RV_Instance* inst);
  static RV_ShaderProgram* getUIPickShader(RV_Instance* inst);

  static void cleanup();

  static fpreal32 getBufferedRenderZBump();

 protected:
  virtual void addVertex(fpreal32 x, fpreal32 y, fpreal32 z);

  void resetCurrentZ();
  bool hasAnyData();
  void clearSourceData();

  /// Basic vertex properties.
  UT_Vector3Array myPositionData;
  UT_Array<UT_Vector4F> myColorData;
  UT_Fpreal32Array myPointSizeData;
  UT_Fpreal32Array myWidthData;
  UT_Fpreal32Array myLineStyleData;
  UT_Array<UT_Vector3i> myPickBaseData;
  UT_Array<UT_Vector3i> myPickComponentData;

  UT_IntArray myTriangleElementData;

  UT_IntArray myLineElementData;
  UT_IntArray myLineDottedElementData;
  UT_IntArray myLineSmoothElementData;
  UT_IntArray myLineWideElementData;

 UT_IntArray myPointElementData;

 private:
  bool getPrimitiveIsActive() const;

  void buildGeometry(RV_Render* r);
  void createUISet(
          RV_Render* r,
          RV_Instance* inst,
          RV_ShaderProgram* draw_shader,
          bool pickpass,
          int pick_depthpass,
          UT_UniquePtr<RV_ShaderBlock> &block,
          UT_UniquePtr<RV_ShaderVariableSet> &set);
  void renderPrimitives(RV_Render* r, bool pickpass, int pick_depthpass);

  int myTriangleVertexCount;
  bool myTriangleBuildFan;
  bool myTriangleBuildStrip;
  int myPolygonMaxVertexCount;
  int myLineVertexCount;
  bool myLineClosed;
  bool myLineSegments;
  int myPointVertexCount;

  UT_Array<UT_Vector4F> myColorStack;
  UT_Array<bool> myLineSmoothStack;
  UT_Array<RE_LineStyle> myLineStyleStack;
  UT_Array<fpreal32> myLineWidthStack;
  UT_Array<fpreal32> myPointSizeStack;

  fpreal32 myZ;
  fpreal32 myZStart;
  fpreal32 myXPerPixel;
  fpreal32 myYPerPixel;
  fpreal32 myXOrigin;
  fpreal32 myYOrigin;

  UT_Matrix4F myViewMatrix;
  UT_Matrix4F myProjMatrix;
  bool myMatricesSet;
  UT_Vector3i myPickBaseID;
  UT_Vector3i myPickComponentID;

  /// Convexer for concave polygons.
  UT_UniquePtr<rv_RenderUIPolyConvex> myConvexer;

  /// Cached geometry for rendering.
  UT_UniquePtr<RV_Geometry> myTriangleGeometry;
  UT_UniquePtr<RV_Geometry> myLineGeometry;
  UT_UniquePtr<RV_Geometry> myLineDottedGeometry;
  UT_UniquePtr<RV_Geometry> myLineSmoothGeometry;
  UT_UniquePtr<RV_Geometry> myLineWideGeometry;
  UT_UniquePtr<RV_Geometry> myPointGeometry;
};

typedef UT_SharedPtr<RV_RenderUI> RV_RenderUIHandle;
typedef UT_Array<RV_RenderUIHandle> RV_RenderUIArray;

// Inline implementations
inline void RV_RenderUI::c3DW(const fpreal32 clr[3]) {
  setColor(clr[0], clr[1], clr[2], 1.0f);
}

inline void RV_RenderUI::c4DW(const fpreal32 clr[4]) {
  setColor(clr[0], clr[1], clr[2], clr[3]);
}

inline void RV_RenderUI::vertex2DW(fpreal32 x, fpreal32 y) {
  fpreal32 vtxf[2] = {x, y};
  v2DW(vtxf);
}

inline void RV_RenderUI::vertex2DI(int x, int y) {
  fpreal32 vtxf[2] = {fpreal32(x + 0.375f), fpreal32(y + 0.375f)};
  v2DW(vtxf);
}

inline void RV_RenderUI::vertex2DS(int x, int y) {
  fpreal32 vtxf[2] = {fpreal32(x + 0.375f), fpreal32(y + 0.375f)};
  v2DW(vtxf);
}

inline void RV_RenderUI::v2DI(const int vtx[2]) {
  fpreal32 vtxf[2] = {fpreal32(vtx[0] + 0.375f), fpreal32(vtx[1] + 0.375f)};
  v2DW(vtxf);
}

inline void RV_RenderUI::vertex3DW(float x, float y, float z) {
  float vtx[3] = {x, y, z};
  v3DW(vtx);
}

#endif  // RV_RenderUI_h