DtBdiRenderGizmoRemapper.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2021 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include <RenderGizmo.h>
#include <vrvFx/vrvFx.h>

namespace makVrv
{
   class DtFxGizmoRenderer;

   class DT_DLL_VRVFX DtBdiRenderGizmoRemapper : public RenderGizmo
   {
   public:
      DtBdiRenderGizmoRemapper(DtFxGizmoRenderer* gizmo);

      virtual void draw_sphere(
         const bdiFarPosition& center,
         float radius,
         const bdiVec4f& color,
         int solid = 1,
         int slices = 10,
         int stacks = 10) override;

      virtual void add_fp_line(
         const bdiFarPosition& p1,
         const bdiFarPosition& p2,
         const bdiVec4f& color1,
         const bdiVec4f& color2) override;

      virtual bdiVec3f convert_to_local_camera(const bdiFarPosition& pos) override {
         return pos - m_camera_pos;
      }

      virtual void draw_coordinate_system(const bdiFarPosition& pos, const bdiMat4f& base,
         float size = .5f, float alpha = .5f) override;
 
      virtual void disable_depth_test() override { m_depth_test_mode = 0; }
      virtual void enable_depth_test() override { m_depth_test_mode = 1; }

      virtual void draw_buffered_data() override;


      virtual void init_font_drawing() override { ; }

      virtual void draw_arrow(
         const bdiFarPosition& start,
         const bdiFarPosition& end,
         float arrow_width,
         float shaft_width,
         const bdiVec4f& color_4f) override {
         ;
      }

      virtual void draw_edged_arrow(
         const bdiFarPosition& start,
         const bdiFarPosition& end,
         float arrow_width,
         float shaft_width,
         const bdiVec4f& pen,
         const bdiVec4f& brush,
         int options = EDGE_AND_FILL) override {
         ;
      }

      virtual void draw_auto_scaling_arrow(
         const bdiFarPosition& start,
         const bdiFarPosition& end,
         float arrowSize,
         float shaftWidth,
         const bdiVec4f& color) override {
         ;
      }

      virtual void draw_circle(
         const bdiVec3f& axis,
         const bdiFarPosition& center,
         float radius,
         const bdiVec4f& color_4f,
         int solid = 1,
         int num_sides = 12) override;


      virtual void draw_cylinder(
         const bdiVec3f& axis,
         const bdiFarPosition& center,
         float radius,
         float height,
         const bdiVec4f& color_4f,
         int solid = 1,
         int cap = 1) override {
         ;
      }

      virtual void draw_cylinder(
         const bdiFarPosition& start,
         const bdiFarPosition& end,
         float radius,
         const bdiVec4f& color_4f,
         int solid = 1,
         int cap = 1) override {
         ;
      }

      virtual void draw_edged_cylinder(
         const bdiVec3f& axis,
         const bdiFarPosition& center,
         float radius,
         float height,
         const bdiVec4f& pen,
         const bdiVec4f& brush,
         int options = EDGE_AND_FILL) override {
         ;
      }

      virtual void draw_edged_cylinder(
         const bdiFarPosition& start,
         const bdiFarPosition& end,
         float radius,
         const bdiVec4f& pen,
         const bdiVec4f& brush,
         int options = EDGE_AND_FILL) override
      {
         ;
      }

      virtual void draw_torus(const bdiFarPosition& center,
         float inner_radius,
         float outer_radius,
         const bdiVec4f& pen,
         const bdiVec4f& brush,
         int options = EDGE_AND_FILL) override
      {
         ;
      }

      virtual void draw_wedge(const bdiFarPosition& center,
         const bdiFarPosition& target,
         float inner_radius,
         float arc_width,
         const bdiVec4f& pen,
         const bdiVec4f& brush,
         int options = EDGE_AND_FILL) override
      {
         ;
      }

      virtual void draw_wedge_with_normal(const bdiFarPosition& center,
         const bdiFarPosition& target,
         const bdiVec3f& snormal,
         float inner_radius,
         float arc_width,
         const bdiVec4f& pen,
         const bdiVec4f& brush,
         int options = EDGE_AND_FILL) override
      {
         ;
      }

      virtual void draw_cone(
         const bdiVec3f& axis,
         const bdiFarPosition& center,
         float radius,
         float height,
         const bdiVec4f& color_4f,
         int solid = 1) override
      {
         ;
      }

      virtual void draw_edged_cone(
         const bdiVec3f& axis,
         const bdiFarPosition& center,
         float radius,
         float height,
         const bdiVec4f& pen,
         const bdiVec4f& brush,
         int options = EDGE_AND_FILL) override
      {
         ;
      }

      virtual void draw_edged_sphere(
         const bdiFarPosition& center,
         float radius,
         const bdiVec4f& pen,
         const bdiVec4f& brush,
         int options = EDGE_AND_FILL,
         int num_slices = -1) override
      {
         ;
      }

      virtual void draw_edged_sphere(
         const bdiMat4f& transform,
         float radius,
         const bdiVec4f& pen,
         const bdiVec4f& brush,
         int options = EDGE_AND_FILL,
         int num_slices = -1) override {
         ;
      }

      virtual void draw_fp_line(
         const bdiFarPosition& p1,
         const bdiFarPosition& p2,
         const bdiVec4f& color1,
         const bdiVec4f& color2,
         float line_width = -1.0f)  // -1.0 means don't change current line width
         override {
         ;
      } 

     
      virtual void draw_box(
         bool hightlight,
         const bdiFarPosition& p1,
         const bdiFarPosition& p2,
         const bdiVec4f& color) override
      {
         ;
      }

      virtual void draw_box(
         const bdiMat4f& model_matrix,
         bool hightlight,
         const bdiVec3f& p1,
         const bdiVec3f& p2,
         const bdiVec4f& color) override
      {
         ;
      }

      virtual void draw_rotated_box(
         bool hightlight,
         const bdiVec3f& min_xyz,  // unrotated min xyz extents
         const bdiVec3f& max_xyz,  // unrotated max xyz extents
         const bdiVec3f& rotation, // euler angles
         const bdiFarPosition& rotation_pt,
         const bdiVec4f& color) override
      {
         ;
      }

      virtual void draw_coordinate_system(const bdiMat4f& modelview, const bdiMat4f& base, float size = .5f, float alpha = .5f) override { ; }

      virtual void draw_selected_disc(
         const bdiVec3f& axis,
         const bdiFarPosition& center,
         float radius,
         const bdiVec4f& color,
         int solid = 1) override {
         ;
      }

      virtual void draw_frustum(const bdiCameraFrustum& frust,
         const bdiVec3f& color) override {
         ;
      }

      virtual bdiVec3f get_eye_point(const bdiCameraFrustum& get_eye_point) override { return bdiVec3f(); }

      virtual void draw_simplified_character(
         int class_type,
         const bdiFarPosition& pos,
         const bdiVec3f& orientation,
         const bdiVec3f& velocity,
         const bdiVec4f& color,
         int depth_test,
         float camera_fov) override {
         ;
      }

      virtual void draw_symbolic_character(const bdiFarPosition& pos,
         const char* symbol,
         const bdiVec3f& orientation,
         const bdiVec3f& velocity,
         const bdiVec4f& color,
         int depth_test,
         float camera_fov) override
      {
         ;
      };

      virtual void draw_simplified_crowd(
         const bdiFarPosition& pos,
         const float radius,
         const bdiVec4f& color,
         float camera_fov) override {
         ;
      };

      virtual void draw_point_array(const bdiRenderPointArray& array, float point_size = 1.0f) override
      {
         ;
      };

      virtual void draw_fp_line_array(const bdiFarPositionArray& array,
         const bdiVec4f& color, const bdiVec4f& color2, float line_width = 1.0f) override
      {
         ;
      };

      virtual void draw_fp_line_array(int vert_count, const bdiFarPosition* array,
         const bdiVec4f& color, const bdiVec4f& color2, float line_width = 1.0f) override
      {
         ;
      };

      virtual void draw_edge_array(bdiRenderEdgeArray& array, const bdiVec4f& color,
         int draw_normals, float line_width = 1.0f) override {
         ;
      };


      virtual void draw_triangle_array_as_quads(const bdiOctTreeTriangleArray& array,
         const bdiVec4f& color, int edged = 0) override {
         ;
      }

      virtual void draw_quad_array(const bdiMat4f& model_matrix, const bdiRenderQuadArray& array,
         const bdiVec4f& color, int edged = FILL)override {
         ;
      }
      virtual void draw_quad_array(const bdiVec4f& color,
         const bdiRenderQuadArray& array, int edged = FILL) override {
         ;
      }

      virtual void world_to_screen(const bdiFarPosition& world,
         bdiVec3f* screen,
         int world_coords_already_camera_local = 0) override {
         ;
      }

      virtual void world_to_screen(const bdiMat4f& model_matrix, const bdiFarPosition& world,
         bdiVec3f* screen,
         int world_coords_already_camera_local = 0) override {
         ;
      }

      virtual void screen_to_world(const bdiVec3f& screen,
         bdiFarPosition* world,
         int world_coords_already_camera_local = 0) override {
         ;
      }

      virtual float distance_to_render_position(const bdiVec3f& pos) override { return 1; }

      //low level gl function wrappers

      virtual void draw_point(const bdiFarPosition& point, const bdiVec4f& color) override { ; }

      virtual void disable_depth_write() override { ; }
      virtual void enable_depth_write() override { ; }

      virtual void disable_blend() override { ; }
      virtual void enable_blend() override { ; }


      virtual void disable_alpha_test() override { ; }
      virtual void enable_alpha_test() override { ; }


      virtual void disable_alpha_to_coverage() override { ; }
      virtual void enable_alpha_to_coverage() override { ; }

      virtual void set_depth_test_type(bdiDepthTestOption option) override { ; }

      virtual void set_line_width(float width) override { ; }

      virtual void begin_2d_text_mode() override { ; }
      virtual void begin_2d_mode() override { ; }
      virtual void end_2d_mode() override { ; }
      virtual void draw_text(float x, float y, const bdiVec4f& pen_color, const char* text, float text_scale = 1.0f) { ; }
      virtual void draw_text(float x, float y, const char* text) override { ; }
      virtual float get_text_width(const char* text) override { return 0; }
      virtual float get_text_height(const char* text) override { return 0; }

      virtual void draw_queued_text(bdiVec3fArray& verts, bdiVec2fArray& uvs, bdiVec4fArray& colors) override { ; }

      virtual void add_text_to_draw_queue(float x, float y, const bdiVec4f& pen_color, const char* string, float text_scale,
         bdiVec3fArray& verts,
         bdiVec2fArray& uvs,
         bdiVec4fArray& colors) override
      {
         ;
      }


      // viewport function
      virtual void get_viewport_size(float* width, float* height) override { ; }

      virtual void free_resource(unsigned int vertex_object) override { ; }


      virtual void gl_debug_marker(const char* marker) override { ; }

      virtual void draw_light_source(const bdiVec3f& position, float size) override { ; }

      virtual void draw_skeleton(bdiCreature* creature) override { ; }

      virtual void draw_point_arrays() override { ; }

      virtual void draw_streamed_data(const bdiMat4f& model_matrix, int primitive_type, const bdiVec3fArray& verts,
         const bdiVec4fArray* colors = NULL, const bdiVec3fArray* normals = NULL, const bdiVec2fArray* uvs = NULL, const bdiUShortArray* indexes = NULL,
         const bdiVec4f& default_color = bdiVec4f(1, 1, 1, 1), const diguyGraphicsMaterial* mtl = NULL) override
      {
         ;
      }

      virtual void draw_streamed_data(const bdiMat4f& model_matrix, int primitive_type, const bdiVec3fArray& verts,
         const diguyGraphicsMaterial* mtl) override {
         ;
      }

      // for drawing from the public api
      virtual void draw_opengl_primitive(diguyGraphicsShaderProgram* shader, int primitive_type, int vert_count, const float* verts, const float* colors, const float* normals,
         const float* uvs) override
      {
         ;
      }

      
      virtual void set_buffered_data_sets_material(int value) override { m_buffered_data_sets_material = value; }


      virtual void gl_PushDebugGroup(const char* group) override { ; }
      virtual void gl_PopDebugGroup() override { ; }

   protected:
      DtFxGizmoRenderer* myFxGizmoRenderer;
      int m_depth_test_mode;

   };
};