diff options
Diffstat (limited to 'source/blender/draw/modes')
34 files changed, 5921 insertions, 0 deletions
diff --git a/source/blender/draw/modes/draw_mode_engines.h b/source/blender/draw/modes/draw_mode_engines.h new file mode 100644 index 00000000000..c3b4d5ee61a --- /dev/null +++ b/source/blender/draw/modes/draw_mode_engines.h @@ -0,0 +1,44 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/draw_mode_engines.h + * \ingroup draw + */ + +#ifndef __DRAW_MODES_ENGINES_H__ +#define __DRAW_MODES_ENGINES_H__ + +extern DrawEngineType draw_engine_object_type; +extern DrawEngineType draw_engine_edit_armature_type; +extern DrawEngineType draw_engine_edit_curve_type; +extern DrawEngineType draw_engine_edit_lattice_type; +extern DrawEngineType draw_engine_edit_mesh_type; +extern DrawEngineType draw_engine_edit_metaball_type; +extern DrawEngineType draw_engine_edit_surface_type; +extern DrawEngineType draw_engine_edit_text_type; +extern DrawEngineType draw_engine_paint_texture_type; +extern DrawEngineType draw_engine_paint_vertex_type; +extern DrawEngineType draw_engine_paint_weight_type; +extern DrawEngineType draw_engine_particle_type; +extern DrawEngineType draw_engine_pose_type; +extern DrawEngineType draw_engine_sculpt_type; + +#endif /* __DRAW_MODES_ENGINES_H__ */
\ No newline at end of file diff --git a/source/blender/draw/modes/edit_armature_mode.c b/source/blender/draw/modes/edit_armature_mode.c new file mode 100644 index 00000000000..6111b9b160b --- /dev/null +++ b/source/blender/draw/modes/edit_armature_mode.c @@ -0,0 +1,139 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/edit_armature_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +#include "DNA_armature_types.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +extern GlobalsUboStorage ts; + +/* *********** LISTS *********** */ +/* keep it under MAX_PASSES */ +typedef struct EDIT_ARMATURE_PassList { + struct DRWPass *bone_solid; + struct DRWPass *bone_wire; + struct DRWPass *relationship; +} EDIT_ARMATURE_PassList; + +/* keep it under MAX_STORAGE */ +typedef struct EDIT_ARMATURE_StorageList { + struct g_data *g_data; +} EDIT_ARMATURE_StorageList; + +typedef struct EDIT_ARMATURE_Data { + void *engine_type; + void *fbl; + void *txl; + EDIT_ARMATURE_PassList *psl; + void *stl; +} EDIT_ARMATURE_Data; + +/* *********** STATIC *********** */ + +typedef struct g_data { + DRWShadingGroup *relationship_lines; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +static void EDIT_ARMATURE_cache_init(void *vedata) +{ + EDIT_ARMATURE_PassList *psl = ((EDIT_ARMATURE_Data *)vedata)->psl; + EDIT_ARMATURE_StorageList *stl = ((EDIT_ARMATURE_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Solid bones */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS; + psl->bone_solid = DRW_pass_create("Bone Solid Pass", state); + } + + { + /* Wire bones */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND; + psl->bone_wire = DRW_pass_create("Bone Wire Pass", state); + } + + { + /* Non Meshes Pass (Camera, empties, lamps ...) */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->relationship = DRW_pass_create("Bone Relationship Pass", state); + + /* Relationship Lines */ + stl->g_data->relationship_lines = shgroup_dynlines_uniform_color(psl->relationship, ts.colorWire); + DRW_shgroup_state_set(stl->g_data->relationship_lines, DRW_STATE_STIPPLE_3); + } +} + +static void EDIT_ARMATURE_cache_populate(void *vedata, Object *ob) +{ + bArmature *arm = ob->data; + EDIT_ARMATURE_PassList *psl = ((EDIT_ARMATURE_Data *)vedata)->psl; + EDIT_ARMATURE_StorageList *stl = ((EDIT_ARMATURE_Data *)vedata)->stl; + + if (ob->type == OB_ARMATURE) { + if (arm->edbo) { + DRW_shgroup_armature_edit(ob, psl->bone_solid, psl->bone_wire, stl->g_data->relationship_lines); + } + } +} + +static void EDIT_ARMATURE_draw_scene(void *vedata) +{ + EDIT_ARMATURE_PassList *psl = ((EDIT_ARMATURE_Data *)vedata)->psl; + + DRW_draw_pass(psl->bone_solid); + DRW_draw_pass(psl->bone_wire); + DRW_draw_pass(psl->relationship); +} + +#if 0 +void EDIT_ARMATURE_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + //BKE_collection_engine_property_add_int(ces, "show_occlude_wire", false); +} +#endif + +DrawEngineType draw_engine_edit_armature_type = { + NULL, NULL, + N_("EditArmatureMode"), + NULL, + NULL, + &EDIT_ARMATURE_cache_init, + &EDIT_ARMATURE_cache_populate, + NULL, + NULL, + &EDIT_ARMATURE_draw_scene +}; diff --git a/source/blender/draw/modes/edit_curve_mode.c b/source/blender/draw/modes/edit_curve_mode.c new file mode 100644 index 00000000000..d70db64d946 --- /dev/null +++ b/source/blender/draw/modes/edit_curve_mode.c @@ -0,0 +1,272 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/edit_curve_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* If needed, contains all global/Theme colors + * Add needed theme colors / values to DRW_globals_update() and update UBO + * Not needed for constant color. */ +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern struct GlobalsUboStorage ts; /* draw_common.c */ + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use EDIT_CURVE_engine_init() to + * initialize most of them and EDIT_CURVE_cache_init() + * for EDIT_CURVE_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct EDIT_CURVE_PassList { + /* Declare all passes here and init them in + * EDIT_CURVE_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} EDIT_CURVE_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct EDIT_CURVE_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} EDIT_CURVE_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct EDIT_CURVE_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} EDIT_CURVE_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct EDIT_CURVE_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} EDIT_CURVE_StorageList; + +typedef struct EDIT_CURVE_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + EDIT_CURVE_FramebufferList *fbl; + EDIT_CURVE_TextureList *txl; + EDIT_CURVE_PassList *psl; + EDIT_CURVE_StorageList *stl; +} EDIT_CURVE_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in EDIT_CURVE_engine_init(); + * free in EDIT_CURVE_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + + + /* This keeps the references of the shading groups for + * easy access in EDIT_CURVE_cache_populate() */ + DRWShadingGroup *group; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void EDIT_CURVE_engine_init(void *vedata) +{ + EDIT_CURVE_TextureList *txl = ((EDIT_CURVE_Data *)vedata)->txl; + EDIT_CURVE_FramebufferList *fbl = ((EDIT_CURVE_Data *)vedata)->fbl; + EDIT_CURVE_StorageList *stl = ((EDIT_CURVE_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void EDIT_CURVE_cache_init(void *vedata) +{ + EDIT_CURVE_PassList *psl = ((EDIT_CURVE_Data *)vedata)->psl; + EDIT_CURVE_StorageList *stl = ((EDIT_CURVE_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {0.2f, 0.5f, 0.3f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void EDIT_CURVE_cache_populate(void *vedata, Object *ob) +{ + EDIT_CURVE_PassList *psl = ((EDIT_CURVE_Data *)vedata)->psl; + EDIT_CURVE_StorageList *stl = ((EDIT_CURVE_Data *)vedata)->stl; + + UNUSED_VARS(psl, stl); + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void EDIT_CURVE_cache_finish(void *vedata) +{ + EDIT_CURVE_PassList *psl = ((EDIT_CURVE_Data *)vedata)->psl; + EDIT_CURVE_StorageList *stl = ((EDIT_CURVE_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void EDIT_CURVE_draw_scene(void *vedata) +{ + EDIT_CURVE_PassList *psl = ((EDIT_CURVE_Data *)vedata)->psl; + EDIT_CURVE_FramebufferList *fbl = ((EDIT_CURVE_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void EDIT_CURVE_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void EDIT_CURVE_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_edit_curve_type = { + NULL, NULL, + N_("EditCurveMode"), + &EDIT_CURVE_engine_init, + &EDIT_CURVE_engine_free, + &EDIT_CURVE_cache_init, + &EDIT_CURVE_cache_populate, + &EDIT_CURVE_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &EDIT_CURVE_draw_scene +}; diff --git a/source/blender/draw/modes/edit_lattice_mode.c b/source/blender/draw/modes/edit_lattice_mode.c new file mode 100644 index 00000000000..79d43c73378 --- /dev/null +++ b/source/blender/draw/modes/edit_lattice_mode.c @@ -0,0 +1,270 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/edit_lattice_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* If needed, contains all global/Theme colors + * Add needed theme colors / values to DRW_globals_update() and update UBO + * Not needed for constant color. */ +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern struct GlobalsUboStorage ts; /* draw_common.c */ + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use EDIT_LATTICE_engine_init() to + * initialize most of them and EDIT_LATTICE_cache_init() + * for EDIT_LATTICE_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct EDIT_LATTICE_PassList { + /* Declare all passes here and init them in + * EDIT_LATTICE_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} EDIT_LATTICE_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct EDIT_LATTICE_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} EDIT_LATTICE_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct EDIT_LATTICE_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} EDIT_LATTICE_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct EDIT_LATTICE_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} EDIT_LATTICE_StorageList; + +typedef struct EDIT_LATTICE_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + EDIT_LATTICE_FramebufferList *fbl; + EDIT_LATTICE_TextureList *txl; + EDIT_LATTICE_PassList *psl; + EDIT_LATTICE_StorageList *stl; +} EDIT_LATTICE_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in EDIT_LATTICE_engine_init(); + * free in EDIT_LATTICE_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + /* This keeps the references of the shading groups for + * easy access in EDIT_LATTICE_cache_populate() */ + DRWShadingGroup *group; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void EDIT_LATTICE_engine_init(void *vedata) +{ + EDIT_LATTICE_TextureList *txl = ((EDIT_LATTICE_Data *)vedata)->txl; + EDIT_LATTICE_FramebufferList *fbl = ((EDIT_LATTICE_Data *)vedata)->fbl; + EDIT_LATTICE_StorageList *stl = ((EDIT_LATTICE_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void EDIT_LATTICE_cache_init(void *vedata) +{ + EDIT_LATTICE_PassList *psl = ((EDIT_LATTICE_Data *)vedata)->psl; + EDIT_LATTICE_StorageList *stl = ((EDIT_LATTICE_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {1.0f, 0.0f, 0.0f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void EDIT_LATTICE_cache_populate(void *vedata, Object *ob) +{ + EDIT_LATTICE_PassList *psl = ((EDIT_LATTICE_Data *)vedata)->psl; + EDIT_LATTICE_StorageList *stl = ((EDIT_LATTICE_Data *)vedata)->stl; + + UNUSED_VARS(psl, stl); + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void EDIT_LATTICE_cache_finish(void *vedata) +{ + EDIT_LATTICE_PassList *psl = ((EDIT_LATTICE_Data *)vedata)->psl; + EDIT_LATTICE_StorageList *stl = ((EDIT_LATTICE_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void EDIT_LATTICE_draw_scene(void *vedata) +{ + EDIT_LATTICE_PassList *psl = ((EDIT_LATTICE_Data *)vedata)->psl; + EDIT_LATTICE_FramebufferList *fbl = ((EDIT_LATTICE_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void EDIT_LATTICE_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void EDIT_LATTICE_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_edit_lattice_type = { + NULL, NULL, + N_("EditLatticeMode"), + &EDIT_LATTICE_engine_init, + &EDIT_LATTICE_engine_free, + &EDIT_LATTICE_cache_init, + &EDIT_LATTICE_cache_populate, + &EDIT_LATTICE_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &EDIT_LATTICE_draw_scene +}; diff --git a/source/blender/draw/modes/edit_mesh_mode.c b/source/blender/draw/modes/edit_mesh_mode.c new file mode 100644 index 00000000000..2991d212efa --- /dev/null +++ b/source/blender/draw/modes/edit_mesh_mode.c @@ -0,0 +1,500 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/edit_mesh_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +#include "GPU_shader.h" +#include "DNA_view3d_types.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern struct GlobalsUboStorage ts; /* draw_common.c */ + +extern char datatoc_edit_overlay_frag_glsl[]; +extern char datatoc_edit_overlay_vert_glsl[]; +extern char datatoc_edit_overlay_geom_tri_glsl[]; +extern char datatoc_edit_overlay_geom_edge_glsl[]; +extern char datatoc_edit_overlay_loosevert_vert_glsl[]; +extern char datatoc_edit_overlay_facedot_frag_glsl[]; +extern char datatoc_edit_overlay_facedot_vert_glsl[]; +extern char datatoc_edit_overlay_mix_vert_glsl[]; +extern char datatoc_edit_overlay_mix_frag_glsl[]; +extern char datatoc_edit_overlay_facefill_vert_glsl[]; +extern char datatoc_edit_overlay_facefill_frag_glsl[]; +extern char datatoc_edit_normals_vert_glsl[]; +extern char datatoc_edit_normals_geom_glsl[]; +extern char datatoc_common_globals_lib_glsl[]; + +extern char datatoc_gpu_shader_uniform_color_frag_glsl[]; + +/* *********** LISTS *********** */ +/* keep it under MAX_PASSES */ +typedef struct EDIT_MESH_PassList { + struct DRWPass *depth_hidden_wire; + struct DRWPass *edit_face_overlay; + struct DRWPass *edit_face_occluded; + struct DRWPass *mix_occlude; + struct DRWPass *facefill_occlude; + struct DRWPass *normals; +} EDIT_MESH_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct EDIT_MESH_FramebufferList { + struct GPUFrameBuffer *occlude_wire_fb; +} EDIT_MESH_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct EDIT_MESH_TextureList { + struct GPUTexture *occlude_wire_depth_tx; + struct GPUTexture *occlude_wire_color_tx; +} EDIT_MESH_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct EDIT_MESH_StorageList { + struct g_data *g_data; +} EDIT_MESH_StorageList; + +typedef struct EDIT_MESH_Data { + void *engine_type; + EDIT_MESH_FramebufferList *fbl; + EDIT_MESH_TextureList *txl; + EDIT_MESH_PassList *psl; + void *stl; +} EDIT_MESH_Data; + +/* *********** STATIC *********** */ + +static struct { + struct GPUShader *overlay_tri_sh; + struct GPUShader *overlay_tri_fast_sh; + struct GPUShader *overlay_tri_vcol_sh; + struct GPUShader *overlay_tri_vcol_fast_sh; + struct GPUShader *overlay_edge_sh; + struct GPUShader *overlay_edge_vcol_sh; + struct GPUShader *overlay_vert_sh; + struct GPUShader *overlay_facedot_sh; + struct GPUShader *overlay_mix_sh; + struct GPUShader *overlay_facefill_sh; + struct GPUShader *normals_face_sh; + struct GPUShader *normals_sh; + struct GPUShader *depth_sh; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + DRWShadingGroup *depth_shgrp_hidden_wire; + + DRWShadingGroup *fnormals_shgrp; + DRWShadingGroup *vnormals_shgrp; + DRWShadingGroup *lnormals_shgrp; + + DRWShadingGroup *face_overlay_shgrp; + DRWShadingGroup *ledges_overlay_shgrp; + DRWShadingGroup *lverts_overlay_shgrp; + DRWShadingGroup *facedot_overlay_shgrp; + + DRWShadingGroup *face_occluded_shgrp; + DRWShadingGroup *ledges_occluded_shgrp; + DRWShadingGroup *lverts_occluded_shgrp; + DRWShadingGroup *facedot_occluded_shgrp; + DRWShadingGroup *facefill_occluded_shgrp; + +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +static void EDIT_MESH_engine_init(void *vedata) +{ + EDIT_MESH_TextureList *txl = ((EDIT_MESH_Data *)vedata)->txl; + EDIT_MESH_FramebufferList *fbl = ((EDIT_MESH_Data *)vedata)->fbl; + + float *viewport_size = DRW_viewport_size_get(); + + DRWFboTexture tex[2] = {{&txl->occlude_wire_depth_tx, DRW_BUF_DEPTH_24}, + {&txl->occlude_wire_color_tx, DRW_BUF_RGBA_8}}; + DRW_framebuffer_init(&fbl->occlude_wire_fb, + (int)viewport_size[0], (int)viewport_size[1], + tex, 2); + + if (!e_data.overlay_tri_sh) { + e_data.overlay_tri_sh = DRW_shader_create_with_lib(datatoc_edit_overlay_vert_glsl, + datatoc_edit_overlay_geom_tri_glsl, + datatoc_edit_overlay_frag_glsl, + datatoc_common_globals_lib_glsl, "#define EDGE_FIX\n"); + } + if (!e_data.overlay_tri_fast_sh) { + e_data.overlay_tri_fast_sh = DRW_shader_create_with_lib(datatoc_edit_overlay_vert_glsl, + datatoc_edit_overlay_geom_tri_glsl, + datatoc_edit_overlay_frag_glsl, + datatoc_common_globals_lib_glsl, NULL); + } + if (!e_data.overlay_tri_vcol_sh) { + e_data.overlay_tri_vcol_sh = DRW_shader_create_with_lib(datatoc_edit_overlay_vert_glsl, + datatoc_edit_overlay_geom_tri_glsl, + datatoc_edit_overlay_frag_glsl, + datatoc_common_globals_lib_glsl, "#define EDGE_FIX\n" + "#define VERTEX_SELECTION\n"); + } + if (!e_data.overlay_tri_vcol_fast_sh) { + e_data.overlay_tri_vcol_fast_sh = DRW_shader_create_with_lib(datatoc_edit_overlay_vert_glsl, + datatoc_edit_overlay_geom_tri_glsl, + datatoc_edit_overlay_frag_glsl, + datatoc_common_globals_lib_glsl, "#define VERTEX_SELECTION\n"); + } + if (!e_data.overlay_edge_sh) { + e_data.overlay_edge_sh = DRW_shader_create_with_lib(datatoc_edit_overlay_vert_glsl, + datatoc_edit_overlay_geom_edge_glsl, + datatoc_edit_overlay_frag_glsl, + datatoc_common_globals_lib_glsl, NULL); + } + if (!e_data.overlay_edge_vcol_sh) { + e_data.overlay_edge_vcol_sh = DRW_shader_create_with_lib(datatoc_edit_overlay_vert_glsl, + datatoc_edit_overlay_geom_edge_glsl, + datatoc_edit_overlay_frag_glsl, + datatoc_common_globals_lib_glsl, "#define VERTEX_SELECTION\n"); + } + if (!e_data.overlay_vert_sh) { + e_data.overlay_vert_sh = DRW_shader_create_with_lib(datatoc_edit_overlay_loosevert_vert_glsl, NULL, + datatoc_edit_overlay_frag_glsl, + datatoc_common_globals_lib_glsl, "#define VERTEX_SELECTION\n"); + } + if (!e_data.overlay_facedot_sh) { + e_data.overlay_facedot_sh = DRW_shader_create_with_lib(datatoc_edit_overlay_facedot_vert_glsl, NULL, + datatoc_edit_overlay_facedot_frag_glsl, + datatoc_common_globals_lib_glsl, NULL); + } + if (!e_data.overlay_mix_sh) { + e_data.overlay_mix_sh = DRW_shader_create_fullscreen(datatoc_edit_overlay_mix_frag_glsl, NULL); + } + if (!e_data.overlay_facefill_sh) { + e_data.overlay_facefill_sh = DRW_shader_create_with_lib(datatoc_edit_overlay_facefill_vert_glsl, NULL, + datatoc_edit_overlay_facefill_frag_glsl, + datatoc_common_globals_lib_glsl, NULL); + } + if (!e_data.normals_face_sh) { + e_data.normals_face_sh = DRW_shader_create(datatoc_edit_normals_vert_glsl, + datatoc_edit_normals_geom_glsl, + datatoc_gpu_shader_uniform_color_frag_glsl, "#define FACE_NORMALS\n"); + } + if (!e_data.normals_sh) { + e_data.normals_sh = DRW_shader_create(datatoc_edit_normals_vert_glsl, + datatoc_edit_normals_geom_glsl, + datatoc_gpu_shader_uniform_color_frag_glsl, NULL); + } + if (!e_data.depth_sh) { + e_data.depth_sh = DRW_shader_create_3D_depth_only(); + } +} + +static DRWPass *edit_mesh_create_overlay_pass(DRWShadingGroup **face_shgrp, DRWShadingGroup **ledges_shgrp, + DRWShadingGroup **lverts_shgrp, DRWShadingGroup **facedot_shgrp, + float *faceAlpha, DRWState statemod) +{ + static struct GPUShader *tri_sh, *ledge_sh; + const struct bContext *C = DRW_get_context(); + RegionView3D *rv3d = CTX_wm_region_view3d(C); + Scene *scene = CTX_data_scene(C); + ToolSettings *tsettings = scene->toolsettings; + + if ((tsettings->selectmode & SCE_SELECT_VERTEX) != 0) { + ledge_sh = e_data.overlay_edge_vcol_sh; + + if ((rv3d->rflag & RV3D_NAVIGATING) != 0) + tri_sh = e_data.overlay_tri_vcol_fast_sh; + else + tri_sh = e_data.overlay_tri_vcol_sh; + } + else { + ledge_sh = e_data.overlay_edge_sh; + + if ((rv3d->rflag & RV3D_NAVIGATING) != 0) + tri_sh = e_data.overlay_tri_fast_sh; + else + tri_sh = e_data.overlay_tri_sh; + } + + DRWPass *pass = DRW_pass_create("Edit Mesh Face Overlay Pass", DRW_STATE_WRITE_COLOR | DRW_STATE_POINT | statemod); + + *face_shgrp = DRW_shgroup_create(tri_sh, pass); + DRW_shgroup_uniform_block(*face_shgrp, "globalsBlock", globals_ubo, 0); + DRW_shgroup_uniform_vec2(*face_shgrp, "viewportSize", DRW_viewport_size_get(), 1); + DRW_shgroup_uniform_float(*face_shgrp, "faceAlphaMod", faceAlpha, 1); + + *ledges_shgrp = DRW_shgroup_create(ledge_sh, pass); + DRW_shgroup_uniform_vec2(*ledges_shgrp, "viewportSize", DRW_viewport_size_get(), 1); + + if ((tsettings->selectmode & (SCE_SELECT_VERTEX)) != 0) { + *lverts_shgrp = DRW_shgroup_create(e_data.overlay_vert_sh, pass); + DRW_shgroup_uniform_vec2(*lverts_shgrp, "viewportSize", DRW_viewport_size_get(), 1); + } + + if ((tsettings->selectmode & (SCE_SELECT_FACE)) != 0) { + *facedot_shgrp = DRW_shgroup_create(e_data.overlay_facedot_sh, pass); + } + + return pass; +} + +static float backwire_opacity; +static float face_mod; +static float size_normal; + +static void EDIT_MESH_cache_init(void *vedata) +{ + EDIT_MESH_TextureList *txl = ((EDIT_MESH_Data *)vedata)->txl; + EDIT_MESH_PassList *psl = ((EDIT_MESH_Data *)vedata)->psl; + EDIT_MESH_StorageList *stl = ((EDIT_MESH_Data *)vedata)->stl; + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + const struct bContext *C = DRW_get_context(); + View3D *v3d = CTX_wm_view3d(C); + + bool do_zbufclip = ((v3d->flag & V3D_ZBUF_SELECT) == 0); + + static float zero = 0.0f; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Complementary Depth Pass */ + psl->depth_hidden_wire = DRW_pass_create("Depth Pass Hidden Wire", DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_CULL_BACK); + stl->g_data->depth_shgrp_hidden_wire = DRW_shgroup_create(e_data.depth_sh, psl->depth_hidden_wire); + } + + { + /* Normals */ + psl->normals = DRW_pass_create("Edit Mesh Normals Pass", DRW_STATE_WRITE_DEPTH | DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS); + + stl->g_data->fnormals_shgrp = DRW_shgroup_create(e_data.normals_face_sh, psl->normals); + DRW_shgroup_uniform_float(stl->g_data->fnormals_shgrp, "normalSize", &size_normal, 1); + DRW_shgroup_uniform_vec4(stl->g_data->fnormals_shgrp, "color", ts.colorNormal, 1); + + stl->g_data->vnormals_shgrp = DRW_shgroup_create(e_data.normals_sh, psl->normals); + DRW_shgroup_uniform_float(stl->g_data->vnormals_shgrp, "normalSize", &size_normal, 1); + DRW_shgroup_uniform_vec4(stl->g_data->vnormals_shgrp, "color", ts.colorVNormal, 1); + + stl->g_data->lnormals_shgrp = DRW_shgroup_create(e_data.normals_sh, psl->normals); + DRW_shgroup_uniform_float(stl->g_data->lnormals_shgrp, "normalSize", &size_normal, 1); + DRW_shgroup_uniform_vec4(stl->g_data->lnormals_shgrp, "color", ts.colorLNormal, 1); + } + + if (!do_zbufclip) { + psl->edit_face_overlay = edit_mesh_create_overlay_pass(&stl->g_data->face_overlay_shgrp, &stl->g_data->ledges_overlay_shgrp, &stl->g_data->lverts_overlay_shgrp, + &stl->g_data->facedot_overlay_shgrp, &face_mod, DRW_STATE_DEPTH_LESS | DRW_STATE_WRITE_DEPTH | DRW_STATE_BLEND); + } + else { + /* We render all wires with depth and opaque to a new fbo and blend the result based on depth values */ + psl->edit_face_occluded = edit_mesh_create_overlay_pass(&stl->g_data->face_occluded_shgrp, &stl->g_data->ledges_occluded_shgrp, &stl->g_data->lverts_occluded_shgrp, + &stl->g_data->facedot_occluded_shgrp, &zero, DRW_STATE_DEPTH_LESS | DRW_STATE_WRITE_DEPTH); + + /* however we loose the front faces value (because we need the depth of occluded wires and + * faces are alpha blended ) so we recover them in a new pass. */ + psl->facefill_occlude = DRW_pass_create("Front Face Color", DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND); + stl->g_data->facefill_occluded_shgrp = DRW_shgroup_create(e_data.overlay_facefill_sh, psl->facefill_occlude); + DRW_shgroup_uniform_block(stl->g_data->facefill_occluded_shgrp, "globalsBlock", globals_ubo, 0); + + /* we need a full screen pass to combine the result */ + struct Batch *quad = DRW_cache_fullscreen_quad_get(); + + psl->mix_occlude = DRW_pass_create("Mix Occluded Wires", DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND); + DRWShadingGroup *mix_shgrp = DRW_shgroup_create(e_data.overlay_mix_sh, psl->mix_occlude); + DRW_shgroup_call_add(mix_shgrp, quad, NULL); + DRW_shgroup_uniform_float(mix_shgrp, "alpha", &backwire_opacity, 1); + DRW_shgroup_uniform_buffer(mix_shgrp, "wireColor", &txl->occlude_wire_color_tx, 0); + DRW_shgroup_uniform_buffer(mix_shgrp, "wireDepth", &txl->occlude_wire_depth_tx, 2); + DRW_shgroup_uniform_buffer(mix_shgrp, "sceneDepth", &dtxl->depth, 3); + } +} + +static void edit_mesh_add_ob_to_pass(Scene *scene, Object *ob, DRWShadingGroup *face_shgrp, DRWShadingGroup *ledges_shgrp, + DRWShadingGroup *lverts_shgrp, DRWShadingGroup *facedot_shgrp, DRWShadingGroup *facefill_shgrp) +{ + struct Batch *geo_ovl_tris, *geo_ovl_ledges, *geo_ovl_lverts, *geo_ovl_fcenter; + ToolSettings *tsettings = scene->toolsettings; + + DRW_cache_wire_overlay_get(ob, &geo_ovl_tris, &geo_ovl_ledges, &geo_ovl_lverts); + DRW_shgroup_call_add(face_shgrp, geo_ovl_tris, ob->obmat); + DRW_shgroup_call_add(ledges_shgrp, geo_ovl_ledges, ob->obmat); + + if (facefill_shgrp) + DRW_shgroup_call_add(facefill_shgrp, geo_ovl_tris, ob->obmat); + + if ((tsettings->selectmode & SCE_SELECT_VERTEX) != 0) + DRW_shgroup_call_add(lverts_shgrp, geo_ovl_lverts, ob->obmat); + + if ((tsettings->selectmode & SCE_SELECT_FACE) != 0) { + geo_ovl_fcenter = DRW_cache_face_centers_get(ob); + DRW_shgroup_call_add(facedot_shgrp, geo_ovl_fcenter, ob->obmat); + } +} + +static void EDIT_MESH_cache_populate(void *vedata, Object *ob) +{ + EDIT_MESH_StorageList *stl = ((EDIT_MESH_Data *)vedata)->stl; + const struct bContext *C = DRW_get_context(); + View3D *v3d = CTX_wm_view3d(C); + Scene *scene = CTX_data_scene(C); + Object *obedit = scene->obedit; + struct Batch *geom; + + if (ob->type == OB_MESH) { + if (ob == obedit) { + IDProperty *ces_mode_ed = BKE_object_collection_engine_get(ob, COLLECTION_MODE_EDIT, ""); + bool do_occlude_wire = BKE_collection_engine_property_value_get_bool(ces_mode_ed, "show_occlude_wire"); + backwire_opacity = BKE_collection_engine_property_value_get_float(ces_mode_ed, "backwire_opacity"); /* Updating uniform */ + + bool fnormals_do = BKE_collection_engine_property_value_get_bool(ces_mode_ed, "face_normals_show"); + bool vnormals_do = BKE_collection_engine_property_value_get_bool(ces_mode_ed, "vert_normals_show"); + bool lnormals_do = BKE_collection_engine_property_value_get_bool(ces_mode_ed, "loop_normals_show"); + size_normal = BKE_collection_engine_property_value_get_float(ces_mode_ed, "normals_length"); /* Updating uniform */ + + face_mod = (do_occlude_wire) ? 0.0f : 1.0f; + + if (do_occlude_wire) { + geom = DRW_cache_surface_get(ob); + DRW_shgroup_call_add(stl->g_data->depth_shgrp_hidden_wire, geom, ob->obmat); + } + + if (fnormals_do) { + geom = DRW_cache_face_centers_get(ob); + DRW_shgroup_call_add(stl->g_data->fnormals_shgrp, geom, ob->obmat); + } + + if (vnormals_do) { + geom = DRW_cache_verts_get(ob); + DRW_shgroup_call_add(stl->g_data->vnormals_shgrp, geom, ob->obmat); + } + + if (lnormals_do) { + geom = DRW_cache_surface_verts_get(ob); + DRW_shgroup_call_add(stl->g_data->lnormals_shgrp, geom, ob->obmat); + } + + if ((v3d->flag & V3D_ZBUF_SELECT) == 0) { + edit_mesh_add_ob_to_pass(scene, ob, stl->g_data->face_occluded_shgrp, stl->g_data->ledges_occluded_shgrp, + stl->g_data->lverts_occluded_shgrp, stl->g_data->facedot_occluded_shgrp, stl->g_data->facefill_occluded_shgrp); + } + else { + edit_mesh_add_ob_to_pass(scene, ob, stl->g_data->face_overlay_shgrp, stl->g_data->ledges_overlay_shgrp, + stl->g_data->lverts_overlay_shgrp, stl->g_data->facedot_overlay_shgrp, NULL); + } + } + } +} + +static void EDIT_MESH_draw_scene(void *vedata) +{ + EDIT_MESH_PassList *psl = ((EDIT_MESH_Data *)vedata)->psl; + EDIT_MESH_FramebufferList *fbl = ((EDIT_MESH_Data *)vedata)->fbl; + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + DRW_draw_pass(psl->depth_hidden_wire); + + if (psl->edit_face_occluded) { + float clearcol[4] = {0.0f, 0.0f, 0.0f, 0.0f}; + /* render facefill */ + DRW_draw_pass(psl->facefill_occlude); + + /* Render wires on a separate framebuffer */ + DRW_framebuffer_bind(fbl->occlude_wire_fb); + DRW_framebuffer_clear(true, true, false, clearcol, 1.0f); + DRW_draw_pass(psl->normals); + DRW_draw_pass(psl->edit_face_occluded); + + /* detach textures */ + DRW_framebuffer_texture_detach(dtxl->depth); + + /* Combine with scene buffer */ + DRW_framebuffer_bind(dfbl->default_fb); + DRW_draw_pass(psl->mix_occlude); + + /* reattach */ + DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + } + else { + DRW_draw_pass(psl->normals); + DRW_draw_pass(psl->edit_face_overlay); + } +} + +void EDIT_MESH_collection_settings_create(IDProperty *properties) +{ + BLI_assert(properties && + properties->type == IDP_GROUP && + properties->subtype == IDP_GROUP_SUB_MODE_EDIT); + BKE_collection_engine_property_add_int(properties, "show_occlude_wire", false); + BKE_collection_engine_property_add_int(properties, "face_normals_show", false); + BKE_collection_engine_property_add_int(properties, "vert_normals_show", false); + BKE_collection_engine_property_add_int(properties, "loop_normals_show", false); + BKE_collection_engine_property_add_float(properties, "normals_length", 0.1); + BKE_collection_engine_property_add_float(properties, "backwire_opacity", 0.5); +} + +static void EDIT_MESH_engine_free(void) +{ + if (e_data.overlay_tri_sh) + DRW_shader_free(e_data.overlay_tri_sh); + if (e_data.overlay_tri_fast_sh) + DRW_shader_free(e_data.overlay_tri_fast_sh); + if (e_data.overlay_tri_vcol_sh) + DRW_shader_free(e_data.overlay_tri_vcol_sh); + if (e_data.overlay_tri_vcol_fast_sh) + DRW_shader_free(e_data.overlay_tri_vcol_fast_sh); + if (e_data.overlay_edge_sh) + DRW_shader_free(e_data.overlay_edge_sh); + if (e_data.overlay_edge_vcol_sh) + DRW_shader_free(e_data.overlay_edge_vcol_sh); + if (e_data.overlay_vert_sh) + DRW_shader_free(e_data.overlay_vert_sh); + if (e_data.overlay_facedot_sh) + DRW_shader_free(e_data.overlay_facedot_sh); + if (e_data.overlay_mix_sh) + DRW_shader_free(e_data.overlay_mix_sh); + if (e_data.overlay_facefill_sh) + DRW_shader_free(e_data.overlay_facefill_sh); + if (e_data.normals_face_sh) + DRW_shader_free(e_data.normals_face_sh); + if (e_data.normals_sh) + DRW_shader_free(e_data.normals_sh); +} + +DrawEngineType draw_engine_edit_mesh_type = { + NULL, NULL, + N_("EditMeshMode"), + &EDIT_MESH_engine_init, + &EDIT_MESH_engine_free, + &EDIT_MESH_cache_init, + &EDIT_MESH_cache_populate, + NULL, + NULL, + &EDIT_MESH_draw_scene +}; diff --git a/source/blender/draw/modes/edit_metaball_mode.c b/source/blender/draw/modes/edit_metaball_mode.c new file mode 100644 index 00000000000..098dca7ac38 --- /dev/null +++ b/source/blender/draw/modes/edit_metaball_mode.c @@ -0,0 +1,270 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/edit_metaball_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* If needed, contains all global/Theme colors + * Add needed theme colors / values to DRW_globals_update() and update UBO + * Not needed for constant color. */ +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern struct GlobalsUboStorage ts; /* draw_common.c */ + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use EDIT_METABALL_engine_init() to + * initialize most of them and EDIT_METABALL_cache_init() + * for EDIT_METABALL_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct EDIT_METABALL_PassList { + /* Declare all passes here and init them in + * EDIT_METABALL_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} EDIT_METABALL_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct EDIT_METABALL_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} EDIT_METABALL_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct EDIT_METABALL_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} EDIT_METABALL_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct EDIT_METABALL_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} EDIT_METABALL_StorageList; + +typedef struct EDIT_METABALL_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + EDIT_METABALL_FramebufferList *fbl; + EDIT_METABALL_TextureList *txl; + EDIT_METABALL_PassList *psl; + EDIT_METABALL_StorageList *stl; +} EDIT_METABALL_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in EDIT_METABALL_engine_init(); + * free in EDIT_METABALL_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + /* This keeps the references of the shading groups for + * easy access in EDIT_METABALL_cache_populate() */ + DRWShadingGroup *group; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void EDIT_METABALL_engine_init(void *vedata) +{ + EDIT_METABALL_TextureList *txl = ((EDIT_METABALL_Data *)vedata)->txl; + EDIT_METABALL_FramebufferList *fbl = ((EDIT_METABALL_Data *)vedata)->fbl; + EDIT_METABALL_StorageList *stl = ((EDIT_METABALL_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void EDIT_METABALL_cache_init(void *vedata) +{ + EDIT_METABALL_PassList *psl = ((EDIT_METABALL_Data *)vedata)->psl; + EDIT_METABALL_StorageList *stl = ((EDIT_METABALL_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {0.0f, 1.0f, 0.0f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void EDIT_METABALL_cache_populate(void *vedata, Object *ob) +{ + EDIT_METABALL_PassList *psl = ((EDIT_METABALL_Data *)vedata)->psl; + EDIT_METABALL_StorageList *stl = ((EDIT_METABALL_Data *)vedata)->stl; + + UNUSED_VARS(psl, stl); + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void EDIT_METABALL_cache_finish(void *vedata) +{ + EDIT_METABALL_PassList *psl = ((EDIT_METABALL_Data *)vedata)->psl; + EDIT_METABALL_StorageList *stl = ((EDIT_METABALL_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void EDIT_METABALL_draw_scene(void *vedata) +{ + EDIT_METABALL_PassList *psl = ((EDIT_METABALL_Data *)vedata)->psl; + EDIT_METABALL_FramebufferList *fbl = ((EDIT_METABALL_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void EDIT_METABALL_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void EDIT_METABALL_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_edit_metaball_type = { + NULL, NULL, + N_("EditMetaballMode"), + &EDIT_METABALL_engine_init, + &EDIT_METABALL_engine_free, + &EDIT_METABALL_cache_init, + &EDIT_METABALL_cache_populate, + &EDIT_METABALL_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &EDIT_METABALL_draw_scene +}; diff --git a/source/blender/draw/modes/edit_surface_mode.c b/source/blender/draw/modes/edit_surface_mode.c new file mode 100644 index 00000000000..fcae505a673 --- /dev/null +++ b/source/blender/draw/modes/edit_surface_mode.c @@ -0,0 +1,270 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/edit_surface_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* If needed, contains all global/Theme colors + * Add needed theme colors / values to DRW_globals_update() and update UBO + * Not needed for constant color. */ +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern struct GlobalsUboStorage ts; /* draw_common.c */ + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use EDIT_SURFACE_engine_init() to + * initialize most of them and EDIT_SURFACE_cache_init() + * for EDIT_SURFACE_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct EDIT_SURFACE_PassList { + /* Declare all passes here and init them in + * EDIT_SURFACE_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} EDIT_SURFACE_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct EDIT_SURFACE_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} EDIT_SURFACE_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct EDIT_SURFACE_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} EDIT_SURFACE_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct EDIT_SURFACE_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} EDIT_SURFACE_StorageList; + +typedef struct EDIT_SURFACE_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + EDIT_SURFACE_FramebufferList *fbl; + EDIT_SURFACE_TextureList *txl; + EDIT_SURFACE_PassList *psl; + EDIT_SURFACE_StorageList *stl; +} EDIT_SURFACE_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in EDIT_SURFACE_engine_init(); + * free in EDIT_SURFACE_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + /* This keeps the references of the shading groups for + * easy access in EDIT_SURFACE_cache_populate() */ + DRWShadingGroup *group; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void EDIT_SURFACE_engine_init(void *vedata) +{ + EDIT_SURFACE_TextureList *txl = ((EDIT_SURFACE_Data *)vedata)->txl; + EDIT_SURFACE_FramebufferList *fbl = ((EDIT_SURFACE_Data *)vedata)->fbl; + EDIT_SURFACE_StorageList *stl = ((EDIT_SURFACE_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void EDIT_SURFACE_cache_init(void *vedata) +{ + EDIT_SURFACE_PassList *psl = ((EDIT_SURFACE_Data *)vedata)->psl; + EDIT_SURFACE_StorageList *stl = ((EDIT_SURFACE_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {0.0f, 0.0f, 1.0f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void EDIT_SURFACE_cache_populate(void *vedata, Object *ob) +{ + EDIT_SURFACE_PassList *psl = ((EDIT_SURFACE_Data *)vedata)->psl; + EDIT_SURFACE_StorageList *stl = ((EDIT_SURFACE_Data *)vedata)->stl; + + UNUSED_VARS(psl, stl); + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void EDIT_SURFACE_cache_finish(void *vedata) +{ + EDIT_SURFACE_PassList *psl = ((EDIT_SURFACE_Data *)vedata)->psl; + EDIT_SURFACE_StorageList *stl = ((EDIT_SURFACE_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void EDIT_SURFACE_draw_scene(void *vedata) +{ + EDIT_SURFACE_PassList *psl = ((EDIT_SURFACE_Data *)vedata)->psl; + EDIT_SURFACE_FramebufferList *fbl = ((EDIT_SURFACE_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void EDIT_SURFACE_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void EDIT_SURFACE_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_edit_surface_type = { + NULL, NULL, + N_("EditSurfaceMode"), + &EDIT_SURFACE_engine_init, + &EDIT_SURFACE_engine_free, + &EDIT_SURFACE_cache_init, + &EDIT_SURFACE_cache_populate, + &EDIT_SURFACE_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &EDIT_SURFACE_draw_scene +}; diff --git a/source/blender/draw/modes/edit_text_mode.c b/source/blender/draw/modes/edit_text_mode.c new file mode 100644 index 00000000000..2a1b0d4e4ae --- /dev/null +++ b/source/blender/draw/modes/edit_text_mode.c @@ -0,0 +1,270 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/edit_text_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* If needed, contains all global/Theme colors + * Add needed theme colors / values to DRW_globals_update() and update UBO + * Not needed for constant color. */ +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern struct GlobalsUboStorage ts; /* draw_common.c */ + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use EDIT_TEXT_engine_init() to + * initialize most of them and EDIT_TEXT_cache_init() + * for EDIT_TEXT_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct EDIT_TEXT_PassList { + /* Declare all passes here and init them in + * EDIT_TEXT_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} EDIT_TEXT_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct EDIT_TEXT_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} EDIT_TEXT_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct EDIT_TEXT_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} EDIT_TEXT_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct EDIT_TEXT_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} EDIT_TEXT_StorageList; + +typedef struct EDIT_TEXT_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + EDIT_TEXT_FramebufferList *fbl; + EDIT_TEXT_TextureList *txl; + EDIT_TEXT_PassList *psl; + EDIT_TEXT_StorageList *stl; +} EDIT_TEXT_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in EDIT_TEXT_engine_init(); + * free in EDIT_TEXT_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + /* This keeps the references of the shading groups for + * easy access in EDIT_TEXT_cache_populate() */ + DRWShadingGroup *group; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void EDIT_TEXT_engine_init(void *vedata) +{ + EDIT_TEXT_TextureList *txl = ((EDIT_TEXT_Data *)vedata)->txl; + EDIT_TEXT_FramebufferList *fbl = ((EDIT_TEXT_Data *)vedata)->fbl; + EDIT_TEXT_StorageList *stl = ((EDIT_TEXT_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void EDIT_TEXT_cache_init(void *vedata) +{ + EDIT_TEXT_PassList *psl = ((EDIT_TEXT_Data *)vedata)->psl; + EDIT_TEXT_StorageList *stl = ((EDIT_TEXT_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {1.0f, 0.0f, 0.0f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void EDIT_TEXT_cache_populate(void *vedata, Object *ob) +{ + EDIT_TEXT_PassList *psl = ((EDIT_TEXT_Data *)vedata)->psl; + EDIT_TEXT_StorageList *stl = ((EDIT_TEXT_Data *)vedata)->stl; + + UNUSED_VARS(psl, stl); + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void EDIT_TEXT_cache_finish(void *vedata) +{ + EDIT_TEXT_PassList *psl = ((EDIT_TEXT_Data *)vedata)->psl; + EDIT_TEXT_StorageList *stl = ((EDIT_TEXT_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void EDIT_TEXT_draw_scene(void *vedata) +{ + EDIT_TEXT_PassList *psl = ((EDIT_TEXT_Data *)vedata)->psl; + EDIT_TEXT_FramebufferList *fbl = ((EDIT_TEXT_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void EDIT_TEXT_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void EDIT_TEXT_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_edit_text_type = { + NULL, NULL, + N_("EditTextMode"), + &EDIT_TEXT_engine_init, + &EDIT_TEXT_engine_free, + &EDIT_TEXT_cache_init, + &EDIT_TEXT_cache_populate, + &EDIT_TEXT_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &EDIT_TEXT_draw_scene +}; diff --git a/source/blender/draw/modes/object_mode.c b/source/blender/draw/modes/object_mode.c new file mode 100644 index 00000000000..5a9582bd319 --- /dev/null +++ b/source/blender/draw/modes/object_mode.c @@ -0,0 +1,1061 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/object_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +#include "DNA_userdef_types.h" +#include "DNA_armature_types.h" +#include "DNA_camera_types.h" +#include "DNA_view3d_types.h" +#include "DNA_world_types.h" + +#include "BKE_camera.h" +#include "BKE_global.h" + +#include "ED_view3d.h" +#include "ED_view3d.h" + +#include "GPU_shader.h" + +#include "UI_resources.h" + +#include "draw_mode_engines.h" +#include "draw_common.h" + +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern GlobalsUboStorage ts; + +extern char datatoc_object_outline_resolve_frag_glsl[]; +extern char datatoc_object_outline_detect_frag_glsl[]; +extern char datatoc_object_outline_expand_frag_glsl[]; +extern char datatoc_object_grid_frag_glsl[]; +extern char datatoc_object_grid_vert_glsl[]; +extern char datatoc_common_globals_lib_glsl[]; + +/* *********** LISTS *********** */ +/* keep it under MAX_PASSES */ +typedef struct OBJECT_PassList { + struct DRWPass *non_meshes; + struct DRWPass *ob_center; + struct DRWPass *outlines; + struct DRWPass *outlines_search; + struct DRWPass *outlines_expand; + struct DRWPass *outlines_fade1; + struct DRWPass *outlines_fade2; + struct DRWPass *outlines_fade3; + struct DRWPass *outlines_fade4; + struct DRWPass *outlines_fade5; + struct DRWPass *outlines_resolve; + struct DRWPass *grid; + struct DRWPass *bone_solid; + struct DRWPass *bone_wire; +} OBJECT_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct OBJECT_FramebufferList { + struct GPUFrameBuffer *outlines; + struct GPUFrameBuffer *blur; +} OBJECT_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct OBJECT_TextureList { + struct GPUTexture *outlines_depth_tx; + struct GPUTexture *outlines_color_tx; + struct GPUTexture *outlines_blur_tx; +} OBJECT_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct OBJECT_StorageList { + struct g_data *g_data; +} OBJECT_StorageList; + +typedef struct OBJECT_Data { + void *engine_type; + void *fbl; + void *txl; + OBJECT_PassList *psl; + void *stl; +} OBJECT_Data; + +/* *********** STATIC *********** */ + +typedef struct g_data{ + /* Empties */ + DRWShadingGroup *plain_axes; + DRWShadingGroup *cube; + DRWShadingGroup *circle; + DRWShadingGroup *sphere; + DRWShadingGroup *cone; + DRWShadingGroup *single_arrow; + DRWShadingGroup *single_arrow_line; + DRWShadingGroup *arrows; + DRWShadingGroup *axis_names; + + /* Speaker */ + DRWShadingGroup *speaker; + + /* Lamps */ + DRWShadingGroup *lamp_center; + DRWShadingGroup *lamp_center_group; + DRWShadingGroup *lamp_groundpoint; + DRWShadingGroup *lamp_groundline; + DRWShadingGroup *lamp_circle; + DRWShadingGroup *lamp_circle_shadow; + DRWShadingGroup *lamp_sunrays; + DRWShadingGroup *lamp_distance; + DRWShadingGroup *lamp_buflimit; + DRWShadingGroup *lamp_buflimit_points; + DRWShadingGroup *lamp_area; + DRWShadingGroup *lamp_hemi; + DRWShadingGroup *lamp_spot_cone; + DRWShadingGroup *lamp_spot_blend; + DRWShadingGroup *lamp_spot_pyramid; + DRWShadingGroup *lamp_spot_blend_rect; + + /* Helpers */ + DRWShadingGroup *relationship_lines; + + /* Objects Centers */ + DRWShadingGroup *center_active; + DRWShadingGroup *center_selected; + DRWShadingGroup *center_deselected; + + /* Camera */ + DRWShadingGroup *camera; + DRWShadingGroup *camera_tria; + DRWShadingGroup *camera_focus; + DRWShadingGroup *camera_clip; + DRWShadingGroup *camera_clip_points; + DRWShadingGroup *camera_mist; + DRWShadingGroup *camera_mist_points; + + /* Outlines */ + DRWShadingGroup *outlines_active; + DRWShadingGroup *outlines_active_group; + DRWShadingGroup *outlines_select; + DRWShadingGroup *outlines_select_group; + DRWShadingGroup *outlines_transform; + +} g_data; /* Transient data */ + +static struct { + struct GPUShader *outline_resolve_sh; + struct GPUShader *outline_detect_sh; + struct GPUShader *outline_fade_sh; + struct GPUShader *grid_sh; + float camera_pos[3]; + float grid_settings[5]; + float grid_mat[4][4]; + int grid_flag; + int zpos_flag; + int zneg_flag; +} e_data = {NULL}; /* Engine data */ + + +enum { + SHOW_AXIS_X = (1 << 0), + SHOW_AXIS_Y = (1 << 1), + SHOW_AXIS_Z = (1 << 2), + SHOW_GRID = (1 << 3), + PLANE_XY = (1 << 4), + PLANE_XZ = (1 << 5), + PLANE_YZ = (1 << 6), + CLIP_ZPOS = (1 << 7), + CLIP_ZNEG = (1 << 8), +}; + +/* *********** FUNCTIONS *********** */ + +static void OBJECT_engine_init(void *vedata) +{ + OBJECT_TextureList *txl = ((OBJECT_Data *)vedata)->txl; + OBJECT_FramebufferList *fbl = ((OBJECT_Data *)vedata)->fbl; + + float *viewport_size = DRW_viewport_size_get(); + + DRWFboTexture tex[2] = {{&txl->outlines_depth_tx, DRW_BUF_DEPTH_24}, + {&txl->outlines_color_tx, DRW_BUF_RGBA_8}}; + DRW_framebuffer_init(&fbl->outlines, + (int)viewport_size[0], (int)viewport_size[1], + tex, 2); + + DRWFboTexture blur_tex = {&txl->outlines_blur_tx, DRW_BUF_RGBA_8}; + DRW_framebuffer_init(&fbl->blur, + (int)viewport_size[0], (int)viewport_size[1], + &blur_tex, 1); + + if (!e_data.outline_resolve_sh) { + e_data.outline_resolve_sh = DRW_shader_create_fullscreen(datatoc_object_outline_resolve_frag_glsl, NULL); + } + + if (!e_data.outline_detect_sh) { + e_data.outline_detect_sh = DRW_shader_create_fullscreen(datatoc_object_outline_detect_frag_glsl, NULL); + } + + if (!e_data.outline_fade_sh) { + e_data.outline_fade_sh = DRW_shader_create_fullscreen(datatoc_object_outline_expand_frag_glsl, NULL); + } + + if (!e_data.grid_sh) { + e_data.grid_sh = DRW_shader_create_with_lib(datatoc_object_grid_vert_glsl, NULL, + datatoc_object_grid_frag_glsl, + datatoc_common_globals_lib_glsl, NULL); + } + + { + /* Grid precompute */ + float viewinvmat[4][4], winmat[4][4], invwinmat[4][4], viewmat[4][4]; + const bContext *C = DRW_get_context(); + View3D *v3d = CTX_wm_view3d(C); + Scene *scene = CTX_data_scene(C); + RegionView3D *rv3d = CTX_wm_region_view3d(C); + float grid_scale = ED_view3d_grid_scale(scene, v3d, NULL); + float grid_res, offs; + + const bool show_axis_x = v3d->gridflag & V3D_SHOW_X; + const bool show_axis_y = v3d->gridflag & V3D_SHOW_Y; + const bool show_axis_z = v3d->gridflag & V3D_SHOW_Z; + const bool show_floor = (v3d->gridflag & V3D_SHOW_FLOOR); + + DRW_viewport_matrix_get(winmat, DRW_MAT_WIN); + DRW_viewport_matrix_get(viewmat, DRW_MAT_VIEW); + DRW_viewport_matrix_get(viewinvmat, DRW_MAT_VIEWINV); + + /* Setup camera pos */ + copy_v3_v3(e_data.camera_pos, viewinvmat[3]); + + /* if perps */ + if (winmat[3][3] == 0.0f) { + float fov; + float viewvecs[2][4] = { + {1.0f, -1.0f, -1.0f, 1.0f}, + {-1.0f, 1.0f, -1.0f, 1.0f} + }; + /* invert the proj matrix */ + invert_m4_m4(invwinmat, winmat); + + /* convert the view vectors to view space */ + for (int i = 0; i < 2; i++) { + mul_m4_v4(invwinmat, viewvecs[i]); + mul_v3_fl(viewvecs[i], 1.0f / viewvecs[i][2]); /* normalize */ + } + + fov = angle_v3v3(viewvecs[0], viewvecs[1]) / 2.0f; + grid_res = fabsf(tanf(fov)) / grid_scale; + + /* Grid matrix polygon offset (fix depth fighting) */ + /* see ED_view3d_polygon_offset */ + offs = winmat[3][2] * -0.0025f; + + e_data.grid_flag = (1 << 4); /* XY plane */ + if (show_axis_x) + e_data.grid_flag |= SHOW_AXIS_X; + if (show_axis_y) + e_data.grid_flag |= SHOW_AXIS_Y; + if (show_floor) + e_data.grid_flag |= SHOW_GRID; + } + else { + float viewdist = 1.0f / max_ff(fabsf(winmat[0][0]), fabsf(winmat[1][1])); + grid_res = viewdist / grid_scale; + + /* Grid matrix polygon offset (fix depth fighting) */ + /* see ED_view3d_polygon_offset */ + offs = 0.00001f * viewdist; + if (ELEM(rv3d->view, RV3D_VIEW_RIGHT, RV3D_VIEW_LEFT)) { + e_data.grid_flag = PLANE_YZ; + e_data.grid_flag |= SHOW_AXIS_Y; + e_data.grid_flag |= SHOW_AXIS_Z; + e_data.grid_flag |= SHOW_GRID; + } + else if (ELEM(rv3d->view, RV3D_VIEW_TOP, RV3D_VIEW_BOTTOM)) { + e_data.grid_flag = PLANE_XY; + e_data.grid_flag |= SHOW_AXIS_X; + e_data.grid_flag |= SHOW_AXIS_Y; + e_data.grid_flag |= SHOW_GRID; + } + else if (ELEM(rv3d->view, RV3D_VIEW_FRONT, RV3D_VIEW_BACK)) { + e_data.grid_flag = PLANE_XZ; + e_data.grid_flag |= SHOW_AXIS_X; + e_data.grid_flag |= SHOW_AXIS_Z; + e_data.grid_flag |= SHOW_GRID; + } + else { /* RV3D_VIEW_USER */ + e_data.grid_flag = PLANE_XY; + if (show_axis_x) + e_data.grid_flag |= SHOW_AXIS_X; + if (show_axis_y) + e_data.grid_flag |= SHOW_AXIS_Y; + if (show_floor) + e_data.grid_flag |= SHOW_GRID; + } + } + + /* Z axis if needed */ + if (((rv3d->view == RV3D_VIEW_USER) || (rv3d->persp != RV3D_ORTHO)) && show_axis_z) { + e_data.zpos_flag = SHOW_AXIS_Z; + + float zvec[4] = {0.0f, 0.0f, -1.0f, 0.0f}; + mul_m4_v4(viewinvmat, zvec); + + /* z axis : chose the most facing plane */ + if (fabsf(zvec[0]) < fabsf(zvec[1])) { + e_data.zpos_flag |= PLANE_XZ; + } + else { + e_data.zpos_flag |= PLANE_YZ; + } + + e_data.zneg_flag = e_data.zpos_flag; + + /* Persp : If camera is below floor plane, we switch clipping + * Ortho : If eye vector is looking up, we switch clipping */ + if (((winmat[3][3] == 0.0f) && (e_data.camera_pos[2] > 0.0f)) || + ((winmat[3][3] != 0.0f) && (zvec[2] < 0.0f))) { + e_data.zpos_flag |= CLIP_ZPOS; + e_data.zneg_flag |= CLIP_ZNEG; + } + else { + e_data.zpos_flag |= CLIP_ZNEG; + e_data.zneg_flag |= CLIP_ZPOS; + } + } + else { + e_data.zneg_flag = e_data.zpos_flag = CLIP_ZNEG | CLIP_ZPOS; + } + + winmat[3][2] -= offs; + mul_m4_m4m4(e_data.grid_mat, winmat, viewmat); + + e_data.grid_settings[0] = v3d->far / 2.0f; /* gridDistance */ + e_data.grid_settings[1] = grid_res; /* gridResolution */ + e_data.grid_settings[2] = grid_scale; /* gridScale */ + e_data.grid_settings[3] = v3d->gridsubdiv; /* gridSubdiv */ + e_data.grid_settings[4] = (v3d->gridsubdiv > 1) ? 1.0f / log(v3d->gridsubdiv) : 0.0; /* 1/log(gridSubdiv) */ + } +} + +static void OBJECT_engine_free(void) +{ + if (e_data.outline_resolve_sh) + DRW_shader_free(e_data.outline_resolve_sh); + if (e_data.outline_detect_sh) + DRW_shader_free(e_data.outline_detect_sh); + if (e_data.outline_fade_sh) + DRW_shader_free(e_data.outline_fade_sh); + if (e_data.grid_sh) + DRW_shader_free(e_data.grid_sh); +} + +static DRWShadingGroup *shgroup_outline(DRWPass *pass, const float col[4], struct GPUShader *sh) +{ + DRWShadingGroup *grp = DRW_shgroup_create(sh, pass); + DRW_shgroup_uniform_vec4(grp, "color", col, 1); + + return grp; +} + +static void OBJECT_cache_init(void *vedata) +{ + OBJECT_PassList *psl = ((OBJECT_Data *)vedata)->psl; + OBJECT_TextureList *txl = ((OBJECT_Data *)vedata)->txl; + OBJECT_StorageList *stl = ((OBJECT_Data *)vedata)->stl; + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_WIRE; + psl->outlines = DRW_pass_create("Outlines Pass", state); + + struct GPUShader *sh = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + + /* Select */ + stl->g_data->outlines_select = shgroup_outline(psl->outlines, ts.colorSelect, sh); + stl->g_data->outlines_select_group = shgroup_outline(psl->outlines, ts.colorGroupActive, sh); + + /* Transform */ + stl->g_data->outlines_transform = shgroup_outline(psl->outlines, ts.colorTransform, sh); + + /* Active */ + stl->g_data->outlines_active = shgroup_outline(psl->outlines, ts.colorActive, sh); + stl->g_data->outlines_active_group = shgroup_outline(psl->outlines, ts.colorGroupActive, sh); + } + + { + DRWState state = DRW_STATE_WRITE_COLOR; + struct Batch *quad = DRW_cache_fullscreen_quad_get(); + static float alphaOcclu = 0.35f; + static float one = 1.0f; + static float alpha1 = 5.0f / 6.0f; + static float alpha2 = 4.0f / 5.0f; + static float alpha3 = 3.0f / 4.0f; + static float alpha4 = 2.0f / 3.0f; + static float alpha5 = 1.0f / 2.0f; + static bool bTrue = true; + static bool bFalse = false; + + psl->outlines_search = DRW_pass_create("Outlines Expand Pass", state); + + DRWShadingGroup *grp = DRW_shgroup_create(e_data.outline_detect_sh, psl->outlines_search); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_color_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_buffer(grp, "sceneDepth", &dtxl->depth, 2); + DRW_shgroup_uniform_float(grp, "alphaOcclu", &alphaOcclu, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_expand = DRW_pass_create("Outlines Expand Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_expand); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_blur_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &one, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bTrue, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_fade1 = DRW_pass_create("Outlines Fade 1 Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_fade1); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_color_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &alpha1, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bFalse, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_fade2 = DRW_pass_create("Outlines Fade 2 Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_fade2); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_blur_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &alpha2, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bFalse, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_fade3 = DRW_pass_create("Outlines Fade 3 Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_fade3); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_color_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &alpha3, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bFalse, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_fade4 = DRW_pass_create("Outlines Fade 4 Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_fade4); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_blur_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &alpha4, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bFalse, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_fade5 = DRW_pass_create("Outlines Fade 5 Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_fade5); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_color_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &alpha5, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bFalse, 1); + DRW_shgroup_call_add(grp, quad, NULL); + } + + { + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND; + psl->outlines_resolve = DRW_pass_create("Outlines Resolve Pass", state); + + struct Batch *quad = DRW_cache_fullscreen_quad_get(); + + DRWShadingGroup *grp = DRW_shgroup_create(e_data.outline_resolve_sh, psl->outlines_resolve); + DRW_shgroup_uniform_buffer(grp, "outlineBluredColor", &txl->outlines_blur_tx, 0); + DRW_shgroup_call_add(grp, quad, NULL); + } + + { + /* Grid pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND; + psl->grid = DRW_pass_create("Infinite Grid Pass", state); + + struct Batch *quad = DRW_cache_fullscreen_quad_get(); + static float mat[4][4]; + unit_m4(mat); + + /* Create 3 quads to render ordered transparency Z axis */ + DRWShadingGroup *grp = DRW_shgroup_create(e_data.grid_sh, psl->grid); + DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.zneg_flag, 1); + DRW_shgroup_uniform_mat4(grp, "ViewProjectionOffsetMatrix", (float *)e_data.grid_mat); + DRW_shgroup_uniform_vec3(grp, "cameraPos", e_data.camera_pos, 1); + DRW_shgroup_uniform_vec4(grp, "gridSettings", e_data.grid_settings, 1); + DRW_shgroup_uniform_float(grp, "gridOneOverLogSubdiv", &e_data.grid_settings[4], 1); + DRW_shgroup_uniform_block(grp, "globalsBlock", globals_ubo, 0); + DRW_shgroup_call_add(grp, quad, mat); + + grp = DRW_shgroup_create(e_data.grid_sh, psl->grid); + DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.grid_flag, 1); + DRW_shgroup_call_add(grp, quad, mat); + + grp = DRW_shgroup_create(e_data.grid_sh, psl->grid); + DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.zpos_flag, 1); + DRW_shgroup_call_add(grp, quad, mat); + } + + { + /* Solid bones */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS; + psl->bone_solid = DRW_pass_create("Bone Solid Pass", state); + } + + { + /* Wire bones */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND; + psl->bone_wire = DRW_pass_create("Bone Wire Pass", state); + } + + { + /* Non Meshes Pass (Camera, empties, lamps ...) */ + struct Batch *geom; + + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_POINT; + state |= DRW_STATE_WIRE; + psl->non_meshes = DRW_pass_create("Non Meshes Pass", state); + + /* Empties */ + geom = DRW_cache_plain_axes_get(); + stl->g_data->plain_axes = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_cube_get(); + stl->g_data->cube = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_circle_get(); + stl->g_data->circle = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_empty_sphere_get(); + stl->g_data->sphere = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_empty_cone_get(); + stl->g_data->cone = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_arrow_get(); + stl->g_data->single_arrow = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_line_get(); + stl->g_data->single_arrow_line = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_arrows_get(); + stl->g_data->arrows = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_axis_names_get(); + stl->g_data->axis_names = shgroup_instance_axis_names(psl->non_meshes, geom); + + /* Speaker */ + geom = DRW_cache_speaker_get(); + stl->g_data->speaker = shgroup_instance(psl->non_meshes, geom); + + /* Camera */ + geom = DRW_cache_camera_get(); + stl->g_data->camera = shgroup_camera_instance(psl->non_meshes, geom); + + geom = DRW_cache_camera_tria_get(); + stl->g_data->camera_tria = shgroup_camera_instance(psl->non_meshes, geom); + + geom = DRW_cache_plain_axes_get(); + stl->g_data->camera_focus = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_line_get(); + stl->g_data->camera_clip = shgroup_distance_lines_instance(psl->non_meshes, geom); + stl->g_data->camera_mist = shgroup_distance_lines_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_line_endpoints_get(); + stl->g_data->camera_clip_points = shgroup_distance_lines_instance(psl->non_meshes, geom); + stl->g_data->camera_mist_points = shgroup_distance_lines_instance(psl->non_meshes, geom); + + /* Lamps */ + /* TODO + * for now we create multiple times the same VBO with only lamp center coordinates + * but ideally we would only create it once */ + + /* start with buflimit because we don't want stipples */ + geom = DRW_cache_single_line_get(); + stl->g_data->lamp_buflimit = shgroup_distance_lines_instance(psl->non_meshes, geom); + + stl->g_data->lamp_center = shgroup_dynpoints_uniform_color(psl->non_meshes, ts.colorLampNoAlpha, &ts.sizeLampCenter); + stl->g_data->lamp_center_group = shgroup_dynpoints_uniform_color(psl->non_meshes, ts.colorGroup, &ts.sizeLampCenter); + + geom = DRW_cache_lamp_get(); + stl->g_data->lamp_circle = shgroup_instance_screenspace(psl->non_meshes, geom, &ts.sizeLampCircle); + stl->g_data->lamp_circle_shadow = shgroup_instance_screenspace(psl->non_meshes, geom, &ts.sizeLampCircleShadow); + + geom = DRW_cache_lamp_sunrays_get(); + stl->g_data->lamp_sunrays = shgroup_instance_screenspace(psl->non_meshes, geom, &ts.sizeLampCircle); + + stl->g_data->lamp_groundline = shgroup_groundlines_uniform_color(psl->non_meshes, ts.colorLamp); + stl->g_data->lamp_groundpoint = shgroup_groundpoints_uniform_color(psl->non_meshes, ts.colorLamp); + + geom = DRW_cache_lamp_area_get(); + stl->g_data->lamp_area = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_lamp_hemi_get(); + stl->g_data->lamp_hemi = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_line_get(); + stl->g_data->lamp_distance = shgroup_distance_lines_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_line_endpoints_get(); + stl->g_data->lamp_buflimit_points = shgroup_distance_lines_instance(psl->non_meshes, geom); + + geom = DRW_cache_lamp_spot_get(); + stl->g_data->lamp_spot_cone = shgroup_spot_instance(psl->non_meshes, geom); + + geom = DRW_cache_circle_get(); + stl->g_data->lamp_spot_blend = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_lamp_spot_square_get(); + stl->g_data->lamp_spot_pyramid = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_square_get(); + stl->g_data->lamp_spot_blend_rect = shgroup_instance(psl->non_meshes, geom); + + /* Relationship Lines */ + stl->g_data->relationship_lines = shgroup_dynlines_uniform_color(psl->non_meshes, ts.colorWire); + DRW_shgroup_state_set(stl->g_data->relationship_lines, DRW_STATE_STIPPLE_3); + } + + { + /* Object Center pass grouped by State */ + DRWShadingGroup *grp; + static float outlineWidth, size; + + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND | DRW_STATE_POINT; + psl->ob_center = DRW_pass_create("Obj Center Pass", state); + + outlineWidth = 1.0f * U.pixelsize; + size = U.obcenter_dia * U.pixelsize + outlineWidth; + + struct GPUShader *sh = GPU_shader_get_builtin_shader(GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA); + + /* Active */ + grp = DRW_shgroup_point_batch_create(sh, psl->ob_center); + DRW_shgroup_uniform_float(grp, "size", &size, 1); + DRW_shgroup_uniform_float(grp, "outlineWidth", &outlineWidth, 1); + DRW_shgroup_uniform_vec4(grp, "color", ts.colorActive, 1); + DRW_shgroup_uniform_vec4(grp, "outlineColor", ts.colorOutline, 1); + stl->g_data->center_active = grp; + + /* Select */ + grp = DRW_shgroup_point_batch_create(sh, psl->ob_center); + DRW_shgroup_uniform_vec4(grp, "color", ts.colorSelect, 1); + stl->g_data->center_selected = grp; + + /* Deselect */ + grp = DRW_shgroup_point_batch_create(sh, psl->ob_center); + DRW_shgroup_uniform_vec4(grp, "color", ts.colorDeselect, 1); + stl->g_data->center_deselected = grp; + } +} + +static void DRW_shgroup_lamp(OBJECT_StorageList *stl, Object *ob, SceneLayer *sl) +{ + Lamp *la = ob->data; + float *color; + int theme_id = DRW_object_wire_theme_get(ob, sl, &color); + static float zero = 0.0f; + + float **la_mats = (float **)DRW_object_engine_data_get(ob, &draw_engine_object_type); + if (*la_mats == NULL) { + /* we need 2 matrices */ + *la_mats = MEM_mallocN(sizeof(float) * 16 * 2, "Lamp Object Mode Matrices"); + } + + float (*shapemat)[4], (*spotblendmat)[4]; + shapemat = (float (*)[4])(*la_mats); + spotblendmat = (float (*)[4])(*la_mats + 16); + + /* Don't draw the center if it's selected or active */ + if (theme_id == TH_GROUP) + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_center_group, ob->obmat[3]); + else if (theme_id == TH_LAMP) + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_center, ob->obmat[3]); + + /* First circle */ + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_circle, ob->obmat[3], color); + + /* draw dashed outer circle if shadow is on. remember some lamps can't have certain shadows! */ + if (la->type != LA_HEMI) { + if ((la->mode & LA_SHAD_RAY) || ((la->mode & LA_SHAD_BUF) && (la->type == LA_SPOT))) { + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_circle_shadow, ob->obmat[3], color); + } + } + + /* Distance */ + if (ELEM(la->type, LA_HEMI, LA_SUN, LA_AREA)) { + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_distance, color, &zero, &la->dist, ob->obmat); + } + + copy_m4_m4(shapemat, ob->obmat); + + if (la->type == LA_SUN) { + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_sunrays, ob->obmat[3], color); + } + else if (la->type == LA_SPOT) { + float size[3], sizemat[4][4]; + static float one = 1.0f; + float blend = 1.0f - pow2f(la->spotblend); + + size[0] = size[1] = sinf(la->spotsize * 0.5f) * la->dist; + size[2] = cosf(la->spotsize * 0.5f) * la->dist; + + size_to_mat4(sizemat, size); + mul_m4_m4m4(shapemat, ob->obmat, sizemat); + + size[0] = size[1] = blend; size[2] = 1.0f; + size_to_mat4(sizemat, size); + translate_m4(sizemat, 0.0f, 0.0f, -1.0f); + rotate_m4(sizemat, 'X', M_PI / 2.0f); + mul_m4_m4m4(spotblendmat, shapemat, sizemat); + + if (la->mode & LA_SQUARE) { + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_spot_pyramid, color, &one, shapemat); + + /* hide line if it is zero size or overlaps with outer border, + * previously it adjusted to always to show it but that seems + * confusing because it doesn't show the actual blend size */ + if (blend != 0.0f && blend != 1.0f) { + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_spot_blend_rect, color, &one, spotblendmat); + } + } + else { + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_spot_cone, color, shapemat); + + /* hide line if it is zero size or overlaps with outer border, + * previously it adjusted to always to show it but that seems + * confusing because it doesn't show the actual blend size */ + if (blend != 0.0f && blend != 1.0f) { + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_spot_blend, color, &one, spotblendmat); + } + } + + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_buflimit, color, &la->clipsta, &la->clipend, ob->obmat); + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_buflimit_points, color, &la->clipsta, &la->clipend, ob->obmat); + } + else if (la->type == LA_HEMI) { + static float hemisize = 2.0f; + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_hemi, color, &hemisize, shapemat); + } + else if (la->type == LA_AREA) { + float size[3] = {1.0f, 1.0f, 1.0f}, sizemat[4][4]; + + if (la->area_shape == LA_AREA_RECT) { + size[1] = la->area_sizey / la->area_size; + size_to_mat4(sizemat, size); + mul_m4_m4m4(shapemat, shapemat, sizemat); + } + + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_area, color, &la->area_size, shapemat); + } + + /* Line and point going to the ground */ + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_groundline, ob->obmat[3]); + DRW_shgroup_dynamic_call_add(stl->g_data->lamp_groundpoint, ob->obmat[3]); +} + +static void DRW_shgroup_camera(OBJECT_StorageList *stl, Object *ob, SceneLayer *sl) +{ + const struct bContext *C = DRW_get_context(); + View3D *v3d = CTX_wm_view3d(C); + Scene *scene = CTX_data_scene(C); + + Camera *cam = ob->data; + const bool is_active = (ob == v3d->camera); + float *color; + DRW_object_wire_theme_get(ob, sl, &color); + + float vec[4][3], asp[2], shift[2], scale[3], drawsize; + + scale[0] = 1.0f / len_v3(ob->obmat[0]); + scale[1] = 1.0f / len_v3(ob->obmat[1]); + scale[2] = 1.0f / len_v3(ob->obmat[2]); + + BKE_camera_view_frame_ex(scene, cam, cam->drawsize, false, scale, + asp, shift, &drawsize, vec); + + // /* Frame coords */ + copy_v2_v2(cam->drwcorners[0], vec[0]); + copy_v2_v2(cam->drwcorners[1], vec[1]); + copy_v2_v2(cam->drwcorners[2], vec[2]); + copy_v2_v2(cam->drwcorners[3], vec[3]); + + /* depth */ + cam->drwdepth = vec[0][2]; + + /* tria */ + cam->drwtria[0][0] = shift[0] + ((0.7f * drawsize) * scale[0]); + cam->drwtria[0][1] = shift[1] + ((drawsize * (asp[1] + 0.1f)) * scale[1]); + cam->drwtria[1][0] = shift[0]; + cam->drwtria[1][1] = shift[1] + ((1.1f * drawsize * (asp[1] + 0.7f)) * scale[1]); + + DRW_shgroup_dynamic_call_add(stl->g_data->camera, color, cam->drwcorners, &cam->drwdepth, cam->drwtria, ob->obmat); + + /* Active cam */ + if (is_active) { + DRW_shgroup_dynamic_call_add(stl->g_data->camera_tria, color, cam->drwcorners, &cam->drwdepth, cam->drwtria, ob->obmat); + } + + /* draw the rest in normalize object space */ + copy_m4_m4(cam->drwnormalmat, ob->obmat); + normalize_m4(cam->drwnormalmat); + + if (cam->flag & CAM_SHOWLIMITS) { + static float col[3] = {0.5f, 0.5f, 0.25f}, col_hi[3] = {1.0f, 1.0f, 0.5f}; + float sizemat[4][4], size[3] = {1.0f, 1.0f, 0.0f}; + float focusdist = BKE_camera_object_dof_distance(ob); + + copy_m4_m4(cam->drwfocusmat, cam->drwnormalmat); + translate_m4(cam->drwfocusmat, 0.0f, 0.0f, -focusdist); + size_to_mat4(sizemat, size); + mul_m4_m4m4(cam->drwfocusmat, cam->drwfocusmat, sizemat); + + DRW_shgroup_dynamic_call_add(stl->g_data->camera_focus, (is_active ? col_hi : col), &cam->drawsize, cam->drwfocusmat); + + DRW_shgroup_dynamic_call_add(stl->g_data->camera_clip, color, &cam->clipsta, &cam->clipend, cam->drwnormalmat); + DRW_shgroup_dynamic_call_add(stl->g_data->camera_clip_points, (is_active ? col_hi : col), &cam->clipsta, &cam->clipend, cam->drwnormalmat); + } + + if (cam->flag & CAM_SHOWMIST) { + World *world = scene->world; + + if (world) { + static float col[3] = {0.5f, 0.5f, 0.5f}, col_hi[3] = {1.0f, 1.0f, 1.0f}; + world->mistend = world->miststa + world->mistdist; + DRW_shgroup_dynamic_call_add(stl->g_data->camera_mist, color, &world->miststa, &world->mistend, cam->drwnormalmat); + DRW_shgroup_dynamic_call_add(stl->g_data->camera_mist_points, (is_active ? col_hi : col), &world->miststa, &world->mistend, cam->drwnormalmat); + } + } +} + +static void DRW_shgroup_empty(OBJECT_StorageList *stl, Object *ob, SceneLayer *sl) +{ + float *color; + DRW_object_wire_theme_get(ob, sl, &color); + + switch (ob->empty_drawtype) { + case OB_PLAINAXES: + DRW_shgroup_dynamic_call_add(stl->g_data->plain_axes, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_SINGLE_ARROW: + DRW_shgroup_dynamic_call_add(stl->g_data->single_arrow, color, &ob->empty_drawsize, ob->obmat); + DRW_shgroup_dynamic_call_add(stl->g_data->single_arrow_line, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_CUBE: + DRW_shgroup_dynamic_call_add(stl->g_data->cube, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_CIRCLE: + DRW_shgroup_dynamic_call_add(stl->g_data->circle, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_EMPTY_SPHERE: + DRW_shgroup_dynamic_call_add(stl->g_data->sphere, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_EMPTY_CONE: + DRW_shgroup_dynamic_call_add(stl->g_data->cone, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_ARROWS: + DRW_shgroup_dynamic_call_add(stl->g_data->arrows, color, &ob->empty_drawsize, ob->obmat); + DRW_shgroup_dynamic_call_add(stl->g_data->axis_names, color, &ob->empty_drawsize, ob->obmat); + break; + } +} + +static void DRW_shgroup_speaker(OBJECT_StorageList *stl, Object *ob, SceneLayer *sl) +{ + float *color; + static float one = 1.0f; + DRW_object_wire_theme_get(ob, sl, &color); + + DRW_shgroup_dynamic_call_add(stl->g_data->speaker, color, &one, ob->obmat); +} + +static void DRW_shgroup_relationship_lines(OBJECT_StorageList *stl, Object *ob) +{ + if (ob->parent) { + DRW_shgroup_dynamic_call_add(stl->g_data->relationship_lines, ob->obmat[3]); + DRW_shgroup_dynamic_call_add(stl->g_data->relationship_lines, ob->parent->obmat[3]); + } +} + +static void DRW_shgroup_object_center(OBJECT_StorageList *stl, Object *ob) +{ + if ((ob->base_flag & BASE_SELECTED) != 0) { + DRW_shgroup_dynamic_call_add(stl->g_data->center_selected, ob->obmat[3]); + } + else if (0) { + DRW_shgroup_dynamic_call_add(stl->g_data->center_deselected, ob->obmat[3]); + } +} + +static void OBJECT_cache_populate(void *vedata, Object *ob) +{ + OBJECT_StorageList *stl = ((OBJECT_Data *)vedata)->stl; + const struct bContext *C = DRW_get_context(); + Scene *scene = CTX_data_scene(C); + SceneLayer *sl = CTX_data_scene_layer(C); + + //CollectionEngineSettings *ces_mode_ob = BKE_object_collection_engine_get(ob, COLLECTION_MODE_OBJECT, ""); + + //bool do_wire = BKE_collection_engine_property_value_get_bool(ces_mode_ob, "show_wire"); + bool do_outlines = ((ob->base_flag & BASE_SELECTED) != 0); + + switch (ob->type) { + case OB_MESH: + { + Object *obedit = scene->obedit; + int theme_id = DRW_object_wire_theme_get(ob, sl, NULL); + if (ob != obedit) { + if (do_outlines) { + struct Batch *geom = DRW_cache_surface_get(ob); + switch (theme_id) { + case TH_ACTIVE: + DRW_shgroup_call_add(stl->g_data->outlines_active, geom, ob->obmat); + break; + case TH_SELECT: + DRW_shgroup_call_add(stl->g_data->outlines_select, geom, ob->obmat); + break; + case TH_GROUP_ACTIVE: + DRW_shgroup_call_add(stl->g_data->outlines_select_group, geom, ob->obmat); + break; + case TH_TRANSFORM: + DRW_shgroup_call_add(stl->g_data->outlines_transform, geom, ob->obmat); + break; + } + } + } + } + break; + case OB_LAMP: + DRW_shgroup_lamp(stl, ob, sl); + break; + case OB_CAMERA: + DRW_shgroup_camera(stl, ob, sl); + break; + case OB_EMPTY: + DRW_shgroup_empty(stl, ob, sl); + break; + case OB_SPEAKER: + DRW_shgroup_speaker(stl, ob, sl); + break; + case OB_ARMATURE: + { + bArmature *arm = ob->data; + if (arm->edbo == NULL) { + DRW_shgroup_armature_object(ob, sl, ((OBJECT_Data *)vedata)->psl->bone_solid, + ((OBJECT_Data *)vedata)->psl->bone_wire, + stl->g_data->relationship_lines); + } + } + break; + default: + break; + } + + DRW_shgroup_object_center(stl, ob); + DRW_shgroup_relationship_lines(stl, ob); +} + +static void OBJECT_draw_scene(void *vedata) +{ + + OBJECT_PassList *psl = ((OBJECT_Data *)vedata)->psl; + OBJECT_FramebufferList *fbl = ((OBJECT_Data *)vedata)->fbl; + OBJECT_TextureList *txl = ((OBJECT_Data *)vedata)->txl; + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + float clearcol[4] = {0.0f, 0.0f, 0.0f, 0.0f}; + + /* Render filled polygon on a separate framebuffer */ + DRW_framebuffer_bind(fbl->outlines); + DRW_framebuffer_clear(true, true, false, clearcol, 1.0f); + DRW_draw_pass(psl->outlines); + + /* detach textures */ + DRW_framebuffer_texture_detach(txl->outlines_depth_tx); + + /* Search outline pixels */ + DRW_framebuffer_bind(fbl->blur); + DRW_draw_pass(psl->outlines_search); + + /* Expand and fade gradually */ + DRW_framebuffer_bind(fbl->outlines); + DRW_draw_pass(psl->outlines_expand); + + DRW_framebuffer_bind(fbl->blur); + DRW_draw_pass(psl->outlines_fade1); + + DRW_framebuffer_bind(fbl->outlines); + DRW_draw_pass(psl->outlines_fade2); + + DRW_framebuffer_bind(fbl->blur); + DRW_draw_pass(psl->outlines_fade3); + + DRW_framebuffer_bind(fbl->outlines); + DRW_draw_pass(psl->outlines_fade4); + + DRW_framebuffer_bind(fbl->blur); + DRW_draw_pass(psl->outlines_fade5); + + /* reattach */ + DRW_framebuffer_texture_attach(fbl->outlines, txl->outlines_depth_tx, 0); + DRW_framebuffer_bind(dfbl->default_fb); + + /* This needs to be drawn after the oultine */ + DRW_draw_pass(psl->bone_wire); + DRW_draw_pass(psl->bone_solid); + DRW_draw_pass(psl->non_meshes); + DRW_draw_pass(psl->ob_center); + DRW_draw_pass(psl->grid); + + /* Combine with scene buffer last */ + DRW_draw_pass(psl->outlines_resolve); +} + +void OBJECT_collection_settings_create(IDProperty *props) +{ + BLI_assert(props && + props->type == IDP_GROUP && + props->subtype == IDP_GROUP_SUB_MODE_OBJECT); + BKE_collection_engine_property_add_int(props, "show_wire", false); + BKE_collection_engine_property_add_int(props, "show_backface_culling", false); +} + +DrawEngineType draw_engine_object_type = { + NULL, NULL, + N_("ObjectMode"), + &OBJECT_engine_init, + &OBJECT_engine_free, + &OBJECT_cache_init, + &OBJECT_cache_populate, + NULL, + NULL, + &OBJECT_draw_scene +}; diff --git a/source/blender/draw/modes/paint_texture_mode.c b/source/blender/draw/modes/paint_texture_mode.c new file mode 100644 index 00000000000..9d620e0ce25 --- /dev/null +++ b/source/blender/draw/modes/paint_texture_mode.c @@ -0,0 +1,270 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/paint_texture_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* If needed, contains all global/Theme colors + * Add needed theme colors / values to DRW_globals_update() and update UBO + * Not needed for constant color. */ +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern struct GlobalsUboStorage ts; /* draw_common.c */ + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use PAINT_TEXTURE_engine_init() to + * initialize most of them and PAINT_TEXTURE_cache_init() + * for PAINT_TEXTURE_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct PAINT_TEXTURE_PassList { + /* Declare all passes here and init them in + * PAINT_TEXTURE_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} PAINT_TEXTURE_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct PAINT_TEXTURE_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} PAINT_TEXTURE_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct PAINT_TEXTURE_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} PAINT_TEXTURE_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct PAINT_TEXTURE_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} PAINT_TEXTURE_StorageList; + +typedef struct PAINT_TEXTURE_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + PAINT_TEXTURE_FramebufferList *fbl; + PAINT_TEXTURE_TextureList *txl; + PAINT_TEXTURE_PassList *psl; + PAINT_TEXTURE_StorageList *stl; +} PAINT_TEXTURE_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in PAINT_TEXTURE_engine_init(); + * free in PAINT_TEXTURE_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + /* This keeps the references of the shading groups for + * easy access in PAINT_TEXTURE_cache_populate() */ + DRWShadingGroup *group; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void PAINT_TEXTURE_engine_init(void *vedata) +{ + PAINT_TEXTURE_TextureList *txl = ((PAINT_TEXTURE_Data *)vedata)->txl; + PAINT_TEXTURE_FramebufferList *fbl = ((PAINT_TEXTURE_Data *)vedata)->fbl; + PAINT_TEXTURE_StorageList *stl = ((PAINT_TEXTURE_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void PAINT_TEXTURE_cache_init(void *vedata) +{ + PAINT_TEXTURE_PassList *psl = ((PAINT_TEXTURE_Data *)vedata)->psl; + PAINT_TEXTURE_StorageList *stl = ((PAINT_TEXTURE_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {0.2f, 0.5f, 0.3f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void PAINT_TEXTURE_cache_populate(void *vedata, Object *ob) +{ + PAINT_TEXTURE_PassList *psl = ((PAINT_TEXTURE_Data *)vedata)->psl; + PAINT_TEXTURE_StorageList *stl = ((PAINT_TEXTURE_Data *)vedata)->stl; + + UNUSED_VARS(psl, stl); + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void PAINT_TEXTURE_cache_finish(void *vedata) +{ + PAINT_TEXTURE_PassList *psl = ((PAINT_TEXTURE_Data *)vedata)->psl; + PAINT_TEXTURE_StorageList *stl = ((PAINT_TEXTURE_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void PAINT_TEXTURE_draw_scene(void *vedata) +{ + PAINT_TEXTURE_PassList *psl = ((PAINT_TEXTURE_Data *)vedata)->psl; + PAINT_TEXTURE_FramebufferList *fbl = ((PAINT_TEXTURE_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void PAINT_TEXTURE_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void PAINT_TEXTURE_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_paint_texture_type = { + NULL, NULL, + N_("PaintTextureMode"), + &PAINT_TEXTURE_engine_init, + &PAINT_TEXTURE_engine_free, + &PAINT_TEXTURE_cache_init, + &PAINT_TEXTURE_cache_populate, + &PAINT_TEXTURE_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &PAINT_TEXTURE_draw_scene +}; diff --git a/source/blender/draw/modes/paint_vertex_mode.c b/source/blender/draw/modes/paint_vertex_mode.c new file mode 100644 index 00000000000..b3b32a4d6e9 --- /dev/null +++ b/source/blender/draw/modes/paint_vertex_mode.c @@ -0,0 +1,270 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/paint_vertex_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* If needed, contains all global/Theme colors + * Add needed theme colors / values to DRW_globals_update() and update UBO + * Not needed for constant color. */ +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern struct GlobalsUboStorage ts; /* draw_common.c */ + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use PAINT_VERTEX_engine_init() to + * initialize most of them and PAINT_VERTEX_cache_init() + * for PAINT_VERTEX_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct PAINT_VERTEX_PassList { + /* Declare all passes here and init them in + * PAINT_VERTEX_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} PAINT_VERTEX_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct PAINT_VERTEX_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} PAINT_VERTEX_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct PAINT_VERTEX_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} PAINT_VERTEX_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct PAINT_VERTEX_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} PAINT_VERTEX_StorageList; + +typedef struct PAINT_VERTEX_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + PAINT_VERTEX_FramebufferList *fbl; + PAINT_VERTEX_TextureList *txl; + PAINT_VERTEX_PassList *psl; + PAINT_VERTEX_StorageList *stl; +} PAINT_VERTEX_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in PAINT_VERTEX_engine_init(); + * free in PAINT_VERTEX_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + /* This keeps the references of the shading groups for + * easy access in PAINT_VERTEX_cache_populate() */ + DRWShadingGroup *group; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void PAINT_VERTEX_engine_init(void *vedata) +{ + PAINT_VERTEX_TextureList *txl = ((PAINT_VERTEX_Data *)vedata)->txl; + PAINT_VERTEX_FramebufferList *fbl = ((PAINT_VERTEX_Data *)vedata)->fbl; + PAINT_VERTEX_StorageList *stl = ((PAINT_VERTEX_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void PAINT_VERTEX_cache_init(void *vedata) +{ + PAINT_VERTEX_PassList *psl = ((PAINT_VERTEX_Data *)vedata)->psl; + PAINT_VERTEX_StorageList *stl = ((PAINT_VERTEX_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {0.2f, 0.5f, 0.3f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void PAINT_VERTEX_cache_populate(void *vedata, Object *ob) +{ + PAINT_VERTEX_PassList *psl = ((PAINT_VERTEX_Data *)vedata)->psl; + PAINT_VERTEX_StorageList *stl = ((PAINT_VERTEX_Data *)vedata)->stl; + + UNUSED_VARS(psl, stl); + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void PAINT_VERTEX_cache_finish(void *vedata) +{ + PAINT_VERTEX_PassList *psl = ((PAINT_VERTEX_Data *)vedata)->psl; + PAINT_VERTEX_StorageList *stl = ((PAINT_VERTEX_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void PAINT_VERTEX_draw_scene(void *vedata) +{ + PAINT_VERTEX_PassList *psl = ((PAINT_VERTEX_Data *)vedata)->psl; + PAINT_VERTEX_FramebufferList *fbl = ((PAINT_VERTEX_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void PAINT_VERTEX_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void PAINT_VERTEX_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_paint_vertex_type = { + NULL, NULL, + N_("PaintVertexMode"), + &PAINT_VERTEX_engine_init, + &PAINT_VERTEX_engine_free, + &PAINT_VERTEX_cache_init, + &PAINT_VERTEX_cache_populate, + &PAINT_VERTEX_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &PAINT_VERTEX_draw_scene +}; diff --git a/source/blender/draw/modes/paint_weight_mode.c b/source/blender/draw/modes/paint_weight_mode.c new file mode 100644 index 00000000000..2d189e07fd2 --- /dev/null +++ b/source/blender/draw/modes/paint_weight_mode.c @@ -0,0 +1,267 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/paint_weight_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* If needed, contains all global/Theme colors + * Add needed theme colors / values to DRW_globals_update() and update UBO + * Not needed for constant color. */ +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern struct GlobalsUboStorage ts; /* draw_common.c */ + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use PAINT_WEIGHT_engine_init() to + * initialize most of them and PAINT_WEIGHT_cache_init() + * for PAINT_WEIGHT_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct PAINT_WEIGHT_PassList { + /* Declare all passes here and init them in + * PAINT_WEIGHT_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} PAINT_WEIGHT_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct PAINT_WEIGHT_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} PAINT_WEIGHT_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct PAINT_WEIGHT_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} PAINT_WEIGHT_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct PAINT_WEIGHT_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} PAINT_WEIGHT_StorageList; + +typedef struct PAINT_WEIGHT_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + PAINT_WEIGHT_FramebufferList *fbl; + PAINT_WEIGHT_TextureList *txl; + PAINT_WEIGHT_PassList *psl; + PAINT_WEIGHT_StorageList *stl; +} PAINT_WEIGHT_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in PAINT_WEIGHT_engine_init(); + * free in PAINT_WEIGHT_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + /* This keeps the references of the shading groups for + * easy access in PAINT_WEIGHT_cache_populate() */ + DRWShadingGroup *group; +} g_data; + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void PAINT_WEIGHT_engine_init(void *vedata) +{ + PAINT_WEIGHT_TextureList *txl = ((PAINT_WEIGHT_Data *)vedata)->txl; + PAINT_WEIGHT_FramebufferList *fbl = ((PAINT_WEIGHT_Data *)vedata)->fbl; + PAINT_WEIGHT_StorageList *stl = ((PAINT_WEIGHT_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void PAINT_WEIGHT_cache_init(void *vedata) +{ + PAINT_WEIGHT_PassList *psl = ((PAINT_WEIGHT_Data *)vedata)->psl; + PAINT_WEIGHT_StorageList *stl = ((PAINT_WEIGHT_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {0.2f, 0.5f, 0.3f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void PAINT_WEIGHT_cache_populate(void *vedata, Object *ob) +{ + PAINT_WEIGHT_StorageList *stl = ((PAINT_WEIGHT_Data *)vedata)->stl; + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void PAINT_WEIGHT_cache_finish(void *vedata) +{ + PAINT_WEIGHT_PassList *psl = ((PAINT_WEIGHT_Data *)vedata)->psl; + PAINT_WEIGHT_StorageList *stl = ((PAINT_WEIGHT_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void PAINT_WEIGHT_draw_scene(void *vedata) +{ + PAINT_WEIGHT_PassList *psl = ((PAINT_WEIGHT_Data *)vedata)->psl; + PAINT_WEIGHT_FramebufferList *fbl = ((PAINT_WEIGHT_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void PAINT_WEIGHT_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void PAINT_WEIGHT_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_paint_weight_type = { + NULL, NULL, + N_("PaintWeightMode"), + &PAINT_WEIGHT_engine_init, + &PAINT_WEIGHT_engine_free, + &PAINT_WEIGHT_cache_init, + &PAINT_WEIGHT_cache_populate, + &PAINT_WEIGHT_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &PAINT_WEIGHT_draw_scene +}; diff --git a/source/blender/draw/modes/particle_mode.c b/source/blender/draw/modes/particle_mode.c new file mode 100644 index 00000000000..aab9c41a233 --- /dev/null +++ b/source/blender/draw/modes/particle_mode.c @@ -0,0 +1,265 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/particle_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use PARTICLE_engine_init() to + * initialize most of them and PARTICLE_cache_init() + * for PARTICLE_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct PARTICLE_PassList { + /* Declare all passes here and init them in + * PARTICLE_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} PARTICLE_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct PARTICLE_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} PARTICLE_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct PARTICLE_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} PARTICLE_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct PARTICLE_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} PARTICLE_StorageList; + +typedef struct PARTICLE_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + PARTICLE_FramebufferList *fbl; + PARTICLE_TextureList *txl; + PARTICLE_PassList *psl; + PARTICLE_StorageList *stl; +} PARTICLE_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in PARTICLE_engine_init(); + * free in PARTICLE_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + /* This keeps the references of the shading groups for + * easy access in PARTICLE_cache_populate() */ + DRWShadingGroup *group; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void PARTICLE_engine_init(void *vedata) +{ + PARTICLE_TextureList *txl = ((PARTICLE_Data *)vedata)->txl; + PARTICLE_FramebufferList *fbl = ((PARTICLE_Data *)vedata)->fbl; + PARTICLE_StorageList *stl = ((PARTICLE_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void PARTICLE_cache_init(void *vedata) +{ + PARTICLE_PassList *psl = ((PARTICLE_Data *)vedata)->psl; + PARTICLE_StorageList *stl = ((PARTICLE_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {0.2f, 0.5f, 0.3f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void PARTICLE_cache_populate(void *vedata, Object *ob) +{ + PARTICLE_PassList *psl = ((PARTICLE_Data *)vedata)->psl; + PARTICLE_StorageList *stl = ((PARTICLE_Data *)vedata)->stl; + + UNUSED_VARS(psl, stl); + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void PARTICLE_cache_finish(void *vedata) +{ + PARTICLE_PassList *psl = ((PARTICLE_Data *)vedata)->psl; + PARTICLE_StorageList *stl = ((PARTICLE_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void PARTICLE_draw_scene(void *vedata) +{ + + PARTICLE_PassList *psl = ((PARTICLE_Data *)vedata)->psl; + PARTICLE_FramebufferList *fbl = ((PARTICLE_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void PARTICLE_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void PARTICLE_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_particle_type = { + NULL, NULL, + N_("ParticleMode"), + &PARTICLE_engine_init, + &PARTICLE_engine_free, + &PARTICLE_cache_init, + &PARTICLE_cache_populate, + &PARTICLE_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &PARTICLE_draw_scene +}; diff --git a/source/blender/draw/modes/pose_mode.c b/source/blender/draw/modes/pose_mode.c new file mode 100644 index 00000000000..93514701010 --- /dev/null +++ b/source/blender/draw/modes/pose_mode.c @@ -0,0 +1,265 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/pose_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use POSE_engine_init() to + * initialize most of them and POSE_cache_init() + * for POSE_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct POSE_PassList { + /* Declare all passes here and init them in + * POSE_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} POSE_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct POSE_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} POSE_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct POSE_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} POSE_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct POSE_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} POSE_StorageList; + +typedef struct POSE_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + POSE_FramebufferList *fbl; + POSE_TextureList *txl; + POSE_PassList *psl; + POSE_StorageList *stl; +} POSE_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in POSE_engine_init(); + * free in POSE_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + /* This keeps the references of the shading groups for + * easy access in POSE_cache_populate() */ + DRWShadingGroup *group; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void POSE_engine_init(void *vedata) +{ + POSE_TextureList *txl = ((POSE_Data *)vedata)->txl; + POSE_FramebufferList *fbl = ((POSE_Data *)vedata)->fbl; + POSE_StorageList *stl = ((POSE_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void POSE_cache_init(void *vedata) +{ + POSE_PassList *psl = ((POSE_Data *)vedata)->psl; + POSE_StorageList *stl = ((POSE_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {0.2f, 0.5f, 0.3f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void POSE_cache_populate(void *vedata, Object *ob) +{ + POSE_PassList *psl = ((POSE_Data *)vedata)->psl; + POSE_StorageList *stl = ((POSE_Data *)vedata)->stl; + + UNUSED_VARS(psl, stl); + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void POSE_cache_finish(void *vedata) +{ + POSE_PassList *psl = ((POSE_Data *)vedata)->psl; + POSE_StorageList *stl = ((POSE_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void POSE_draw_scene(void *vedata) +{ + + POSE_PassList *psl = ((POSE_Data *)vedata)->psl; + POSE_FramebufferList *fbl = ((POSE_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void POSE_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void POSE_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_pose_type = { + NULL, NULL, + N_("PoseMode"), + &POSE_engine_init, + &POSE_engine_free, + &POSE_cache_init, + &POSE_cache_populate, + &POSE_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &POSE_draw_scene +}; diff --git a/source/blender/draw/modes/sculpt_mode.c b/source/blender/draw/modes/sculpt_mode.c new file mode 100644 index 00000000000..4b500c4d6fd --- /dev/null +++ b/source/blender/draw/modes/sculpt_mode.c @@ -0,0 +1,264 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/sculpt_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +/* If builtin shaders are needed */ +#include "GPU_shader.h" + +#include "draw_common.h" + +#include "draw_mode_engines.h" + +/* *********** LISTS *********** */ +/* All lists are per viewport specific datas. + * They are all free when viewport changes engines + * or is free itself. Use SCULPT_engine_init() to + * initialize most of them and SCULPT_cache_init() + * for SCULPT_PassList */ + +/* keep it under MAX_PASSES */ +typedef struct SCULPT_PassList { + /* Declare all passes here and init them in + * SCULPT_cache_init(). + * Only contains (DRWPass *) */ + struct DRWPass *pass; +} SCULPT_PassList; + +/* keep it under MAX_BUFFERS */ +typedef struct SCULPT_FramebufferList { + /* Contains all framebuffer objects needed by this engine. + * Only contains (GPUFrameBuffer *) */ + struct GPUFrameBuffer *fb; +} SCULPT_FramebufferList; + +/* keep it under MAX_TEXTURES */ +typedef struct SCULPT_TextureList { + /* Contains all framebuffer textures / utility textures + * needed by this engine. Only viewport specific textures + * (not per object). Only contains (GPUTexture *) */ + struct GPUTexture *texture; +} SCULPT_TextureList; + +/* keep it under MAX_STORAGE */ +typedef struct SCULPT_StorageList { + /* Contains any other memory block that the engine needs. + * Only directly MEM_(m/c)allocN'ed blocks because they are + * free with MEM_freeN() when viewport is freed. + * (not per object) */ + struct CustomStruct *block; + struct g_data *g_data; +} SCULPT_StorageList; + +typedef struct SCULPT_Data { + /* Struct returned by DRW_viewport_engine_data_get. + * If you don't use one of these, just make it a (void *) */ + // void *fbl; + void *engine_type; /* Required */ + SCULPT_FramebufferList *fbl; + SCULPT_TextureList *txl; + SCULPT_PassList *psl; + SCULPT_StorageList *stl; +} SCULPT_Data; + +/* *********** STATIC *********** */ + +static struct { + /* Custom shaders : + * Add sources to source/blender/draw/modes/shaders + * init in SCULPT_engine_init(); + * free in SCULPT_engine_free(); */ + struct GPUShader *custom_shader; +} e_data = {NULL}; /* Engine data */ + +typedef struct g_data { + /* This keeps the references of the shading groups for + * easy access in SCULPT_cache_populate() */ + DRWShadingGroup *group; +} g_data; /* Transient data */ + +/* *********** FUNCTIONS *********** */ + +/* Init Textures, Framebuffers, Storage and Shaders. + * It is called for every frames. + * (Optional) */ +static void SCULPT_engine_init(void *vedata) +{ + SCULPT_TextureList *txl = ((SCULPT_Data *)vedata)->txl; + SCULPT_FramebufferList *fbl = ((SCULPT_Data *)vedata)->fbl; + SCULPT_StorageList *stl = ((SCULPT_Data *)vedata)->stl; + + UNUSED_VARS(txl, fbl, stl); + + /* Init Framebuffers like this: order is attachment order (for color texs) */ + /* + * DRWFboTexture tex[2] = {{&txl->depth, DRW_BUF_DEPTH_24}, + * {&txl->color, DRW_BUF_RGBA_8}}; + */ + + /* DRW_framebuffer_init takes care of checking if + * the framebuffer is valid and has the right size*/ + /* + * float *viewport_size = DRW_viewport_size_get(); + * DRW_framebuffer_init(&fbl->occlude_wire_fb, + * (int)viewport_size[0], (int)viewport_size[1], + * tex, 2); + */ + + if (!e_data.custom_shader) { + e_data.custom_shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + } +} + +/* Here init all passes and shading groups + * Assume that all Passes are NULL */ +static void SCULPT_cache_init(void *vedata) +{ + SCULPT_PassList *psl = ((SCULPT_Data *)vedata)->psl; + SCULPT_StorageList *stl = ((SCULPT_Data *)vedata)->stl; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + /* Create a pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_WIRE; + psl->pass = DRW_pass_create("My Pass", state); + + /* Create a shadingGroup using a function in draw_common.c or custom one */ + /* + * stl->g_data->group = shgroup_dynlines_uniform_color(psl->pass, ts.colorWire); + * -- or -- + * stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + */ + stl->g_data->group = DRW_shgroup_create(e_data.custom_shader, psl->pass); + + /* Uniforms need a pointer to it's value so be sure it's accessible at + * any given time (i.e. use static vars) */ + static float color[4] = {0.2f, 0.5f, 0.3f, 1.0}; + DRW_shgroup_uniform_vec4(stl->g_data->group, "color", color, 1); + } + +} + +/* Add geometry to shadingGroups. Execute for each objects */ +static void SCULPT_cache_populate(void *vedata, Object *ob) +{ + SCULPT_PassList *psl = ((SCULPT_Data *)vedata)->psl; + SCULPT_StorageList *stl = ((SCULPT_Data *)vedata)->stl; + + UNUSED_VARS(psl, stl); + + if (ob->type == OB_MESH) { + /* Get geometry cache */ + struct Batch *geom = DRW_cache_surface_get(ob); + + /* Add geom to a shading group */ + DRW_shgroup_call_add(stl->g_data->group, geom, ob->obmat); + } +} + +/* Optional: Post-cache_populate callback */ +static void SCULPT_cache_finish(void *vedata) +{ + SCULPT_PassList *psl = ((SCULPT_Data *)vedata)->psl; + SCULPT_StorageList *stl = ((SCULPT_Data *)vedata)->stl; + + /* Do something here! dependant on the objects gathered */ + UNUSED_VARS(psl, stl); +} + +/* Draw time ! Control rendering pipeline from here */ +static void SCULPT_draw_scene(void *vedata) +{ + SCULPT_PassList *psl = ((SCULPT_Data *)vedata)->psl; + SCULPT_FramebufferList *fbl = ((SCULPT_Data *)vedata)->fbl; + + /* Default framebuffer and texture */ + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + UNUSED_VARS(fbl, dfbl, dtxl); + + /* Show / hide entire passes, swap framebuffers ... whatever you fancy */ + /* + * DRW_framebuffer_texture_detach(dtxl->depth); + * DRW_framebuffer_bind(fbl->custom_fb); + * DRW_draw_pass(psl->pass); + * DRW_framebuffer_texture_attach(dfbl->default_fb, dtxl->depth, 0); + * DRW_framebuffer_bind(dfbl->default_fb); + */ + + /* ... or just render passes on default framebuffer. */ + DRW_draw_pass(psl->pass); + + /* If you changed framebuffer, double check you rebind + * the default one with its textures attached before finishing */ +} + +/* Cleanup when destroying the engine. + * This is not per viewport ! only when quitting blender. + * Mostly used for freeing shaders */ +static void SCULPT_engine_free(void) +{ + // if (custom_shader) + // DRW_shader_free(custom_shader); +} + +/* Create collection settings here. + * + * Be sure to add this function there : + * source/blender/draw/DRW_engine.h + * source/blender/blenkernel/intern/layer.c + * source/blenderplayer/bad_level_call_stubs/stubs.c + * + * And relevant collection settings to : + * source/blender/makesrna/intern/rna_scene.c + * source/blender/blenkernel/intern/layer.c + */ +#if 0 +void SCULPT_collection_settings_create(CollectionEngineSettings *ces) +{ + BLI_assert(ces); + // BKE_collection_engine_property_add_int(ces, "my_bool_prop", false); + // BKE_collection_engine_property_add_int(ces, "my_int_prop", 0); + // BKE_collection_engine_property_add_float(ces, "my_float_prop", 0.0f); +} +#endif + +DrawEngineType draw_engine_sculpt_type = { + NULL, NULL, + N_("SculptMode"), + &SCULPT_engine_init, + &SCULPT_engine_free, + &SCULPT_cache_init, + &SCULPT_cache_populate, + &SCULPT_cache_finish, + NULL, /* draw_background but not needed by mode engines */ + &SCULPT_draw_scene +}; diff --git a/source/blender/draw/modes/shaders/common_globals_lib.glsl b/source/blender/draw/modes/shaders/common_globals_lib.glsl new file mode 100644 index 00000000000..579a5f5089b --- /dev/null +++ b/source/blender/draw/modes/shaders/common_globals_lib.glsl @@ -0,0 +1,55 @@ + +/* keep in sync with GlobalsUboStorage */ +layout(std140) uniform globalsBlock { + vec4 colorWire; + vec4 colorWireEdit; + vec4 colorActive; + vec4 colorSelect; + vec4 colorTransform; + vec4 colorGroupActive; + vec4 colorGroup; + vec4 colorLamp; + vec4 colorSpeaker; + vec4 colorCamera; + vec4 colorEmpty; + vec4 colorVertex; + vec4 colorVertexSelect; + vec4 colorEditMeshActive; + vec4 colorEdgeSelect; + vec4 colorEdgeSeam; + vec4 colorEdgeSharp; + vec4 colorEdgeCrease; + vec4 colorEdgeBWeight; + vec4 colorEdgeFaceSelect; + vec4 colorFace; + vec4 colorFaceSelect; + vec4 colorNormal; + vec4 colorVNormal; + vec4 colorLNormal; + vec4 colorFaceDot; + + vec4 colorDeselect; + vec4 colorOutline; + vec4 colorLampNoAlpha; + + vec4 colorBackground; + + vec4 colorGrid; + vec4 colorGridEmphasise; + vec4 colorGridAxisX; + vec4 colorGridAxisY; + vec4 colorGridAxisZ; + + float sizeLampCenter; + float sizeLampCircle; + float sizeLampCircleShadow; + float sizeVertex; + float sizeEdge; + float sizeEdgeFix; + float sizeFaceDot; + + float gridDistance; + float gridResolution; + float gridSubdivisions; + float gridScale; +}; diff --git a/source/blender/draw/modes/shaders/edit_normals_face_vert.glsl b/source/blender/draw/modes/shaders/edit_normals_face_vert.glsl new file mode 100644 index 00000000000..9c70eabc056 --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_normals_face_vert.glsl @@ -0,0 +1,18 @@ + +uniform mat4 ModelViewProjectionMatrix; +uniform mat3 NormalMatrix; +uniform mat4 ProjectionMatrix; +uniform float normalSize; + +in vec3 pos; +in vec4 norAndFlag; + +flat out vec4 v1; +flat out vec4 v2; + +void main() +{ + v1 = ModelViewProjectionMatrix * vec4(pos, 1.0); + vec3 n = normalize(NormalMatrix * norAndFlag.xyz); /* viewspace */ + v2 = v1 + ProjectionMatrix * vec4(n * normalSize, 0.0); +} diff --git a/source/blender/draw/modes/shaders/edit_normals_geom.glsl b/source/blender/draw/modes/shaders/edit_normals_geom.glsl new file mode 100644 index 00000000000..d17823f2f5a --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_normals_geom.glsl @@ -0,0 +1,15 @@ + +layout(points) in; +layout(line_strip, max_vertices=2) out; + +flat in vec4 v1[1]; +flat in vec4 v2[1]; + +void main() +{ + gl_Position = v1[0]; + EmitVertex(); + gl_Position = v2[0]; + EmitVertex(); + EndPrimitive(); +} diff --git a/source/blender/draw/modes/shaders/edit_normals_vert.glsl b/source/blender/draw/modes/shaders/edit_normals_vert.glsl new file mode 100644 index 00000000000..3e00181c8dd --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_normals_vert.glsl @@ -0,0 +1,24 @@ + +uniform mat4 ModelViewProjectionMatrix; +uniform mat3 NormalMatrix; +uniform mat4 ProjectionMatrix; +uniform float normalSize; + +in vec3 pos; + +#ifdef FACE_NORMALS +in vec4 norAndFlag; +#define nor norAndFlag.xyz +#else +in vec3 nor; +#endif + +flat out vec4 v1; +flat out vec4 v2; + +void main() +{ + v1 = ModelViewProjectionMatrix * vec4(pos, 1.0); + vec3 n = normalize(NormalMatrix * nor); /* viewspace */ + v2 = v1 + ProjectionMatrix * vec4(n * normalSize, 0.0); +} diff --git a/source/blender/draw/modes/shaders/edit_overlay_facedot_frag.glsl b/source/blender/draw/modes/shaders/edit_overlay_facedot_frag.glsl new file mode 100644 index 00000000000..9b3fe6286e8 --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_overlay_facedot_frag.glsl @@ -0,0 +1,12 @@ + +flat in int isSelected; + +out vec4 FragColor; + +void main() +{ + if (isSelected != 0) + FragColor = colorFaceDot; + else + FragColor = colorWireEdit; +} diff --git a/source/blender/draw/modes/shaders/edit_overlay_facedot_vert.glsl b/source/blender/draw/modes/shaders/edit_overlay_facedot_vert.glsl new file mode 100644 index 00000000000..2e541fa75e6 --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_overlay_facedot_vert.glsl @@ -0,0 +1,14 @@ + +uniform mat4 ModelViewProjectionMatrix; + +in vec3 pos; +in vec4 norAndFlag; + +flat out int isSelected; + +void main() +{ + gl_Position = ModelViewProjectionMatrix * vec4(pos, 1.0); + gl_PointSize = sizeFaceDot; + isSelected = int(norAndFlag.w); +} diff --git a/source/blender/draw/modes/shaders/edit_overlay_facefill_frag.glsl b/source/blender/draw/modes/shaders/edit_overlay_facefill_frag.glsl new file mode 100644 index 00000000000..fa0197573ff --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_overlay_facefill_frag.glsl @@ -0,0 +1,27 @@ + +/* Solid Wirefram implementation + * Mike Erwin, Clément Foucault */ + +/* This shader follows the principles of + * http://developer.download.nvidia.com/SDK/10/direct3d/Source/SolidWireframe/Doc/SolidWireframe.pdf */ + +flat in vec4 faceColor; +flat in int faceActive; + +out vec4 FragColor; + +const mat4 stipple_matrix = mat4(vec4(1.0, 0.0, 0.0, 0.0), + vec4(0.0, 0.0, 0.0, 0.0), + vec4(0.0, 0.0, 1.0, 0.0), + vec4(0.0, 0.0, 0.0, 0.0)); + +void main() +{ + FragColor = faceColor; + + if (faceActive == 1) { + int x = int(gl_FragCoord.x) & 0x3; /* mod 4 */ + int y = int(gl_FragCoord.y) & 0x3; /* mod 4 */ + FragColor *= stipple_matrix[x][y]; + } +} diff --git a/source/blender/draw/modes/shaders/edit_overlay_facefill_vert.glsl b/source/blender/draw/modes/shaders/edit_overlay_facefill_vert.glsl new file mode 100644 index 00000000000..5755ba40951 --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_overlay_facefill_vert.glsl @@ -0,0 +1,29 @@ + +uniform mat4 ModelViewProjectionMatrix; + +in vec3 pos; +in ivec4 data; + +flat out vec4 faceColor; +flat out int faceActive; + +#define FACE_ACTIVE (1 << 2) +#define FACE_SELECTED (1 << 3) + +void main() +{ + gl_Position = ModelViewProjectionMatrix * vec4(pos, 1.0); + + if ((data.x & FACE_ACTIVE) != 0) { + faceColor = colorEditMeshActive; + faceActive = 1; + } + else if ((data.x & FACE_SELECTED) != 0) { + faceColor = colorFaceSelect; + faceActive = 0; + } + else { + faceColor = colorFace; + faceActive = 0; + } +} diff --git a/source/blender/draw/modes/shaders/edit_overlay_frag.glsl b/source/blender/draw/modes/shaders/edit_overlay_frag.glsl new file mode 100644 index 00000000000..cca1a2cc8e5 --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_overlay_frag.glsl @@ -0,0 +1,185 @@ + +/* Solid Wirefram implementation + * Mike Erwin, Clément Foucault */ + +/* This shader follows the principles of + * http://developer.download.nvidia.com/SDK/10/direct3d/Source/SolidWireframe/Doc/SolidWireframe.pdf */ + +uniform float faceAlphaMod; + +flat in vec3 edgesCrease; +flat in vec3 edgesBweight; +flat in ivec3 flag; +flat in vec4 faceColor; +flat in int clipCase; +#ifdef VERTEX_SELECTION +smooth in vec3 vertexColor; +#endif + +/* We use a vec4[2] interface to pass edge data + * (without fragmenting memory accesses) + * + * There is 2 cases : + * + * - Simple case : geometry shader return edge distances + * in the first 2 components of the first vec4. + * This needs noperspective interpolation. + * The rest is filled with vertex screen positions. + * eData1.zw actually contain v2 + * eData2.xy actually contain v1 + * eData2.zw actually contain v0 + * + * - Hard case : two 2d edge corner are described by each + * vec4 as origin and direction. This is constant over + * the triangle and use to detect the correct case. */ + +noperspective in vec4 eData1; +flat in vec4 eData2; + +out vec4 FragColor; + +#define EDGE_EXISTS (1 << 0) +#define EDGE_ACTIVE (1 << 1) +#define EDGE_SELECTED (1 << 2) +#define EDGE_SEAM (1 << 3) +#define EDGE_SHARP (1 << 4) +/* Vertex flag is shifted and combined with the edge flag */ +#define VERTEX_ACTIVE (1 << (0 + 8)) +#define VERTEX_SELECTED (1 << (1 + 8)) +#define FACE_ACTIVE (1 << (2 + 8)) + +/* Style Parameters in pixel */ + +/* Array to retreive vert/edge indices */ +const ivec3 clipEdgeIdx[6] = ivec3[6]( + ivec3(1, 0, 2), + ivec3(2, 0, 1), + ivec3(2, 1, 0), + ivec3(2, 1, 0), + ivec3(2, 0, 1), + ivec3(1, 0, 2) +); + +const ivec3 clipPointIdx[6] = ivec3[6]( + ivec3(0, 1, 2), + ivec3(0, 2, 1), + ivec3(0, 2, 1), + ivec3(1, 2, 0), + ivec3(1, 2, 0), + ivec3(2, 1, 0) +); + +const mat4 stipple_matrix = mat4(vec4(1.0, 0.0, 0.0, 0.0), + vec4(0.0, 0.0, 0.0, 0.0), + vec4(0.0, 0.0, 1.0, 0.0), + vec4(0.0, 0.0, 0.0, 0.0)); + +void colorDist(vec4 color, float dist) +{ + FragColor = (dist < 0) ? color : FragColor; +} + +float distToEdge(vec2 o, vec2 dir) +{ + vec2 af = gl_FragCoord.xy - o; + float daf = dot(dir, af); + return sqrt(abs(dot(af, af) - daf * daf)); +} + +void main() +{ + vec3 e, p; + + /* Step 1 : Computing Distances */ + + if (clipCase == 0) { + e.xy = eData1.xy; + + /* computing missing distance */ + vec2 dir = normalize(eData2.zw - eData2.xy); + e.z = distToEdge(eData2.zw, dir); + + p.x = distance(eData2.zw, gl_FragCoord.xy); + p.y = distance(eData2.xy, gl_FragCoord.xy); + p.z = distance(eData1.zw, gl_FragCoord.xy); + } + else { + ivec3 eidxs = clipEdgeIdx[clipCase - 1]; + ivec3 pidxs = clipPointIdx[clipCase - 1]; + + e[eidxs.x] = distToEdge(eData1.xy, eData1.zw); + e[eidxs.y] = distToEdge(eData2.xy, eData2.zw); + + /* Three edges visible cases */ + if (clipCase == 1 || clipCase == 2 || clipCase == 4) { + e[eidxs.z] = distToEdge(eData1.xy, normalize(eData2.xy - eData1.xy)); + p[pidxs.y] = distance(eData2.xy, gl_FragCoord.xy); + } + else { + e[eidxs.z] = 1e10; /* off screen */ + p[pidxs.y] = 1e10; /* off screen */ + } + + p[pidxs.x] = distance(eData1.xy, gl_FragCoord.xy); + p[pidxs.z] = 1e10; /* off screen */ + } + + /* Step 2 : coloring (order dependant) */ + + /* First */ + FragColor = faceColor; + + if ((flag[0] & FACE_ACTIVE) != 0) { + int x = int(gl_FragCoord.x) & 0x3; /* mod 4 */ + int y = int(gl_FragCoord.y) & 0x3; /* mod 4 */ + FragColor *= stipple_matrix[x][y]; + } + else { + FragColor.a *= faceAlphaMod; + } + + /* Edges */ + for (int v = 0; v < 3; ++v) { + if ((flag[v] & EDGE_EXISTS) != 0) { + float largeEdge = e[v] - sizeEdge * 2.0; + float innerEdge = e[v] - sizeEdge; + + if ((flag[v] & EDGE_SEAM) != 0) + colorDist(colorEdgeSeam, largeEdge); + else if (edgesBweight[v] > 0.0) + colorDist(vec4(colorEdgeBWeight.rgb, edgesBweight[v]), largeEdge); + else if (edgesCrease[v] > 0.0) + colorDist(vec4(colorEdgeCrease.rgb, edgesCrease[v]), largeEdge); + else if ((flag[v] & EDGE_SHARP) != 0) + colorDist(colorEdgeSharp, largeEdge); +#ifndef VERTEX_SELECTION + else + colorDist(colorWireEdit, innerEdge); + + if ((flag[v] & EDGE_ACTIVE) != 0) + colorDist(vec4(colorEditMeshActive.xyz, 1.0), innerEdge); + else if ((flag[v] & EDGE_SELECTED) != 0) + colorDist(colorEdgeSelect, innerEdge); +#else + colorDist(vec4(vertexColor, 1.0), innerEdge); +#endif + } + } + + /* Points */ +#ifdef VERTEX_SELECTION + for (int v = 0; v < 3; ++v) { + float size = p[v] - sizeVertex; + + if ((flag[v] & VERTEX_ACTIVE) != 0) + colorDist(vec4(colorEditMeshActive.xyz, 1.0), size); + else if ((flag[v] & VERTEX_SELECTED) != 0) + colorDist(colorVertexSelect, size); + else + colorDist(colorVertex, size); + } +#endif + + /* don't write depth if not opaque */ + if (FragColor.a == 0.0) discard; +} diff --git a/source/blender/draw/modes/shaders/edit_overlay_geom_edge.glsl b/source/blender/draw/modes/shaders/edit_overlay_geom_edge.glsl new file mode 100644 index 00000000000..ddeecf12bd6 --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_overlay_geom_edge.glsl @@ -0,0 +1,143 @@ + +/* Solid Wirefram implementation + * Mike Erwin, Clément Foucault */ + +/* This shader follows the principles of + * http://developer.download.nvidia.com/SDK/10/direct3d/Source/SolidWireframe/Doc/SolidWireframe.pdf */ + +layout(lines) in; +layout(triangle_strip, max_vertices=6) out; + +uniform mat4 ProjectionMatrix; +uniform vec2 viewportSize; + +in vec4 vPos[]; +in vec4 pPos[]; +in ivec4 vData[]; + +/* these are the same for all vertices + * and does not need interpolation */ +flat out vec3 edgesCrease; +flat out vec3 edgesSharp; +flat out ivec3 flag; +flat out vec4 faceColor; +flat out int clipCase; +#ifdef VERTEX_SELECTION +smooth out vec3 vertexColor; +#endif + +/* See fragment shader */ +noperspective out vec4 eData1; +flat out vec4 eData2; + +#define VERTEX_ACTIVE (1 << 0) +#define VERTEX_SELECTED (1 << 1) + +#define FACE_ACTIVE (1 << 2) +#define FACE_SELECTED (1 << 3) + +/* Table 1. Triangle Projection Cases */ +const ivec4 clipPointsIdx[6] = ivec4[6]( + ivec4(0, 1, 2, 2), + ivec4(0, 2, 1, 1), + ivec4(0, 0, 1, 2), + ivec4(1, 2, 0, 0), + ivec4(1, 1, 0, 2), + ivec4(2, 2, 0, 1) +); + +/* project to screen space */ +vec2 proj(vec4 pos) +{ + return (0.5 * (pos.xy / pos.w) + 0.5) * viewportSize; +} + +float dist(vec2 pos[3], vec2 vpos, int v) +{ + /* endpoints of opposite edge */ + vec2 e1 = pos[(v + 1) % 3]; + vec2 e2 = pos[(v + 2) % 3]; + /* Edge normalized vector */ + vec2 dir = normalize(e2 - e1); + /* perpendicular to dir */ + vec2 orthogonal = vec2(-dir.y, dir.x); + + return abs(dot(vpos - e1, orthogonal)); +} + +vec3 getVertexColor(int v) +{ + if ((vData[v].x & (VERTEX_ACTIVE | VERTEX_SELECTED)) != 0) + return colorEdgeSelect.rgb; + else + return colorWireEdit.rgb; +} + +void doVertex(int v, vec4 pos) +{ +#ifdef VERTEX_SELECTION + vertexColor = getVertexColor(v); +#endif + + gl_Position = pos; + + EmitVertex(); +} + +void main() +{ + clipCase = 0; + + /* Face */ + faceColor = vec4(0.0); + + /* Proj Vertex */ + vec2 pos[2] = vec2[2](proj(pPos[0]), proj(pPos[1])); + + /* little optimization use a vec4 to vectorize + * following operations */ + vec4 dirs1, dirs2; + + /* Edge normalized vector */ + dirs1.xy = normalize(pos[1] - pos[0]); + + /* perpendicular to dir */ + dirs1.zw = vec2(-dirs1.y, dirs1.x); + + /* Make it view independant */ + dirs1 *= sizeEdgeFix / viewportSize.xyxy; + + dirs2 = dirs1; + + /* Perspective */ + if (ProjectionMatrix[3][3] == 0.0) { + /* vPos[i].z is negative and we don't want + * our fixvec to be flipped */ + dirs1 *= -vPos[0].z; + dirs2 *= -vPos[1].z; + } + + /* Edge / Vert data */ + eData1 = vec4(1e10); + eData2.zw = pos[0]; + eData2.xy = pos[1]; + flag[0] = (vData[0].x << 8); + flag[1] = (vData[1].x << 8); + flag[2] = 0; + + doVertex(0, pPos[0] + vec4(-dirs1.xy, 0.0, 0.0)); + doVertex(0, pPos[0] + vec4( dirs1.zw, 0.0, 0.0)); + doVertex(0, pPos[0] + vec4(-dirs1.zw, 0.0, 0.0)); + + flag[2] = vData[0].y | (vData[0].x << 8); + edgesCrease[2] = vData[0].z / 255.0; + edgesSharp[2] = vData[0].w / 255.0; + + doVertex(1, pPos[1] + vec4( dirs2.zw, 0.0, 0.0)); + doVertex(1, pPos[1] + vec4(-dirs2.zw, 0.0, 0.0)); + + flag[2] = 0; + doVertex(1, pPos[1] + vec4( dirs2.xy, 0.0, 0.0)); + + EndPrimitive(); +} diff --git a/source/blender/draw/modes/shaders/edit_overlay_geom_tri.glsl b/source/blender/draw/modes/shaders/edit_overlay_geom_tri.glsl new file mode 100644 index 00000000000..41aade3d3c7 --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_overlay_geom_tri.glsl @@ -0,0 +1,277 @@ + +/* Solid Wirefram implementation + * Mike Erwin, Clément Foucault */ + +/* This shader follows the principles of + * http://developer.download.nvidia.com/SDK/10/direct3d/Source/SolidWireframe/Doc/SolidWireframe.pdf */ + +layout(triangles) in; + +#ifdef EDGE_FIX +/* To fix the edge artifacts, we render + * an outline strip around the screenspace + * triangle. Order is important. + * TODO diagram + */ + +#ifdef VERTEX_SELECTION +layout(triangle_strip, max_vertices=23) out; +#else +layout(triangle_strip, max_vertices=17) out; +#endif +#else +layout(triangle_strip, max_vertices=3) out; +#endif + +uniform mat4 ProjectionMatrix; +uniform vec2 viewportSize; + +in vec4 vPos[]; +in vec4 pPos[]; +in ivec4 vData[]; + +/* these are the same for all vertices + * and does not need interpolation */ +flat out vec3 edgesCrease; +flat out vec3 edgesSharp; +flat out ivec3 flag; +flat out vec4 faceColor; +flat out int clipCase; +#ifdef VERTEX_SELECTION +smooth out vec3 vertexColor; +#endif + +/* See fragment shader */ +noperspective out vec4 eData1; +flat out vec4 eData2; + + +#define VERTEX_ACTIVE (1 << 0) +#define VERTEX_SELECTED (1 << 1) + +#define FACE_ACTIVE (1 << 2) +#define FACE_SELECTED (1 << 3) + +/* Table 1. Triangle Projection Cases */ +const ivec4 clipPointsIdx[6] = ivec4[6]( + ivec4(0, 1, 2, 2), + ivec4(0, 2, 1, 1), + ivec4(0, 0, 1, 2), + ivec4(1, 2, 0, 0), + ivec4(1, 1, 0, 2), + ivec4(2, 2, 0, 1) +); + +/* project to screen space */ +vec2 proj(vec4 pos) +{ + return (0.5 * (pos.xy / pos.w) + 0.5) * viewportSize; +} + +float dist(vec2 pos[3], vec2 vpos, int v) +{ + /* endpoints of opposite edge */ + vec2 e1 = pos[(v + 1) % 3]; + vec2 e2 = pos[(v + 2) % 3]; + /* Edge normalized vector */ + vec2 dir = normalize(e2 - e1); + /* perpendicular to dir */ + vec2 orthogonal = vec2(-dir.y, dir.x); + + return abs(dot(vpos - e1, orthogonal)); +} + +vec3 getVertexColor(int v) +{ + if ((vData[v].x & (VERTEX_ACTIVE | VERTEX_SELECTED)) != 0) + return colorEdgeSelect.rgb; + else + return colorWireEdit.rgb; +} + +vec4 getClipData(vec2 pos[3], ivec2 vidx) +{ + vec2 A = pos[vidx.x]; + vec2 Adir = normalize(A - pos[vidx.y]); + + return vec4(A, Adir); +} + +void doVertex(int v, vec4 pos) +{ +#ifdef VERTEX_SELECTION + vertexColor = getVertexColor(v); +#endif + + gl_Position = pos; + + EmitVertex(); +} + +void main() +{ + /* First we detect which case we are in */ + clipCase = 0; + + /* if perspective */ + if (ProjectionMatrix[3][3] == 0.0) { + /* See Table 1. Triangle Projection Cases */ + clipCase += int(pPos[0].z / pPos[0].w < -1 || vPos[0].z > 0.0) * 4; + clipCase += int(pPos[1].z / pPos[1].w < -1 || vPos[1].z > 0.0) * 2; + clipCase += int(pPos[2].z / pPos[2].w < -1 || vPos[2].z > 0.0) * 1; + } + + /* If triangle is behind nearplane, early out */ + if (clipCase == 7) + return; + + /* Edge */ + ivec3 eflag; vec3 ecrease, esharp; + for (int v = 0; v < 3; ++v) { + flag[v] = eflag[v] = vData[v].y | (vData[v].x << 8); + edgesCrease[v] = ecrease[v] = vData[v].z / 255.0; + edgesSharp[v] = esharp[v] = vData[v].w / 255.0; + } + + /* Face */ + if ((vData[0].x & FACE_ACTIVE) != 0) + faceColor = colorEditMeshActive; + else if ((vData[0].x & FACE_SELECTED) != 0) + faceColor = colorFaceSelect; + else + faceColor = colorFace; + + /* Vertex */ + vec2 pos[3] = vec2[3](proj(pPos[0]), proj(pPos[1]), proj(pPos[2])); + + /* Simple case : compute edge distances in geometry shader */ + if (clipCase == 0) { + + /* Packing screen positions and 2 distances */ + eData1 = vec4(0.0, 0.0, pos[2]); + eData2 = vec4(pos[1], pos[0]); + + /* Only pass the first 2 distances */ + for (int v = 0; v < 2; ++v) { + eData1[v] = dist(pos, pos[v], v); + doVertex(v, pPos[v]); + eData1[v] = 0.0; + } + + /* and the last vertex */ + doVertex(2, pPos[2]); + +#ifdef EDGE_FIX + vec2 fixvec[6]; + vec2 fixvecaf[6]; + vec2 cornervec[3]; + + /* This fix the case when 2 vertices are perfectly aligned + * and corner vectors have nowhere to go. + * ie: length(cornervec[i]) == 0 */ + const float epsilon = 1e-2; /* in pixel so not that much */ + const vec2 bias[3] = vec2[3]( + vec2( epsilon, epsilon), + vec2(-epsilon, epsilon), + vec2( 0.0, -epsilon) + ); + + for (int i = 0; i < 3; ++i) { + int i1 = (i + 1) % 3; + int i2 = (i + 2) % 3; + + vec2 v1 = pos[i] + bias[i]; + vec2 v2 = pos[i1] + bias[i1]; + vec2 v3 = pos[i2] + bias[i2]; + + /* Edge normalized vector */ + vec2 dir = normalize(v2 - v1); + vec2 dir2 = normalize(v3 - v1); + + cornervec[i] = -normalize(dir + dir2); + + /* perpendicular to dir */ + vec2 perp = vec2(-dir.y, dir.x); + + /* Backface case */ + if (dot(perp, dir2) > 0) { + perp = -perp; + } + + /* Make it view independant */ + perp *= sizeEdgeFix / viewportSize; + cornervec[i] *= sizeEdgeFix / viewportSize; + fixvec[i] = fixvecaf[i] = perp; + + /* Perspective */ + if (ProjectionMatrix[3][3] == 0.0) { + /* vPos[i].z is negative and we don't want + * our fixvec to be flipped */ + fixvec[i] *= -vPos[i].z; + fixvecaf[i] *= -vPos[i1].z; + cornervec[i] *= -vPos[i].z; + } + } + + /* to not let face color bleed */ + faceColor = vec4(0.0, 0.0, 0.0, 0.0); + + /* we don't want other edges : make them far*/ + eData1 = vec4(1e10); + + /* Start with the same last vertex to create a + * degenerate triangle in order to "create" + * a new triangle strip */ + for (int i = 2; i < 5; ++i) { + int vbe = (i - 1) % 3; + int vaf = (i + 1) % 3; + int v = i % 3; + + /* Position of the "hidden" thrid vertex */ + eData1.zw = pos[vbe]; + + doVertex(v, pPos[v]); + doVertex(v, pPos[v] + vec4(fixvec[v], 0.0, 0.0)); + + /* Now one triangle only shade one edge + * so we use the edge distance calculated + * in the fragment shader, the third edge; + * we do this because we need flat interp to + * draw a continuous triangle strip */ + eData2.xy = pos[vaf]; + eData2.zw = pos[v]; + flag[0] = (vData[v].x << 8); + flag[1] = (vData[vaf].x << 8); + flag[2] = eflag[vbe]; + edgesCrease[2] = ecrease[vbe]; + edgesSharp[2] = esharp[vbe]; + + doVertex(vaf, pPos[vaf]); + doVertex(vaf, pPos[vaf] + vec4(fixvecaf[v], 0.0, 0.0)); + + /* corner vertices should not drax edges but draw point only */ + flag[2] = (vData[vbe].x << 8); +#ifdef VERTEX_SELECTION + doVertex(vaf, pPos[vaf]); + doVertex(vaf, pPos[vaf] + vec4(cornervec[vaf], 0.0, 0.0)); +#endif + } + + /* finish the loop strip */ + doVertex(2, pPos[2]); + doVertex(2, pPos[2] + vec4(fixvec[2], 0.0, 0.0)); +#endif + } + /* Harder case : compute visible edges vectors */ + else { + ivec4 vindices = clipPointsIdx[clipCase - 1]; + + eData1 = getClipData(pos, vindices.xz); + eData2 = getClipData(pos, vindices.yw); + + for (int v = 0; v < 3; ++v) + doVertex(v, pPos[v]); + } + + EndPrimitive(); +} diff --git a/source/blender/draw/modes/shaders/edit_overlay_loosevert_vert.glsl b/source/blender/draw/modes/shaders/edit_overlay_loosevert_vert.glsl new file mode 100644 index 00000000000..3ff76a77da2 --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_overlay_loosevert_vert.glsl @@ -0,0 +1,48 @@ + +/* Solid Wirefram implementation + * Mike Erwin, Clément Foucault */ + +/* This shader follows the principles of + * http://developer.download.nvidia.com/SDK/10/direct3d/Source/SolidWireframe/Doc/SolidWireframe.pdf */ + +uniform mat4 ModelViewProjectionMatrix; +uniform vec2 viewportSize; + +in vec3 pos; +in ivec4 data; + +/* these are the same for all vertices + * and does not need interpolation */ +flat out ivec3 flag; +flat out vec4 faceColor; +flat out int clipCase; + +/* See fragment shader */ +noperspective out vec4 eData1; +flat out vec4 eData2; + +/* project to screen space */ +vec2 proj(vec4 pos) +{ + return (0.5 * (pos.xy / pos.w) + 0.5) * viewportSize; +} + +void main() +{ + clipCase = 0; + + vec4 pPos = ModelViewProjectionMatrix * vec4(pos, 1.0); + + /* there is no face */ + faceColor = vec4(0.0); + + /* only verterx position 0 is used */ + eData1 = eData2 = vec4(1e10); + eData2.zw = proj(pPos); + + flag = ivec3(0); + flag[0] = (data.x << 8); + + gl_PointSize = sizeEdgeFix; + gl_Position = pPos; +} diff --git a/source/blender/draw/modes/shaders/edit_overlay_mix_frag.glsl b/source/blender/draw/modes/shaders/edit_overlay_mix_frag.glsl new file mode 100644 index 00000000000..f567a3a5cbd --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_overlay_mix_frag.glsl @@ -0,0 +1,24 @@ + +out vec4 FragColor; + +uniform sampler2D wireColor; +uniform sampler2D wireDepth; +uniform sampler2D sceneDepth; +uniform float alpha; + +void main() +{ + ivec2 uv = ivec2(gl_FragCoord.xy); + float wire_depth = texelFetch(wireDepth, uv, 0).r; + float scene_depth = texelFetch(sceneDepth, uv, 0).r; + vec4 wire_color = texelFetch(wireColor, uv, 0).rgba; + + FragColor = wire_color; + + /* this works because not rendered depth is 1.0 and the + * following test is always true even when no wires */ + if ((wire_depth > scene_depth) && (wire_color.a > 0)) { + /* Note : Using wire_color.a * alpha produce unwanted result */ + FragColor.a = alpha; + } +} diff --git a/source/blender/draw/modes/shaders/edit_overlay_vert.glsl b/source/blender/draw/modes/shaders/edit_overlay_vert.glsl new file mode 100644 index 00000000000..5bc9a8bef85 --- /dev/null +++ b/source/blender/draw/modes/shaders/edit_overlay_vert.glsl @@ -0,0 +1,23 @@ + +/* Solid Wirefram implementation + * Mike Erwin, Clément Foucault */ + +/* This shader follows the principles of + * http://developer.download.nvidia.com/SDK/10/direct3d/Source/SolidWireframe/Doc/SolidWireframe.pdf */ + +uniform mat4 ModelViewMatrix; +uniform mat4 ModelViewProjectionMatrix; + +in vec3 pos; +in ivec4 data; + +out vec4 vPos; +out vec4 pPos; +out ivec4 vData; + +void main() +{ + vPos = ModelViewMatrix * vec4(pos, 1.0); + pPos = ModelViewProjectionMatrix * vec4(pos, 1.0); + vData = data; +} diff --git a/source/blender/draw/modes/shaders/object_grid_frag.glsl b/source/blender/draw/modes/shaders/object_grid_frag.glsl new file mode 100644 index 00000000000..9b1283e46af --- /dev/null +++ b/source/blender/draw/modes/shaders/object_grid_frag.glsl @@ -0,0 +1,147 @@ + +/* Infinite grid + * Clément Foucault */ + +in vec3 wPos; + +out vec4 FragColor; + +uniform mat4 ProjectionMatrix; +uniform vec3 cameraPos; +uniform vec3 eye; +uniform vec4 gridSettings; +uniform float gridOneOverLogSubdiv; + +#define gridDistance gridSettings.x +#define gridResolution gridSettings.y +#define gridScale gridSettings.z +#define gridSubdiv gridSettings.w + +uniform int gridFlag; + +#define AXIS_X (1 << 0) +#define AXIS_Y (1 << 1) +#define AXIS_Z (1 << 2) +#define GRID (1 << 3) +#define PLANE_XY (1 << 4) +#define PLANE_XZ (1 << 5) +#define PLANE_YZ (1 << 6) + +#define GRID_LINE_SMOOTH 1.15 + +float grid(vec3 uv, vec3 fwidthCos, float grid_size) +{ + float half_size = grid_size / 2.0; + /* triangular wave pattern, amplitude is [0, grid_size] */ + vec3 grid_domain = abs(mod(uv + half_size, grid_size) - half_size); + /* modulate by the absolute rate of change of the uvs + * (make lines have the same width under perspective) */ + grid_domain /= fwidthCos; + + /* collapse waves and normalize */ + grid_domain.x = min(grid_domain.x, min(grid_domain.y, grid_domain.z)) / grid_size; + + return 1.0 - smoothstep(0.0, GRID_LINE_SMOOTH / grid_size, grid_domain.x); +} + +float axis(float u, float fwidthU, float line_size) +{ + float axis_domain = abs(u); + /* modulate by the absolute rate of change of the uvs + * (make line have the same width under perspective) */ + axis_domain /= fwidthU; + + return 1.0 - smoothstep(0.0, GRID_LINE_SMOOTH, axis_domain - line_size); +} + +void main() +{ + vec3 fwidthCos = fwidth(wPos); + + float dist, fade; + /* if persp */ + if (ProjectionMatrix[3][3] == 0.0) { + vec3 viewvec = cameraPos - wPos; + dist = length(viewvec); + viewvec /= dist; + + float angle; + if ((gridFlag & PLANE_XZ) > 0) + angle = viewvec.y; + else if ((gridFlag & PLANE_YZ) > 0) + angle = viewvec.x; + else + angle = viewvec.z; + + angle = 1.0 - abs(angle); + fade = 1.0 - angle * angle; + fade *= 1.0 - smoothstep(0.0, gridDistance, dist - gridDistance); + } + else { + dist = abs(gl_FragCoord.z * 2.0 - 1.0); + fade = 1.0 - smoothstep(0.0, 0.5, dist - 0.5); + dist = 1.0; /* avoid branch after */ + + if ((gridFlag & PLANE_XY) > 0) { + float angle = 1.0 - abs(eye.z); + fade *= 1.0 - angle * angle * angle; + dist = 1.0 + angle * 2.0; + } + } + + if ((gridFlag & GRID) > 0) { + float grid_res = log(dist * gridResolution) * gridOneOverLogSubdiv; + + float blend = fract(-max(grid_res, 0.0)); + float lvl = floor(grid_res); + + /* from smallest to biggest */ + float scaleA = gridScale * pow(gridSubdiv, max(lvl - 1.0, 0.0)); + float scaleB = gridScale * pow(gridSubdiv, max(lvl + 0.0, 0.0)); + float scaleC = gridScale * pow(gridSubdiv, max(lvl + 1.0, 1.0)); + + float gridA = grid(wPos, fwidthCos, scaleA); + float gridB = grid(wPos, fwidthCos, scaleB); + float gridC = grid(wPos, fwidthCos, scaleC); + + FragColor = vec4(colorGrid.rgb, gridA * blend); + FragColor = mix(FragColor, vec4(mix(colorGrid.rgb, colorGridEmphasise.rgb, blend), 1.0), gridB); + FragColor = mix(FragColor, vec4(colorGridEmphasise.rgb, 1.0), gridC); + } + else { + FragColor = vec4(colorGrid.rgb, 0.0); + } + + if ((gridFlag & AXIS_X) > 0) { + float xAxis; + if ((gridFlag & PLANE_XZ) > 0) { + xAxis = axis(wPos.z, fwidthCos.z, 0.1); + } + else { + xAxis = axis(wPos.y, fwidthCos.y, 0.1); + } + FragColor = mix(FragColor, colorGridAxisX, xAxis); + } + if ((gridFlag & AXIS_Y) > 0) { + float yAxis; + if ((gridFlag & PLANE_YZ) > 0) { + yAxis = axis(wPos.z, fwidthCos.z, 0.1); + } + else { + yAxis = axis(wPos.x, fwidthCos.x, 0.1); + } + FragColor = mix(FragColor, colorGridAxisY, yAxis); + } + if ((gridFlag & AXIS_Z) > 0) { + float zAxis; + if ((gridFlag & PLANE_YZ) > 0) { + zAxis = axis(wPos.y, fwidthCos.y, 0.1); + } + else { + zAxis = axis(wPos.x, fwidthCos.x, 0.1); + } + FragColor = mix(FragColor, colorGridAxisZ, zAxis); + } + + FragColor.a *= fade; +}
\ No newline at end of file diff --git a/source/blender/draw/modes/shaders/object_grid_vert.glsl b/source/blender/draw/modes/shaders/object_grid_vert.glsl new file mode 100644 index 00000000000..2da8e45c560 --- /dev/null +++ b/source/blender/draw/modes/shaders/object_grid_vert.glsl @@ -0,0 +1,66 @@ + +/* Infinite grid + * Clément Foucault */ + +uniform mat4 ViewProjectionOffsetMatrix; +uniform mat4 ProjectionMatrix; +uniform vec3 cameraPos; +uniform vec4 gridSettings; + +#define gridDistance gridSettings.x +#define gridResolution gridSettings.y +#define gridScale gridSettings.z +#define gridSubdiv gridSettings.w + +uniform int gridFlag; + +#define PLANE_XY (1 << 4) +#define PLANE_XZ (1 << 5) +#define PLANE_YZ (1 << 6) +#define CLIP_Z_POS (1 << 7) +#define CLIP_Z_NEG (1 << 8) + +in vec3 pos; + +out vec3 wPos; + +void main() +{ + vec3 vert_pos, proj_camera_pos; + + /* Project camera pos to the needed plane */ + if ((gridFlag & PLANE_XY) > 0) { + vert_pos = vec3(pos.x, pos.y, 0.0); + proj_camera_pos = vec3(cameraPos.x, cameraPos.y, 0.0); + } + else if ((gridFlag & PLANE_XZ) > 0) { + vert_pos = vec3(pos.x, 0.0, pos.y); + proj_camera_pos = vec3(cameraPos.x, 0.0, cameraPos.z); + } + else { + vert_pos = vec3(0.0, pos.x, pos.y); + proj_camera_pos = vec3(0.0, cameraPos.y, cameraPos.z); + } + + /* if persp */ + if (ProjectionMatrix[3][3] == 0.0) { + vert_pos *= gridDistance * 2.0; + } + else { + float viewdist = 1.0f / min(abs(ProjectionMatrix[0][0]), abs(ProjectionMatrix[1][1])); + vert_pos *= viewdist * gridDistance * 2.0; + } + + vec3 realPos = proj_camera_pos + vert_pos; + + /* Used for additional Z axis */ + if ((gridFlag & CLIP_Z_POS) > 0) { + realPos.z = max(realPos.z, 0.0); + } + if ((gridFlag & CLIP_Z_NEG) > 0) { + realPos.z = min(realPos.z, 0.0); + } + + gl_Position = ViewProjectionOffsetMatrix * vec4(realPos, 1.0); + wPos = realPos; +} diff --git a/source/blender/draw/modes/shaders/object_outline_detect_frag.glsl b/source/blender/draw/modes/shaders/object_outline_detect_frag.glsl new file mode 100644 index 00000000000..5565a0f1e09 --- /dev/null +++ b/source/blender/draw/modes/shaders/object_outline_detect_frag.glsl @@ -0,0 +1,61 @@ + +in vec4 uvcoordsvar; + +out vec4 FragColor; + +uniform sampler2D outlineColor; +uniform sampler2D outlineDepth; +uniform sampler2D sceneDepth; + +uniform float alphaOcclu; +uniform vec2 viewportSize; + +void search_outline(ivec2 uv, vec4 ref_col, inout bool ref_occlu, inout bool outline) +{ + if (!outline) { + vec4 color = texelFetch(outlineColor, uv, 0).rgba; + if (color != ref_col) { + outline = true; + } + else { + float depth = texelFetch(outlineDepth, uv, 0).r; + float scene_depth = texelFetch(sceneDepth, uv, 0).r; + bool occlu = (depth > scene_depth); + + if (occlu != ref_occlu && !ref_occlu) { + outline = true; + } + } + } +} + +void main() +{ + ivec2 uv = ivec2(gl_FragCoord.xy); + vec4 ref_col = texelFetch(outlineColor, uv, 0).rgba; + + float depth = texelFetch(outlineDepth, uv, 0).r; + /* Modulate color if occluded */ + float scene_depth = texelFetch(sceneDepth, uv, 0).r; + + bool ref_occlu = (depth > scene_depth); + + bool outline = false; + + search_outline(uv + ivec2( 1, 0), ref_col, ref_occlu, outline); + search_outline(uv + ivec2( 0, 1), ref_col, ref_occlu, outline); + search_outline(uv + ivec2(-1, 0), ref_col, ref_occlu, outline); + search_outline(uv + ivec2( 0, -1), ref_col, ref_occlu, outline); + + FragColor = ref_col; + + /* We Hit something ! */ + if (outline) { + if (ref_occlu) { + FragColor.a *= alphaOcclu; + } + } + else { + FragColor.a = 0.0; + } +} diff --git a/source/blender/draw/modes/shaders/object_outline_expand_frag.glsl b/source/blender/draw/modes/shaders/object_outline_expand_frag.glsl new file mode 100644 index 00000000000..e0568d1157a --- /dev/null +++ b/source/blender/draw/modes/shaders/object_outline_expand_frag.glsl @@ -0,0 +1,45 @@ + +in vec4 uvcoordsvar; + +out vec4 FragColor; + +uniform sampler2D outlineColor; +uniform sampler2D outlineDepth; + +uniform float alpha; +uniform bool doExpand; + +void search_outline(ivec2 uv, inout bool found_edge) +{ + if (!found_edge) { + vec4 color = texelFetch(outlineColor, uv, 0).rgba; + if (color.a != 0.0) { + if (doExpand || color.a != 1.0) { + FragColor = color; + found_edge = true; + } + } + } +} + +void main() +{ + ivec2 uv = ivec2(gl_FragCoord.xy); + FragColor = texelFetch(outlineColor, uv, 0).rgba; + float depth = texelFetch(outlineDepth, uv, 0).r; + + if (FragColor.a != 0.0 || (depth == 1.0 && !doExpand)) + return; + + bool found_edge = false; + search_outline(uv + ivec2( 1, 0), found_edge); + search_outline(uv + ivec2( 0, 1), found_edge); + search_outline(uv + ivec2(-1, 0), found_edge); + search_outline(uv + ivec2( 0, -1), found_edge); + + /* We Hit something ! */ + if (found_edge) { + /* only change alpha */ + FragColor.a *= alpha; + } +} diff --git a/source/blender/draw/modes/shaders/object_outline_resolve_frag.glsl b/source/blender/draw/modes/shaders/object_outline_resolve_frag.glsl new file mode 100644 index 00000000000..3937828eca2 --- /dev/null +++ b/source/blender/draw/modes/shaders/object_outline_resolve_frag.glsl @@ -0,0 +1,11 @@ + +in vec4 uvcoordsvar; + +out vec4 FragColor; + +uniform sampler2D outlineBluredColor; + +void main() +{ + FragColor = texture(outlineBluredColor, uvcoordsvar.st).rgba; +} |