tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: Remove unnecessary keywords in C++ headers

This commit is contained in:
Hans Goudey 2024-01-24 11:46:28 -05:00
parent 500f09b88a
commit d02d6ec4e5
15 changed files with 758 additions and 815 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
source/blender/blenkernel/BKE_mball.hh
View File

@ -15,30 +15,30 @@ struct MetaElem;
struct Object; struct Object;
struct Scene; struct Scene;
struct MetaBall *BKE_mball_add(struct Main *bmain, const char *name); MetaBall *BKE_mball_add(Main *bmain, const char *name);
bool BKE_mball_is_any_selected(const struct MetaBall *mb); bool BKE_mball_is_any_selected(const MetaBall *mb);
bool BKE_mball_is_any_selected_multi(struct Base **bases, int bases_len); bool BKE_mball_is_any_selected_multi(Base **bases, int bases_len);
bool BKE_mball_is_any_unselected(const struct MetaBall *mb); bool BKE_mball_is_any_unselected(const MetaBall *mb);
/** /**
* Return `true` if `ob1` and `ob2` are part of the same metaBall group. * Return `true` if `ob1` and `ob2` are part of the same metaBall group.
* *
* \note Currently checks whether their two base names (without numerical suffix) is the same. * \note Currently checks whether their two base names (without numerical suffix) is the same.
*/ */
bool BKE_mball_is_same_group(const struct Object *ob1, const struct Object *ob2); bool BKE_mball_is_same_group(const Object *ob1, const Object *ob2);
/** /**
* Return `true` if `ob1` and `ob2` are part of the same metaBall group, and `ob1` is its * Return `true` if `ob1` and `ob2` are part of the same metaBall group, and `ob1` is its
* basis. * basis.
*/ */
bool BKE_mball_is_basis_for(const struct Object *ob1, const struct Object *ob2); bool BKE_mball_is_basis_for(const Object *ob1, const Object *ob2);
/** /**
* Test, if \a ob is a basis meta-ball. * Test, if \a ob is a basis meta-ball.
* *
* It test last character of Object ID name. * It test last character of Object ID name.
* If last character is digit it return 0, else it return 1. * If last character is digit it return 0, else it return 1.
*/ */
bool BKE_mball_is_basis(const struct Object *ob); bool BKE_mball_is_basis(const Object *ob);
/** /**
* This function finds the basis meta-ball. * This function finds the basis meta-ball.
* *
@ -48,7 +48,7 @@ bool BKE_mball_is_basis(const struct Object *ob);
* *
* \warning #BKE_mball_is_basis() can fail on returned object, see function docs for details. * \warning #BKE_mball_is_basis() can fail on returned object, see function docs for details.
*/ */
struct Object *BKE_mball_basis_find(struct Scene *scene, struct Object *ob); Object *BKE_mball_basis_find(Scene *scene, Object *ob);
/** /**
* Copy some properties from a meta-ball obdata to all other meta-ball obdata belonging to the same * Copy some properties from a meta-ball obdata to all other meta-ball obdata belonging to the same
@ -59,37 +59,37 @@ struct Object *BKE_mball_basis_find(struct Scene *scene, struct Object *ob);
* `MBall`, `MBall.001`, `MBall.002`, etc). The most important is to copy properties to the base * `MBall`, `MBall.001`, `MBall.002`, etc). The most important is to copy properties to the base
* meta-ball, because this meta-ball influences polygonization of meta-balls. * meta-ball, because this meta-ball influences polygonization of meta-balls.
*/ */
void BKE_mball_properties_copy(struct Main *bmain, struct MetaBall *metaball_src); void BKE_mball_properties_copy(Main *bmain, MetaBall *metaball_src);
bool BKE_mball_minmax_ex( bool BKE_mball_minmax_ex(
const struct MetaBall *mb, float min[3], float max[3], const float obmat[4][4], short flag); const MetaBall *mb, float min[3], float max[3], const float obmat[4][4], short flag);
/* Basic vertex data functions. */ /* Basic vertex data functions. */
bool BKE_mball_minmax(const struct MetaBall *mb, float min[3], float max[3]); bool BKE_mball_minmax(const MetaBall *mb, float min[3], float max[3]);
bool BKE_mball_center_median(const struct MetaBall *mb, float r_cent[3]); bool BKE_mball_center_median(const MetaBall *mb, float r_cent[3]);
bool BKE_mball_center_bounds(const struct MetaBall *mb, float r_cent[3]); bool BKE_mball_center_bounds(const MetaBall *mb, float r_cent[3]);
void BKE_mball_transform(struct MetaBall *mb, const float mat[4][4], bool do_props); void BKE_mball_transform(MetaBall *mb, const float mat[4][4], bool do_props);
void BKE_mball_translate(struct MetaBall *mb, const float offset[3]); void BKE_mball_translate(MetaBall *mb, const float offset[3]);
/** /**
* Most simple meta-element adding function. * Most simple meta-element adding function.
* *
* \note don't do context manipulation here (rna uses). * \note don't do context manipulation here (rna uses).
*/ */
struct MetaElem *BKE_mball_element_add(struct MetaBall *mb, int type); MetaElem *BKE_mball_element_add(MetaBall *mb, int type);
/* *** Select functions *** */ /* *** Select functions *** */
int BKE_mball_select_count(const struct MetaBall *mb); int BKE_mball_select_count(const MetaBall *mb);
int BKE_mball_select_count_multi(struct Base **bases, int bases_len); int BKE_mball_select_count_multi(Base **bases, int bases_len);
bool BKE_mball_select_all(struct MetaBall *mb); bool BKE_mball_select_all(MetaBall *mb);
bool BKE_mball_select_all_multi_ex(struct Base **bases, int bases_len); bool BKE_mball_select_all_multi_ex(Base **bases, int bases_len);
bool BKE_mball_deselect_all(struct MetaBall *mb); bool BKE_mball_deselect_all(MetaBall *mb);
bool BKE_mball_deselect_all_multi_ex(struct Base **bases, int bases_len); bool BKE_mball_deselect_all_multi_ex(Base **bases, int bases_len);
bool BKE_mball_select_swap(struct MetaBall *mb); bool BKE_mball_select_swap(MetaBall *mb);
bool BKE_mball_select_swap_multi_ex(struct Base **bases, int bases_len); bool BKE_mball_select_swap_multi_ex(Base **bases, int bases_len);
/* **** Depsgraph evaluation **** */ /* **** Depsgraph evaluation **** */
void BKE_mball_data_update(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob); void BKE_mball_data_update(Depsgraph *depsgraph, Scene *scene, Object *ob);

6
source/blender/blenkernel/BKE_mball_tessellate.hh
View File

@ -12,8 +12,6 @@ struct Object;
struct Scene; struct Scene;
struct Mesh; struct Mesh;
struct Mesh *BKE_mball_polygonize(struct Depsgraph *depsgraph, Mesh *BKE_mball_polygonize(Depsgraph *depsgraph, Scene *scene, Object *ob);
struct Scene *scene,
struct Object *ob);
void BKE_mball_cubeTable_free(void); void BKE_mball_cubeTable_free();

9
source/blender/blenkernel/BKE_undo_system.hh
View File

@ -95,7 +95,7 @@ enum eUndoPushReturn {
}; };
ENUM_OPERATORS(eUndoPushReturn, UNDO_PUSH_RET_OVERRIDE_CHANGED) ENUM_OPERATORS(eUndoPushReturn, UNDO_PUSH_RET_OVERRIDE_CHANGED)
using UndoTypeForEachIDRefFn = void (*)(void *user_data, struct UndoRefID *id_ref); using UndoTypeForEachIDRefFn = void (*)(void *user_data, UndoRefID *id_ref);
struct UndoType { struct UndoType {
UndoType *next, *prev; UndoType *next, *prev;
@ -116,11 +116,10 @@ struct UndoType {
* Note that 'step_encode_init' is optional, * Note that 'step_encode_init' is optional,
* some undo types need to perform operations before undo push finishes. * some undo types need to perform operations before undo push finishes.
*/ */
void (*step_encode_init)(struct bContext *C, UndoStep *us); void (*step_encode_init)(bContext *C, UndoStep *us);
bool (*step_encode)(struct bContext *C, struct Main *bmain, UndoStep *us); bool (*step_encode)(bContext *C, Main *bmain, UndoStep *us);
void (*step_decode)( void (*step_decode)(bContext *C, Main *bmain, UndoStep *us, eUndoStepDir dir, bool is_final);
struct bContext *C, struct Main *bmain, UndoStep *us, eUndoStepDir dir, bool is_final);
/** /**
* \note When freeing all steps, * \note When freeing all steps,

4
source/blender/bmesh/tools/bmesh_boolean.hh
View File

@ -9,7 +9,7 @@
*/ */
bool BM_mesh_boolean(BMesh *bm, bool BM_mesh_boolean(BMesh *bm,
struct BMLoop *(*looptris)[3], BMLoop *(*looptris)[3],
int looptris_tot, int looptris_tot,
int (*test_fn)(BMFace *f, void *user_data), int (*test_fn)(BMFace *f, void *user_data),
void *user_data, void *user_data,
@ -30,7 +30,7 @@ bool BM_mesh_boolean(BMesh *bm,
* to the intersection result faces. * to the intersection result faces.
*/ */
bool BM_mesh_boolean_knife(BMesh *bm, bool BM_mesh_boolean_knife(BMesh *bm,
struct BMLoop *(*looptris)[3], BMLoop *(*looptris)[3],
int looptris_tot, int looptris_tot,
int (*test_fn)(BMFace *f, void *user_data), int (*test_fn)(BMFace *f, void *user_data),
void *user_data, void *user_data,

39
source/blender/bmesh/tools/bmesh_path.hh
View File

@ -13,26 +13,23 @@ struct BMCalcPathParams {
uint use_step_face : 1; uint use_step_face : 1;
}; };
struct LinkNode *BM_mesh_calc_path_vert(BMesh *bm, LinkNode *BM_mesh_calc_path_vert(BMesh *bm,
BMVert *v_src, BMVert *v_src,
BMVert *v_dst, BMVert *v_dst,
const struct BMCalcPathParams *params, const BMCalcPathParams *params,
bool (*filter_fn)(BMVert *, void *), bool (*filter_fn)(BMVert *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT void *user_data) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2, 3, 5);
ATTR_NONNULL(1, 2, 3, 5);
struct LinkNode *BM_mesh_calc_path_edge(BMesh *bm, LinkNode *BM_mesh_calc_path_edge(BMesh *bm,
BMEdge *e_src, BMEdge *e_src,
BMEdge *e_dst, BMEdge *e_dst,
const struct BMCalcPathParams *params, const BMCalcPathParams *params,
bool (*filter_fn)(BMEdge *, void *), bool (*filter_fn)(BMEdge *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT void *user_data) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2, 3, 5);
ATTR_NONNULL(1, 2, 3, 5);
struct LinkNode *BM_mesh_calc_path_face(BMesh *bm, LinkNode *BM_mesh_calc_path_face(BMesh *bm,
BMFace *f_src, BMFace *f_src,
BMFace *f_dst, BMFace *f_dst,
const struct BMCalcPathParams *params, const BMCalcPathParams *params,
bool (*filter_fn)(BMFace *, void *), bool (*filter_fn)(BMFace *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT void *user_data) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2, 3, 5);
ATTR_NONNULL(1, 2, 3, 5);

36
source/blender/bmesh/tools/bmesh_path_uv.hh
View File

@ -15,26 +15,26 @@ struct BMCalcPathUVParams {
float aspect_y; float aspect_y;
}; };
struct LinkNode *BM_mesh_calc_path_uv_vert(BMesh *bm, LinkNode *BM_mesh_calc_path_uv_vert(BMesh *bm,
BMLoop *l_src, BMLoop *l_src,
BMLoop *l_dst, BMLoop *l_dst,
const struct BMCalcPathUVParams *params, const BMCalcPathUVParams *params,
bool (*filter_fn)(BMLoop *, void *), bool (*filter_fn)(BMLoop *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT void *user_data) ATTR_WARN_UNUSED_RESULT
ATTR_NONNULL(1, 2, 3, 5); ATTR_NONNULL(1, 2, 3, 5);
struct LinkNode *BM_mesh_calc_path_uv_edge(BMesh *bm, LinkNode *BM_mesh_calc_path_uv_edge(BMesh *bm,
BMLoop *l_src, BMLoop *l_src,
BMLoop *l_dst, BMLoop *l_dst,
const struct BMCalcPathUVParams *params, const BMCalcPathUVParams *params,
bool (*filter_fn)(BMLoop *, void *), bool (*filter_fn)(BMLoop *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT void *user_data) ATTR_WARN_UNUSED_RESULT
ATTR_NONNULL(1, 2, 3, 5); ATTR_NONNULL(1, 2, 3, 5);
struct LinkNode *BM_mesh_calc_path_uv_face(BMesh *bm, LinkNode *BM_mesh_calc_path_uv_face(BMesh *bm,
BMFace *f_src, BMFace *f_src,
BMFace *f_dst, BMFace *f_dst,
const struct BMCalcPathUVParams *params, const BMCalcPathUVParams *params,
bool (*filter_fn)(BMFace *, void *), bool (*filter_fn)(BMFace *, void *),
void *user_data) ATTR_WARN_UNUSED_RESULT void *user_data) ATTR_WARN_UNUSED_RESULT
ATTR_NONNULL(1, 2, 3, 5); ATTR_NONNULL(1, 2, 3, 5);

154
source/blender/draw/DRW_engine.hh
View File

@ -16,6 +16,7 @@ struct ARegion;
struct DRWData; struct DRWData;
struct DRWInstanceDataList; struct DRWInstanceDataList;
struct Depsgraph; struct Depsgraph;
struct DrawDataList;
struct DrawEngineType; struct DrawEngineType;
struct GHash; struct GHash;
struct GPUMaterial; struct GPUMaterial;
@ -37,23 +38,23 @@ struct ViewLayer;
struct bContext; struct bContext;
struct rcti; struct rcti;
void DRW_engines_register(void); void DRW_engines_register();
void DRW_engines_free(void); void DRW_engines_free();
bool DRW_engine_render_support(struct DrawEngineType *draw_engine_type); bool DRW_engine_render_support(DrawEngineType *draw_engine_type);
void DRW_engine_register(struct DrawEngineType *draw_engine_type); void DRW_engine_register(DrawEngineType *draw_engine_type);
void DRW_engine_external_free(struct RegionView3D *rv3d); void DRW_engine_external_free(RegionView3D *rv3d);
typedef struct DRWUpdateContext { struct DRWUpdateContext {
struct Main *bmain; Main *bmain;
struct Depsgraph *depsgraph; Depsgraph *depsgraph;
struct Scene *scene; Scene *scene;
struct ViewLayer *view_layer; ViewLayer *view_layer;
struct ARegion *region; ARegion *region;
struct View3D *v3d; View3D *v3d;
struct RenderEngineType *engine_type; RenderEngineType *engine_type;
} DRWUpdateContext; };
void DRW_notify_view_update(const DRWUpdateContext *update_ctx); void DRW_notify_view_update(const DRWUpdateContext *update_ctx);
typedef enum eDRWSelectStage { typedef enum eDRWSelectStage {
@ -61,14 +62,14 @@ typedef enum eDRWSelectStage {
DRW_SELECT_PASS_POST, DRW_SELECT_PASS_POST,
} eDRWSelectStage; } eDRWSelectStage;
typedef bool (*DRW_SelectPassFn)(eDRWSelectStage stage, void *user_data); typedef bool (*DRW_SelectPassFn)(eDRWSelectStage stage, void *user_data);
typedef bool (*DRW_ObjectFilterFn)(struct Object *ob, void *user_data); typedef bool (*DRW_ObjectFilterFn)(Object *ob, void *user_data);
/** /**
* Everything starts here. * Everything starts here.
* This function takes care of calling all cache and rendering functions * This function takes care of calling all cache and rendering functions
* for each relevant engine / mode engine. * for each relevant engine / mode engine.
*/ */
void DRW_draw_view(const struct bContext *C); void DRW_draw_view(const bContext *C);
/** /**
* Draw render engine info. * Draw render engine info.
*/ */
@ -78,43 +79,43 @@ void DRW_draw_region_engine_info(int xoffset, int *yoffset, int line_height);
* Used for both regular and off-screen drawing. * Used for both regular and off-screen drawing.
* Need to reset DST before calling this function * Need to reset DST before calling this function
*/ */
void DRW_draw_render_loop_ex(struct Depsgraph *depsgraph, void DRW_draw_render_loop_ex(Depsgraph *depsgraph,
struct RenderEngineType *engine_type, RenderEngineType *engine_type,
struct ARegion *region, ARegion *region,
struct View3D *v3d, View3D *v3d,
struct GPUViewport *viewport, GPUViewport *viewport,
const struct bContext *evil_C); const bContext *evil_C);
void DRW_draw_render_loop(struct Depsgraph *depsgraph, void DRW_draw_render_loop(Depsgraph *depsgraph,
struct ARegion *region, ARegion *region,
struct View3D *v3d, View3D *v3d,
struct GPUViewport *viewport); GPUViewport *viewport);
/** /**
* \param viewport: can be NULL, in this case we create one. * \param viewport: can be NULL, in this case we create one.
*/ */
void DRW_draw_render_loop_offscreen(struct Depsgraph *depsgraph, void DRW_draw_render_loop_offscreen(Depsgraph *depsgraph,
struct RenderEngineType *engine_type, RenderEngineType *engine_type,
struct ARegion *region, ARegion *region,
struct View3D *v3d, View3D *v3d,
bool is_image_render, bool is_image_render,
bool draw_background, bool draw_background,
bool do_color_management, bool do_color_management,
struct GPUOffScreen *ofs, GPUOffScreen *ofs,
struct GPUViewport *viewport); GPUViewport *viewport);
void DRW_draw_render_loop_2d_ex(struct Depsgraph *depsgraph, void DRW_draw_render_loop_2d_ex(Depsgraph *depsgraph,
struct ARegion *region, ARegion *region,
struct GPUViewport *viewport, GPUViewport *viewport,
const struct bContext *evil_C); const bContext *evil_C);
/** /**
* object mode select-loop, see: #ED_view3d_draw_select_loop (legacy drawing). * object mode select-loop, see: #ED_view3d_draw_select_loop (legacy drawing).
*/ */
void DRW_draw_select_loop(struct Depsgraph *depsgraph, void DRW_draw_select_loop(Depsgraph *depsgraph,
struct ARegion *region, ARegion *region,
struct View3D *v3d, View3D *v3d,
bool use_obedit_skip, bool use_obedit_skip,
bool draw_surface, bool draw_surface,
bool use_nearest, bool use_nearest,
bool do_material_sub_selection, bool do_material_sub_selection,
const struct rcti *rect, const rcti *rect,
DRW_SelectPassFn select_pass_fn, DRW_SelectPassFn select_pass_fn,
void *select_pass_user_data, void *select_pass_user_data,
DRW_ObjectFilterFn object_filter_fn, DRW_ObjectFilterFn object_filter_fn,
@ -122,63 +123,60 @@ void DRW_draw_select_loop(struct Depsgraph *depsgraph,
/** /**
* Object mode select-loop, see: #ED_view3d_draw_depth_loop (legacy drawing). * Object mode select-loop, see: #ED_view3d_draw_depth_loop (legacy drawing).
*/ */
void DRW_draw_depth_loop(struct Depsgraph *depsgraph, void DRW_draw_depth_loop(Depsgraph *depsgraph,
struct ARegion *region, ARegion *region,
struct View3D *v3d, View3D *v3d,
struct GPUViewport *viewport, GPUViewport *viewport,
const bool use_gpencil, const bool use_gpencil,
const bool use_basic, const bool use_basic,
const bool use_overlay); const bool use_overlay);
/** /**
* Clears the Depth Buffer and draws only the specified object. * Clears the Depth Buffer and draws only the specified object.
*/ */
void DRW_draw_depth_object(struct Scene *scene, void DRW_draw_depth_object(
struct ARegion *region, Scene *scene, ARegion *region, View3D *v3d, GPUViewport *viewport, Object *object);
struct View3D *v3d, void DRW_draw_select_id(Depsgraph *depsgraph, ARegion *region, View3D *v3d);
struct GPUViewport *viewport,
struct Object *object);
void DRW_draw_select_id(struct Depsgraph *depsgraph, struct ARegion *region, struct View3D *v3d);
/* Grease pencil render. */ /* Grease pencil render. */
/** /**
* Helper to check if exit object type to render. * Helper to check if exit object type to render.
*/ */
bool DRW_render_check_grease_pencil(struct Depsgraph *depsgraph); bool DRW_render_check_grease_pencil(Depsgraph *depsgraph);
void DRW_render_gpencil(struct RenderEngine *engine, struct Depsgraph *depsgraph); void DRW_render_gpencil(RenderEngine *engine, Depsgraph *depsgraph);
/** /**
* This is here because #GPUViewport needs it. * This is here because #GPUViewport needs it.
*/ */
struct DRWInstanceDataList *DRW_instance_data_list_create(void); DRWInstanceDataList *DRW_instance_data_list_create();
void DRW_instance_data_list_free(struct DRWInstanceDataList *idatalist); void DRW_instance_data_list_free(DRWInstanceDataList *idatalist);
void DRW_uniform_attrs_pool_free(struct GHash *table); void DRW_uniform_attrs_pool_free(GHash *table);
void DRW_render_context_enable(struct Render *render); void DRW_render_context_enable(Render *render);
void DRW_render_context_disable(struct Render *render); void DRW_render_context_disable(Render *render);
void DRW_gpu_context_create(void); void DRW_gpu_context_create();
void DRW_gpu_context_destroy(void); void DRW_gpu_context_destroy();
void DRW_gpu_context_enable(void); void DRW_gpu_context_enable();
void DRW_gpu_context_disable(void); void DRW_gpu_context_disable();
#ifdef WITH_XR_OPENXR #ifdef WITH_XR_OPENXR
/* XXX: see comment on #DRW_system_gpu_context_get() */ /* XXX: see comment on #DRW_system_gpu_context_get() */
void *DRW_system_gpu_context_get(void); void *DRW_system_gpu_context_get();
void *DRW_xr_blender_gpu_context_get(void); void *DRW_xr_blender_gpu_context_get();
void DRW_xr_drawing_begin(void); void DRW_xr_drawing_begin();
void DRW_xr_drawing_end(void); void DRW_xr_drawing_end();
#endif #endif
/* For garbage collection */ /* For garbage collection */
void DRW_cache_free_old_batches(struct Main *bmain); void DRW_cache_free_old_batches(Main *bmain);
namespace blender::draw { namespace blender::draw {
void DRW_cache_free_old_subdiv(void); void DRW_cache_free_old_subdiv();
/* For the OpenGL evaluators and garbage collected subdivision data. */ /* For the OpenGL evaluators and garbage collected subdivision data. */
void DRW_subdiv_free(void); void DRW_subdiv_free();
} // namespace blender::draw } // namespace blender::draw
@ -194,29 +192,29 @@ void DRW_system_gpu_render_context_disable(void *re_system_gpu_context);
void DRW_blender_gpu_render_context_enable(void *re_gpu_context); void DRW_blender_gpu_render_context_enable(void *re_gpu_context);
void DRW_blender_gpu_render_context_disable(void *re_gpu_context); void DRW_blender_gpu_render_context_disable(void *re_gpu_context);
void DRW_deferred_shader_remove(struct GPUMaterial *mat); void DRW_deferred_shader_remove(GPUMaterial *mat);
void DRW_deferred_shader_optimize_remove(struct GPUMaterial *mat); void DRW_deferred_shader_optimize_remove(GPUMaterial *mat);
/** /**
* Get DrawData from the given ID-block. In order for this to work, we assume that * Get DrawData from the given ID-block. In order for this to work, we assume that
* the DrawData pointer is stored in the struct in the same fashion as in #IdDdtTemplate. * the DrawData pointer is stored in the in the same fashion as in #IdDdtTemplate.
*/ */
struct DrawDataList *DRW_drawdatalist_from_id(struct ID *id); DrawDataList *DRW_drawdatalist_from_id(ID *id);
void DRW_drawdata_free(struct ID *id); void DRW_drawdata_free(ID *id);
struct DRWData *DRW_viewport_data_create(void); DRWData *DRW_viewport_data_create();
void DRW_viewport_data_free(struct DRWData *drw_data); void DRW_viewport_data_free(DRWData *drw_data);
bool DRW_gpu_context_release(void); bool DRW_gpu_context_release();
void DRW_gpu_context_activate(bool drw_state); void DRW_gpu_context_activate(bool drw_state);
/** /**
* We may want to move this into a more general location. * We may want to move this into a more general location.
* \note This doesn't require the draw context to be in use. * \note This doesn't require the draw context to be in use.
*/ */
void DRW_draw_cursor_2d_ex(const struct ARegion *region, const float cursor[2]); void DRW_draw_cursor_2d_ex(const ARegion *region, const float cursor[2]);
void DRW_cdlayer_attr_aliases_add(struct GPUVertFormat *format, void DRW_cdlayer_attr_aliases_add(GPUVertFormat *format,
const char *base_name, const char *base_name,
int data_type, int data_type,
const char *layer_name, const char *layer_name,

451
source/blender/draw/intern/DRW_render.hh
View File

@ -71,6 +71,7 @@ struct ParticleSystem;
struct RenderEngineType; struct RenderEngineType;
struct bContext; struct bContext;
struct rcti; struct rcti;
struct TaskGraph;
namespace blender::draw { namespace blender::draw {
struct DRW_Attributes; struct DRW_Attributes;
struct DRW_MeshCDMask; struct DRW_MeshCDMask;
@ -85,9 +86,9 @@ typedef struct DRWUniform DRWUniform;
typedef struct DRWView DRWView; typedef struct DRWView DRWView;
/* TODO: Put it somewhere else? */ /* TODO: Put it somewhere else? */
typedef struct BoundSphere { struct BoundSphere {
float center[3], radius; float center[3], radius;
} BoundSphere; };
/* declare members as empty (unused) */ /* declare members as empty (unused) */
typedef char DRWViewportEmptyList; typedef char DRWViewportEmptyList;
@ -103,141 +104,141 @@ typedef char DRWViewportEmptyList;
DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->stl)), \ DRW_VIEWPORT_LIST_SIZE(*(((ty *)NULL)->stl)), \
} }
typedef struct DrawEngineDataSize { struct DrawEngineDataSize {
int fbl_len; int fbl_len;
int txl_len; int txl_len;
int psl_len; int psl_len;
int stl_len; int stl_len;
} DrawEngineDataSize; };
typedef struct DrawEngineType { struct DrawEngineType {
struct DrawEngineType *next, *prev; DrawEngineType *next, *prev;
char idname[32]; char idname[32];
const DrawEngineDataSize *vedata_size; const DrawEngineDataSize *vedata_size;
void (*engine_init)(void *vedata); void (*engine_init)(void *vedata);
void (*engine_free)(void); void (*engine_free)();
void (*instance_free)(void *instance_data); void (*instance_free)(void *instance_data);
void (*cache_init)(void *vedata); void (*cache_init)(void *vedata);
void (*cache_populate)(void *vedata, struct Object *ob); void (*cache_populate)(void *vedata, Object *ob);
void (*cache_finish)(void *vedata); void (*cache_finish)(void *vedata);
void (*draw_scene)(void *vedata); void (*draw_scene)(void *vedata);
void (*view_update)(void *vedata); void (*view_update)(void *vedata);
void (*id_update)(void *vedata, struct ID *id); void (*id_update)(void *vedata, ID *id);
void (*render_to_image)(void *vedata, void (*render_to_image)(void *vedata,
struct RenderEngine *engine, RenderEngine *engine,
struct RenderLayer *layer, RenderLayer *layer,
const struct rcti *rect); const rcti *rect);
void (*store_metadata)(void *vedata, struct RenderResult *render_result); void (*store_metadata)(void *vedata, RenderResult *render_result);
} DrawEngineType; };
/* Textures */ /* Textures */
typedef enum { enum DRWTextureFlag {
DRW_TEX_FILTER = (1 << 0), DRW_TEX_FILTER = (1 << 0),
DRW_TEX_WRAP = (1 << 1), DRW_TEX_WRAP = (1 << 1),
DRW_TEX_COMPARE = (1 << 2), DRW_TEX_COMPARE = (1 << 2),
DRW_TEX_MIPMAP = (1 << 3), DRW_TEX_MIPMAP = (1 << 3),
} DRWTextureFlag; };
/** /**
* Textures from `DRW_texture_pool_query_*` have the options * Textures from `DRW_texture_pool_query_*` have the options
* #DRW_TEX_FILTER for color float textures, and no options * #DRW_TEX_FILTER for color float textures, and no options
* for depth textures and integer textures. * for depth textures and integer textures.
*/ */
struct GPUTexture *DRW_texture_pool_query_2d(int w, GPUTexture *DRW_texture_pool_query_2d(int w,
int h, int h,
eGPUTextureFormat format, eGPUTextureFormat format,
DrawEngineType *engine_type); DrawEngineType *engine_type);
struct GPUTexture *DRW_texture_pool_query_fullscreen(eGPUTextureFormat format, GPUTexture *DRW_texture_pool_query_fullscreen(eGPUTextureFormat format,
DrawEngineType *engine_type); DrawEngineType *engine_type);
struct GPUTexture *DRW_texture_create_1d(int w, GPUTexture *DRW_texture_create_1d(int w,
eGPUTextureFormat format, eGPUTextureFormat format,
DRWTextureFlag flags, DRWTextureFlag flags,
const float *fpixels); const float *fpixels);
struct GPUTexture *DRW_texture_create_2d( GPUTexture *DRW_texture_create_2d(
int w, int h, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels); int w, int h, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
struct GPUTexture *DRW_texture_create_2d_array( GPUTexture *DRW_texture_create_2d_array(
int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels); int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
struct GPUTexture *DRW_texture_create_3d( GPUTexture *DRW_texture_create_3d(
int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels); int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
struct GPUTexture *DRW_texture_create_cube(int w, GPUTexture *DRW_texture_create_cube(int w,
eGPUTextureFormat format, eGPUTextureFormat format,
DRWTextureFlag flags, DRWTextureFlag flags,
const float *fpixels); const float *fpixels);
struct GPUTexture *DRW_texture_create_cube_array( GPUTexture *DRW_texture_create_cube_array(
int w, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels); int w, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
void DRW_texture_ensure_fullscreen_2d(struct GPUTexture **tex, void DRW_texture_ensure_fullscreen_2d(GPUTexture **tex,
eGPUTextureFormat format, eGPUTextureFormat format,
DRWTextureFlag flags); DRWTextureFlag flags);
void DRW_texture_ensure_2d( void DRW_texture_ensure_2d(
struct GPUTexture **tex, int w, int h, eGPUTextureFormat format, DRWTextureFlag flags); GPUTexture **tex, int w, int h, eGPUTextureFormat format, DRWTextureFlag flags);
/* Explicit parameter variants. */ /* Explicit parameter variants. */
struct GPUTexture *DRW_texture_pool_query_2d_ex( GPUTexture *DRW_texture_pool_query_2d_ex(
int w, int h, eGPUTextureFormat format, eGPUTextureUsage usage, DrawEngineType *engine_type); int w, int h, eGPUTextureFormat format, eGPUTextureUsage usage, DrawEngineType *engine_type);
struct GPUTexture *DRW_texture_pool_query_fullscreen_ex(eGPUTextureFormat format, GPUTexture *DRW_texture_pool_query_fullscreen_ex(eGPUTextureFormat format,
eGPUTextureUsage usage, eGPUTextureUsage usage,
DrawEngineType *engine_type); DrawEngineType *engine_type);
struct GPUTexture *DRW_texture_create_1d_ex(int w, GPUTexture *DRW_texture_create_1d_ex(int w,
eGPUTextureFormat format, eGPUTextureFormat format,
eGPUTextureUsage usage_flags, eGPUTextureUsage usage_flags,
DRWTextureFlag flags, DRWTextureFlag flags,
const float *fpixels); const float *fpixels);
struct GPUTexture *DRW_texture_create_2d_ex(int w, GPUTexture *DRW_texture_create_2d_ex(int w,
int h, int h,
eGPUTextureFormat format, eGPUTextureFormat format,
eGPUTextureUsage usage_flags, eGPUTextureUsage usage_flags,
DRWTextureFlag flags, DRWTextureFlag flags,
const float *fpixels); const float *fpixels);
struct GPUTexture *DRW_texture_create_2d_array_ex(int w, GPUTexture *DRW_texture_create_2d_array_ex(int w,
int h, int h,
int d, int d,
eGPUTextureFormat format, eGPUTextureFormat format,
eGPUTextureUsage usage_flags, eGPUTextureUsage usage_flags,
DRWTextureFlag flags, DRWTextureFlag flags,
const float *fpixels); const float *fpixels);
struct GPUTexture *DRW_texture_create_3d_ex(int w, GPUTexture *DRW_texture_create_3d_ex(int w,
int h, int h,
int d, int d,
eGPUTextureFormat format, eGPUTextureFormat format,
eGPUTextureUsage usage_flags, eGPUTextureUsage usage_flags,
DRWTextureFlag flags, DRWTextureFlag flags,
const float *fpixels); const float *fpixels);
struct GPUTexture *DRW_texture_create_cube_ex(int w, GPUTexture *DRW_texture_create_cube_ex(int w,
eGPUTextureFormat format, eGPUTextureFormat format,
eGPUTextureUsage usage_flags, eGPUTextureUsage usage_flags,
DRWTextureFlag flags, DRWTextureFlag flags,
const float *fpixels); const float *fpixels);
struct GPUTexture *DRW_texture_create_cube_array_ex(int w, GPUTexture *DRW_texture_create_cube_array_ex(int w,
int d, int d,
eGPUTextureFormat format, eGPUTextureFormat format,
eGPUTextureUsage usage_flags, eGPUTextureUsage usage_flags,
DRWTextureFlag flags, DRWTextureFlag flags,
const float *fpixels); const float *fpixels);
void DRW_texture_ensure_fullscreen_2d_ex(struct GPUTexture **tex, void DRW_texture_ensure_fullscreen_2d_ex(GPUTexture **tex,
eGPUTextureFormat format, eGPUTextureFormat format,
eGPUTextureUsage usage, eGPUTextureUsage usage,
DRWTextureFlag flags); DRWTextureFlag flags);
void DRW_texture_ensure_2d_ex(struct GPUTexture **tex, void DRW_texture_ensure_2d_ex(GPUTexture **tex,
int w, int w,
int h, int h,
eGPUTextureFormat format, eGPUTextureFormat format,
eGPUTextureUsage usage, eGPUTextureUsage usage,
DRWTextureFlag flags); DRWTextureFlag flags);
void DRW_texture_generate_mipmaps(struct GPUTexture *tex); void DRW_texture_generate_mipmaps(GPUTexture *tex);
void DRW_texture_free(struct GPUTexture *tex); void DRW_texture_free(GPUTexture *tex);
#define DRW_TEXTURE_FREE_SAFE(tex) \ #define DRW_TEXTURE_FREE_SAFE(tex) \
do { \ do { \
if (tex != NULL) { \ if (tex != NULL) { \
@ -255,34 +256,34 @@ void DRW_texture_free(struct GPUTexture *tex);
} while (0) } while (0)
/* Shaders */ /* Shaders */
struct GPUShader *DRW_shader_create_from_info_name(const char *info_name); GPUShader *DRW_shader_create_from_info_name(const char *info_name);
struct GPUShader *DRW_shader_create_ex( GPUShader *DRW_shader_create_ex(
const char *vert, const char *geom, const char *frag, const char *defines, const char *name); const char *vert, const char *geom, const char *frag, const char *defines, const char *name);
struct GPUShader *DRW_shader_create_with_lib_ex(const char *vert, GPUShader *DRW_shader_create_with_lib_ex(const char *vert,
const char *geom, const char *geom,
const char *frag, const char *frag,
const char *lib, const char *lib,
const char *defines, const char *defines,
const char *name); const char *name);
struct GPUShader *DRW_shader_create_with_shaderlib_ex(const char *vert, GPUShader *DRW_shader_create_with_shaderlib_ex(const char *vert,
const char *geom, const char *geom,
const char *frag, const char *frag,
const DRWShaderLibrary *lib, const DRWShaderLibrary *lib,
const char *defines, const char *defines,
const char *name); const char *name);
struct GPUShader *DRW_shader_create_with_transform_feedback(const char *vert, GPUShader *DRW_shader_create_with_transform_feedback(const char *vert,
const char *geom, const char *geom,
const char *defines, const char *defines,
eGPUShaderTFBType prim_type, eGPUShaderTFBType prim_type,
const char **varying_names, const char **varying_names,
int varying_count); int varying_count);
struct GPUShader *DRW_shader_create_fullscreen_ex(const char *frag, GPUShader *DRW_shader_create_fullscreen_ex(const char *frag,
const char *defines, const char *defines,
const char *name); const char *name);
struct GPUShader *DRW_shader_create_fullscreen_with_shaderlib_ex(const char *frag, GPUShader *DRW_shader_create_fullscreen_with_shaderlib_ex(const char *frag,
const DRWShaderLibrary *lib, const DRWShaderLibrary *lib,
const char *defines, const char *defines,
const char *name); const char *name);
#define DRW_shader_create(vert, geom, frag, defines) \ #define DRW_shader_create(vert, geom, frag, defines) \
DRW_shader_create_ex(vert, geom, frag, defines, __func__) DRW_shader_create_ex(vert, geom, frag, defines, __func__)
#define DRW_shader_create_with_lib(vert, geom, frag, lib, defines) \ #define DRW_shader_create_with_lib(vert, geom, frag, lib, defines) \
@ -294,24 +295,24 @@ struct GPUShader *DRW_shader_create_fullscreen_with_shaderlib_ex(const char *fra
#define DRW_shader_create_fullscreen_with_shaderlib(frag, lib, defines) \ #define DRW_shader_create_fullscreen_with_shaderlib(frag, lib, defines) \
DRW_shader_create_fullscreen_with_shaderlib_ex(frag, lib, defines, __func__) DRW_shader_create_fullscreen_with_shaderlib_ex(frag, lib, defines, __func__)
struct GPUMaterial *DRW_shader_from_world(struct World *wo, GPUMaterial *DRW_shader_from_world(World *wo,
struct bNodeTree *ntree, bNodeTree *ntree,
eGPUMaterialEngine engine, eGPUMaterialEngine engine,
const uint64_t shader_id, const uint64_t shader_id,
const bool is_volume_shader, const bool is_volume_shader,
bool deferred, bool deferred,
GPUCodegenCallbackFn callback, GPUCodegenCallbackFn callback,
void *thunk); void *thunk);
struct GPUMaterial *DRW_shader_from_material(struct Material *ma, GPUMaterial *DRW_shader_from_material(Material *ma,
struct bNodeTree *ntree, bNodeTree *ntree,
eGPUMaterialEngine engine, eGPUMaterialEngine engine,
const uint64_t shader_id, const uint64_t shader_id,
const bool is_volume_shader, const bool is_volume_shader,
bool deferred, bool deferred,
GPUCodegenCallbackFn callback, GPUCodegenCallbackFn callback,
void *thunk); void *thunk);
void DRW_shader_queue_optimize_material(struct GPUMaterial *mat); void DRW_shader_queue_optimize_material(GPUMaterial *mat);
void DRW_shader_free(struct GPUShader *shader); void DRW_shader_free(GPUShader *shader);
#define DRW_SHADER_FREE_SAFE(shader) \ #define DRW_SHADER_FREE_SAFE(shader) \
do { \ do { \
if (shader != NULL) { \ if (shader != NULL) { \
@ -320,7 +321,7 @@ void DRW_shader_free(struct GPUShader *shader);
} \ } \
} while (0) } while (0)
DRWShaderLibrary *DRW_shader_library_create(void); DRWShaderLibrary *DRW_shader_library_create();
/** /**
* \warning Each library must be added after all its dependencies. * \warning Each library must be added after all its dependencies.
@ -352,19 +353,19 @@ void DRW_shader_library_free(DRWShaderLibrary *lib);
/* Batches */ /* Batches */
typedef enum { enum eDRWAttrType {
DRW_ATTR_INT, DRW_ATTR_INT,
DRW_ATTR_FLOAT, DRW_ATTR_FLOAT,
} eDRWAttrType; };
typedef struct DRWInstanceAttrFormat { struct DRWInstanceAttrFormat {
char name[32]; char name[32];
eDRWAttrType type; eDRWAttrType type;
int components; int components;
} DRWInstanceAttrFormat; };
struct GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttrFormat attrs[], GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttrFormat attrs[],
int arraysize); int arraysize);
#define DRW_shgroup_instance_format(format, ...) \ #define DRW_shgroup_instance_format(format, ...) \
do { \ do { \
if (format == NULL) { \ if (format == NULL) { \
@ -374,14 +375,14 @@ struct GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttrFor
} \ } \
} while (0) } while (0)
DRWShadingGroup *DRW_shgroup_create(struct GPUShader *shader, DRWPass *pass); DRWShadingGroup *DRW_shgroup_create(GPUShader *shader, DRWPass *pass);
DRWShadingGroup *DRW_shgroup_create_sub(DRWShadingGroup *shgroup); DRWShadingGroup *DRW_shgroup_create_sub(DRWShadingGroup *shgroup);
DRWShadingGroup *DRW_shgroup_material_create(struct GPUMaterial *material, DRWPass *pass); DRWShadingGroup *DRW_shgroup_material_create(GPUMaterial *material, DRWPass *pass);
DRWShadingGroup *DRW_shgroup_transform_feedback_create(struct GPUShader *shader, DRWShadingGroup *DRW_shgroup_transform_feedback_create(GPUShader *shader,
DRWPass *pass, DRWPass *pass,
struct GPUVertBuf *tf_target); GPUVertBuf *tf_target);
void DRW_shgroup_add_material_resources(DRWShadingGroup *grp, struct GPUMaterial *material); void DRW_shgroup_add_material_resources(DRWShadingGroup *grp, GPUMaterial *material);
/** /**
* Return final visibility. * Return final visibility.
@ -391,7 +392,7 @@ typedef bool(DRWCallVisibilityFn)(bool vis_in, void *user_data);
void DRW_shgroup_call_ex(DRWShadingGroup *shgroup, void DRW_shgroup_call_ex(DRWShadingGroup *shgroup,
const Object *ob, const Object *ob,
const float (*obmat)[4], const float (*obmat)[4],
struct GPUBatch *geom, GPUBatch *geom,
bool bypass_culling, bool bypass_culling,
void *user_data); void *user_data);
@ -419,12 +420,12 @@ void DRW_shgroup_call_ex(DRWShadingGroup *shgroup,
DRW_shgroup_call_ex(shgroup, ob, NULL, geom, true, NULL) DRW_shgroup_call_ex(shgroup, ob, NULL, geom, true, NULL)
void DRW_shgroup_call_range( void DRW_shgroup_call_range(
DRWShadingGroup *shgroup, const Object *ob, struct GPUBatch *geom, uint v_sta, uint v_num); DRWShadingGroup *shgroup, const Object *ob, GPUBatch *geom, uint v_sta, uint v_num);
/** /**
* A count of 0 instance will use the default number of instance in the batch. * A count of 0 instance will use the default number of instance in the batch.
*/ */
void DRW_shgroup_call_instance_range( void DRW_shgroup_call_instance_range(
DRWShadingGroup *shgroup, const Object *ob, struct GPUBatch *geom, uint i_sta, uint i_num); DRWShadingGroup *shgroup, const Object *ob, GPUBatch *geom, uint i_sta, uint i_num);
void DRW_shgroup_call_compute(DRWShadingGroup *shgroup, void DRW_shgroup_call_compute(DRWShadingGroup *shgroup,
int groups_x_len, int groups_x_len,
@ -451,15 +452,15 @@ void DRW_shgroup_call_procedural_indirect(DRWShadingGroup *shgroup,
*/ */
void DRW_shgroup_call_instances(DRWShadingGroup *shgroup, void DRW_shgroup_call_instances(DRWShadingGroup *shgroup,
const Object *ob, const Object *ob,
struct GPUBatch *geom, GPUBatch *geom,
uint count); uint count);
/** /**
* \warning Only use with Shaders that have INSTANCED_ATTR defined. * \warning Only use with Shaders that have INSTANCED_ATTR defined.
*/ */
void DRW_shgroup_call_instances_with_attrs(DRWShadingGroup *shgroup, void DRW_shgroup_call_instances_with_attrs(DRWShadingGroup *shgroup,
const Object *ob, const Object *ob,
struct GPUBatch *geom, GPUBatch *geom,
struct GPUBatch *inst_attributes); GPUBatch *inst_attributes);
void DRW_shgroup_call_sculpt(DRWShadingGroup *shgroup, void DRW_shgroup_call_sculpt(DRWShadingGroup *shgroup,
Object *ob, Object *ob,
@ -470,16 +471,16 @@ void DRW_shgroup_call_sculpt(DRWShadingGroup *shgroup,
bool use_uv); bool use_uv);
void DRW_shgroup_call_sculpt_with_materials(DRWShadingGroup **shgroups, void DRW_shgroup_call_sculpt_with_materials(DRWShadingGroup **shgroups,
struct GPUMaterial **gpumats, GPUMaterial **gpumats,
int num_shgroups, int num_shgroups,
const Object *ob); const Object *ob);
DRWCallBuffer *DRW_shgroup_call_buffer(DRWShadingGroup *shgroup, DRWCallBuffer *DRW_shgroup_call_buffer(DRWShadingGroup *shgroup,
struct GPUVertFormat *format, GPUVertFormat *format,
GPUPrimType prim_type); GPUPrimType prim_type);
DRWCallBuffer *DRW_shgroup_call_buffer_instance(DRWShadingGroup *shgroup, DRWCallBuffer *DRW_shgroup_call_buffer_instance(DRWShadingGroup *shgroup,
struct GPUVertFormat *format, GPUVertFormat *format,
struct GPUBatch *geom); GPUBatch *geom);
void DRW_buffer_add_entry_struct(DRWCallBuffer *callbuf, const void *data); void DRW_buffer_add_entry_struct(DRWCallBuffer *callbuf, const void *data);
void DRW_buffer_add_entry_array(DRWCallBuffer *callbuf, const void *attr[], uint attr_len); void DRW_buffer_add_entry_array(DRWCallBuffer *callbuf, const void *attr[], uint attr_len);
@ -536,7 +537,7 @@ void DRW_shgroup_clear_framebuffer(DRWShadingGroup *shgroup,
void DRW_shgroup_uniform_texture_ex(DRWShadingGroup *shgroup, void DRW_shgroup_uniform_texture_ex(DRWShadingGroup *shgroup,
const char *name, const char *name,
const struct GPUTexture *tex, const GPUTexture *tex,
GPUSamplerState sampler_state); GPUSamplerState sampler_state);
void DRW_shgroup_uniform_texture_ref_ex(DRWShadingGroup *shgroup, void DRW_shgroup_uniform_texture_ref_ex(DRWShadingGroup *shgroup,
const char *name, const char *name,
@ -544,22 +545,20 @@ void DRW_shgroup_uniform_texture_ref_ex(DRWShadingGroup *shgroup,
GPUSamplerState sampler_state); GPUSamplerState sampler_state);
void DRW_shgroup_uniform_texture(DRWShadingGroup *shgroup, void DRW_shgroup_uniform_texture(DRWShadingGroup *shgroup,
const char *name, const char *name,
const struct GPUTexture *tex); const GPUTexture *tex);
void DRW_shgroup_uniform_texture_ref(DRWShadingGroup *shgroup, void DRW_shgroup_uniform_texture_ref(DRWShadingGroup *shgroup, const char *name, GPUTexture **tex);
const char *name,
struct GPUTexture **tex);
void DRW_shgroup_uniform_block_ex(DRWShadingGroup *shgroup, void DRW_shgroup_uniform_block_ex(DRWShadingGroup *shgroup,
const char *name, const char *name,
const struct GPUUniformBuf *ubo DRW_DEBUG_FILE_LINE_ARGS); const GPUUniformBuf *ubo DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_uniform_block_ref_ex(DRWShadingGroup *shgroup, void DRW_shgroup_uniform_block_ref_ex(DRWShadingGroup *shgroup,
const char *name, const char *name,
struct GPUUniformBuf **ubo DRW_DEBUG_FILE_LINE_ARGS); GPUUniformBuf **ubo DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_storage_block_ex(DRWShadingGroup *shgroup, void DRW_shgroup_storage_block_ex(DRWShadingGroup *shgroup,
const char *name, const char *name,
const struct GPUStorageBuf *ssbo DRW_DEBUG_FILE_LINE_ARGS); const GPUStorageBuf *ssbo DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_storage_block_ref_ex(DRWShadingGroup *shgroup, void DRW_shgroup_storage_block_ref_ex(DRWShadingGroup *shgroup,
const char *name, const char *name,
struct GPUStorageBuf **ssbo DRW_DEBUG_FILE_LINE_ARGS); GPUStorageBuf **ssbo DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_uniform_float(DRWShadingGroup *shgroup, void DRW_shgroup_uniform_float(DRWShadingGroup *shgroup,
const char *name, const char *name,
const float *value, const float *value,
@ -620,16 +619,16 @@ void DRW_shgroup_uniform_mat4_copy(DRWShadingGroup *shgroup,
const float (*value)[4]); const float (*value)[4]);
void DRW_shgroup_vertex_buffer_ex(DRWShadingGroup *shgroup, void DRW_shgroup_vertex_buffer_ex(DRWShadingGroup *shgroup,
const char *name, const char *name,
struct GPUVertBuf *vertex_buffer DRW_DEBUG_FILE_LINE_ARGS); GPUVertBuf *vertex_buffer DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_vertex_buffer_ref_ex(DRWShadingGroup *shgroup, void DRW_shgroup_vertex_buffer_ref_ex(DRWShadingGroup *shgroup,
const char *name, const char *name,
struct GPUVertBuf **vertex_buffer DRW_DEBUG_FILE_LINE_ARGS); GPUVertBuf **vertex_buffer DRW_DEBUG_FILE_LINE_ARGS);
void DRW_shgroup_buffer_texture(DRWShadingGroup *shgroup, void DRW_shgroup_buffer_texture(DRWShadingGroup *shgroup,
const char *name, const char *name,
struct GPUVertBuf *vertex_buffer); GPUVertBuf *vertex_buffer);
void DRW_shgroup_buffer_texture_ref(DRWShadingGroup *shgroup, void DRW_shgroup_buffer_texture_ref(DRWShadingGroup *shgroup,
const char *name, const char *name,
struct GPUVertBuf **vertex_buffer); GPUVertBuf **vertex_buffer);
#ifdef DRW_UNUSED_RESOURCE_TRACKING #ifdef DRW_UNUSED_RESOURCE_TRACKING
# define DRW_shgroup_vertex_buffer(shgroup, name, vert) \ # define DRW_shgroup_vertex_buffer(shgroup, name, vert) \
@ -725,7 +724,7 @@ void DRW_view_update_sub(DRWView *view, const float viewmat[4][4], const float w
/** /**
* \return default view if it is a viewport render. * \return default view if it is a viewport render.
*/ */
const DRWView *DRW_view_default_get(void); const DRWView *DRW_view_default_get();
/** /**
* MUST only be called once per render and only in render mode. Sets default view. * MUST only be called once per render and only in render mode. Sets default view.
*/ */
@ -733,12 +732,12 @@ void DRW_view_default_set(const DRWView *view);
/** /**
* \warning Only use in render AND only if you are going to set view_default again. * \warning Only use in render AND only if you are going to set view_default again.
*/ */
void DRW_view_reset(void); void DRW_view_reset();
/** /**
* Set active view for rendering. * Set active view for rendering.
*/ */
void DRW_view_set_active(const DRWView *view); void DRW_view_set_active(const DRWView *view);
const DRWView *DRW_view_get_active(void); const DRWView *DRW_view_get_active();
/** /**
* This only works if DRWPasses have been tagged with DRW_STATE_CLIP_PLANES, * This only works if DRWPasses have been tagged with DRW_STATE_CLIP_PLANES,
@ -799,34 +798,29 @@ void DRW_culling_frustum_planes_get(const DRWView *view, float planes[6][4]);
/* Viewport. */ /* Viewport. */
const float *DRW_viewport_size_get(void); const float *DRW_viewport_size_get();
const float *DRW_viewport_invert_size_get(void); const float *DRW_viewport_invert_size_get();
const float *DRW_viewport_pixelsize_get(void); const float *DRW_viewport_pixelsize_get();
struct DefaultFramebufferList *DRW_viewport_framebuffer_list_get(void); DefaultFramebufferList *DRW_viewport_framebuffer_list_get();
struct DefaultTextureList *DRW_viewport_texture_list_get(void); DefaultTextureList *DRW_viewport_texture_list_get();
void DRW_viewport_request_redraw(void); void DRW_viewport_request_redraw();
void DRW_render_to_image(struct RenderEngine *engine, struct Depsgraph *depsgraph); void DRW_render_to_image(RenderEngine *engine, Depsgraph *depsgraph);
void DRW_render_object_iter(void *vedata, void DRW_render_object_iter(
struct RenderEngine *engine, void *vedata,
struct Depsgraph *depsgraph, RenderEngine *engine,
void (*callback)(void *vedata, Depsgraph *depsgraph,
struct Object *ob, void (*callback)(void *vedata, Object *ob, RenderEngine *engine, Depsgraph *depsgraph));
struct RenderEngine *engine,
struct Depsgraph *depsgraph));
/** /**
* Must run after all instance datas have been added. * Must run after all instance datas have been added.
*/ */
void DRW_render_instance_buffer_finish(void); void DRW_render_instance_buffer_finish();
/** /**
* \warning Changing frame might free the #ViewLayerEngineData. * \warning Changing frame might free the #ViewLayerEngineData.
*/ */
void DRW_render_set_time(struct RenderEngine *engine, void DRW_render_set_time(RenderEngine *engine, Depsgraph *depsgraph, int frame, float subframe);
struct Depsgraph *depsgraph,
int frame,
float subframe);
/** /**
* \warning only use for custom pipeline. 99% of the time, you don't want to use this. * \warning only use for custom pipeline. 99% of the time, you don't want to use this.
*/ */
@ -838,24 +832,24 @@ void DRW_render_viewport_size_set(const int size[2]);
* \warning similar to DRW_render_to_image you cannot use default lists (`dfbl` & `dtxl`). * \warning similar to DRW_render_to_image you cannot use default lists (`dfbl` & `dtxl`).
*/ */
void DRW_custom_pipeline(DrawEngineType *draw_engine_type, void DRW_custom_pipeline(DrawEngineType *draw_engine_type,
struct Depsgraph *depsgraph, Depsgraph *depsgraph,
void (*callback)(void *vedata, void *user_data), void (*callback)(void *vedata, void *user_data),
void *user_data); void *user_data);
/** /**
* Same as `DRW_custom_pipeline` but allow better code-flow than a callback. * Same as `DRW_custom_pipeline` but allow better code-flow than a callback.
*/ */
void DRW_custom_pipeline_begin(DrawEngineType *draw_engine_type, struct Depsgraph *depsgraph); void DRW_custom_pipeline_begin(DrawEngineType *draw_engine_type, Depsgraph *depsgraph);
void DRW_custom_pipeline_end(void); void DRW_custom_pipeline_end();
/** /**
* Used when the render engine want to redo another cache populate inside the same render frame. * Used when the render engine want to redo another cache populate inside the same render frame.
*/ */
void DRW_cache_restart(void); void DRW_cache_restart();
/* ViewLayers */ /* ViewLayers */
void *DRW_view_layer_engine_data_get(DrawEngineType *engine_type); void *DRW_view_layer_engine_data_get(DrawEngineType *engine_type);
void **DRW_view_layer_engine_data_ensure_ex(struct ViewLayer *view_layer, void **DRW_view_layer_engine_data_ensure_ex(ViewLayer *view_layer,
DrawEngineType *engine_type, DrawEngineType *engine_type,
void (*callback)(void *storage)); void (*callback)(void *storage));
void **DRW_view_layer_engine_data_ensure(DrawEngineType *engine_type, void **DRW_view_layer_engine_data_ensure(DrawEngineType *engine_type,
@ -876,7 +870,7 @@ void **DRW_duplidata_get(void *vedata);
/* Settings. */ /* Settings. */
bool DRW_object_is_renderable(const struct Object *ob); bool DRW_object_is_renderable(const Object *ob);
/** /**
* Does `ob` needs to be rendered in edit mode. * Does `ob` needs to be rendered in edit mode.
* *
@ -884,19 +878,19 @@ bool DRW_object_is_renderable(const struct Object *ob);
* it is in edit mode, when another object with the same mesh is in edit mode. * it is in edit mode, when another object with the same mesh is in edit mode.
* This will not be the case when one of the objects are influenced by modifiers. * This will not be the case when one of the objects are influenced by modifiers.
*/ */
bool DRW_object_is_in_edit_mode(const struct Object *ob); bool DRW_object_is_in_edit_mode(const Object *ob);
/** /**
* Return whether this object is visible depending if * Return whether this object is visible depending if
* we are rendering or drawing in the viewport. * we are rendering or drawing in the viewport.
*/ */
int DRW_object_visibility_in_active_context(const struct Object *ob); int DRW_object_visibility_in_active_context(const Object *ob);
bool DRW_object_use_hide_faces(const struct Object *ob); bool DRW_object_use_hide_faces(const Object *ob);
bool DRW_object_is_visible_psys_in_active_context(const struct Object *object, bool DRW_object_is_visible_psys_in_active_context(const Object *object,
const struct ParticleSystem *psys); const ParticleSystem *psys);
struct Object *DRW_object_get_dupli_parent(const struct Object *ob); Object *DRW_object_get_dupli_parent(const Object *ob);
struct DupliObject *DRW_object_get_dupli(const struct Object *ob); DupliObject *DRW_object_get_dupli(const Object *ob);
/* Draw commands */ /* Draw commands */
@ -906,14 +900,14 @@ void DRW_draw_pass(DRWPass *pass);
*/ */
void DRW_draw_pass_subset(DRWPass *pass, DRWShadingGroup *start_group, DRWShadingGroup *end_group); void DRW_draw_pass_subset(DRWPass *pass, DRWShadingGroup *start_group, DRWShadingGroup *end_group);
void DRW_draw_callbacks_pre_scene(void); void DRW_draw_callbacks_pre_scene();
void DRW_draw_callbacks_post_scene(void); void DRW_draw_callbacks_post_scene();
/** /**
* Reset state to not interfere with other UI draw-call. * Reset state to not interfere with other UI draw-call.
*/ */
void DRW_state_reset_ex(DRWState state); void DRW_state_reset_ex(DRWState state);
void DRW_state_reset(void); void DRW_state_reset();
/** /**
* Use with care, intended so selection code can override passes depth settings, * Use with care, intended so selection code can override passes depth settings,
* which is important for selection to work properly. * which is important for selection to work properly.
@ -932,64 +926,64 @@ void DRW_select_load_id(uint id);
* When false, drawing doesn't output to a pixel buffer * When false, drawing doesn't output to a pixel buffer
* eg: Occlusion queries, or when we have setup a context to draw in already. * eg: Occlusion queries, or when we have setup a context to draw in already.
*/ */
bool DRW_state_is_fbo(void); bool DRW_state_is_fbo();
/** /**
* For when engines need to know if this is drawing for selection or not. * For when engines need to know if this is drawing for selection or not.
*/ */
bool DRW_state_is_select(void); bool DRW_state_is_select();
bool DRW_state_is_material_select(void); bool DRW_state_is_material_select();
bool DRW_state_is_depth(void); bool DRW_state_is_depth();
/** /**
* Whether we are rendering for an image * Whether we are rendering for an image
*/ */
bool DRW_state_is_image_render(void); bool DRW_state_is_image_render();
/** /**
* Whether we are rendering only the render engine, * Whether we are rendering only the render engine,
* or if we should also render the mode engines. * or if we should also render the mode engines.
*/ */
bool DRW_state_is_scene_render(void); bool DRW_state_is_scene_render();
/** /**
* Whether we are rendering simple opengl render * Whether we are rendering simple opengl render
*/ */
bool DRW_state_is_viewport_image_render(void); bool DRW_state_is_viewport_image_render();
bool DRW_state_is_playback(void); bool DRW_state_is_playback();
/** /**
* Is the user navigating the region. * Is the user navigating the region.
*/ */
bool DRW_state_is_navigating(void); bool DRW_state_is_navigating();
/** /**
* Should text draw in this mode? * Should text draw in this mode?
*/ */
bool DRW_state_show_text(void); bool DRW_state_show_text();
/** /**
* Should draw support elements * Should draw support elements
* Objects center, selection outline, probe data, ... * Objects center, selection outline, probe data, ...
*/ */
bool DRW_state_draw_support(void); bool DRW_state_draw_support();
/** /**
* Whether we should render the background * Whether we should render the background
*/ */
bool DRW_state_draw_background(void); bool DRW_state_draw_background();
/* Avoid too many lookups while drawing */ /* Avoid too many lookups while drawing */
typedef struct DRWContextState { struct DRWContextState {
struct ARegion *region; /* 'CTX_wm_region(C)' */ ARegion *region; /* 'CTX_wm_region(C)' */
struct RegionView3D *rv3d; /* 'CTX_wm_region_view3d(C)' */ RegionView3D *rv3d; /* 'CTX_wm_region_view3d(C)' */
struct View3D *v3d; /* 'CTX_wm_view3d(C)' */ View3D *v3d; /* 'CTX_wm_view3d(C)' */
struct SpaceLink *space_data; /* 'CTX_wm_space_data(C)' */ SpaceLink *space_data; /* 'CTX_wm_space_data(C)' */
struct Scene *scene; /* 'CTX_data_scene(C)' */ Scene *scene; /* 'CTX_data_scene(C)' */
struct ViewLayer *view_layer; /* 'CTX_data_view_layer(C)' */ ViewLayer *view_layer; /* 'CTX_data_view_layer(C)' */
/* Use 'object_edit' for edit-mode */ /* Use 'object_edit' for edit-mode */
struct Object *obact; Object *obact;
struct RenderEngineType *engine_type; RenderEngineType *engine_type;
struct Depsgraph *depsgraph; Depsgraph *depsgraph;
struct TaskGraph *task_graph; TaskGraph *task_graph;
eObjectMode object_mode; eObjectMode object_mode;
@ -997,20 +991,19 @@ typedef struct DRWContextState {
/** Last resort (some functions take this as an arg so we can't easily avoid). /** Last resort (some functions take this as an arg so we can't easily avoid).
* May be NULL when used for selection or depth buffer. */ * May be NULL when used for selection or depth buffer. */
const struct bContext *evil_C; const bContext *evil_C;
/* ---- */ /* ---- */
/* Cache: initialized by 'drw_context_state_init'. */ /* Cache: initialized by 'drw_context_state_init'. */
struct Object *object_pose; Object *object_pose;
struct Object *object_edit; Object *object_edit;
};
} DRWContextState; const DRWContextState *DRW_context_state_get();
const DRWContextState *DRW_context_state_get(void); void DRW_mesh_batch_cache_get_attributes(Object *object,
Mesh *mesh,
void DRW_mesh_batch_cache_get_attributes(struct Object *object,
struct Mesh *mesh,
blender::draw::DRW_Attributes **r_attrs, blender::draw::DRW_Attributes **r_attrs,
blender::draw::DRW_MeshCDMask **r_cd_needed); blender::draw::DRW_MeshCDMask **r_cd_needed);

288
source/blender/draw/intern/draw_cache.hh
View File

@ -33,210 +33,208 @@ typedef enum eDRWLevelOfDetail {
DRW_LOD_MAX, /* Max number of level of detail */ DRW_LOD_MAX, /* Max number of level of detail */
} eDRWLevelOfDetail; } eDRWLevelOfDetail;
void DRW_shape_cache_free(void); void DRW_shape_cache_free();
/* 3D cursor */ /* 3D cursor */
struct GPUBatch *DRW_cache_cursor_get(bool crosshair_lines); GPUBatch *DRW_cache_cursor_get(bool crosshair_lines);
/* Common Shapes */ /* Common Shapes */
struct GPUBatch *DRW_cache_groundline_get(void); GPUBatch *DRW_cache_groundline_get();
/* Grid */ /* Grid */
struct GPUBatch *DRW_cache_grid_get(void); GPUBatch *DRW_cache_grid_get();
/** /**
* Use this one for rendering full-screen passes. For 3D objects use #DRW_cache_quad_get(). * Use this one for rendering full-screen passes. For 3D objects use #DRW_cache_quad_get().
*/ */
struct GPUBatch *DRW_cache_fullscreen_quad_get(void); GPUBatch *DRW_cache_fullscreen_quad_get();
/* Just a regular quad with 4 vertices. */ /* Just a regular quad with 4 vertices. */
struct GPUBatch *DRW_cache_quad_get(void); GPUBatch *DRW_cache_quad_get();
/* Just a regular quad with 4 vertices - wires. */ /* Just a regular quad with 4 vertices - wires. */
struct GPUBatch *DRW_cache_quad_wires_get(void); GPUBatch *DRW_cache_quad_wires_get();
struct GPUBatch *DRW_cache_cube_get(void); GPUBatch *DRW_cache_cube_get();
struct GPUBatch *DRW_cache_normal_arrow_get(void); GPUBatch *DRW_cache_normal_arrow_get();
struct GPUBatch *DRW_cache_sphere_get(eDRWLevelOfDetail level_of_detail); GPUBatch *DRW_cache_sphere_get(eDRWLevelOfDetail level_of_detail);
/* Dummy VBOs */ /* Dummy VBOs */
struct GPUBatch *DRW_gpencil_dummy_buffer_get(void); GPUBatch *DRW_gpencil_dummy_buffer_get();
/* Common Object */ /* Common Object */
struct GPUBatch *DRW_cache_object_all_edges_get(struct Object *ob); GPUBatch *DRW_cache_object_all_edges_get(Object *ob);
struct GPUBatch *DRW_cache_object_edge_detection_get(struct Object *ob, bool *r_is_manifold); GPUBatch *DRW_cache_object_edge_detection_get(Object *ob, bool *r_is_manifold);
struct GPUBatch *DRW_cache_object_surface_get(struct Object *ob); GPUBatch *DRW_cache_object_surface_get(Object *ob);
struct GPUBatch *DRW_cache_object_loose_edges_get(struct Object *ob); GPUBatch *DRW_cache_object_loose_edges_get(Object *ob);
struct GPUBatch **DRW_cache_object_surface_material_get(struct Object *ob, GPUBatch **DRW_cache_object_surface_material_get(Object *ob,
struct GPUMaterial **gpumat_array, GPUMaterial **gpumat_array,
uint gpumat_array_len); uint gpumat_array_len);
struct GPUBatch *DRW_cache_object_face_wireframe_get(struct Object *ob); GPUBatch *DRW_cache_object_face_wireframe_get(Object *ob);
int DRW_cache_object_material_count_get(const struct Object *ob); int DRW_cache_object_material_count_get(const Object *ob);
/** /**
* Returns the vertbuf used by shaded surface batch. * Returns the vertbuf used by shaded surface batch.
*/ */
struct GPUVertBuf *DRW_cache_object_pos_vertbuf_get(struct Object *ob); GPUVertBuf *DRW_cache_object_pos_vertbuf_get(Object *ob);
/* Empties */ /* Empties */
struct GPUBatch *DRW_cache_plain_axes_get(void); GPUBatch *DRW_cache_plain_axes_get();
struct GPUBatch *DRW_cache_single_arrow_get(void); GPUBatch *DRW_cache_single_arrow_get();
struct GPUBatch *DRW_cache_empty_cube_get(void); GPUBatch *DRW_cache_empty_cube_get();
struct GPUBatch *DRW_cache_circle_get(void); GPUBatch *DRW_cache_circle_get();
struct GPUBatch *DRW_cache_empty_sphere_get(void); GPUBatch *DRW_cache_empty_sphere_get();
struct GPUBatch *DRW_cache_empty_cylinder_get(void); GPUBatch *DRW_cache_empty_cylinder_get();
struct GPUBatch *DRW_cache_empty_cone_get(void); GPUBatch *DRW_cache_empty_cone_get();
struct GPUBatch *DRW_cache_empty_capsule_cap_get(void); GPUBatch *DRW_cache_empty_capsule_cap_get();
struct GPUBatch *DRW_cache_empty_capsule_body_get(void); GPUBatch *DRW_cache_empty_capsule_body_get();
/* Force Field */ /* Force Field */
struct GPUBatch *DRW_cache_field_wind_get(void); GPUBatch *DRW_cache_field_wind_get();
struct GPUBatch *DRW_cache_field_force_get(void); GPUBatch *DRW_cache_field_force_get();
struct GPUBatch *DRW_cache_field_vortex_get(void); GPUBatch *DRW_cache_field_vortex_get();
/* Screen-aligned circle. */ /* Screen-aligned circle. */
struct GPUBatch *DRW_cache_field_curve_get(void); GPUBatch *DRW_cache_field_curve_get();
struct GPUBatch *DRW_cache_field_tube_limit_get(void); GPUBatch *DRW_cache_field_tube_limit_get();
struct GPUBatch *DRW_cache_field_cone_limit_get(void); GPUBatch *DRW_cache_field_cone_limit_get();
/* Screen-aligned dashed circle */ /* Screen-aligned dashed circle */
struct GPUBatch *DRW_cache_field_sphere_limit_get(void); GPUBatch *DRW_cache_field_sphere_limit_get();
/* Lights */ /* Lights */
struct GPUBatch *DRW_cache_light_icon_inner_lines_get(void); GPUBatch *DRW_cache_light_icon_inner_lines_get();
struct GPUBatch *DRW_cache_light_icon_outer_lines_get(void); GPUBatch *DRW_cache_light_icon_outer_lines_get();
struct GPUBatch *DRW_cache_light_icon_sun_rays_get(void); GPUBatch *DRW_cache_light_icon_sun_rays_get();
struct GPUBatch *DRW_cache_light_point_lines_get(void); GPUBatch *DRW_cache_light_point_lines_get();
struct GPUBatch *DRW_cache_light_sun_lines_get(void); GPUBatch *DRW_cache_light_sun_lines_get();
struct GPUBatch *DRW_cache_light_spot_lines_get(void); GPUBatch *DRW_cache_light_spot_lines_get();
struct GPUBatch *DRW_cache_light_area_disk_lines_get(void); GPUBatch *DRW_cache_light_area_disk_lines_get();
struct GPUBatch *DRW_cache_light_area_square_lines_get(void); GPUBatch *DRW_cache_light_area_square_lines_get();
struct GPUBatch *DRW_cache_light_spot_volume_get(void); GPUBatch *DRW_cache_light_spot_volume_get();
/* Camera */ /* Camera */
struct GPUBatch *DRW_cache_camera_frame_get(void); GPUBatch *DRW_cache_camera_frame_get();
struct GPUBatch *DRW_cache_camera_volume_get(void); GPUBatch *DRW_cache_camera_volume_get();
struct GPUBatch *DRW_cache_camera_volume_wire_get(void); GPUBatch *DRW_cache_camera_volume_wire_get();
struct GPUBatch *DRW_cache_camera_tria_wire_get(void); GPUBatch *DRW_cache_camera_tria_wire_get();
struct GPUBatch *DRW_cache_camera_tria_get(void); GPUBatch *DRW_cache_camera_tria_get();
struct GPUBatch *DRW_cache_camera_distances_get(void); GPUBatch *DRW_cache_camera_distances_get();
/* Speaker */ /* Speaker */
struct GPUBatch *DRW_cache_speaker_get(void); GPUBatch *DRW_cache_speaker_get();
/* Probe */ /* Probe */
struct GPUBatch *DRW_cache_lightprobe_cube_get(void); GPUBatch *DRW_cache_lightprobe_cube_get();
struct GPUBatch *DRW_cache_lightprobe_grid_get(void); GPUBatch *DRW_cache_lightprobe_grid_get();
struct GPUBatch *DRW_cache_lightprobe_planar_get(void); GPUBatch *DRW_cache_lightprobe_planar_get();
/* Bones */ /* Bones */
struct GPUBatch *DRW_cache_bone_octahedral_get(void); GPUBatch *DRW_cache_bone_octahedral_get();
struct GPUBatch *DRW_cache_bone_octahedral_wire_get(void); GPUBatch *DRW_cache_bone_octahedral_wire_get();
struct GPUBatch *DRW_cache_bone_box_get(void); GPUBatch *DRW_cache_bone_box_get();
struct GPUBatch *DRW_cache_bone_box_wire_get(void); GPUBatch *DRW_cache_bone_box_wire_get();
struct GPUBatch *DRW_cache_bone_envelope_solid_get(void); GPUBatch *DRW_cache_bone_envelope_solid_get();
struct GPUBatch *DRW_cache_bone_envelope_outline_get(void); GPUBatch *DRW_cache_bone_envelope_outline_get();
struct GPUBatch *DRW_cache_bone_point_get(void); GPUBatch *DRW_cache_bone_point_get();
struct GPUBatch *DRW_cache_bone_point_wire_outline_get(void); GPUBatch *DRW_cache_bone_point_wire_outline_get();
struct GPUBatch *DRW_cache_bone_stick_get(void); GPUBatch *DRW_cache_bone_stick_get();
struct GPUBatch *DRW_cache_bone_arrows_get(void); GPUBatch *DRW_cache_bone_arrows_get();
struct GPUBatch *DRW_cache_bone_dof_sphere_get(void); GPUBatch *DRW_cache_bone_dof_sphere_get();
struct GPUBatch *DRW_cache_bone_dof_lines_get(void); GPUBatch *DRW_cache_bone_dof_lines_get();
/* Meshes */ /* Meshes */
struct GPUBatch *DRW_cache_mesh_all_verts_get(struct Object *ob); GPUBatch *DRW_cache_mesh_all_verts_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_all_edges_get(struct Object *ob); GPUBatch *DRW_cache_mesh_all_edges_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_loose_edges_get(struct Object *ob); GPUBatch *DRW_cache_mesh_loose_edges_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_edge_detection_get(struct Object *ob, bool *r_is_manifold); GPUBatch *DRW_cache_mesh_edge_detection_get(Object *ob, bool *r_is_manifold);
struct GPUBatch *DRW_cache_mesh_surface_get(struct Object *ob); GPUBatch *DRW_cache_mesh_surface_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_edges_get(struct Object *ob); GPUBatch *DRW_cache_mesh_surface_edges_get(Object *ob);
/** /**
* Return list of batches with length equal to `max(1, totcol)`. * Return list of batches with length equal to `max(1, totcol)`.
*/ */
struct GPUBatch **DRW_cache_mesh_surface_shaded_get(struct Object *ob, GPUBatch **DRW_cache_mesh_surface_shaded_get(Object *ob,
struct GPUMaterial **gpumat_array, GPUMaterial **gpumat_array,
uint gpumat_array_len); uint gpumat_array_len);
/** /**
* Return list of batches with length equal to `max(1, totcol)`. * Return list of batches with length equal to `max(1, totcol)`.
*/ */
struct GPUBatch **DRW_cache_mesh_surface_texpaint_get(struct Object *ob); GPUBatch **DRW_cache_mesh_surface_texpaint_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_texpaint_single_get(struct Object *ob); GPUBatch *DRW_cache_mesh_surface_texpaint_single_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_vertpaint_get(struct Object *ob); GPUBatch *DRW_cache_mesh_surface_vertpaint_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_sculptcolors_get(struct Object *ob); GPUBatch *DRW_cache_mesh_surface_sculptcolors_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_weights_get(struct Object *ob); GPUBatch *DRW_cache_mesh_surface_weights_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_mesh_analysis_get(struct Object *ob); GPUBatch *DRW_cache_mesh_surface_mesh_analysis_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_face_wireframe_get(struct Object *ob); GPUBatch *DRW_cache_mesh_face_wireframe_get(Object *ob);
struct GPUBatch *DRW_cache_mesh_surface_viewer_attribute_get(struct Object *ob); GPUBatch *DRW_cache_mesh_surface_viewer_attribute_get(Object *ob);
/* Curve */ /* Curve */
struct GPUBatch *DRW_cache_curve_edge_wire_get(struct Object *ob); GPUBatch *DRW_cache_curve_edge_wire_get(Object *ob);
struct GPUBatch *DRW_cache_curve_edge_wire_viewer_attribute_get(struct Object *ob); GPUBatch *DRW_cache_curve_edge_wire_viewer_attribute_get(Object *ob);
/* edit-mode */ /* edit-mode */
struct GPUBatch *DRW_cache_curve_edge_normal_get(struct Object *ob); GPUBatch *DRW_cache_curve_edge_normal_get(Object *ob);
struct GPUBatch *DRW_cache_curve_edge_overlay_get(struct Object *ob); GPUBatch *DRW_cache_curve_edge_overlay_get(Object *ob);
struct GPUBatch *DRW_cache_curve_vert_overlay_get(struct Object *ob); GPUBatch *DRW_cache_curve_vert_overlay_get(Object *ob);
/* Font */ /* Font */
struct GPUBatch *DRW_cache_text_edge_wire_get(struct Object *ob); GPUBatch *DRW_cache_text_edge_wire_get(Object *ob);
/* Surface */ /* Surface */
struct GPUBatch *DRW_cache_surf_edge_wire_get(struct Object *ob); GPUBatch *DRW_cache_surf_edge_wire_get(Object *ob);
/* Lattice */ /* Lattice */
struct GPUBatch *DRW_cache_lattice_verts_get(struct Object *ob); GPUBatch *DRW_cache_lattice_verts_get(Object *ob);
struct GPUBatch *DRW_cache_lattice_wire_get(struct Object *ob, bool use_weight); GPUBatch *DRW_cache_lattice_wire_get(Object *ob, bool use_weight);
struct GPUBatch *DRW_cache_lattice_vert_overlay_get(struct Object *ob); GPUBatch *DRW_cache_lattice_vert_overlay_get(Object *ob);
/* Particles */ /* Particles */
struct GPUBatch *DRW_cache_particles_get_hair(struct Object *object, GPUBatch *DRW_cache_particles_get_hair(Object *object, ParticleSystem *psys, ModifierData *md);
struct ParticleSystem *psys, GPUBatch *DRW_cache_particles_get_dots(Object *object, ParticleSystem *psys);
struct ModifierData *md); GPUBatch *DRW_cache_particles_get_edit_strands(Object *object,
struct GPUBatch *DRW_cache_particles_get_dots(struct Object *object, struct ParticleSystem *psys); ParticleSystem *psys,
struct GPUBatch *DRW_cache_particles_get_edit_strands(struct Object *object, PTCacheEdit *edit,
struct ParticleSystem *psys, bool use_weight);
struct PTCacheEdit *edit, GPUBatch *DRW_cache_particles_get_edit_inner_points(Object *object,
bool use_weight); ParticleSystem *psys,
struct GPUBatch *DRW_cache_particles_get_edit_inner_points(struct Object *object, PTCacheEdit *edit);
struct ParticleSystem *psys, GPUBatch *DRW_cache_particles_get_edit_tip_points(Object *object,
struct PTCacheEdit *edit); ParticleSystem *psys,
struct GPUBatch *DRW_cache_particles_get_edit_tip_points(struct Object *object, PTCacheEdit *edit);
struct ParticleSystem *psys, GPUBatch *DRW_cache_particles_get_prim(int type);
struct PTCacheEdit *edit);
struct GPUBatch *DRW_cache_particles_get_prim(int type);
/* Curves */ /* Curves */
struct GPUBatch *DRW_cache_curves_surface_get(struct Object *ob); GPUBatch *DRW_cache_curves_surface_get(Object *ob);
struct GPUBatch **DRW_cache_curves_surface_shaded_get(struct Object *ob, GPUBatch **DRW_cache_curves_surface_shaded_get(Object *ob,
struct GPUMaterial **gpumat_array, GPUMaterial **gpumat_array,
uint gpumat_array_len); uint gpumat_array_len);
struct GPUBatch *DRW_cache_curves_face_wireframe_get(struct Object *ob); GPUBatch *DRW_cache_curves_face_wireframe_get(Object *ob);
struct GPUBatch *DRW_cache_curves_edge_detection_get(struct Object *ob, bool *r_is_manifold); GPUBatch *DRW_cache_curves_edge_detection_get(Object *ob, bool *r_is_manifold);
/* Volume */ /* Volume */
typedef struct DRWVolumeGrid { struct DRWVolumeGrid {
struct DRWVolumeGrid *next, *prev; DRWVolumeGrid *next, *prev;
/* Grid name. */ /* Grid name. */
char *name; char *name;
/* 3D texture. */ /* 3D texture. */
struct GPUTexture *texture; GPUTexture *texture;
/* Transform between 0..1 texture space and object space. */ /* Transform between 0..1 texture space and object space. */
float texture_to_object[4][4]; float texture_to_object[4][4];
@ -245,47 +243,41 @@ typedef struct DRWVolumeGrid {
/* Transform from bounds to texture space. */ /* Transform from bounds to texture space. */
float object_to_bounds[4][4]; float object_to_bounds[4][4];
float bounds_to_texture[4][4]; float bounds_to_texture[4][4];
} DRWVolumeGrid; };
namespace blender::draw { namespace blender::draw {
DRWVolumeGrid *DRW_volume_batch_cache_get_grid(struct Volume *volume, DRWVolumeGrid *DRW_volume_batch_cache_get_grid(Volume *volume, const bke::VolumeGridData *grid);
const bke::VolumeGridData *grid); GPUBatch *DRW_cache_volume_face_wireframe_get(Object *ob);
struct GPUBatch *DRW_cache_volume_face_wireframe_get(struct Object *ob); GPUBatch *DRW_cache_volume_selection_surface_get(Object *ob);
struct GPUBatch *DRW_cache_volume_selection_surface_get(struct Object *ob);
/* GPencil (legacy) */ /* GPencil (legacy) */
struct GPUBatch *DRW_cache_gpencil_get(struct Object *ob, int cfra); GPUBatch *DRW_cache_gpencil_get(Object *ob, int cfra);
struct GPUVertBuf *DRW_cache_gpencil_position_buffer_get(struct Object *ob, int cfra); GPUVertBuf *DRW_cache_gpencil_position_buffer_get(Object *ob, int cfra);
struct GPUVertBuf *DRW_cache_gpencil_color_buffer_get(struct Object *ob, int cfra); GPUVertBuf *DRW_cache_gpencil_color_buffer_get(Object *ob, int cfra);
struct GPUBatch *DRW_cache_gpencil_edit_lines_get(struct Object *ob, int cfra); GPUBatch *DRW_cache_gpencil_edit_lines_get(Object *ob, int cfra);
struct GPUBatch *DRW_cache_gpencil_edit_points_get(struct Object *ob, int cfra); GPUBatch *DRW_cache_gpencil_edit_points_get(Object *ob, int cfra);
struct GPUBatch *DRW_cache_gpencil_edit_curve_handles_get(struct Object *ob, int cfra); GPUBatch *DRW_cache_gpencil_edit_curve_handles_get(Object *ob, int cfra);
struct GPUBatch *DRW_cache_gpencil_edit_curve_points_get(struct Object *ob, int cfra); GPUBatch *DRW_cache_gpencil_edit_curve_points_get(Object *ob, int cfra);
struct GPUBatch *DRW_cache_gpencil_sbuffer_get(struct Object *ob, bool show_fill); GPUBatch *DRW_cache_gpencil_sbuffer_get(Object *ob, bool show_fill);
struct GPUVertBuf *DRW_cache_gpencil_sbuffer_position_buffer_get(struct Object *ob, GPUVertBuf *DRW_cache_gpencil_sbuffer_position_buffer_get(Object *ob, bool show_fill);
bool show_fill); GPUVertBuf *DRW_cache_gpencil_sbuffer_color_buffer_get(Object *ob, bool show_fill);
struct GPUVertBuf *DRW_cache_gpencil_sbuffer_color_buffer_get(struct Object *ob, bool show_fill); int DRW_gpencil_material_count_get(const bGPdata *gpd);
int DRW_gpencil_material_count_get(const struct bGPdata *gpd);
struct GPUBatch *DRW_cache_gpencil_face_wireframe_get(struct Object *ob); GPUBatch *DRW_cache_gpencil_face_wireframe_get(Object *ob);
struct bGPDstroke *DRW_cache_gpencil_sbuffer_stroke_data_get(struct Object *ob); bGPDstroke *DRW_cache_gpencil_sbuffer_stroke_data_get(Object *ob);
/** /**
* Sbuffer batches are temporary. We need to clear it after drawing. * Sbuffer batches are temporary. We need to clear it after drawing.
*/ */
void DRW_cache_gpencil_sbuffer_clear(struct Object *ob); void DRW_cache_gpencil_sbuffer_clear(Object *ob);
/* Grease Pencil */ /* Grease Pencil */
struct GPUBatch *DRW_cache_grease_pencil_get(const struct Scene *scene, struct Object *ob); GPUBatch *DRW_cache_grease_pencil_get(const Scene *scene, Object *ob);
struct GPUBatch *DRW_cache_grease_pencil_edit_points_get(const struct Scene *scene, GPUBatch *DRW_cache_grease_pencil_edit_points_get(const Scene *scene, Object *ob);
struct Object *ob); GPUBatch *DRW_cache_grease_pencil_edit_lines_get(const Scene *scene, Object *ob);
struct GPUBatch *DRW_cache_grease_pencil_edit_lines_get(const struct Scene *scene, GPUVertBuf *DRW_cache_grease_pencil_position_buffer_get(const Scene *scene, Object *ob);
struct Object *ob); GPUVertBuf *DRW_cache_grease_pencil_color_buffer_get(const Scene *scene, Object *ob);
struct GPUVertBuf *DRW_cache_grease_pencil_position_buffer_get(const struct Scene *scene,
struct Object *ob);
struct GPUVertBuf *DRW_cache_grease_pencil_color_buffer_get(const struct Scene *scene,
struct Object *ob);
} // namespace blender::draw } // namespace blender::draw

4
source/blender/draw/intern/draw_subdivision.hh
View File

@ -31,8 +31,8 @@ struct MeshRenderData;
* \{ */ * \{ */
struct DRWPatchMap { struct DRWPatchMap {
struct GPUVertBuf *patch_map_handles; GPUVertBuf *patch_map_handles;
struct GPUVertBuf *patch_map_quadtree; GPUVertBuf *patch_map_quadtree;
int min_patch_face; int min_patch_face;
int max_patch_face; int max_patch_face;
int max_depth; int max_depth;

293
source/blender/editors/armature/armature_intern.hh
View File

@ -8,76 +8,72 @@
#pragma once #pragma once
/* internal exports only */
struct wmOperatorType;
struct Base;
struct GPUSelectResult;
struct Object;
struct Scene;
struct bContext;
struct bPoseChannel;
struct Bone;
struct EditBone;
struct bArmature; struct bArmature;
struct Base;
struct bContext;
struct Bone;
struct bPoseChannel;
struct EditBone;
struct GPUSelectResult;
struct LinkData; struct LinkData;
struct ListBase; struct ListBase;
struct Object;
struct Scene;
struct wmOperatorType;
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
/** \name Armature EditMode Operators /** \name Armature EditMode Operators
* \{ */ * \{ */
void ARMATURE_OT_bone_primitive_add(struct wmOperatorType *ot); void ARMATURE_OT_bone_primitive_add(wmOperatorType *ot);
void ARMATURE_OT_align(struct wmOperatorType *ot); void ARMATURE_OT_align(wmOperatorType *ot);
void ARMATURE_OT_calculate_roll(struct wmOperatorType *ot); void ARMATURE_OT_calculate_roll(wmOperatorType *ot);
void ARMATURE_OT_roll_clear(struct wmOperatorType *ot); void ARMATURE_OT_roll_clear(wmOperatorType *ot);
void ARMATURE_OT_switch_direction(struct wmOperatorType *ot); void ARMATURE_OT_switch_direction(wmOperatorType *ot);
void ARMATURE_OT_subdivide(struct wmOperatorType *ot); void ARMATURE_OT_subdivide(wmOperatorType *ot);
void ARMATURE_OT_parent_set(struct wmOperatorType *ot); void ARMATURE_OT_parent_set(wmOperatorType *ot);
void ARMATURE_OT_parent_clear(struct wmOperatorType *ot); void ARMATURE_OT_parent_clear(wmOperatorType *ot);
void ARMATURE_OT_select_all(struct wmOperatorType *ot); void ARMATURE_OT_select_all(wmOperatorType *ot);
void ARMATURE_OT_select_mirror(struct wmOperatorType *ot); void ARMATURE_OT_select_mirror(wmOperatorType *ot);
void ARMATURE_OT_select_more(struct wmOperatorType *ot); void ARMATURE_OT_select_more(wmOperatorType *ot);
void ARMATURE_OT_select_less(struct wmOperatorType *ot); void ARMATURE_OT_select_less(wmOperatorType *ot);
void ARMATURE_OT_select_hierarchy(struct wmOperatorType *ot); void ARMATURE_OT_select_hierarchy(wmOperatorType *ot);
void ARMATURE_OT_select_linked_pick(struct wmOperatorType *ot); void ARMATURE_OT_select_linked_pick(wmOperatorType *ot);
void ARMATURE_OT_select_linked(struct wmOperatorType *ot); void ARMATURE_OT_select_linked(wmOperatorType *ot);
void ARMATURE_OT_select_similar(struct wmOperatorType *ot); void ARMATURE_OT_select_similar(wmOperatorType *ot);
void ARMATURE_OT_shortest_path_pick(struct wmOperatorType *ot); void ARMATURE_OT_shortest_path_pick(wmOperatorType *ot);
void ARMATURE_OT_delete(struct wmOperatorType *ot); void ARMATURE_OT_delete(wmOperatorType *ot);
void ARMATURE_OT_dissolve(struct wmOperatorType *ot); void ARMATURE_OT_dissolve(wmOperatorType *ot);
void ARMATURE_OT_duplicate(struct wmOperatorType *ot); void ARMATURE_OT_duplicate(wmOperatorType *ot);
void ARMATURE_OT_symmetrize(struct wmOperatorType *ot); void ARMATURE_OT_symmetrize(wmOperatorType *ot);
void ARMATURE_OT_extrude(struct wmOperatorType *ot); void ARMATURE_OT_extrude(wmOperatorType *ot);
void ARMATURE_OT_hide(struct wmOperatorType *ot); void ARMATURE_OT_hide(wmOperatorType *ot);
void ARMATURE_OT_reveal(struct wmOperatorType *ot); void ARMATURE_OT_reveal(wmOperatorType *ot);
void ARMATURE_OT_click_extrude(struct wmOperatorType *ot); void ARMATURE_OT_click_extrude(wmOperatorType *ot);
void ARMATURE_OT_fill(struct wmOperatorType *ot); void ARMATURE_OT_fill(wmOperatorType *ot);
void ARMATURE_OT_separate(struct wmOperatorType *ot); void ARMATURE_OT_separate(wmOperatorType *ot);
void ARMATURE_OT_split(struct wmOperatorType *ot); void ARMATURE_OT_split(wmOperatorType *ot);
void ARMATURE_OT_autoside_names(struct wmOperatorType *ot); void ARMATURE_OT_autoside_names(wmOperatorType *ot);
void ARMATURE_OT_flip_names(struct wmOperatorType *ot); void ARMATURE_OT_flip_names(wmOperatorType *ot);
void ARMATURE_OT_collection_add(struct wmOperatorType *ot); void ARMATURE_OT_collection_add(wmOperatorType *ot);
void ARMATURE_OT_collection_remove(struct wmOperatorType *ot); void ARMATURE_OT_collection_remove(wmOperatorType *ot);
void ARMATURE_OT_collection_move(struct wmOperatorType *ot); void ARMATURE_OT_collection_move(wmOperatorType *ot);
void ARMATURE_OT_collection_assign(struct wmOperatorType *ot); void ARMATURE_OT_collection_assign(wmOperatorType *ot);
void ARMATURE_OT_collection_create_and_assign(struct wmOperatorType *ot); void ARMATURE_OT_collection_create_and_assign(wmOperatorType *ot);
void ARMATURE_OT_collection_unassign(struct wmOperatorType *ot); void ARMATURE_OT_collection_unassign(wmOperatorType *ot);
void ARMATURE_OT_collection_unassign_named(struct wmOperatorType *ot); void ARMATURE_OT_collection_unassign_named(wmOperatorType *ot);
void ARMATURE_OT_collection_select(struct wmOperatorType *ot); void ARMATURE_OT_collection_select(wmOperatorType *ot);
void ARMATURE_OT_collection_deselect(struct wmOperatorType *ot); void ARMATURE_OT_collection_deselect(wmOperatorType *ot);
void ARMATURE_OT_move_to_collection(struct wmOperatorType *ot); void ARMATURE_OT_move_to_collection(wmOperatorType *ot);
void ARMATURE_OT_assign_to_collection(struct wmOperatorType *ot); void ARMATURE_OT_assign_to_collection(wmOperatorType *ot);
/** \} */ /** \} */
@ -85,41 +81,41 @@ void ARMATURE_OT_assign_to_collection(struct wmOperatorType *ot);
/** \name Pose-Mode Operators /** \name Pose-Mode Operators
* \{ */ * \{ */
void POSE_OT_hide(struct wmOperatorType *ot); void POSE_OT_hide(wmOperatorType *ot);
void POSE_OT_reveal(struct wmOperatorType *ot); void POSE_OT_reveal(wmOperatorType *ot);
void POSE_OT_armature_apply(struct wmOperatorType *ot); void POSE_OT_armature_apply(wmOperatorType *ot);
void POSE_OT_visual_transform_apply(struct wmOperatorType *ot); void POSE_OT_visual_transform_apply(wmOperatorType *ot);
void POSE_OT_rot_clear(struct wmOperatorType *ot); void POSE_OT_rot_clear(wmOperatorType *ot);
void POSE_OT_loc_clear(struct wmOperatorType *ot); void POSE_OT_loc_clear(wmOperatorType *ot);
void POSE_OT_scale_clear(struct wmOperatorType *ot); void POSE_OT_scale_clear(wmOperatorType *ot);
void POSE_OT_transforms_clear(struct wmOperatorType *ot); void POSE_OT_transforms_clear(wmOperatorType *ot);
void POSE_OT_user_transforms_clear(struct wmOperatorType *ot); void POSE_OT_user_transforms_clear(wmOperatorType *ot);
void POSE_OT_copy(struct wmOperatorType *ot); void POSE_OT_copy(wmOperatorType *ot);
void POSE_OT_paste(struct wmOperatorType *ot); void POSE_OT_paste(wmOperatorType *ot);
void POSE_OT_select_all(struct wmOperatorType *ot); void POSE_OT_select_all(wmOperatorType *ot);
void POSE_OT_select_parent(struct wmOperatorType *ot); void POSE_OT_select_parent(wmOperatorType *ot);
void POSE_OT_select_hierarchy(struct wmOperatorType *ot); void POSE_OT_select_hierarchy(wmOperatorType *ot);
void POSE_OT_select_linked(struct wmOperatorType *ot); void POSE_OT_select_linked(wmOperatorType *ot);
void POSE_OT_select_linked_pick(struct wmOperatorType *ot); void POSE_OT_select_linked_pick(wmOperatorType *ot);
void POSE_OT_select_constraint_target(struct wmOperatorType *ot); void POSE_OT_select_constraint_target(wmOperatorType *ot);
void POSE_OT_select_grouped(struct wmOperatorType *ot); void POSE_OT_select_grouped(wmOperatorType *ot);
void POSE_OT_select_mirror(struct wmOperatorType *ot); void POSE_OT_select_mirror(wmOperatorType *ot);
void POSE_OT_paths_calculate(struct wmOperatorType *ot); void POSE_OT_paths_calculate(wmOperatorType *ot);
void POSE_OT_paths_update(struct wmOperatorType *ot); void POSE_OT_paths_update(wmOperatorType *ot);
void POSE_OT_paths_clear(struct wmOperatorType *ot); void POSE_OT_paths_clear(wmOperatorType *ot);
void POSE_OT_paths_range_update(struct wmOperatorType *ot); void POSE_OT_paths_range_update(wmOperatorType *ot);
void POSE_OT_autoside_names(struct wmOperatorType *ot); void POSE_OT_autoside_names(wmOperatorType *ot);
void POSE_OT_flip_names(struct wmOperatorType *ot); void POSE_OT_flip_names(wmOperatorType *ot);
void POSE_OT_rotation_mode_set(struct wmOperatorType *ot); void POSE_OT_rotation_mode_set(wmOperatorType *ot);
void POSE_OT_quaternions_flip(struct wmOperatorType *ot); void POSE_OT_quaternions_flip(wmOperatorType *ot);
/** \} */ /** \} */
@ -130,16 +126,16 @@ void POSE_OT_quaternions_flip(struct wmOperatorType *ot);
/* `pose_utils.cc` */ /* `pose_utils.cc` */
/* Temporary data linking PoseChannels with the F-Curves they affect */ /* Temporary data linking PoseChannels with the F-Curves they affect */
typedef struct tPChanFCurveLink { struct tPChanFCurveLink {
struct tPChanFCurveLink *next, *prev; tPChanFCurveLink *next, *prev;
/** Object this Pose Channel belongs to. */ /** Object this Pose Channel belongs to. */
struct Object *ob; Object *ob;
/** F-Curves for this PoseChannel (wrapped with LinkData) */ /** F-Curves for this PoseChannel (wrapped with LinkData) */
ListBase fcurves; ListBase fcurves;
/** Pose Channel which data is attached to */ /** Pose Channel which data is attached to */
struct bPoseChannel *pchan; bPoseChannel *pchan;
/** RNA Path to this Pose Channel (needs to be freed when we're done) */ /** RNA Path to this Pose Channel (needs to be freed when we're done) */
char *pchan_path; char *pchan_path;
@ -162,31 +158,28 @@ typedef struct tPChanFCurveLink {
float scale_out[3]; float scale_out[3];
/** copy of custom properties at start of operator (to be restored before each modal step) */ /** copy of custom properties at start of operator (to be restored before each modal step) */
struct IDProperty *oldprops; IDProperty *oldprops;
} tPChanFCurveLink; };
/* ----------- */ /* ----------- */
/** Returns a valid pose armature for this object, else returns NULL. */ /** Returns a valid pose armature for this object, else returns NULL. */
struct Object *poseAnim_object_get(struct Object *ob_); Object *poseAnim_object_get(Object *ob_);
/** Get sets of F-Curves providing transforms for the bones in the Pose. */ /** Get sets of F-Curves providing transforms for the bones in the Pose. */
void poseAnim_mapping_get(struct bContext *C, ListBase *pfLinks); void poseAnim_mapping_get(bContext *C, ListBase *pfLinks);
/** Free F-Curve <-> PoseChannel links. */ /** Free F-Curve <-> PoseChannel links. */
void poseAnim_mapping_free(ListBase *pfLinks); void poseAnim_mapping_free(ListBase *pfLinks);
/** /**
* Helper for apply() / reset() - refresh the data. * Helper for apply() / reset() - refresh the data.
*/ */
void poseAnim_mapping_refresh(struct bContext *C, struct Scene *scene, struct Object *ob); void poseAnim_mapping_refresh(bContext *C, Scene *scene, Object *ob);
/** /**
* Reset changes made to current pose. * Reset changes made to current pose.
*/ */
void poseAnim_mapping_reset(ListBase *pfLinks); void poseAnim_mapping_reset(ListBase *pfLinks);
/** Perform auto-key-framing after changes were made + confirmed. */ /** Perform auto-key-framing after changes were made + confirmed. */
void poseAnim_mapping_autoKeyframe(struct bContext *C, void poseAnim_mapping_autoKeyframe(bContext *C, Scene *scene, ListBase *pfLinks, float cframe);
struct Scene *scene,
ListBase *pfLinks,
float cframe);
/** /**
* Find the next F-Curve for a PoseChannel with matching path. * Find the next F-Curve for a PoseChannel with matching path.
@ -203,8 +196,8 @@ LinkData *poseAnim_mapping_getNextFCurve(ListBase *fcuLinks, LinkData *prev, con
/* `pose_lib_2.cc` */ /* `pose_lib_2.cc` */
void POSELIB_OT_apply_pose_asset(struct wmOperatorType *ot); void POSELIB_OT_apply_pose_asset(wmOperatorType *ot);
void POSELIB_OT_blend_pose_asset(struct wmOperatorType *ot); void POSELIB_OT_blend_pose_asset(wmOperatorType *ot);
/** \} */ /** \} */
@ -214,13 +207,13 @@ void POSELIB_OT_blend_pose_asset(struct wmOperatorType *ot);
/* `pose_slide.cc` */ /* `pose_slide.cc` */
void POSE_OT_push(struct wmOperatorType *ot); void POSE_OT_push(wmOperatorType *ot);
void POSE_OT_relax(struct wmOperatorType *ot); void POSE_OT_relax(wmOperatorType *ot);
void POSE_OT_blend_with_rest(struct wmOperatorType *ot); void POSE_OT_blend_with_rest(wmOperatorType *ot);
void POSE_OT_breakdown(struct wmOperatorType *ot); void POSE_OT_breakdown(wmOperatorType *ot);
void POSE_OT_blend_to_neighbors(struct wmOperatorType *ot); void POSE_OT_blend_to_neighbors(wmOperatorType *ot);
void POSE_OT_propagate(struct wmOperatorType *ot); void POSE_OT_propagate(wmOperatorType *ot);
/** \} */ /** \} */
@ -233,44 +226,36 @@ void POSE_OT_propagate(struct wmOperatorType *ot);
* but some tools still have a bit of overlap which makes things messy -- Feb 2013 * but some tools still have a bit of overlap which makes things messy -- Feb 2013
*/ */
struct EditBone *make_boneList(struct ListBase *edbo, EditBone *make_boneList(ListBase *edbo, ListBase *bones, Bone *actBone);
struct ListBase *bones,
struct Bone *actBone);
/* Duplicate method. */ /* Duplicate method. */
/** Call this before doing any duplications. */ /** Call this before doing any duplications. */
void preEditBoneDuplicate(struct ListBase *editbones); void preEditBoneDuplicate(ListBase *editbones);
void postEditBoneDuplicate(struct ListBase *editbones, struct Object *ob); void postEditBoneDuplicate(ListBase *editbones, Object *ob);
struct EditBone *duplicateEditBone(struct EditBone *cur_bone, EditBone *duplicateEditBone(EditBone *cur_bone, const char *name, ListBase *editbones, Object *ob);
const char *name,
struct ListBase *editbones,
struct Object *ob);
/* Duplicate method (cross objects). */ /* Duplicate method (cross objects). */
/** /**
* \param editbones: The target list. * \param editbones: The target list.
*/ */
struct EditBone *duplicateEditBoneObjects(struct EditBone *cur_bone, EditBone *duplicateEditBoneObjects(
const char *name, EditBone *cur_bone, const char *name, ListBase *editbones, Object *src_ob, Object *dst_ob);
struct ListBase *editbones,
struct Object *src_ob,
struct Object *dst_ob);
/** Adds an EditBone between the nominated locations (should be in the right space). */ /** Adds an EditBone between the nominated locations (should be in the right space). */
struct EditBone *add_points_bone(struct Object *obedit, float head[3], float tail[3]); EditBone *add_points_bone(Object *obedit, float head[3], float tail[3]);
void bone_free(struct bArmature *arm, struct EditBone *bone); void bone_free(bArmature *arm, EditBone *bone);
void armature_tag_select_mirrored(struct bArmature *arm); void armature_tag_select_mirrored(bArmature *arm);
/** /**
* Helper function for tools to work on mirrored parts. * Helper function for tools to work on mirrored parts.
* it leaves mirrored bones selected then too, which is a good indication of what happened. * it leaves mirrored bones selected then too, which is a good indication of what happened.
*/ */
void armature_select_mirrored_ex(struct bArmature *arm, int flag); void armature_select_mirrored_ex(bArmature *arm, int flag);
void armature_select_mirrored(struct bArmature *arm); void armature_select_mirrored(bArmature *arm);
/** Only works when tagged. */ /** Only works when tagged. */
void armature_tag_unselect(struct bArmature *arm); void armature_tag_unselect(bArmature *arm);
/** \} */ /** \} */
@ -278,42 +263,31 @@ void armature_tag_unselect(struct bArmature *arm);
/** \name Selection Picking /** \name Selection Picking
* \{ */ * \{ */
struct EditBone *ED_armature_pick_ebone(struct bContext *C, EditBone *ED_armature_pick_ebone(bContext *C, const int xy[2], bool findunsel, Base **r_base);
const int xy[2], bPoseChannel *ED_armature_pick_pchan(bContext *C, const int xy[2], bool findunsel, Base **r_base);
bool findunsel, Bone *ED_armature_pick_bone(bContext *C, const int xy[2], bool findunsel, Base **r_base);
struct Base **r_base);
struct bPoseChannel *ED_armature_pick_pchan(struct bContext *C,
const int xy[2],
bool findunsel,
struct Base **r_base);
struct Bone *ED_armature_pick_bone(struct bContext *C,
const int xy[2],
bool findunsel,
struct Base **r_base);
struct EditBone *ED_armature_pick_ebone_from_selectbuffer( EditBone *ED_armature_pick_ebone_from_selectbuffer(Base **bases,
struct Base **bases, uint bases_len,
uint bases_len, const GPUSelectResult *hit_results,
const struct GPUSelectResult *hit_results, int hits,
int hits, bool findunsel,
bool findunsel, bool do_nearest,
bool do_nearest, Base **r_base);
struct Base **r_base); bPoseChannel *ED_armature_pick_pchan_from_selectbuffer(Base **bases,
struct bPoseChannel *ED_armature_pick_pchan_from_selectbuffer( uint bases_len,
struct Base **bases, const GPUSelectResult *hit_results,
uint bases_len, int hits,
const struct GPUSelectResult *hit_results, bool findunsel,
int hits, bool do_nearest,
bool findunsel, Base **r_base);
bool do_nearest, Bone *ED_armature_pick_bone_from_selectbuffer(Base **bases,
struct Base **r_base); uint bases_len,
struct Bone *ED_armature_pick_bone_from_selectbuffer(struct Base **bases, const GPUSelectResult *hit_results,
uint bases_len, int hits,
const struct GPUSelectResult *hit_results, bool findunsel,
int hits, bool do_nearest,
bool findunsel, Base **r_base);
bool do_nearest,
struct Base **r_base);
/** \} */ /** \} */
@ -325,9 +299,6 @@ struct Bone *ED_armature_pick_bone_from_selectbuffer(struct Base **bases,
* XXX: bone_looper is only to be used when we want to access settings * XXX: bone_looper is only to be used when we want to access settings
* (i.e. editability/visibility/selected) that context doesn't offer. * (i.e. editability/visibility/selected) that context doesn't offer.
*/ */
int bone_looper(struct Object *ob, int bone_looper(Object *ob, Bone *bone, void *data, int (*bone_func)(Object *, Bone *, void *));
struct Bone *bone,
void *data,
int (*bone_func)(struct Object *, struct Bone *, void *));
/** \} */ /** \} */

2
source/blender/editors/interface/interface_intern.hh
View File

@ -333,7 +333,7 @@ struct uiButColor : public uiBut {
/** Derived struct for #UI_BTYPE_TAB */ /** Derived struct for #UI_BTYPE_TAB */
struct uiButTab : public uiBut { struct uiButTab : public uiBut {
struct MenuType *menu = nullptr; MenuType *menu = nullptr;
}; };
/** Derived struct for #UI_BTYPE_SEARCH_MENU */ /** Derived struct for #UI_BTYPE_SEARCH_MENU */

193
source/blender/imbuf/intern/IMB_filetype.hh
View File

@ -22,7 +22,7 @@ struct ImBuf;
#define IM_FTYPE_FLOAT 1 #define IM_FTYPE_FLOAT 1
typedef struct ImFileType { struct ImFileType {
/** Optional, called once when initializing. */ /** Optional, called once when initializing. */
void (*init)(void); void (*init)(void);
/** Optional, called once when exiting. */ /** Optional, called once when exiting. */
@ -36,25 +36,22 @@ typedef struct ImFileType {
bool (*is_a)(const unsigned char *buf, size_t size); bool (*is_a)(const unsigned char *buf, size_t size);
/** Load an image from memory. */ /** Load an image from memory. */
struct ImBuf *(*load)(const unsigned char *mem, ImBuf *(*load)(const unsigned char *mem, size_t size, int flags, char colorspace[IM_MAX_SPACE]);
size_t size,
int flags,
char colorspace[IM_MAX_SPACE]);
/** Load an image from a file. */ /** Load an image from a file. */
struct ImBuf *(*load_filepath)(const char *filepath, int flags, char colorspace[IM_MAX_SPACE]); ImBuf *(*load_filepath)(const char *filepath, int flags, char colorspace[IM_MAX_SPACE]);
/** /**
* Load/Create a thumbnail image from a filepath. `max_thumb_size` is maximum size of either * Load/Create a thumbnail image from a filepath. `max_thumb_size` is maximum size of either
* dimension, so can return less on either or both. Should, if possible and performant, return * dimension, so can return less on either or both. Should, if possible and performant, return
* dimensions of the full-size image in r_width & r_height. * dimensions of the full-size image in r_width & r_height.
*/ */
struct ImBuf *(*load_filepath_thumbnail)(const char *filepath, ImBuf *(*load_filepath_thumbnail)(const char *filepath,
int flags, int flags,
size_t max_thumb_size, size_t max_thumb_size,
char colorspace[IM_MAX_SPACE], char colorspace[IM_MAX_SPACE],
size_t *r_width, size_t *r_width,
size_t *r_height); size_t *r_height);
/** Save to a file (or memory if #IB_mem is set in `flags` and the format supports it). */ /** Save to a file (or memory if #IB_mem is set in `flags` and the format supports it). */
bool (*save)(struct ImBuf *ibuf, const char *filepath, int flags); bool (*save)(ImBuf *ibuf, const char *filepath, int flags);
int flag; int flag;
@ -62,13 +59,13 @@ typedef struct ImFileType {
int filetype; int filetype;
int default_save_role; int default_save_role;
} ImFileType; };
extern const ImFileType IMB_FILE_TYPES[]; extern const ImFileType IMB_FILE_TYPES[];
extern const ImFileType *IMB_FILE_TYPES_LAST; extern const ImFileType *IMB_FILE_TYPES_LAST;
const ImFileType *IMB_file_type_from_ftype(int ftype); const ImFileType *IMB_file_type_from_ftype(int ftype);
const ImFileType *IMB_file_type_from_ibuf(const struct ImBuf *ibuf); const ImFileType *IMB_file_type_from_ibuf(const ImBuf *ibuf);
void imb_filetypes_init(void); void imb_filetypes_init(void);
void imb_filetypes_exit(void); void imb_filetypes_exit(void);
@ -82,11 +79,11 @@ void imb_filetypes_exit(void);
* \{ */ * \{ */
bool imb_is_a_png(const unsigned char *mem, size_t size); bool imb_is_a_png(const unsigned char *mem, size_t size);
struct ImBuf *imb_load_png(const unsigned char *mem, ImBuf *imb_load_png(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
bool imb_save_png(struct ImBuf *ibuf, const char *filepath, int flags); bool imb_save_png(ImBuf *ibuf, const char *filepath, int flags);
/** \} */ /** \} */
@ -95,11 +92,11 @@ bool imb_save_png(struct ImBuf *ibuf, const char *filepath, int flags);
* \{ */ * \{ */
bool imb_is_a_tga(const unsigned char *mem, size_t size); bool imb_is_a_tga(const unsigned char *mem, size_t size);
struct ImBuf *imb_load_tga(const unsigned char *mem, ImBuf *imb_load_tga(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
bool imb_save_tga(struct ImBuf *ibuf, const char *filepath, int flags); bool imb_save_tga(ImBuf *ibuf, const char *filepath, int flags);
/** \} */ /** \} */
@ -111,11 +108,11 @@ bool imb_is_a_iris(const unsigned char *mem, size_t size);
/** /**
* Read in a B/W RGB or RGBA iris image file and return an image buffer. * Read in a B/W RGB or RGBA iris image file and return an image buffer.
*/ */
struct ImBuf *imb_loadiris(const unsigned char *mem, ImBuf *imb_loadiris(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
bool imb_saveiris(struct ImBuf *ibuf, const char *filepath, int flags); bool imb_saveiris(ImBuf *ibuf, const char *filepath, int flags);
/** \} */ /** \} */
@ -124,14 +121,12 @@ bool imb_saveiris(struct ImBuf *ibuf, const char *filepath, int flags);
* \{ */ * \{ */
bool imb_is_a_jp2(const unsigned char *buf, size_t size); bool imb_is_a_jp2(const unsigned char *buf, size_t size);
struct ImBuf *imb_load_jp2(const unsigned char *mem, ImBuf *imb_load_jp2(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
struct ImBuf *imb_load_jp2_filepath(const char *filepath, ImBuf *imb_load_jp2_filepath(const char *filepath, int flags, char colorspace[IM_MAX_SPACE]);
int flags, bool imb_save_jp2(ImBuf *ibuf, const char *filepath, int flags);
char colorspace[IM_MAX_SPACE]);
bool imb_save_jp2(struct ImBuf *ibuf, const char *filepath, int flags);
/** \} */ /** \} */
@ -140,17 +135,17 @@ bool imb_save_jp2(struct ImBuf *ibuf, const char *filepath, int flags);
* \{ */ * \{ */
bool imb_is_a_jpeg(const unsigned char *mem, size_t size); bool imb_is_a_jpeg(const unsigned char *mem, size_t size);
bool imb_savejpeg(struct ImBuf *ibuf, const char *filepath, int flags); bool imb_savejpeg(ImBuf *ibuf, const char *filepath, int flags);
struct ImBuf *imb_load_jpeg(const unsigned char *buffer, ImBuf *imb_load_jpeg(const unsigned char *buffer,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
struct ImBuf *imb_thumbnail_jpeg(const char *filepath, ImBuf *imb_thumbnail_jpeg(const char *filepath,
int flags, int flags,
size_t max_thumb_size, size_t max_thumb_size,
char colorspace[IM_MAX_SPACE], char colorspace[IM_MAX_SPACE],
size_t *r_width, size_t *r_width,
size_t *r_height); size_t *r_height);
/** \} */ /** \} */
@ -159,12 +154,12 @@ struct ImBuf *imb_thumbnail_jpeg(const char *filepath,
* \{ */ * \{ */
bool imb_is_a_bmp(const unsigned char *buf, size_t size); bool imb_is_a_bmp(const unsigned char *buf, size_t size);
struct ImBuf *imb_load_bmp(const unsigned char *mem, ImBuf *imb_load_bmp(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
/* Found write info at http://users.ece.gatech.edu/~slabaugh/personal/c/bitmapUnix.c */ /* Found write info at http://users.ece.gatech.edu/~slabaugh/personal/c/bitmapUnix.c */
bool imb_save_bmp(struct ImBuf *ibuf, const char *filepath, int flags); bool imb_save_bmp(ImBuf *ibuf, const char *filepath, int flags);
/** \} */ /** \} */
@ -173,11 +168,11 @@ bool imb_save_bmp(struct ImBuf *ibuf, const char *filepath, int flags);
* \{ */ * \{ */
bool imb_is_a_cineon(const unsigned char *buf, size_t size); bool imb_is_a_cineon(const unsigned char *buf, size_t size);
bool imb_save_cineon(struct ImBuf *buf, const char *filepath, int flags); bool imb_save_cineon(ImBuf *buf, const char *filepath, int flags);
struct ImBuf *imb_load_cineon(const unsigned char *mem, ImBuf *imb_load_cineon(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
/** \} */ /** \} */
@ -186,11 +181,11 @@ struct ImBuf *imb_load_cineon(const unsigned char *mem,
* \{ */ * \{ */
bool imb_is_a_dpx(const unsigned char *buf, size_t size); bool imb_is_a_dpx(const unsigned char *buf, size_t size);
bool imb_save_dpx(struct ImBuf *ibuf, const char *filepath, int flags); bool imb_save_dpx(ImBuf *ibuf, const char *filepath, int flags);
struct ImBuf *imb_load_dpx(const unsigned char *mem, ImBuf *imb_load_dpx(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
/** \} */ /** \} */
@ -199,11 +194,11 @@ struct ImBuf *imb_load_dpx(const unsigned char *mem,
* \{ */ * \{ */
bool imb_is_a_hdr(const unsigned char *buf, size_t size); bool imb_is_a_hdr(const unsigned char *buf, size_t size);
struct ImBuf *imb_load_hdr(const unsigned char *mem, ImBuf *imb_load_hdr(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
bool imb_save_hdr(struct ImBuf *ibuf, const char *filepath, int flags); bool imb_save_hdr(ImBuf *ibuf, const char *filepath, int flags);
/** \} */ /** \} */
@ -221,10 +216,10 @@ bool imb_is_a_tiff(const unsigned char *buf, size_t size);
* *
* \return A newly allocated #ImBuf structure if successful, otherwise NULL. * \return A newly allocated #ImBuf structure if successful, otherwise NULL.
*/ */
struct ImBuf *imb_load_tiff(const unsigned char *mem, ImBuf *imb_load_tiff(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
/** /**
* Saves a TIFF file. * Saves a TIFF file.
* *
@ -239,7 +234,7 @@ struct ImBuf *imb_load_tiff(const unsigned char *mem,
* *
* \return 1 if the function is successful, 0 on failure. * \return 1 if the function is successful, 0 on failure.
*/ */
bool imb_save_tiff(struct ImBuf *ibuf, const char *filepath, int flags); bool imb_save_tiff(ImBuf *ibuf, const char *filepath, int flags);
/** \} */ /** \} */
@ -248,17 +243,17 @@ bool imb_save_tiff(struct ImBuf *ibuf, const char *filepath, int flags);
* \{ */ * \{ */
bool imb_is_a_webp(const unsigned char *buf, size_t size); bool imb_is_a_webp(const unsigned char *buf, size_t size);
struct ImBuf *imb_loadwebp(const unsigned char *mem, ImBuf *imb_loadwebp(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
struct ImBuf *imb_load_filepath_thumbnail_webp(const char *filepath, ImBuf *imb_load_filepath_thumbnail_webp(const char *filepath,
const int flags, const int flags,
const size_t max_thumb_size, const size_t max_thumb_size,
char colorspace[], char colorspace[],
size_t *r_width, size_t *r_width,
size_t *r_height); size_t *r_height);
bool imb_savewebp(struct ImBuf *ibuf, const char *filepath, int flags); bool imb_savewebp(ImBuf *ibuf, const char *filepath, int flags);
/** \} */ /** \} */
@ -270,10 +265,10 @@ void imb_init_dds();
bool imb_is_a_dds(const unsigned char *buf, size_t size); bool imb_is_a_dds(const unsigned char *buf, size_t size);
struct ImBuf *imb_load_dds(const unsigned char *mem, ImBuf *imb_load_dds(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
/** \} */ /** \} */
@ -283,10 +278,10 @@ struct ImBuf *imb_load_dds(const unsigned char *mem,
bool imb_is_a_psd(const unsigned char *buf, size_t size); bool imb_is_a_psd(const unsigned char *buf, size_t size);
struct ImBuf *imb_load_psd(const unsigned char *mem, ImBuf *imb_load_psd(const unsigned char *mem,
size_t size, size_t size,
int flags, int flags,
char colorspace[IM_MAX_SPACE]); char colorspace[IM_MAX_SPACE]);
/** \} */ /** \} */
@ -294,12 +289,12 @@ struct ImBuf *imb_load_psd(const unsigned char *mem,
/** \name Format: SVG - Only for thumbnails. /** \name Format: SVG - Only for thumbnails.
* \{ */ * \{ */
struct ImBuf *imb_load_filepath_thumbnail_svg(const char *filepath, ImBuf *imb_load_filepath_thumbnail_svg(const char *filepath,
const int flags, const int flags,
const size_t max_thumb_size, const size_t max_thumb_size,
char colorspace[], char colorspace[],
size_t *r_width, size_t *r_width,
size_t *r_height); size_t *r_height);
/** \} */ /** \} */

4
source/blender/imbuf/intern/IMB_filter.hh
View File

@ -13,7 +13,7 @@
struct ImBuf; struct ImBuf;
void imb_filterx(struct ImBuf *ibuf); void imb_filterx(ImBuf *ibuf);
void IMB_premultiply_rect(uint8_t *rect, char planes, int w, int h); void IMB_premultiply_rect(uint8_t *rect, char planes, int w, int h);
void IMB_premultiply_rect_float(float *rect_float, int channels, int w, int h); void IMB_premultiply_rect_float(float *rect_float, int channels, int w, int h);
@ -24,4 +24,4 @@ void IMB_unpremultiply_rect_float(float *rect_float, int channels, int w, int h)
/** /**
* Result in ibuf2, scaling should be done correctly. * Result in ibuf2, scaling should be done correctly.
*/ */
void imb_onehalf_no_alloc(struct ImBuf *ibuf2, struct ImBuf *ibuf1); void imb_onehalf_no_alloc(ImBuf *ibuf2, ImBuf *ibuf1);

40
source/blender/imbuf/intern/IMB_indexer.hh
View File

@ -34,36 +34,36 @@
* the BL_proxy directory structure for later reuse in different blender files. * the BL_proxy directory structure for later reuse in different blender files.
*/ */
typedef struct anim_index_entry { struct anim_index_entry {
int frameno; int frameno;
uint64_t seek_pos; uint64_t seek_pos;
uint64_t seek_pos_pts; uint64_t seek_pos_pts;
uint64_t seek_pos_dts; uint64_t seek_pos_dts;
uint64_t pts; uint64_t pts;
} anim_index_entry; };
struct ImBufAnimIndex { struct ImBufAnimIndex {
char filepath[1024]; char filepath[1024];
int num_entries; int num_entries;
struct anim_index_entry *entries; anim_index_entry *entries;
}; };
struct anim_index_builder; struct anim_index_builder;
typedef struct anim_index_builder { struct anim_index_builder {
FILE *fp; FILE *fp;
char filepath[FILE_MAX]; char filepath[FILE_MAX];
char filepath_temp[FILE_MAX]; char filepath_temp[FILE_MAX];
void *private_data; void *private_data;
void (*delete_priv_data)(struct anim_index_builder *idx); void (*delete_priv_data)(anim_index_builder *idx);
void (*proc_frame)(struct anim_index_builder *idx, void (*proc_frame)(anim_index_builder *idx,
unsigned char *buffer, unsigned char *buffer,
int data_size, int data_size,
struct anim_index_entry *entry); anim_index_entry *entry);
} anim_index_builder; };
anim_index_builder *IMB_index_builder_create(const char *filepath); anim_index_builder *IMB_index_builder_create(const char *filepath);
void IMB_index_builder_add_entry(anim_index_builder *fp, void IMB_index_builder_add_entry(anim_index_builder *fp,
@ -84,23 +84,23 @@ void IMB_index_builder_proc_frame(anim_index_builder *fp,
void IMB_index_builder_finish(anim_index_builder *fp, int rollback); void IMB_index_builder_finish(anim_index_builder *fp, int rollback);
struct ImBufAnimIndex *IMB_indexer_open(const char *name); ImBufAnimIndex *IMB_indexer_open(const char *name);
uint64_t IMB_indexer_get_seek_pos(struct ImBufAnimIndex *idx, int frame_index); uint64_t IMB_indexer_get_seek_pos(ImBufAnimIndex *idx, int frame_index);
uint64_t IMB_indexer_get_seek_pos_pts(struct ImBufAnimIndex *idx, int frame_index); uint64_t IMB_indexer_get_seek_pos_pts(ImBufAnimIndex *idx, int frame_index);
uint64_t IMB_indexer_get_seek_pos_dts(struct ImBufAnimIndex *idx, int frame_index); uint64_t IMB_indexer_get_seek_pos_dts(ImBufAnimIndex *idx, int frame_index);
int IMB_indexer_get_frame_index(struct ImBufAnimIndex *idx, int frameno); int IMB_indexer_get_frame_index(ImBufAnimIndex *idx, int frameno);
uint64_t IMB_indexer_get_pts(struct ImBufAnimIndex *idx, int frame_index); uint64_t IMB_indexer_get_pts(ImBufAnimIndex *idx, int frame_index);
int IMB_indexer_get_duration(struct ImBufAnimIndex *idx); int IMB_indexer_get_duration(ImBufAnimIndex *idx);
int IMB_indexer_can_scan(struct ImBufAnimIndex *idx, int old_frame_index, int new_frame_index); int IMB_indexer_can_scan(ImBufAnimIndex *idx, int old_frame_index, int new_frame_index);
void IMB_indexer_close(struct ImBufAnimIndex *idx); void IMB_indexer_close(ImBufAnimIndex *idx);
void IMB_free_indices(struct ImBufAnim *anim); void IMB_free_indices(ImBufAnim *anim);
struct ImBufAnim *IMB_anim_open_proxy(struct ImBufAnim *anim, IMB_Proxy_Size preview_size); ImBufAnim *IMB_anim_open_proxy(ImBufAnim *anim, IMB_Proxy_Size preview_size);
struct ImBufAnimIndex *IMB_anim_open_index(struct ImBufAnim *anim, IMB_Timecode_Type tc); ImBufAnimIndex *IMB_anim_open_index(ImBufAnim *anim, IMB_Timecode_Type tc);
int IMB_proxy_size_to_array_index(IMB_Proxy_Size pr_size); int IMB_proxy_size_to_array_index(IMB_Proxy_Size pr_size);
int IMB_timecode_to_array_index(IMB_Timecode_Type tc); int IMB_timecode_to_array_index(IMB_Timecode_Type tc);