DRW_render.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2016 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
/* This is the Render Functions used by Realtime engines to draw with OpenGL */
 
#pragma once
 
#include <functional>
 
#include "BKE_mesh_wrapper.hh"
#include "BKE_subdiv_modifier.hh"
#include "BLI_math_vector_types.hh"
#include "DNA_object_enums.h"
#include "DNA_object_types.h"
 
#include "GPU_material.hh"
 
namespace blender::gpu {
class Batch;
class Shader;
class Texture;
class UniformBuf;
class FrameBuffer;
}  // namespace blender::gpu
struct ARegion;
struct bContext;
struct Depsgraph;
struct DefaultFramebufferList;
struct DefaultTextureList;
struct DupliObject;
struct GPUMaterial;
struct Mesh;
struct Object;
struct ParticleSystem;
struct rcti;
struct RegionView3D;
struct RenderEngine;
struct RenderEngineType;
struct RenderLayer;
struct RenderResult;
struct SpaceLink;
struct TaskGraph;
struct View3D;
struct ViewLayer;
struct DRWContext;
struct World;
struct DRWData;
struct DRWViewData;
struct GPUViewport;
struct DRWTextStore;
struct GSet;
struct GPUViewport;
namespace blender::draw {
class TextureFromPool;
class ObjectRef;
class Manager;
}  // namespace blender::draw
 
/* TODO: Put it somewhere else? */
struct BoundSphere {
  float center[3], radius;
};
 
struct DrawEngine {
  static constexpr int GPU_INFO_SIZE = 512; /* IMA_MAX_RENDER_TEXT_SIZE */
 
  char info[GPU_INFO_SIZE] = {'\0'};
 
  bool used = false;
 
  virtual ~DrawEngine() = default;
 
  virtual blender::StringRefNull name_get() = 0;
 
  /* Functions called for viewport. */

  virtual void init() = 0;
  virtual void begin_sync() = 0;
  virtual void object_sync(blender::draw::ObjectRef &ob_ref, blender::draw::Manager &manager) = 0;
  virtual void end_sync() = 0;
  virtual void draw(blender::draw::Manager &manager) = 0;
 
  /* Called when closing blender.
   * Cleanup all lazily initialized static members that have GPU resources.
   * Implemented on a case by case basis and called directly. */
  //  static void exit(){};
 
  struct Pointer {
    DrawEngine *instance = nullptr;
 
    ~Pointer()
    {
      free_instance();
    }
 
    void free_instance()
    {
      delete instance;
      instance = nullptr;
    }
 
    void set_used(bool used)
    {
      if (used) {
        if (instance == nullptr) {
          instance = create_instance();
        }
        instance->used = true;
      }
      else if (instance) {
        instance->used = false;
      }
    }
 
    virtual DrawEngine *create_instance() = 0;
  };
};
 
/* Viewport. */

blender::draw::TextureFromPool &DRW_viewport_pass_texture_get(const char *pass_name);
 
void DRW_viewport_request_redraw();
 
void DRW_render_to_image(
    RenderEngine *engine,
    Depsgraph *depsgraph,
    std::function<void(RenderEngine *, RenderLayer *, const rcti)> render_view_cb,
    std::function<void(RenderResult *)> store_metadata_cb);
 
void DRW_render_object_iter(
    RenderEngine *engine,
    Depsgraph *depsgraph,
    std::function<void(blender::draw::ObjectRef &, RenderEngine *, Depsgraph *)>);
 
void DRW_render_set_time(RenderEngine *engine, Depsgraph *depsgraph, int frame, float subframe);

void DRW_custom_pipeline_begin(DRWContext &draw_ctx, Depsgraph *depsgraph);
void DRW_custom_pipeline_end(DRWContext &draw_ctx);

void DRW_cache_restart();
 
/* Settings. */
 
bool DRW_object_is_renderable(const Object *ob);
bool DRW_object_is_in_edit_mode(const Object *ob);
int DRW_object_visibility_in_active_context(const Object *ob);
bool DRW_object_use_hide_faces(const Object *ob);
 
bool DRW_object_is_visible_psys_in_active_context(const Object *object,
                                                  const ParticleSystem *psys);

template<typename T> T &DRW_object_get_data_for_drawing(const Object &object)
{
  return *static_cast<T *>(object.data);
}
 
inline Mesh &DRW_mesh_get_for_drawing(Mesh &mesh)
{
  /* For drawing we want either the base mesh if GPU subdivision is enabled, or the
   * tessellated mesh if GPU subdivision is disabled. */
  if (BKE_subsurf_modifier_has_gpu_subdiv(&mesh)) {
    return mesh;
  }
  return *BKE_mesh_wrapper_ensure_subdivision(&mesh);
}
 
template<> inline Mesh &DRW_object_get_data_for_drawing(const Object &object)
{
  BLI_assert(object.type == OB_MESH);
  return DRW_mesh_get_for_drawing(*static_cast<Mesh *>(object.data));
}

const Mesh *DRW_object_get_editmesh_cage_for_drawing(const Object &object);
 
/* Draw State. */
 
/* -------------------------------------------------------------------- */
 
struct DRWContext {
 private:
  static thread_local DRWContext *g_context;
 
  /* TODO(fclem): Private? */
 public:
  /* TODO: clean up this struct a bit. */
  DRWData *data = nullptr;
  DRWViewData *view_data_active = nullptr;

  GPUViewport *viewport = nullptr;
  blender::float2 size = {0, 0};
  blender::float2 inv_size = {0, 0};

  blender::gpu::FrameBuffer *default_framebuffer();
  DefaultFramebufferList *viewport_framebuffer_list_get() const;
  DefaultTextureList *viewport_texture_list_get() const;
 
  const enum Mode {
    VIEWPORT = 0,
 
    /* These viewport modes will render without some overlays (i.e. no text). */

    VIEWPORT_XR,
    VIEWPORT_OFFSCREEN,
    VIEWPORT_RENDER,

    SELECT_OBJECT,
    SELECT_OBJECT_MATERIAL,
    SELECT_EDIT_MESH,

    DEPTH,
    DEPTH_ACTIVE_OBJECT,

    RENDER,
    CUSTOM,
  } mode;
 
  struct {
    bool draw_background = false;
  } options;

  DRWTextStore **text_store_p = nullptr;

  GSet *delayed_extraction = nullptr;
 
  /* TODO(fclem): Public. */


  Depsgraph *depsgraph = nullptr;
  Scene *scene = nullptr;
  ViewLayer *view_layer = nullptr;

  const bContext *evil_C = nullptr;
  ARegion *region = nullptr;
  SpaceLink *space_data = nullptr;
  RegionView3D *rv3d = nullptr;
  View3D *v3d = nullptr;
  Object *obact = nullptr;
  Object *object_pose = nullptr;
  Object *object_edit = nullptr;
 
  eObjectMode object_mode = OB_MODE_OBJECT;
 
 public:
  DRWContext(Mode mode,
             Depsgraph *depsgraph,
             GPUViewport *viewport,
             const bContext *C = nullptr,
             ARegion *region = nullptr,
             View3D *v3d = nullptr);
  DRWContext(Mode mode,
             Depsgraph *depsgraph,
             const blender::int2 size = {1, 1},
             const bContext *C = nullptr,
             ARegion *region = nullptr,
             View3D *v3d = nullptr);
 
  ~DRWContext();

  void acquire_data();

  void release_data();

  void enable_engines(bool gpencil_engine_needed = false,
                      RenderEngineType *render_engine_type = nullptr);

  void engines_data_validate();
 
  using iter_callback_t =
      std::function<void(struct DupliCacheManager &, struct ExtractionGraph &)>;

  void sync(iter_callback_t iter_callback);
  void engines_init_and_sync(iter_callback_t iter_callback);
  void engines_draw_scene();
 
  static DRWContext &get_active()
  {
    return *g_context;
  }
 
  blender::float2 viewport_size_get() const
  {
    return size;
  }

  static bool is_active()
  {
    return g_context != nullptr;
  }
 
  bool is_select() const
  {
    return ELEM(mode, SELECT_OBJECT, SELECT_OBJECT_MATERIAL, SELECT_EDIT_MESH);
  }
  bool is_material_select() const
  {
    return ELEM(mode, SELECT_OBJECT_MATERIAL);
  }
  bool is_depth() const
  {
    return ELEM(mode, DEPTH, DEPTH_ACTIVE_OBJECT);
  }
  bool is_image_render() const
  {
    return ELEM(mode, VIEWPORT_RENDER, RENDER);
  }
  bool is_scene_render() const
  {
    return ELEM(mode, RENDER);
  }
  bool is_viewport_image_render() const
  {
    return ELEM(mode, VIEWPORT_RENDER);
  }

  bool is_playback() const;
  bool is_navigating() const;
  bool is_painting() const;
  bool is_transforming() const;
  bool is_viewport_compositor_enabled() const;
};

 
const DRWContext *DRW_context_get();