[Bf-blender-cvs] [e69e3553edb] soc-2018-npr: Implementing DPIX algorithm. (in progress, do not compile!)
Nick Wu
noreply at git.blender.org
Mon Jun 4 17:44:09 CEST 2018
Commit: e69e3553edbdd1d22e0e3a7d701e11ea7140fe55
Author: Nick Wu
Date: Thu May 31 10:35:28 2018 +0800
Branches: soc-2018-npr
https://developer.blender.org/rBe69e3553edbdd1d22e0e3a7d701e11ea7140fe55
Implementing DPIX algorithm. (in progress, do not compile!)
===================================================================
M source/blender/draw/engines/lanpr/NUL_TNS.h
M source/blender/draw/engines/lanpr/NUL_TNS_EdgeRendering.c
M source/blender/makesdna/DNA_scene_types.h
===================================================================
diff --git a/source/blender/draw/engines/lanpr/NUL_TNS.h b/source/blender/draw/engines/lanpr/NUL_TNS.h
index 53b3f18f828..ff6a13f89cf 100644
--- a/source/blender/draw/engines/lanpr/NUL_TNS.h
+++ b/source/blender/draw/engines/lanpr/NUL_TNS.h
@@ -18,7 +18,7 @@
#define rad(d) d*TNS_PI/180.0
-
+#define TNS_DPIX_TEXTURE_SIZE 2048
typedef struct LANPR_TextureSample {
Link Item;
@@ -39,6 +39,7 @@ typedef struct LANPR_LineStrip{
}LANPR_LineStrip;
typedef struct LANPR_PassList {
+ /* Snake */
struct DRWPass *depth_pass;
struct DRWPass *color_pass;
struct DRWPass *normal_pass;
@@ -46,21 +47,40 @@ typedef struct LANPR_PassList {
struct DRWPass *edge_thinning;
struct DRWPass *edge_thinning_2;
struct DRWPass *snake_pass;
+
+ /* DPIX */
+ struct DRWPass *dpix_transform_pass;
+
} LANPR_PassList;
typedef struct LANPR_FramebufferList {
+
+ /* Snake */
struct GPUFrameBuffer *passes;
struct GPUFrameBuffer *edge_intermediate;
struct GPUFrameBuffer *edge_thinning;
- struct GPUFrameBuffer *on_screen;
- //and something...
+
+ /* DPIX */
+ struct GPUFrameBuffer *dpix_transform;
+
} LANPR_FramebufferList;
typedef struct LANPR_TextureList {
+
struct GPUTexture *color;
struct GPUTexture *normal;
struct GPUTexture *depth;
struct GPUTexture *edge_intermediate;
+
+ struct GPUTexture *dpix_in_pl;/* point L */
+ struct GPUTexture *dpix_in_pr;/* point R */
+ struct GPUTexture *dpix_in_nl;/* normal L */
+ struct GPUTexture *dpix_in_nr;/* normal R */
+
+ struct GPUTexture *dpix_out_pl;
+ struct GPUTexture *dpix_out_pr;
+ struct GPUTexture *dpix_out_length;
+
} LANPR_TextureList;
typedef struct LANPR_PrivateData {
@@ -70,6 +90,8 @@ typedef struct LANPR_PrivateData {
DRWShadingGroup *edge_thinning_shgrp_2;
DRWShadingGroup *snake_shgrp;
+ DRWShadingGroup *dpix_transform_shgrp;
+
float normal_clamp;
float normal_strength;
float depth_clamp;
diff --git a/source/blender/draw/engines/lanpr/NUL_TNS_EdgeRendering.c b/source/blender/draw/engines/lanpr/NUL_TNS_EdgeRendering.c
index 8500fe02768..c800f241e8d 100644
--- a/source/blender/draw/engines/lanpr/NUL_TNS_EdgeRendering.c
+++ b/source/blender/draw/engines/lanpr/NUL_TNS_EdgeRendering.c
@@ -28,9 +28,511 @@ extern char datatoc_lanpr_line_connection_vertex[];
extern char datatoc_lanpr_line_connection_fragment[];
extern char datatoc_lanpr_line_connection_geometry[];
+typedef struct LANPROneTimeInit{
+
+ /* Snake */
+
+ GPUShader* multichannel_shader;
+ GPUShader* edge_detect_shader;
+ GPUShader* edge_thinning_shader;
+ GPUShader* snake_connection_shader;
+
+ /* DPIX */
+
+ GPUShader* dpix_transform_shader;
+
+ void* ved;
+} LANPROneTimeInit;
+
//==============================================================[ ATLAS / DPIX ]
-// will be updated here very soon(-ish).....
+
+void lanpr_init_atlas_inputs(void *ved){
+ OneTime.ved = ved;
+ LANPR_Data *vedata = (LANPR_Data *)ved;
+ LANPR_TextureList *txl = vedata->txl;
+ LANPR_FramebufferList *fbl = vedata->fbl;
+ LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+ //LANPR_ViewLayerData *sldata = EEVEE_view_layer_data_ensure();
+ DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
+
+ txl->dpix_in_pl =
+
+ const DRWContextState *draw_ctx = DRW_context_state_get();
+ View3D *v3d = draw_ctx->v3d;
+ RegionView3D *rv3d = draw_ctx->rv3d;
+ Object *camera = (rv3d->persp == RV3D_CAMOB) ? v3d->camera : NULL;
+
+
+ /* Main Buffer */
+ DRW_texture_ensure_2D(&txl->dpix_in_pl, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGB32F, DRW_TEX_FILTER);
+ DRW_texture_ensure_2D(&txl->dpix_in_pr, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGB32F, DRW_TEX_FILTER);
+ DRW_texture_ensure_2D(&txl->dpix_in_nl, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGB32F, DRW_TEX_FILTER);
+ DRW_texture_ensure_2D(&txl->dpix_in_nr, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGB32F, DRW_TEX_FILTER);
+
+ DRW_texture_ensure_2D(&txl->dpix_out_pl, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGB32F, DRW_TEX_FILTER);
+ DRW_texture_ensure_2D(&txl->dpix_out_pr, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGB32F, DRW_TEX_FILTER);
+ DRW_texture_ensure_2D(&txl->dpix_out_length, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGB32F, DRW_TEX_FILTER);
+
+ GPU_framebuffer_ensure_config(&fbl->dpix_transform, {
+ GPU_ATTACHMENT_LEAVE,
+ GPU_ATTACHMENT_TEXTURE(txl->dpix_out_pl),
+ GPU_ATTACHMENT_TEXTURE(txl->dpix_out_pr),
+ GPU_ATTACHMENT_TEXTURE(txl->dpix_out_length),
+ GPU_ATTACHMENT_LEAVE,
+ GPU_ATTACHMENT_LEAVE,
+ GPU_ATTACHMENT_LEAVE
+ });
+
+ if (!OneTime.dpix_transform_shader) {
+ OneTime.dpix_transform_shader =
+ GPU_shader_create(
+ datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl,
+ datatoc_lanpr_snake_multichannel_fragment,NULL,NULL,NULL);
+ }
+}
+void lanpr_destroy_atlas(void *ved){
+ OneTime.ved = ved;
+ LANPR_Data *vedata = (LANPR_Data *)ved;
+ LANPR_TextureList *txl = vedata->txl;
+ LANPR_FramebufferList *fbl = vedata->fbl;
+ LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+
+ DRW_pass_free(psl->dpix_transform_pass);
+
+ GPU_framebuffer_free(fbl->dpix_transform);
+
+ DRW_texture_free(txl->dpix_in_pl);
+ DRW_texture_free(txl->dpix_in_pr);
+ DRW_texture_free(txl->dpix_in_nl);
+ DRW_texture_free(txl->dpix_in_nr);
+ DRW_texture_free(txl->dpix_out_pl);
+ DRW_texture_free(txl->dpix_out_pr);
+}
+
+static Gwn_VertBuf *lanpr_mesh_get_tri_pos_and_normals_raw(
+ MeshRenderData *rdata, const bool use_hide,
+ Gwn_VertBuf **r_vbo)
+{
+ BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
+
+ if (*r_vbo == NULL) {
+ static Gwn_VertFormat format = { 0 };
+ static struct { uint pos, nor; } attr_id;
+ if (format.attrib_ct == 0) {
+ attr_id.pos = GWN_vertformat_attr_add(&format, "pos", GWN_COMP_F32, 3, GWN_FETCH_FLOAT);
+ attr_id.nor = GWN_vertformat_attr_add(&format, "nor", GWN_COMP_I10, 3, GWN_FETCH_INT_TO_FLOAT_UNIT);
+ }
+
+ const int tri_len = mesh_render_data_looptri_len_get(rdata);
+
+ Gwn_VertBuf *vbo = *r_vbo = GWN_vertbuf_create_with_format(&format);
+
+ const int vbo_len_capacity = tri_len * 3;
+ int vbo_len_used = 0;
+ GWN_vertbuf_data_alloc(vbo, vbo_len_capacity);
+
+ Gwn_VertBufRaw pos_step, nor_step;
+ GWN_vertbuf_attr_get_raw_data(vbo, attr_id.pos, &pos_step);
+ GWN_vertbuf_attr_get_raw_data(vbo, attr_id.nor, &nor_step);
+
+ float (*lnors)[3] = rdata->loop_normals;
+
+ if (rdata->edit_bmesh) {
+ Gwn_PackedNormal *pnors_pack, *vnors_pack;
+
+ if (lnors == NULL) {
+ mesh_render_data_ensure_poly_normals_pack(rdata);
+ mesh_render_data_ensure_vert_normals_pack(rdata);
+
+ pnors_pack = rdata->poly_normals_pack;
+ vnors_pack = rdata->vert_normals_pack;
+ }
+
+ for (int i = 0; i < tri_len; i++) {
+ const BMLoop **bm_looptri = (const BMLoop **)rdata->edit_bmesh->looptris[i];
+ const BMFace *bm_face = bm_looptri[0]->f;
+
+ /* use_hide always for edit-mode */
+ if (BM_elem_flag_test(bm_face, BM_ELEM_HIDDEN)) {
+ continue;
+ }
+
+ if (lnors) {
+ for (uint t = 0; t < 3; t++) {
+ const float *nor = lnors[BM_elem_index_get(bm_looptri[t])];
+ *((Gwn_PackedNormal *)GWN_vertbuf_raw_step(&nor_step)) = GWN_normal_convert_i10_v3(nor);
+ }
+ }
+ else if (BM_elem_flag_test(bm_face, BM_ELEM_SMOOTH)) {
+ for (uint t = 0; t < 3; t++) {
+ *((Gwn_PackedNormal *)GWN_vertbuf_raw_step(&nor_step)) = vnors_pack[BM_elem_index_get(bm_looptri[t]->v)];
+ }
+ }
+ else {
+ const Gwn_PackedNormal *snor_pack = &pnors_pack[BM_elem_index_get(bm_face)];
+ for (uint t = 0; t < 3; t++) {
+ *((Gwn_PackedNormal *)GWN_vertbuf_raw_step(&nor_step)) = *snor_pack;
+ }
+ }
+
+ /* TODO(sybren): deduplicate this and all the other places it's pasted to in this file. */
+ if (rdata->edit_data && rdata->edit_data->vertexCos) {
+ for (uint t = 0; t < 3; t++) {
+ int vidx = BM_elem_index_get(bm_looptri[t]->v);
+ const float *pos = rdata->edit_data->vertexCos[vidx];
+ copy_v3_v3(GWN_vertbuf_raw_step(&pos_step), pos);
+ }
+ }
+ else {
+ for (uint t = 0; t < 3; t++) {
+ copy_v3_v3(GWN_vertbuf_raw_step(&pos_step), bm_looptri[t]->v->co);
+ }
+ }
+ }
+ }
+ else {
+ if (lnors == NULL) {
+ /* Use normals from vertex. */
+ mesh_render_data_ensure_poly_normals_pack(rdata);
+ }
+
+ for (int i = 0; i < tri_len; i++) {
+ const MLoopTri *mlt = &rdata->mlooptri[i];
+ const MPoly *mp = &rdata->mpoly[mlt->poly];
+
+ if (use_hide && (mp->flag & ME_HIDE)) {
+ continue;
+ }
+
+ const uint vtri[3] = {
+ rdata->mloop[mlt->tri[0]].v,
+ rdata->mloop[mlt->tri[1]].v,
+ rdata->mloop[mlt->tri[2]].v,
+ };
+
+ if (lnors) {
+ for (uint t = 0; t < 3; t++) {
+ const float *nor = lnors[mlt->tri[t]];
+ *((Gwn_PackedNormal *)GWN_vertbuf_raw_step(&nor_step)) = GWN_normal_convert_i10_v3(nor);
+ }
+ }
+ else if (mp->flag & ME_SMOOTH) {
+ for (uint t = 0; t < 3; t++) {
+ const MVert *mv = &rdata->mvert[vtri[t]];
+ *((Gwn_PackedNormal *)GWN_vertbuf_raw_step(&nor_step)) = GWN_normal_convert_i10_s3(mv->no);
+ }
+ }
+ else {
+ const Gwn_PackedNormal *pnors_pack = &rdata->poly_normals_pack[mlt->poly];
+ for (uint t = 0; t < 3; t++) {
+ *((Gwn_PackedNormal *)GWN_vertbuf_raw_step(&nor_step)) = *pnors_pack;
+ }
+ }
+
+ for (uint t = 0; t < 3; t++) {
+ const MVert *mv = &rdata->mvert[vtri[t]];
+ copy_v3_v3(GWN_vertbuf_raw_step(&pos_step), mv->co);
+ }
+ }
+ }
+
+ vbo_len_used = GWN_vertbuf_raw_used(&pos_step);
+ BLI_assert(vbo_len_used == GWN_vertbuf_raw_used(&nor_step));
+
+ if (vbo_len_capacity != vbo_len_used) {
+ GWN_vertbuf_data_resize(vbo, vbo_len_used);
+ }
+ }
+ return *r_vbo;
+}
+
+void DRW_cache_mesh_surface_get(Object *ob)
+{
+ BLI_assert(ob->type == OB_MESH);
+
+ Mesh *me = ob->data;
+
+ MeshBatchCache *cache = mesh_batch_cache_get(me);
+
+ if (cache->triangles_with_normals == NULL) {
+ const int datatype = MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY;
+ MeshRenderData *rdata = mesh_render_data_create(me, datatype);
+
+ cache->triangles_with_normals =
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list