archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
e40870c47967144aa75c9185a6d0ba1e149bb4e2
blender-archive/source/blender/draw/intern/draw_cache_impl_mesh.c

4584 lines
138 KiB
C
Raw Normal View History

Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* 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.
*
* The Original Code is Copyright (C) 2017 by Blender Foundation.
* All rights reserved.
*
* Contributor(s): Blender Foundation, Mike Erwin, Dalai Felinto
*
* ***** END GPL LICENSE BLOCK *****
*/
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
/** \file draw_cache_impl_mesh.c
* \ingroup draw
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
*
* \brief Mesh API for render engines
*/
#include "MEM_guardedalloc.h"
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
#include "BLI_utildefines.h"
Clay Engine: Correct Mesh Normals
2017-02-16 16:19:48 +01:00
#include "BLI_math_vector.h"
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
#include "BLI_math_bits.h"
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
#include "BLI_math_color.h"
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
#include "BLI_string.h"
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
#include "BLI_alloca.h"
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
#include "BLI_edgehash.h"
Clay Engine: Correct Mesh Normals
2017-02-16 16:19:48 +01:00
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
#include "DNA_object_types.h"
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
#include "BKE_customdata.h"
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
#include "BKE_deform.h"
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
#include "BKE_editmesh.h"
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
#include "BKE_editmesh_tangent.h"
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
#include "BKE_mesh.h"
Fix T51561: Normal maps fail w/ quad + eevee Generalize derived-mesh tangent calculation so it can be used by Batch cache creation too.
2017-05-24 22:33:21 +10:00
#include "BKE_mesh_tangent.h"
Merge branch 'master' into blender2.8
2017-12-07 23:53:03 +11:00
#include "BKE_colorband.h"
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
#include "bmesh.h"
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
#include "GPU_batch.h"
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
#include "GPU_draw.h"
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
#include "GPU_material.h"
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
#include "GPU_texture.h"
#include "DRW_render.h"
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
#include "draw_cache_impl.h" /* own include */
static void mesh_batch_cache_clear(Mesh *me);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
/* ---------------------------------------------------------------------- */
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
/** \name Mesh/BMesh Interface (direct access to basic data).
* \{ */
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
static int mesh_render_verts_len_get(Mesh *me)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
return me->edit_btmesh ? me->edit_btmesh->bm->totvert : me->totvert;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
static int mesh_render_edges_len_get(Mesh *me)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
return me->edit_btmesh ? me->edit_btmesh->bm->totedge : me->totedge;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
static int mesh_render_looptri_len_get(Mesh *me)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
return me->edit_btmesh ? me->edit_btmesh->tottri : poly_to_tri_count(me->totpoly, me->totloop);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
static int mesh_render_polys_len_get(Mesh *me)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
return me->edit_btmesh ? me->edit_btmesh->bm->totface : me->totpoly;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
static int mesh_render_mat_len_get(Mesh *me)
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
{
return MAX2(1, me->totcol);
}
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
static int UNUSED_FUNCTION(mesh_render_loops_len_get)(Mesh *me)
Clay Engine: Correct Mesh Normals
2017-02-16 16:19:48 +01:00
{
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
return me->edit_btmesh ? me->edit_btmesh->bm->totloop : me->totloop;
Clay Engine: Correct Mesh Normals
2017-02-16 16:19:48 +01:00
}
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
/** \} */
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
/* ---------------------------------------------------------------------- */
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
/** \name Mesh/BMesh Interface (indirect, partially cached access to complex data).
* \{ */
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
typedef struct EdgeAdjacentPolys {
int count;
int face_index[2];
} EdgeAdjacentPolys;
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
typedef struct EdgeAdjacentVerts {
int vert_index[2]; /* -1 if none */
} EdgeAdjacentVerts;
Cleanup: replace char array with struct
2017-04-12 14:08:44 +10:00
typedef struct EdgeDrawAttr {
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
uchar v_flag;
uchar e_flag;
uchar crease;
uchar bweight;
Cleanup: replace char array with struct
2017-04-12 14:08:44 +10:00
} EdgeDrawAttr;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
typedef struct MeshRenderData {
int types;
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
int vert_len;
int edge_len;
int tri_len;
int loop_len;
int poly_len;
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
int mat_len;
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
int loose_vert_len;
int loose_edge_len;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
BMEditMesh *edit_bmesh;
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
struct EditMeshData *edit_data;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
MVert *mvert;
MEdge *medge;
MLoop *mloop;
MPoly *mpoly;
Added comment to explain MeshRenderData.orco
2018-04-18 14:13:16 +02:00
float (*orco)[3]; /* vertex coordinates normalized to bounding box */
Eevee: Keep track on whether orco was allocated or not If it's coming from vertex data, we must not free that pointer.
2018-05-30 12:40:16 +02:00
bool is_orco_allocated;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
MDeformVert *dvert;
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
MLoopUV *mloopuv;
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
MLoopCol *mloopcol;
Mesh Auto-Smooth Split Normal Support From D2906 with few changes
2017-10-31 15:15:14 -02:00
float (*loop_normals)[3];
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
/* CustomData 'cd' cache for efficient access. */
struct {
struct {
MLoopUV **uv;
int uv_len;
int uv_active;
MLoopCol **vcol;
int vcol_len;
int vcol_active;
float (**tangent)[4];
DWM: separate tangents from UV conversion Prepare for different number of UV/Tangent layers.
2017-06-28 09:55:40 +10:00
int tangent_len;
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
int tangent_active;
bool *auto_vcol;
} layers;
/* Custom-data offsets (only needed for BMesh access) */
struct {
int crease;
int bweight;
int *uv;
int *vcol;
} offset;
struct {
char (*auto_mix)[32];
char (*uv)[32];
char (*vcol)[32];
char (*tangent)[32];
} uuid;
/* for certain cases we need an output loop-data storage (bmesh tangents) */
struct {
CustomData ldata;
/* grr, special case variable (use in place of 'dm->tangent_mask') */
Merge branch 'master' into blender2.8
2017-07-03 19:49:35 +03:00
short tangent_mask;
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
} output;
} cd;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
Clay Engine: Edit mesh overlays Based on the previous overlay shader from merwin. This shader takes care of clipped vertex cases and do all edit mode face info in one pass (except face centers). As the shading is done one the triangle itself the visual can't go beyond the surface of the mesh. That leads to half displayed edges on the outline of the mesh. This problem can be fixed by a second pass. This is work in progress.
2017-02-26 21:07:37 +01:00
BMVert *eve_act;
BMEdge *eed_act;
BMFace *efa_act;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
/* Data created on-demand (usually not for bmesh-based data). */
EdgeAdjacentPolys *edges_adjacent_polys;
MLoopTri *mlooptri;
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
int *loose_edges;
int *loose_verts;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
float (*poly_normals)[3];
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
float (*vert_weight_color)[3];
char (*vert_color)[3];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUPackedNormal *poly_normals_pack;
GPUPackedNormal *vert_normals_pack;
Cleanup: clarify select terminology In mesh cache we have select: color, id, bool. Current naming didn't make this clear.
2017-05-17 11:46:26 +10:00
bool *edge_select_bool;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
} MeshRenderData;
enum {
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
MR_DATATYPE_VERT = 1 << 0,
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
MR_DATATYPE_EDGE = 1 << 1,
MR_DATATYPE_LOOPTRI = 1 << 2,
MR_DATATYPE_LOOP = 1 << 3,
MR_DATATYPE_POLY = 1 << 4,
MR_DATATYPE_OVERLAY = 1 << 5,
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
MR_DATATYPE_SHADING = 1 << 6,
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
MR_DATATYPE_DVERT = 1 << 7,
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
MR_DATATYPE_LOOPCOL = 1 << 8,
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
MR_DATATYPE_LOOPUV = 1 << 9,
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
};
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
/**
* These functions look like they would be slow but they will typically return true on the first iteration.
* Only false when all attached elements are hidden.
*/
static bool bm_vert_has_visible_edge(const BMVert *v)
{
const BMEdge *e_iter, *e_first;
e_iter = e_first = v->e;
do {
if (!BM_elem_flag_test(e_iter, BM_ELEM_HIDDEN)) {
return true;
}
} while ((e_iter = BM_DISK_EDGE_NEXT(e_iter, v)) != e_first);
return false;
}
static bool bm_edge_has_visible_face(const BMEdge *e)
{
const BMLoop *l_iter, *l_first;
l_iter = l_first = e->l;
do {
if (!BM_elem_flag_test(l_iter->f, BM_ELEM_HIDDEN)) {
return true;
}
} while ((l_iter = l_iter->radial_next) != l_first);
return false;
}
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
static void mesh_cd_calc_used_gpu_layers(
CustomData *UNUSED(cd_vdata), uchar cd_vused[CD_NUMTYPES],
One more fix for merged 'normal map tangents not working correctly when there are no UV maps.'
2017-07-04 16:03:04 +03:00
CustomData *cd_ldata, ushort cd_lused[CD_NUMTYPES],
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
struct GPUMaterial **gpumat_array, int gpumat_array_len)
{
DwM: add CD_AUTO_FROM_NAME for mesh conversion
2017-06-29 15:23:47 +10:00
/* See: DM_vertex_attributes_from_gpu for similar logic */
Code cleanup: fix various compiler warnings.
2017-08-12 14:07:37 +02:00
GPUVertexAttribs gattribs = {{{0}}};
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
for (int i = 0; i < gpumat_array_len; i++) {
GPUMaterial *gpumat = gpumat_array[i];
if (gpumat) {
GPU_material_vertex_attributes(gpumat, &gattribs);
for (int j = 0; j < gattribs.totlayer; j++) {
const char *name = gattribs.layer[j].name;
DwM: add CD_AUTO_FROM_NAME for mesh conversion
2017-06-29 15:23:47 +10:00
int type = gattribs.layer[j].type;
int layer = -1;
if (type == CD_AUTO_FROM_NAME) {
/* We need to deduct what exact layer is used.
*
* We do it based on the specified name.
*/
Fix T51963: Eevee: ASAN crash on copy_attrib_name Bug introduced on f6bb3262f17. CustomData_get_named_layer returns a different result than CustomData_get_named_layer_index.
2017-07-03 12:46:58 +02:00
if (name[0] != '\0') {
layer = CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name);
DwM: add CD_AUTO_FROM_NAME for mesh conversion
2017-06-29 15:23:47 +10:00
type = CD_MTFACE;
Fix T51963: Eevee: ASAN crash on copy_attrib_name Bug introduced on f6bb3262f17. CustomData_get_named_layer returns a different result than CustomData_get_named_layer_index.
2017-07-03 12:46:58 +02:00
DwM: add CD_AUTO_FROM_NAME for mesh conversion
2017-06-29 15:23:47 +10:00
if (layer == -1) {
Fix T51963: Eevee: ASAN crash on copy_attrib_name Bug introduced on f6bb3262f17. CustomData_get_named_layer returns a different result than CustomData_get_named_layer_index.
2017-07-03 12:46:58 +02:00
layer = CustomData_get_named_layer(cd_ldata, CD_MLOOPCOL, name);
DwM: add CD_AUTO_FROM_NAME for mesh conversion
2017-06-29 15:23:47 +10:00
type = CD_MCOL;
}
#if 0 /* Tangents are always from UV's - this will never happen. */
if (layer == -1) {
Fix T51963: Eevee: ASAN crash on copy_attrib_name Bug introduced on f6bb3262f17. CustomData_get_named_layer returns a different result than CustomData_get_named_layer_index.
2017-07-03 12:46:58 +02:00
layer = CustomData_get_named_layer(cd_ldata, CD_TANGENT, name);
DwM: add CD_AUTO_FROM_NAME for mesh conversion
2017-06-29 15:23:47 +10:00
type = CD_TANGENT;
}
#endif
if (layer == -1) {
continue;
}
}
else {
/* Fall back to the UV layer, which matches old behavior. */
type = CD_MTFACE;
}
}
switch (type) {
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
case CD_MTFACE:
{
DwM: add CD_AUTO_FROM_NAME for mesh conversion
2017-06-29 15:23:47 +10:00
if (layer == -1) {
layer = (name[0] != '\0') ?
CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name) :
CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
}
if (layer != -1) {
cd_lused[CD_MLOOPUV] |= (1 << layer);
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
}
break;
}
case CD_TANGENT:
{
DwM: add CD_AUTO_FROM_NAME for mesh conversion
2017-06-29 15:23:47 +10:00
if (layer == -1) {
layer = (name[0] != '\0') ?
CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name) :
CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
}
if (layer != -1) {
cd_lused[CD_TANGENT] |= (1 << layer);
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
}
One more fix for merged 'normal map tangents not working correctly when there are no UV maps.'
2017-07-04 16:03:04 +03:00
else {
/* no UV layers at all => requesting orco */
cd_lused[CD_TANGENT] |= DM_TANGENT_MASK_ORCO;
cd_vused[CD_ORCO] |= 1;
}
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
break;
}
case CD_MCOL:
{
DwM: add CD_AUTO_FROM_NAME for mesh conversion
2017-06-29 15:23:47 +10:00
if (layer == -1) {
layer = (name[0] != '\0') ?
CustomData_get_named_layer(cd_ldata, CD_MLOOPCOL, name) :
CustomData_get_active_layer(cd_ldata, CD_MLOOPCOL);
}
if (layer != -1) {
cd_lused[CD_MLOOPCOL] |= (1 << layer);
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
}
break;
}
case CD_ORCO:
{
cd_vused[CD_ORCO] |= 1;
break;
}
}
}
}
}
}
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
static void mesh_render_calc_normals_loop_and_poly(const Mesh *me, const float split_angle, MeshRenderData *rdata)
{
BLI_assert((me->flag & ME_AUTOSMOOTH) != 0);
int totloop = me->totloop;
int totpoly = me->totpoly;
float (*loop_normals)[3] = MEM_mallocN(sizeof(*loop_normals) * totloop, __func__);
float (*poly_normals)[3] = MEM_mallocN(sizeof(*poly_normals) * totpoly, __func__);
short (*clnors)[2] = CustomData_get_layer(&me->ldata, CD_CUSTOMLOOPNORMAL);
BKE_mesh_calc_normals_poly(
me->mvert, NULL, me->totvert,
me->mloop, me->mpoly, totloop, totpoly, poly_normals, false);
BKE_mesh_normals_loop_split(
me->mvert, me->totvert, me->medge, me->totedge,
me->mloop, loop_normals, totloop, me->mpoly, poly_normals, totpoly,
true, split_angle, NULL, clnors, NULL);
rdata->loop_len = totloop;
rdata->poly_len = totpoly;
rdata->loop_normals = loop_normals;
rdata->poly_normals = poly_normals;
}
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
/**
* TODO(campbell): 'gpumat_array' may include materials linked to the object.
* While not default, object materials should be supported.
Merge branch 'master' into blender2.8
2018-09-19 18:19:49 +02:00
* Although this only impacts the data that's generated, not the materials that display.
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
*/
static MeshRenderData *mesh_render_data_create_ex(
Mesh *me, const int types,
struct GPUMaterial **gpumat_array, uint gpumat_array_len)
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
MeshRenderData *rdata = MEM_callocN(sizeof(*rdata), __func__);
rdata->types = types;
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
rdata->mat_len = mesh_render_mat_len_get(me);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
CustomData_reset(&rdata->cd.output.ldata);
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
const bool is_auto_smooth = (me->flag & ME_AUTOSMOOTH) != 0;
const float split_angle = is_auto_smooth ? me->smoothresh : (float)M_PI;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
if (me->edit_btmesh) {
BMEditMesh *embm = me->edit_btmesh;
BMesh *bm = embm->bm;
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->edit_bmesh = embm;
Mesh: move runtime members to own struct
2018-05-02 15:47:45 +02:00
rdata->edit_data = me->runtime.edit_data;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
int bm_ensure_types = 0;
Workbench: Enable Textures in Edit Mesh Mode Constructed UV out of BMesh data layers.
2018-05-15 08:56:45 +02:00
if (types & MR_DATATYPE_VERT) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->vert_len = bm->totvert;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
bm_ensure_types |= BM_VERT;
}
Workbench: Enable Textures in Edit Mesh Mode Constructed UV out of BMesh data layers.
2018-05-15 08:56:45 +02:00
if (types & MR_DATATYPE_EDGE) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->edge_len = bm->totedge;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
bm_ensure_types |= BM_EDGE;
}
if (types & MR_DATATYPE_LOOPTRI) {
BKE_editmesh_tessface_calc(embm);
Workbench: Enable Textures in Edit Mesh Mode Constructed UV out of BMesh data layers.
2018-05-15 08:56:45 +02:00
int tottri = embm->tottri;
rdata->mlooptri = MEM_mallocN(sizeof(*rdata->mlooptri) * embm->tottri, __func__);
for (int index = 0; index < tottri ; index ++ ) {
BMLoop **bmtri = embm->looptris[index];
MLoopTri *mtri = &rdata->mlooptri[index];
mtri->tri[0] = BM_elem_index_get(bmtri[0]);
mtri->tri[1] = BM_elem_index_get(bmtri[1]);
mtri->tri[2] = BM_elem_index_get(bmtri[2]);
}
rdata->tri_len = tottri;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
if (types & MR_DATATYPE_LOOP) {
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
int totloop = bm->totloop;
if (is_auto_smooth) {
rdata->loop_normals = MEM_mallocN(sizeof(*rdata->loop_normals) * totloop, __func__);
Fix trivial error in call
2018-08-09 18:56:46 +05:30
int cd_loop_clnors_offset = CustomData_get_layer_index(&bm->ldata, CD_CUSTOMLOOPNORMAL);
Cleanup: style
2018-08-10 08:10:07 +10:00
BM_loops_calc_normal_vcos(
bm, NULL, NULL, NULL, true, split_angle, rdata->loop_normals, NULL, NULL,
cd_loop_clnors_offset, false);
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
}
rdata->loop_len = totloop;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
bm_ensure_types |= BM_LOOP;
}
if (types & MR_DATATYPE_POLY) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->poly_len = bm->totface;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
bm_ensure_types |= BM_FACE;
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
if (types & MR_DATATYPE_OVERLAY) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->efa_act = BM_mesh_active_face_get(bm, false, true);
rdata->eed_act = BM_mesh_active_edge_get(bm);
rdata->eve_act = BM_mesh_active_vert_get(bm);
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
rdata->cd.offset.crease = CustomData_get_offset(&bm->edata, CD_CREASE);
rdata->cd.offset.bweight = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
Clay Engine: Edit mesh overlays Based on the previous overlay shader from merwin. This shader takes care of clipped vertex cases and do all edit mode face info in one pass (except face centers). As the shading is done one the triangle itself the visual can't go beyond the surface of the mesh. That leads to half displayed edges on the outline of the mesh. This problem can be fixed by a second pass. This is work in progress.
2017-02-26 21:07:37 +01:00
}
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
if (types & (MR_DATATYPE_DVERT)) {
bm_ensure_types |= BM_VERT;
}
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
if (rdata->edit_data != NULL) {
bm_ensure_types |= BM_VERT;
}
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
BM_mesh_elem_index_ensure(bm, bm_ensure_types);
BM_mesh_elem_table_ensure(bm, bm_ensure_types & ~BM_LOOP);
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
if (types & MR_DATATYPE_OVERLAY) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->loose_vert_len = rdata->loose_edge_len = 0;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
int *lverts = rdata->loose_verts = MEM_mallocN(rdata->vert_len * sizeof(int), "Loose Vert");
int *ledges = rdata->loose_edges = MEM_mallocN(rdata->edge_len * sizeof(int), "Loose Edges");
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
EditMesh Render: remove edges-of-vert loop Replace topology check which checked edges twice with a loop on the edge array.
2017-04-12 15:42:41 +10:00
{
BLI_assert((bm->elem_table_dirty & BM_VERT) == 0);
BMVert **vtable = bm->vtable;
for (int i = 0; i < bm->totvert; i++) {
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
const BMVert *eve = vtable[i];
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
/* Loose vert */
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
if (eve->e == NULL || !bm_vert_has_visible_edge(eve)) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
lverts[rdata->loose_vert_len++] = i;
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
}
EditMesh Render: remove edges-of-vert loop Replace topology check which checked edges twice with a loop on the edge array.
2017-04-12 15:42:41 +10:00
}
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
}
EditMesh Render: remove edges-of-vert loop Replace topology check which checked edges twice with a loop on the edge array.
2017-04-12 15:42:41 +10:00
}
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
EditMesh Render: remove edges-of-vert loop Replace topology check which checked edges twice with a loop on the edge array.
2017-04-12 15:42:41 +10:00
{
BLI_assert((bm->elem_table_dirty & BM_EDGE) == 0);
BMEdge **etable = bm->etable;
for (int i = 0; i < bm->totedge; i++) {
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
const BMEdge *eed = etable[i];
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
/* Loose edge */
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
if (eed->l == NULL || !bm_edge_has_visible_face(eed)) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
ledges[rdata->loose_edge_len++] = i;
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
}
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
}
EditMesh Render: remove edges-of-vert loop Replace topology check which checked edges twice with a loop on the edge array.
2017-04-12 15:42:41 +10:00
}
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
}
EditMesh Render: remove edges-of-vert loop Replace topology check which checked edges twice with a loop on the edge array.
2017-04-12 15:42:41 +10:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->loose_verts = MEM_reallocN(rdata->loose_verts, rdata->loose_vert_len * sizeof(int));
rdata->loose_edges = MEM_reallocN(rdata->loose_edges, rdata->loose_edge_len * sizeof(int));
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
}
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
else {
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
if (types & (MR_DATATYPE_VERT)) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->vert_len = me->totvert;
rdata->mvert = CustomData_get_layer(&me->vdata, CD_MVERT);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
if (types & (MR_DATATYPE_EDGE)) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->edge_len = me->totedge;
rdata->medge = CustomData_get_layer(&me->edata, CD_MEDGE);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
if (types & MR_DATATYPE_LOOPTRI) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
const int tri_len = rdata->tri_len = poly_to_tri_count(me->totpoly, me->totloop);
rdata->mlooptri = MEM_mallocN(sizeof(*rdata->mlooptri) * tri_len, __func__);
BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, rdata->mlooptri);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
if (types & MR_DATATYPE_LOOP) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->loop_len = me->totloop;
rdata->mloop = CustomData_get_layer(&me->ldata, CD_MLOOP);
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
if (is_auto_smooth) {
mesh_render_calc_normals_loop_and_poly(me, split_angle, rdata);
}
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
if (types & MR_DATATYPE_POLY) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
rdata->poly_len = me->totpoly;
rdata->mpoly = CustomData_get_layer(&me->pdata, CD_MPOLY);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
if (types & MR_DATATYPE_DVERT) {
rdata->vert_len = me->totvert;
rdata->dvert = CustomData_get_layer(&me->vdata, CD_MDEFORMVERT);
}
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
if (types & MR_DATATYPE_LOOPCOL) {
rdata->loop_len = me->totloop;
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
rdata->mloopcol = CustomData_get_layer(&me->ldata, CD_MLOOPCOL);
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
}
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
if (types & MR_DATATYPE_LOOPUV) {
rdata->loop_len = me->totloop;
rdata->mloopuv = CustomData_get_layer(&me->ldata, CD_MLOOPUV);
}
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
if (types & MR_DATATYPE_SHADING) {
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
CustomData *cd_vdata, *cd_ldata;
if (me->edit_btmesh) {
BMesh *bm = me->edit_btmesh->bm;
cd_vdata = &bm->vdata;
cd_ldata = &bm->ldata;
}
else {
cd_vdata = &me->vdata;
cd_ldata = &me->ldata;
}
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
/* Add edge/poly if we need them */
uchar cd_vused[CD_NUMTYPES] = {0};
One more fix for merged 'normal map tangents not working correctly when there are no UV maps.'
2017-07-04 16:03:04 +03:00
ushort cd_lused[CD_NUMTYPES] = {0};
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
mesh_cd_calc_used_gpu_layers(
cd_vdata, cd_vused,
cd_ldata, cd_lused,
gpumat_array, gpumat_array_len);
DWM: separate tangents from UV conversion Prepare for different number of UV/Tangent layers.
2017-06-28 09:55:40 +10:00
rdata->cd.layers.uv_active = CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
rdata->cd.layers.vcol_active = CustomData_get_active_layer(cd_ldata, CD_MLOOPCOL);
rdata->cd.layers.tangent_active = rdata->cd.layers.uv_active;
Cleanup: quiet negative shift warning
2017-06-29 15:34:50 +10:00
#define CD_VALIDATE_ACTIVE_LAYER(active_index, used) \
if ((active_index != -1) && (used & (1 << active_index)) == 0) { \
active_index = -1; \
} ((void)0)
CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.uv_active, cd_lused[CD_MLOOPUV]);
CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.tangent_active, cd_lused[CD_TANGENT]);
CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.vcol_active, cd_lused[CD_MLOOPCOL]);
#undef CD_VALIDATE_ACTIVE_LAYER
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
Eevee: Keep track on whether orco was allocated or not If it's coming from vertex data, we must not free that pointer.
2018-05-30 12:40:16 +02:00
rdata->is_orco_allocated = false;
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
if (cd_vused[CD_ORCO] & 1) {
rdata->orco = CustomData_get_layer(cd_vdata, CD_ORCO);
/* If orco is not available compute it ourselves */
if (!rdata->orco) {
Eevee: Keep track on whether orco was allocated or not If it's coming from vertex data, we must not free that pointer.
2018-05-30 12:40:16 +02:00
rdata->is_orco_allocated = true;
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
if (me->edit_btmesh) {
BMesh *bm = me->edit_btmesh->bm;
rdata->orco = MEM_mallocN(sizeof(*rdata->orco) * rdata->vert_len, "orco mesh");
BLI_assert((bm->elem_table_dirty & BM_VERT) == 0);
BMVert **vtable = bm->vtable;
for (int i = 0; i < bm->totvert; i++) {
copy_v3_v3(rdata->orco[i], vtable[i]->co);
}
BKE_mesh_orco_verts_transform(me, rdata->orco, rdata->vert_len, 0);
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
}
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
else {
rdata->orco = MEM_mallocN(sizeof(*rdata->orco) * rdata->vert_len, "orco mesh");
MVert *mvert = rdata->mvert;
for (int a = 0; a < rdata->vert_len; a++, mvert++) {
copy_v3_v3(rdata->orco[a], mvert->co);
}
BKE_mesh_orco_verts_transform(me, rdata->orco, rdata->vert_len, 0);
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
}
}
}
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
else {
rdata->orco = NULL;
}
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
/* don't access mesh directly, instead use vars taken from BMesh or Mesh */
#define me DONT_USE_THIS
Cleanup: warnings
2017-05-21 09:39:31 +10:00
#ifdef me /* quiet warning */
#endif
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
struct {
uint uv_len;
uint vcol_len;
} cd_layers_src = {
.uv_len = CustomData_number_of_layers(cd_ldata, CD_MLOOPUV),
.vcol_len = CustomData_number_of_layers(cd_ldata, CD_MLOOPCOL),
};
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
rdata->cd.layers.uv_len = count_bits_i(cd_lused[CD_MLOOPUV]);
rdata->cd.layers.tangent_len = count_bits_i(cd_lused[CD_TANGENT]);
rdata->cd.layers.vcol_len = count_bits_i(cd_lused[CD_MLOOPCOL]);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
rdata->cd.layers.uv = MEM_mallocN(sizeof(*rdata->cd.layers.uv) * rdata->cd.layers.uv_len, __func__);
rdata->cd.layers.vcol = MEM_mallocN(sizeof(*rdata->cd.layers.vcol) * rdata->cd.layers.vcol_len, __func__);
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
rdata->cd.layers.tangent = MEM_mallocN(sizeof(*rdata->cd.layers.tangent) * rdata->cd.layers.tangent_len, __func__);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
rdata->cd.uuid.uv = MEM_mallocN(sizeof(*rdata->cd.uuid.uv) * rdata->cd.layers.uv_len, __func__);
rdata->cd.uuid.vcol = MEM_mallocN(sizeof(*rdata->cd.uuid.vcol) * rdata->cd.layers.vcol_len, __func__);
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
rdata->cd.uuid.tangent = MEM_mallocN(sizeof(*rdata->cd.uuid.tangent) * rdata->cd.layers.tangent_len, __func__);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
rdata->cd.offset.uv = MEM_mallocN(sizeof(*rdata->cd.offset.uv) * rdata->cd.layers.uv_len, __func__);
rdata->cd.offset.vcol = MEM_mallocN(sizeof(*rdata->cd.offset.vcol) * rdata->cd.layers.vcol_len, __func__);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
/* Allocate max */
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
rdata->cd.layers.auto_vcol = MEM_callocN(
sizeof(*rdata->cd.layers.auto_vcol) * rdata->cd.layers.vcol_len, __func__);
rdata->cd.uuid.auto_mix = MEM_mallocN(
sizeof(*rdata->cd.uuid.auto_mix) * (rdata->cd.layers.vcol_len + rdata->cd.layers.uv_len), __func__);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
/* XXX FIXME XXX */
/* We use a hash to identify each data layer based on its name.
* Gawain then search for this name in the current shader and bind if it exists.
* NOTE : This is prone to hash collision.
* One solution to hash collision would be to format the cd layer name
* to a safe glsl var name, but without name clash.
* NOTE 2 : Replicate changes to code_generate_vertex_new() in gpu_codegen.c */
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
if (rdata->cd.layers.vcol_len != 0) {
for (int i_src = 0, i_dst = 0; i_src < cd_layers_src.vcol_len; i_src++, i_dst++) {
if ((cd_lused[CD_MLOOPCOL] & (1 << i_src)) == 0) {
i_dst--;
if (rdata->cd.layers.vcol_active >= i_src) {
rdata->cd.layers.vcol_active--;
}
}
else {
const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPCOL, i_src);
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint hash = BLI_ghashutil_strhash_p(name);
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
BLI_snprintf(rdata->cd.uuid.vcol[i_dst], sizeof(*rdata->cd.uuid.vcol), "c%u", hash);
rdata->cd.layers.vcol[i_dst] = CustomData_get_layer_n(cd_ldata, CD_MLOOPCOL, i_src);
if (rdata->edit_bmesh) {
rdata->cd.offset.vcol[i_dst] = CustomData_get_n_offset(
&rdata->edit_bmesh->bm->ldata, CD_MLOOPCOL, i_src);
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
/* Gather number of auto layers. */
/* We only do vcols that are not overridden by uvs */
if (CustomData_get_named_layer_index(cd_ldata, CD_MLOOPUV, name) == -1) {
BLI_snprintf(
rdata->cd.uuid.auto_mix[rdata->cd.layers.uv_len + i_dst],
sizeof(*rdata->cd.uuid.auto_mix), "a%u", hash);
rdata->cd.layers.auto_vcol[i_dst] = true;
}
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
}
/* Start Fresh */
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
CustomData_free_layers(cd_ldata, CD_TANGENT, rdata->loop_len);
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
CustomData_free_layers(cd_ldata, CD_MLOOPTANGENT, rdata->loop_len);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
if (rdata->cd.layers.uv_len != 0) {
for (int i_src = 0, i_dst = 0; i_src < cd_layers_src.uv_len; i_src++, i_dst++) {
if ((cd_lused[CD_MLOOPUV] & (1 << i_src)) == 0) {
i_dst--;
if (rdata->cd.layers.uv_active >= i_src) {
rdata->cd.layers.uv_active--;
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
else {
const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i_src);
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint hash = BLI_ghashutil_strhash_p(name);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
BLI_snprintf(rdata->cd.uuid.uv[i_dst], sizeof(*rdata->cd.uuid.uv), "u%u", hash);
rdata->cd.layers.uv[i_dst] = CustomData_get_layer_n(cd_ldata, CD_MLOOPUV, i_src);
if (rdata->edit_bmesh) {
rdata->cd.offset.uv[i_dst] = CustomData_get_n_offset(
&rdata->edit_bmesh->bm->ldata, CD_MLOOPUV, i_src);
Cleanup: minor de-duplicate from last commit
2017-05-24 22:47:18 +10:00
}
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
BLI_snprintf(rdata->cd.uuid.auto_mix[i_dst], sizeof(*rdata->cd.uuid.auto_mix), "a%u", hash);
}
}
}
Cleanup: minor de-duplicate from last commit
2017-05-24 22:47:18 +10:00
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
if (rdata->cd.layers.tangent_len != 0) {
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
/* -------------------------------------------------------------------- */
/* Pre-calculate tangents into 'rdata->cd.output.ldata' */
Only calc split normals when auto-smooth is enabled This matches cycles & derived-mesh
2017-05-25 02:31:39 +10:00
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
BLI_assert(!CustomData_has_layer(&rdata->cd.output.ldata, CD_TANGENT));
/* Tangent Names */
char tangent_names[MAX_MTFACE][MAX_NAME];
for (int i_src = 0, i_dst = 0; i_src < cd_layers_src.uv_len; i_src++, i_dst++) {
if ((cd_lused[CD_TANGENT] & (1 << i_src)) == 0) {
i_dst--;
}
else {
BLI_strncpy(
tangent_names[i_dst],
CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i_src), MAX_NAME);
}
}
One more fix for merged 'normal map tangents not working correctly when there are no UV maps.'
2017-07-04 16:03:04 +03:00
/* If tangent from orco is requested, decrement tangent_len */
int actual_tangent_len = (cd_lused[CD_TANGENT] & DM_TANGENT_MASK_ORCO) ?
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
rdata->cd.layers.tangent_len - 1 : rdata->cd.layers.tangent_len;
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
if (rdata->edit_bmesh) {
BMEditMesh *em = rdata->edit_bmesh;
BMesh *bm = em->bm;
Mesh Auto-Smooth Split Normal Support From D2906 with few changes
2017-10-31 15:15:14 -02:00
if (is_auto_smooth && rdata->loop_normals == NULL) {
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
/* Should we store the previous array of `loop_normals` in somewhere? */
rdata->loop_len = bm->totloop;
rdata->loop_normals = MEM_mallocN(sizeof(*rdata->loop_normals) * rdata->loop_len, __func__);
Applied soc-2017-normal-tools
2018-05-25 22:24:24 +05:30
BM_loops_calc_normal_vcos(bm, NULL, NULL, NULL, true, split_angle, rdata->loop_normals, NULL, NULL, -1, false);
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
}
bool calc_active_tangent = false;
BKE_editmesh_loop_tangent_calc(
em, calc_active_tangent,
One more fix for merged 'normal map tangents not working correctly when there are no UV maps.'
2017-07-04 16:03:04 +03:00
tangent_names, actual_tangent_len,
Mesh Auto-Smooth Split Normal Support From D2906 with few changes
2017-10-31 15:15:14 -02:00
rdata->poly_normals, rdata->loop_normals,
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
rdata->orco,
&rdata->cd.output.ldata, bm->totloop,
&rdata->cd.output.tangent_mask);
}
else {
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
#undef me
Only calc split normals when auto-smooth is enabled This matches cycles & derived-mesh
2017-05-25 02:31:39 +10:00
Mesh Auto-Smooth Split Normal Support From D2906 with few changes
2017-10-31 15:15:14 -02:00
if (is_auto_smooth && rdata->loop_normals == NULL) {
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
/* Should we store the previous array of `loop_normals` in CustomData? */
mesh_render_calc_normals_loop_and_poly(me, split_angle, rdata);
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
}
Fix T51561: Normal maps fail w/ quad + eevee Generalize derived-mesh tangent calculation so it can be used by Batch cache creation too.
2017-05-24 22:33:21 +10:00
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
bool calc_active_tangent = false;
BKE_mesh_calc_loop_tangent_ex(
me->mvert,
me->mpoly, me->totpoly,
me->mloop,
rdata->mlooptri, rdata->tri_len,
cd_ldata,
calc_active_tangent,
One more fix for merged 'normal map tangents not working correctly when there are no UV maps.'
2017-07-04 16:03:04 +03:00
tangent_names, actual_tangent_len,
Mesh Auto-Smooth Split Normal Support From D2906 with few changes
2017-10-31 15:15:14 -02:00
rdata->poly_normals, rdata->loop_normals,
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
rdata->orco,
&rdata->cd.output.ldata, me->totloop,
&rdata->cd.output.tangent_mask);
/* If we store tangents in the mesh, set temporary. */
Fix T51561: Normal maps fail w/ quad + eevee Generalize derived-mesh tangent calculation so it can be used by Batch cache creation too.
2017-05-24 22:33:21 +10:00
#if 0
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
CustomData_set_layer_flag(cd_ldata, CD_TANGENT, CD_FLAG_TEMPORARY);
Fix T51561: Normal maps fail w/ quad + eevee Generalize derived-mesh tangent calculation so it can be used by Batch cache creation too.
2017-05-24 22:33:21 +10:00
#endif
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
#define me DONT_USE_THIS
Cleanup: warnings
2017-05-21 09:39:31 +10:00
#ifdef me /* quiet warning */
#endif
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
}
/* End tangent calculation */
/* -------------------------------------------------------------------- */
BLI_assert(CustomData_number_of_layers(&rdata->cd.output.ldata, CD_TANGENT) == rdata->cd.layers.tangent_len);
One more fix for merged 'normal map tangents not working correctly when there are no UV maps.'
2017-07-04 16:03:04 +03:00
int i_dst = 0;
for (int i_src = 0; i_src < cd_layers_src.uv_len; i_src++, i_dst++) {
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
if ((cd_lused[CD_TANGENT] & (1 << i_src)) == 0) {
i_dst--;
if (rdata->cd.layers.tangent_active >= i_src) {
rdata->cd.layers.tangent_active--;
Cleanup: minor de-duplicate from last commit
2017-05-24 22:47:18 +10:00
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
else {
const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i_src);
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint hash = BLI_ghashutil_strhash_p(name);
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
BLI_snprintf(rdata->cd.uuid.tangent[i_dst], sizeof(*rdata->cd.uuid.tangent), "t%u", hash);
/* Done adding tangents. */
Cleanup: minor de-duplicate from last commit
2017-05-24 22:47:18 +10:00
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
/* note: BKE_editmesh_loop_tangent_calc calculates 'CD_TANGENT',
* not 'CD_MLOOPTANGENT' (as done below). It's OK, they're compatible. */
/* note: normally we'd use 'i_src' here, but 'i_dst' is in sync with 'rdata->cd.output' */
rdata->cd.layers.tangent[i_dst] = CustomData_get_layer_n(&rdata->cd.output.ldata, CD_TANGENT, i_dst);
if (rdata->tri_len != 0) {
BLI_assert(rdata->cd.layers.tangent[i_dst] != NULL);
}
Suppress assert for meshes with no faces
2017-06-02 16:42:39 +10:00
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
One more fix for merged 'normal map tangents not working correctly when there are no UV maps.'
2017-07-04 16:03:04 +03:00
if (cd_lused[CD_TANGENT] & DM_TANGENT_MASK_ORCO) {
const char *name = CustomData_get_layer_name(&rdata->cd.output.ldata, CD_TANGENT, i_dst);
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint hash = BLI_ghashutil_strhash_p(name);
One more fix for merged 'normal map tangents not working correctly when there are no UV maps.'
2017-07-04 16:03:04 +03:00
BLI_snprintf(rdata->cd.uuid.tangent[i_dst], sizeof(*rdata->cd.uuid.tangent), "t%u", hash);
rdata->cd.layers.tangent[i_dst] = CustomData_get_layer_n(&rdata->cd.output.ldata, CD_TANGENT, i_dst);
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
#undef me
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
Cleanup: minor de-duplicate from last commit
2017-05-24 22:47:18 +10:00
return rdata;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
static void mesh_render_data_free(MeshRenderData *rdata)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Eevee: Keep track on whether orco was allocated or not If it's coming from vertex data, we must not free that pointer.
2018-05-30 12:40:16 +02:00
if (rdata->is_orco_allocated) {
MEM_SAFE_FREE(rdata->orco);
}
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
MEM_SAFE_FREE(rdata->cd.offset.uv);
MEM_SAFE_FREE(rdata->cd.offset.vcol);
MEM_SAFE_FREE(rdata->cd.uuid.auto_mix);
MEM_SAFE_FREE(rdata->cd.uuid.uv);
MEM_SAFE_FREE(rdata->cd.uuid.vcol);
MEM_SAFE_FREE(rdata->cd.uuid.tangent);
MEM_SAFE_FREE(rdata->cd.layers.uv);
MEM_SAFE_FREE(rdata->cd.layers.vcol);
MEM_SAFE_FREE(rdata->cd.layers.tangent);
MEM_SAFE_FREE(rdata->cd.layers.auto_vcol);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
MEM_SAFE_FREE(rdata->loose_verts);
MEM_SAFE_FREE(rdata->loose_edges);
MEM_SAFE_FREE(rdata->edges_adjacent_polys);
MEM_SAFE_FREE(rdata->mlooptri);
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
MEM_SAFE_FREE(rdata->loop_normals);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
MEM_SAFE_FREE(rdata->poly_normals);
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
MEM_SAFE_FREE(rdata->poly_normals_pack);
MEM_SAFE_FREE(rdata->vert_normals_pack);
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
MEM_SAFE_FREE(rdata->vert_weight_color);
Cleanup: clarify select terminology In mesh cache we have select: color, id, bool. Current naming didn't make this clear.
2017-05-17 11:46:26 +10:00
MEM_SAFE_FREE(rdata->edge_select_bool);
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
MEM_SAFE_FREE(rdata->vert_color);
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
CustomData_free(&rdata->cd.output.ldata, rdata->loop_len);
DWM: Tangent support for editmesh
2017-05-09 08:50:45 +10:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
MEM_freeN(rdata);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
static MeshRenderData *mesh_render_data_create(Mesh *me, const int types)
{
return mesh_render_data_create_ex(me, types, NULL, 0);
}
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Accessor Functions
* \{ */
Cleanup: rename layer-names -> layer-uuid These names are created from a hash, don't confuse with actual layer names.
2017-05-09 10:38:52 +10:00
static const char *mesh_render_data_uv_auto_layer_uuid_get(const MeshRenderData *rdata, int layer)
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
{
BLI_assert(rdata->types & MR_DATATYPE_SHADING);
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
return rdata->cd.uuid.auto_mix[layer];
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
Cleanup: rename layer-names -> layer-uuid These names are created from a hash, don't confuse with actual layer names.
2017-05-09 10:38:52 +10:00
static const char *mesh_render_data_vcol_auto_layer_uuid_get(const MeshRenderData *rdata, int layer)
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
{
BLI_assert(rdata->types & MR_DATATYPE_SHADING);
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
return rdata->cd.uuid.auto_mix[rdata->cd.layers.uv_len + layer];
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
Cleanup: rename layer-names -> layer-uuid These names are created from a hash, don't confuse with actual layer names.
2017-05-09 10:38:52 +10:00
static const char *mesh_render_data_uv_layer_uuid_get(const MeshRenderData *rdata, int layer)
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
{
BLI_assert(rdata->types & MR_DATATYPE_SHADING);
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
return rdata->cd.uuid.uv[layer];
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
Cleanup: rename layer-names -> layer-uuid These names are created from a hash, don't confuse with actual layer names.
2017-05-09 10:38:52 +10:00
static const char *mesh_render_data_vcol_layer_uuid_get(const MeshRenderData *rdata, int layer)
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
{
BLI_assert(rdata->types & MR_DATATYPE_SHADING);
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
return rdata->cd.uuid.vcol[layer];
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
Cleanup: rename layer-names -> layer-uuid These names are created from a hash, don't confuse with actual layer names.
2017-05-09 10:38:52 +10:00
static const char *mesh_render_data_tangent_layer_uuid_get(const MeshRenderData *rdata, int layer)
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
{
BLI_assert(rdata->types & MR_DATATYPE_SHADING);
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
return rdata->cd.uuid.tangent[layer];
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
static int mesh_render_data_verts_len_get(const MeshRenderData *rdata)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & MR_DATATYPE_VERT);
return rdata->vert_len;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
static int mesh_render_data_loose_verts_len_get(const MeshRenderData *rdata)
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & MR_DATATYPE_OVERLAY);
return rdata->loose_vert_len;
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
}
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
static int mesh_render_data_edges_len_get(const MeshRenderData *rdata)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & MR_DATATYPE_EDGE);
return rdata->edge_len;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
static int mesh_render_data_loose_edges_len_get(const MeshRenderData *rdata)
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & MR_DATATYPE_OVERLAY);
return rdata->loose_edge_len;
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
}
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
static int mesh_render_data_looptri_len_get(const MeshRenderData *rdata)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & MR_DATATYPE_LOOPTRI);
return rdata->tri_len;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
static int mesh_render_data_mat_len_get(const MeshRenderData *rdata)
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
{
BLI_assert(rdata->types & MR_DATATYPE_POLY);
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
return rdata->mat_len;
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
}
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
static int UNUSED_FUNCTION(mesh_render_data_loops_len_get)(const MeshRenderData *rdata)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & MR_DATATYPE_LOOP);
return rdata->loop_len;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
static int mesh_render_data_polys_len_get(const MeshRenderData *rdata)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & MR_DATATYPE_POLY);
return rdata->poly_len;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
/** \} */
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
/* ---------------------------------------------------------------------- */
/** \name Internal Cache (Lazy Initialization)
* \{ */
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
/** Ensure #MeshRenderData.poly_normals_pack */
static void mesh_render_data_ensure_poly_normals_pack(MeshRenderData *rdata)
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
{
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUPackedNormal *pnors_pack = rdata->poly_normals_pack;
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
if (pnors_pack == NULL) {
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter fiter;
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BMFace *efa;
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
int i;
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
pnors_pack = rdata->poly_normals_pack = MEM_mallocN(sizeof(*pnors_pack) * rdata->poly_len, __func__);
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BM_ITER_MESH_INDEX(efa, &fiter, bm, BM_FACES_OF_MESH, i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
pnors_pack[i] = GPU_normal_convert_i10_v3(efa->no);
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
}
}
else {
float (*pnors)[3] = rdata->poly_normals;
if (!pnors) {
pnors = rdata->poly_normals = MEM_mallocN(sizeof(*pnors) * rdata->poly_len, __func__);
BKE_mesh_calc_normals_poly(
rdata->mvert, NULL, rdata->vert_len,
rdata->mloop, rdata->mpoly, rdata->loop_len, rdata->poly_len, pnors, true);
}
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
pnors_pack = rdata->poly_normals_pack = MEM_mallocN(sizeof(*pnors_pack) * rdata->poly_len, __func__);
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
for (int i = 0; i < rdata->poly_len; i++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
pnors_pack[i] = GPU_normal_convert_i10_v3(pnors[i]);
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
}
}
}
}
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
/** Ensure #MeshRenderData.vert_normals_pack */
static void mesh_render_data_ensure_vert_normals_pack(MeshRenderData *rdata)
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
{
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUPackedNormal *vnors_pack = rdata->vert_normals_pack;
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
if (vnors_pack == NULL) {
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter viter;
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BMVert *eve;
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
int i;
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
vnors_pack = rdata->vert_normals_pack = MEM_mallocN(sizeof(*vnors_pack) * rdata->vert_len, __func__);
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BM_ITER_MESH_INDEX(eve, &viter, bm, BM_VERT, i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vnors_pack[i] = GPU_normal_convert_i10_v3(eve->no);
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
}
}
else {
/* data from mesh used directly */
BLI_assert(0);
}
}
}
/** Ensure #MeshRenderData.vert_color */
static void mesh_render_data_ensure_vert_color(MeshRenderData *rdata)
{
char (*vcol)[3] = rdata->vert_color;
if (vcol == NULL) {
if (rdata->edit_bmesh) {
Vertex color access for edit-mode Currently not used, adding since legacy drawing can display this.
2017-05-08 12:41:05 +10:00
BMesh *bm = rdata->edit_bmesh->bm;
const int cd_loop_color_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPCOL);
if (cd_loop_color_offset == -1) {
goto fallback;
}
vcol = rdata->vert_color = MEM_mallocN(sizeof(*vcol) * rdata->loop_len, __func__);
BMIter fiter;
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BMFace *efa;
Vertex color access for edit-mode Currently not used, adding since legacy drawing can display this.
2017-05-08 12:41:05 +10:00
int i = 0;
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BM_ITER_MESH(efa, &fiter, bm, BM_FACES_OF_MESH) {
Vertex color access for edit-mode Currently not used, adding since legacy drawing can display this.
2017-05-08 12:41:05 +10:00
BMLoop *l_iter, *l_first;
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
l_iter = l_first = BM_FACE_FIRST_LOOP(efa);
Vertex color access for edit-mode Currently not used, adding since legacy drawing can display this.
2017-05-08 12:41:05 +10:00
do {
const MLoopCol *lcol = BM_ELEM_CD_GET_VOID_P(l_iter, cd_loop_color_offset);
vcol[i][0] = lcol->r;
vcol[i][1] = lcol->g;
vcol[i][2] = lcol->b;
i += 1;
} while ((l_iter = l_iter->next) != l_first);
}
BLI_assert(i == rdata->loop_len);
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
}
else {
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
if (rdata->mloopcol == NULL) {
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
goto fallback;
}
vcol = rdata->vert_color = MEM_mallocN(sizeof(*vcol) * rdata->loop_len, __func__);
for (int i = 0; i < rdata->loop_len; i++) {
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
vcol[i][0] = rdata->mloopcol[i].r;
vcol[i][1] = rdata->mloopcol[i].g;
vcol[i][2] = rdata->mloopcol[i].b;
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
}
}
}
return;
fallback:
vcol = rdata->vert_color = MEM_mallocN(sizeof(*vcol) * rdata->loop_len, __func__);
for (int i = 0; i < rdata->loop_len; i++) {
vcol[i][0] = 255;
vcol[i][1] = 255;
vcol[i][2] = 255;
}
}
/* TODO, move into shader? */
static void rgb_from_weight(float r_rgb[3], const float weight)
{
const float blend = ((weight / 2.0f) + 0.5f);
if (weight <= 0.25f) { /* blue->cyan */
r_rgb[0] = 0.0f;
r_rgb[1] = blend * weight * 4.0f;
r_rgb[2] = blend;
}
else if (weight <= 0.50f) { /* cyan->green */
r_rgb[0] = 0.0f;
r_rgb[1] = blend;
r_rgb[2] = blend * (1.0f - ((weight - 0.25f) * 4.0f));
}
else if (weight <= 0.75f) { /* green->yellow */
r_rgb[0] = blend * ((weight - 0.50f) * 4.0f);
r_rgb[1] = blend;
r_rgb[2] = 0.0f;
}
else if (weight <= 1.0f) { /* yellow->red */
r_rgb[0] = blend;
r_rgb[1] = blend * (1.0f - ((weight - 0.75f) * 4.0f));
r_rgb[2] = 0.0f;
}
else {
/* exceptional value, unclamped or nan,
* avoid uninitialized memory use */
r_rgb[0] = 1.0f;
r_rgb[1] = 0.0f;
r_rgb[2] = 1.0f;
}
}
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
static void vertex_weight_color(float vweight[3], float weight, bool show_alert_color)
{
CLAMP(weight, 0.0f, 1.0f);
if (show_alert_color) {
bTheme *theme = U.themes.first;
Cleanup: warnings, style
2018-09-26 10:01:32 +10:00
rgb_uchar_to_float(vweight, (uchar *)theme->tv3d.vertex_unreferenced);
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
}
else if (U.flag & USER_CUSTOM_RANGE) {
BKE_colorband_evaluate(&U.coba_weight, weight, vweight);
}
else {
rgb_from_weight(vweight, weight);
}
}
static void evaluate_vertex_weight(float vweight[3], const MDeformVert *dvert, const VertexWeightSelection *vwsel)
{
float input = 0.0f;
bool show_alert_color = false;
if (vwsel->flags & VWEIGHT_MULTIPAINT) {
/* Multi-Paint feature */
input = BKE_defvert_multipaint_collective_weight(
Cleanup: warnings, style
2018-09-26 10:01:32 +10:00
dvert, vwsel->defgroup_tot, vwsel->defgroup_sel, vwsel->defgroup_sel_tot,
(vwsel->flags & VWEIGHT_AUTO_NORMALIZE) != 0);
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
/* make it black if the selected groups have no weight on a vertex */
if (input == 0.0f) {
show_alert_color = true;
}
}
else {
/* default, non tricky behavior */
input = defvert_find_weight(dvert, vwsel->defgroup_active);
if (input == 0.0f) {
switch (vwsel->alert_mode) {
case OB_DRAW_GROUPUSER_ACTIVE:
show_alert_color = true;
break;
case OB_DRAW_GROUPUSER_ALL:
show_alert_color = defvert_is_weight_zero(dvert, vwsel->defgroup_tot);
break;
}
}
}
vertex_weight_color(vweight, input, show_alert_color);
}
/* color-code for missing data (full brightness isn't easy on the eye). */
static const unsigned char missing_weight_color[3] = { 0xa0, 0x00, 0xa0 };
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
Correct own error in copying vertex color to VBO's
2017-05-17 17:14:10 +10:00
/** Ensure #MeshRenderData.vert_weight_color */
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
static void mesh_render_data_ensure_vert_weight_color(MeshRenderData *rdata, const VertexWeightSelection *vwsel)
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
{
float (*vweight)[3] = rdata->vert_weight_color;
if (vweight == NULL) {
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
if (vwsel->defgroup_active == -1) {
Resolve assert in weight paint mode w/ no weights
2017-06-01 13:35:27 +10:00
goto fallback;
}
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
const int cd_dvert_offset = CustomData_get_offset(&bm->vdata, CD_MDEFORMVERT);
if (cd_dvert_offset == -1) {
goto fallback;
}
BMIter viter;
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BMVert *eve;
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
int i;
vweight = rdata->vert_weight_color = MEM_mallocN(sizeof(*vweight) * rdata->vert_len, __func__);
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BM_ITER_MESH_INDEX(eve, &viter, bm, BM_VERT, i) {
const MDeformVert *dvert = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
evaluate_vertex_weight(vweight[i], dvert, vwsel);
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
}
}
else {
if (rdata->dvert == NULL) {
goto fallback;
}
vweight = rdata->vert_weight_color = MEM_mallocN(sizeof(*vweight) * rdata->vert_len, __func__);
for (int i = 0; i < rdata->vert_len; i++) {
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
evaluate_vertex_weight(vweight[i], &rdata->dvert[i], vwsel);
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
}
}
}
return;
fallback:
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
vweight = rdata->vert_weight_color = MEM_mallocN(sizeof(*vweight) * rdata->vert_len, __func__);
float error_color[3];
if ((vwsel->defgroup_active < 0) && (vwsel->defgroup_tot > 0)) {
rgb_uchar_to_float(error_color, missing_weight_color);
}
else {
vertex_weight_color(error_color, 0.0f, vwsel->alert_mode != OB_DRAW_GROUPUSER_NONE);
}
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
for (int i = 0; i < rdata->vert_len; i++) {
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
copy_v3_v3(vweight[i], error_color);
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
}
}
Cleanup: clarify select terminology In mesh cache we have select: color, id, bool. Current naming didn't make this clear.
2017-05-17 11:46:26 +10:00
/** Ensure #MeshRenderData.edge_select_bool */
static void mesh_render_data_ensure_edge_select_bool(MeshRenderData *rdata, bool use_wire)
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
{
Cleanup: clarify select terminology In mesh cache we have select: color, id, bool. Current naming didn't make this clear.
2017-05-17 11:46:26 +10:00
bool *edge_select_bool = rdata->edge_select_bool;
if (edge_select_bool == NULL) {
edge_select_bool = rdata->edge_select_bool =
MEM_callocN(sizeof(*edge_select_bool) * rdata->edge_len, __func__);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
for (int i = 0; i < rdata->poly_len; i++) {
MPoly *poly = &rdata->mpoly[i];
if (poly->flag & ME_FACE_SEL) {
for (int j = 0; j < poly->totloop; j++) {
MLoop *loop = &rdata->mloop[poly->loopstart + j];
if (use_wire) {
Cleanup: clarify select terminology In mesh cache we have select: color, id, bool. Current naming didn't make this clear.
2017-05-17 11:46:26 +10:00
edge_select_bool[loop->e] = true;
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
else {
Cleanup: clarify select terminology In mesh cache we have select: color, id, bool. Current naming didn't make this clear.
2017-05-17 11:46:26 +10:00
/* Not totally correct, will cause problems for edges with 3x faces. */
edge_select_bool[loop->e] = !edge_select_bool[loop->e];
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
}
}
}
}
}
Cleanup: de-duplicate mesh data calculation
2017-05-05 04:56:28 +10:00
/** \} */
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
/* ---------------------------------------------------------------------- */
/** \name Internal Cache Generation
* \{ */
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
static bool mesh_render_data_pnors_pcenter_select_get(
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
MeshRenderData *rdata, const int poly,
Cleanup: naming & line length
2017-04-12 18:23:17 +10:00
float r_pnors[3], float r_center[3], bool *r_selected)
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
if (rdata->edit_bmesh) {
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
const BMFace *efa = BM_face_at_index(rdata->edit_bmesh->bm, poly);
if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
return false;
}
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BM_face_calc_center_mean(efa, r_center);
DwM: no need to calculate face normal
2017-06-29 15:52:08 +10:00
copy_v3_v3(r_pnors, efa->no);
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
*r_selected = (BM_elem_flag_test(efa, BM_ELEM_SELECT) != 0) ? true : false;
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
}
else {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
MVert *mvert = rdata->mvert;
const MPoly *mpoly = rdata->mpoly + poly;
const MLoop *mloop = rdata->mloop + mpoly->loopstart;
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
Cleanup: naming & line length
2017-04-12 18:23:17 +10:00
BKE_mesh_calc_poly_center(mpoly, mloop, mvert, r_center);
BKE_mesh_calc_poly_normal(mpoly, mloop, mvert, r_pnors);
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
Cleanup: naming & line length
2017-04-12 18:23:17 +10:00
*r_selected = false; /* No selection if not in edit mode */
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
}
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
return true;
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
}
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
static bool mesh_render_data_edge_vcos_manifold_pnors(
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
MeshRenderData *rdata, const int edge_index,
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
float **r_vco1, float **r_vco2, float **r_pnor1, float **r_pnor2, bool *r_is_manifold)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BMEdge *eed = BM_edge_at_index(bm, edge_index);
if (BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
return false;
}
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
*r_vco1 = eed->v1->co;
*r_vco2 = eed->v2->co;
if (BM_edge_is_manifold(eed)) {
*r_pnor1 = eed->l->f->no;
*r_pnor2 = eed->l->radial_next->f->no;
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
*r_is_manifold = true;
}
Fix broken draw code from last Thursday commit. Seriously... Not all edges have faces!!!!!!!! Quick fix to make it possible to load/use customshaped bones again, not 100% sure it is correct, but... At least it does not crash anymore!
2018-05-21 17:58:52 +02:00
else if (eed->l != NULL) {
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
*r_pnor1 = eed->l->f->no;
*r_pnor2 = eed->l->f->no;
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
*r_is_manifold = false;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
Fix broken draw code from last Thursday commit. Seriously... Not all edges have faces!!!!!!!! Quick fix to make it possible to load/use customshaped bones again, not 100% sure it is correct, but... At least it does not crash anymore!
2018-05-21 17:58:52 +02:00
else {
*r_pnor1 = eed->v1->no;
*r_pnor2 = eed->v1->no;
*r_is_manifold = false;
}
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
else {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
MVert *mvert = rdata->mvert;
MEdge *medge = rdata->medge;
EdgeAdjacentPolys *eap = rdata->edges_adjacent_polys;
float (*pnors)[3] = rdata->poly_normals;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
if (!eap) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
const MLoop *mloop = rdata->mloop;
const MPoly *mpoly = rdata->mpoly;
const int poly_len = rdata->poly_len;
Fix broken draw code from last Thursday commit. Seriously... Not all edges have faces!!!!!!!! Quick fix to make it possible to load/use customshaped bones again, not 100% sure it is correct, but... At least it does not crash anymore!
2018-05-21 17:58:52 +02:00
const bool do_pnors = (poly_len != 0 && pnors == NULL);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
Fix broken draw code from last Thursday commit. Seriously... Not all edges have faces!!!!!!!! Quick fix to make it possible to load/use customshaped bones again, not 100% sure it is correct, but... At least it does not crash anymore!
2018-05-21 17:58:52 +02:00
eap = rdata->edges_adjacent_polys = MEM_mallocN(sizeof(*eap) * rdata->edge_len, __func__);
for (int i = 0; i < rdata->edge_len; i++) {
eap[i].count = 0;
eap[i].face_index[0] = -1;
eap[i].face_index[1] = -1;
}
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
if (do_pnors) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
pnors = rdata->poly_normals = MEM_mallocN(sizeof(*pnors) * poly_len, __func__);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
Clay Engine: Correct Mesh Normals
2017-02-16 16:19:48 +01:00
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
for (int i = 0; i < poly_len; i++, mpoly++) {
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
if (do_pnors) {
BKE_mesh_calc_poly_normal(mpoly, mloop + mpoly->loopstart, mvert, pnors[i]);
}
const int loopend = mpoly->loopstart + mpoly->totloop;
for (int j = mpoly->loopstart; j < loopend; j++) {
const int edge_idx = mloop[j].e;
if (eap[edge_idx].count < 2) {
eap[edge_idx].face_index[eap[edge_idx].count] = i;
}
eap[edge_idx].count++;
}
}
}
Fix broken draw code from last Thursday commit. Seriously... Not all edges have faces!!!!!!!! Quick fix to make it possible to load/use customshaped bones again, not 100% sure it is correct, but... At least it does not crash anymore!
2018-05-21 17:58:52 +02:00
BLI_assert(eap && (rdata->poly_len == 0 || pnors != NULL));
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
*r_vco1 = mvert[medge[edge_index].v1].co;
*r_vco2 = mvert[medge[edge_index].v2].co;
Fix broken draw code from last Thursday commit. Seriously... Not all edges have faces!!!!!!!! Quick fix to make it possible to load/use customshaped bones again, not 100% sure it is correct, but... At least it does not crash anymore!
2018-05-21 17:58:52 +02:00
if (eap[edge_index].face_index[0] == -1) {
/* Edge has no poly... */
*r_pnor1 = *r_pnor2 = mvert[medge[edge_index].v1].co; /* XXX mvert.no are shorts... :( */
*r_is_manifold = false;
}
else {
*r_pnor1 = pnors[eap[edge_index].face_index[0]];
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
Fix broken draw code from last Thursday commit. Seriously... Not all edges have faces!!!!!!!! Quick fix to make it possible to load/use customshaped bones again, not 100% sure it is correct, but... At least it does not crash anymore!
2018-05-21 17:58:52 +02:00
float nor[3], v1[3], v2[3], r_center[3];
const MPoly *mpoly = rdata->mpoly + eap[edge_index].face_index[0];
const MLoop *mloop = rdata->mloop + mpoly->loopstart;
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
Fix broken draw code from last Thursday commit. Seriously... Not all edges have faces!!!!!!!! Quick fix to make it possible to load/use customshaped bones again, not 100% sure it is correct, but... At least it does not crash anymore!
2018-05-21 17:58:52 +02:00
BKE_mesh_calc_poly_center(mpoly, mloop, mvert, r_center);
sub_v3_v3v3(v1, *r_vco2, *r_vco1);
sub_v3_v3v3(v2, r_center, *r_vco1);
cross_v3_v3v3(nor, v1, v2);
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
Fix broken draw code from last Thursday commit. Seriously... Not all edges have faces!!!!!!!! Quick fix to make it possible to load/use customshaped bones again, not 100% sure it is correct, but... At least it does not crash anymore!
2018-05-21 17:58:52 +02:00
if (dot_v3v3(nor, *r_pnor1) < 0.0) {
SWAP(float *, *r_vco1, *r_vco2);
}
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
Fix broken draw code from last Thursday commit. Seriously... Not all edges have faces!!!!!!!! Quick fix to make it possible to load/use customshaped bones again, not 100% sure it is correct, but... At least it does not crash anymore!
2018-05-21 17:58:52 +02:00
if (eap[edge_index].count == 2) {
BLI_assert(eap[edge_index].face_index[1] >= 0);
*r_pnor2 = pnors[eap[edge_index].face_index[1]];
*r_is_manifold = true;
}
else {
*r_pnor2 = pnors[eap[edge_index].face_index[0]];
*r_is_manifold = false;
}
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
}
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
return true;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
static uchar mesh_render_data_looptri_flag(MeshRenderData *rdata, const BMFace *efa)
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
{
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
uchar fflag = 0;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
if (efa == rdata->efa_act)
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
fflag |= VFLAG_FACE_ACTIVE;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
if (BM_elem_flag_test(efa, BM_ELEM_SELECT))
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
fflag |= VFLAG_FACE_SELECTED;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Fix T56692: The edges are not highlighted in Mark Freestyle Edge This was not ported yet.
2018-09-05 15:42:32 +02:00
#ifdef WITH_FREESTYLE
BMesh *bm = rdata->edit_bmesh->bm;
Fix T56722: Crash - Entering mesh Edit Mode. Seriously...
2018-09-08 11:19:07 +02:00
if (CustomData_has_layer(&bm->pdata, CD_FREESTYLE_FACE)) {
Fix T56692: The edges are not highlighted in Mark Freestyle Edge This was not ported yet.
2018-09-05 15:42:32 +02:00
FreestyleFace *ffa = CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_FREESTYLE_FACE);
if (ffa->flag & FREESTYLE_FACE_MARK)
fflag |= VFLAG_FACE_FREESTYLE;
}
#endif
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
return fflag;
}
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
static void mesh_render_data_edge_flag(
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
const MeshRenderData *rdata, const BMEdge *eed,
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
EdgeDrawAttr *eattr)
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
{
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
eattr->e_flag |= VFLAG_EDGE_EXISTS;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
if (eed == rdata->eed_act)
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
eattr->e_flag |= VFLAG_EDGE_ACTIVE;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
if (BM_elem_flag_test(eed, BM_ELEM_SELECT))
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
eattr->e_flag |= VFLAG_EDGE_SELECTED;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
if (BM_elem_flag_test(eed, BM_ELEM_SEAM))
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
eattr->e_flag |= VFLAG_EDGE_SEAM;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
if (!BM_elem_flag_test(eed, BM_ELEM_SMOOTH))
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
eattr->e_flag |= VFLAG_EDGE_SHARP;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Fix T56692: The edges are not highlighted in Mark Freestyle Edge This was not ported yet.
2018-09-05 15:42:32 +02:00
#ifdef WITH_FREESTYLE
BMesh *bm = rdata->edit_bmesh->bm;
if (CustomData_has_layer(&bm->edata, CD_FREESTYLE_EDGE)) {
FreestyleEdge *fed = CustomData_bmesh_get(&bm->edata, eed->head.data, CD_FREESTYLE_EDGE);
if (fed->flag & FREESTYLE_EDGE_MARK)
eattr->e_flag |= VFLAG_EDGE_FREESTYLE;
}
#endif
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
/* Use a byte for value range */
if (rdata->cd.offset.crease != -1) {
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
float crease = BM_ELEM_CD_GET_FLOAT(eed, rdata->cd.offset.crease);
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
if (crease > 0) {
Fix T56692: The edges are not highlighted in Mark Freestyle Edge This was not ported yet.
2018-09-05 15:42:32 +02:00
eattr->crease = (uchar)(crease * 255.0f);
EditMode: remove edge-hash from MeshRenderData LoopTri's can access this data.
2017-04-12 13:42:27 +10:00
}
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
/* Use a byte for value range */
if (rdata->cd.offset.bweight != -1) {
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
float bweight = BM_ELEM_CD_GET_FLOAT(eed, rdata->cd.offset.bweight);
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
if (bweight > 0) {
Fix T56692: The edges are not highlighted in Mark Freestyle Edge This was not ported yet.
2018-09-05 15:42:32 +02:00
eattr->bweight = (uchar)(bweight * 255.0f);
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
}
}
}
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
static uchar mesh_render_data_vertex_flag(MeshRenderData *rdata, const BMVert *eve)
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
{
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
uchar vflag = 0;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
/* Current vertex */
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
if (eve == rdata->eve_act)
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
vflag |= VFLAG_VERTEX_ACTIVE;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
if (BM_elem_flag_test(eve, BM_ELEM_SELECT))
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
vflag |= VFLAG_VERTEX_SELECTED;
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
return vflag;
}
static void add_overlay_tri(
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
MeshRenderData *rdata, GPUVertBuf *vbo_pos, GPUVertBuf *vbo_nor, GPUVertBuf *vbo_data,
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
const uint pos_id, const uint vnor_id, const uint lnor_id, const uint data_id,
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
const BMLoop **bm_looptri, const int base_vert_idx)
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
{
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
uchar fflag;
uchar vflag;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (vbo_pos) {
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
/* 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 i = 0; i < 3; i++) {
int vidx = BM_elem_index_get(bm_looptri[i]->v);
const float *pos = rdata->edit_data->vertexCos[vidx];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo_pos, pos_id, base_vert_idx + i, pos);
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
}
}
else {
for (uint i = 0; i < 3; i++) {
const float *pos = bm_looptri[i]->v->co;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo_pos, pos_id, base_vert_idx + i, pos);
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
}
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
}
if (vbo_nor) {
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
/* TODO real loop normal */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUPackedNormal lnor = GPU_normal_convert_i10_v3(bm_looptri[0]->f->no);
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
for (uint i = 0; i < 3; i++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUPackedNormal vnor = GPU_normal_convert_i10_v3(bm_looptri[i]->v->no);
GPU_vertbuf_attr_set(vbo_nor, vnor_id, base_vert_idx + i, &vnor);
GPU_vertbuf_attr_set(vbo_nor, lnor_id, base_vert_idx + i, &lnor);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
}
if (vbo_data) {
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
fflag = mesh_render_data_looptri_flag(rdata, bm_looptri[0]->f);
uint i_prev = 1, i = 2;
for (uint i_next = 0; i_next < 3; i_next++) {
vflag = mesh_render_data_vertex_flag(rdata, bm_looptri[i]->v);
EdgeDrawAttr eattr = {0};
if (bm_looptri[i_next] == bm_looptri[i_prev]->prev) {
mesh_render_data_edge_flag(rdata, bm_looptri[i_next]->e, &eattr);
}
eattr.v_flag = fflag | vflag;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo_data, data_id, base_vert_idx + i, &eattr);
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
i_prev = i;
i = i_next;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
}
static void add_overlay_loose_edge(
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
MeshRenderData *rdata, GPUVertBuf *vbo_pos, GPUVertBuf *vbo_nor, GPUVertBuf *vbo_data,
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
const uint pos_id, const uint vnor_id, const uint data_id,
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
const BMEdge *eed, const int base_vert_idx)
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
{
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (vbo_pos) {
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
/* 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 i = 0; i < 2; i++) {
int vidx = BM_elem_index_get((&eed->v1)[i]);
const float *pos = rdata->edit_data->vertexCos[vidx];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo_pos, pos_id, base_vert_idx + i, pos);
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
}
}
else {
for (int i = 0; i < 2; ++i) {
const float *pos = (&eed->v1)[i]->co;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo_pos, pos_id, base_vert_idx + i, pos);
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
}
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (vbo_nor) {
for (int i = 0; i < 2; ++i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUPackedNormal vnor = GPU_normal_convert_i10_v3((&eed->v1)[i]->no);
GPU_vertbuf_attr_set(vbo_nor, vnor_id, base_vert_idx + i, &vnor);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
}
if (vbo_data) {
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
EdgeDrawAttr eattr = {0};
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
mesh_render_data_edge_flag(rdata, eed, &eattr);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
for (int i = 0; i < 2; ++i) {
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
eattr.v_flag = mesh_render_data_vertex_flag(rdata, (&eed->v1)[i]);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo_data, data_id, base_vert_idx + i, &eattr);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
}
static void add_overlay_loose_vert(
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
MeshRenderData *rdata, GPUVertBuf *vbo_pos, GPUVertBuf *vbo_nor, GPUVertBuf *vbo_data,
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
const uint pos_id, const uint vnor_id, const uint data_id,
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
const BMVert *eve, const int base_vert_idx)
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
{
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (vbo_pos) {
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
/* TODO(sybren): deduplicate this and all the other places it's pasted to in this file. */
if (rdata->edit_data && rdata->edit_data->vertexCos) {
int vidx = BM_elem_index_get(eve);
const float *pos = rdata->edit_data->vertexCos[vidx];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo_pos, pos_id, base_vert_idx, pos);
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
}
else {
const float *pos = eve->co;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo_pos, pos_id, base_vert_idx, pos);
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
}
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
if (vbo_nor) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUPackedNormal vnor = GPU_normal_convert_i10_v3(eve->no);
GPU_vertbuf_attr_set(vbo_nor, vnor_id, base_vert_idx, &vnor);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
if (vbo_data) {
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
uchar vflag[4] = {0, 0, 0, 0};
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
vflag[0] = mesh_render_data_vertex_flag(rdata, eve);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo_data, data_id, base_vert_idx, vflag);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
}
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
/** \} */
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
/* ---------------------------------------------------------------------- */
/** \name Vertex Group Selection
* \{ */
/** Reset the selection structure, deallocating heap memory as appropriate. */
void DRW_vweight_selection_clear(struct VertexWeightSelection *sel)
{
MEM_SAFE_FREE(sel->defgroup_sel);
memset(sel, 0, sizeof(VertexWeightSelection));
sel->defgroup_active = -1;
}
/** Copy selection data from one structure to another, including heap memory. */
void DRW_vweight_selection_copy(struct VertexWeightSelection *sel, const struct VertexWeightSelection *src)
{
MEM_SAFE_FREE(sel->defgroup_sel);
memcpy(sel, src, sizeof(VertexWeightSelection));
if (src->defgroup_sel) {
sel->defgroup_sel = MEM_dupallocN(src->defgroup_sel);
}
}
/** Compare two selection structures. */
bool DRW_vweight_selection_compare(const struct VertexWeightSelection *a, const struct VertexWeightSelection *b)
{
return a->defgroup_active == b->defgroup_active &&
a->defgroup_tot == b->defgroup_tot &&
a->flags == b->flags &&
a->alert_mode == b->alert_mode &&
a->defgroup_sel_tot == b->defgroup_sel_tot &&
((!a->defgroup_sel && !b->defgroup_sel) ||
(a->defgroup_sel && b->defgroup_sel &&
memcmp(a->defgroup_sel, b->defgroup_sel, a->defgroup_tot * sizeof(bool)) == 0));
}
/** \} */
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
/* ---------------------------------------------------------------------- */
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
/** \name Mesh GPUBatch Cache
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
* \{ */
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
typedef struct MeshBatchCache {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *pos_in_order;
GPUIndexBuf *edges_in_order;
GPUIndexBuf *edges_adjacency; /* Store edges with adjacent vertices. */
GPUIndexBuf *triangles_in_order;
GPUIndexBuf *ledges_in_order;
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
GPUTexture *pos_in_order_tx; /* Depending on pos_in_order */
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *all_verts;
GPUBatch *all_edges;
GPUBatch *all_triangles;
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *pos_with_normals;
GPUVertBuf *tri_aligned_uv; /* Active UV layer (mloopuv) */
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
/**
* Other uses are all positions or loose elements.
* This stores all visible elements, needed for selection.
*/
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *ed_fcenter_pos_with_nor_and_sel;
GPUVertBuf *ed_edge_pos;
GPUVertBuf *ed_vert_pos;
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *triangles_with_normals;
GPUBatch *ledges_with_normals;
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
/* Skip hidden (depending on paint select mode) */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *triangles_with_weights;
GPUBatch *triangles_with_vert_colors;
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
/* Always skip hidden */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *triangles_with_select_mask;
GPUBatch *triangles_with_select_id;
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
uint triangles_with_select_id_offset;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *facedot_with_select_id; /* shares vbo with 'overlay_facedots' */
GPUBatch *edges_with_select_id;
GPUBatch *verts_with_select_id;
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
uint facedot_with_select_id_offset;
uint edges_with_select_id_offset;
uint verts_with_select_id_offset;
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *points_with_normals;
GPUBatch *fancy_edges; /* owns its vertex buffer (not shared) */
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *edge_detection;
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *edges_face_overlay;
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
GPUTexture *edges_face_overlay_tx;
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
int edges_face_overlay_tri_count; /* Number of tri in edges_face_overlay(_adj)_tx */
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
/* Maybe have shaded_triangles_data split into pos_nor and uv_tangent
Cleanup: typos
2018-07-03 09:08:00 +02:00
* to minimize data transfer for skinned mesh. */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertFormat shaded_triangles_format;
GPUVertBuf *shaded_triangles_data;
GPUIndexBuf **shaded_triangles_in_order;
GPUBatch **shaded_triangles;
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
/* Texture Paint.*/
/* per-texture batch */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch **texpaint_triangles;
GPUBatch *texpaint_triangles_single;
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
/* Edit Cage Mesh buffers */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *ed_tri_pos;
GPUVertBuf *ed_tri_nor; /* LoopNor, VertNor */
GPUVertBuf *ed_tri_data;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *ed_ledge_pos;
GPUVertBuf *ed_ledge_nor; /* VertNor */
GPUVertBuf *ed_ledge_data;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *ed_lvert_pos;
GPUVertBuf *ed_lvert_nor; /* VertNor */
GPUVertBuf *ed_lvert_data;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *overlay_triangles;
GPUBatch *overlay_triangles_nor; /* GPU_PRIM_POINTS */
GPUBatch *overlay_loose_edges;
GPUBatch *overlay_loose_edges_nor; /* GPU_PRIM_POINTS */
GPUBatch *overlay_loose_verts;
GPUBatch *overlay_facedots;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *overlay_weight_faces;
GPUBatch *overlay_weight_verts;
GPUBatch *overlay_paint_edges;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
/* arrays of bool uniform names (and value) that will be use to
* set srgb conversion for auto attribs.*/
char *auto_layer_names;
int *auto_layer_is_srgb;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
int auto_layer_len;
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
Use the ultimate depsgraph callback function Note: when in edit mode this depsgraph update is not being called. We are using DerivedMesh in those cases, so it is fine. I would like to investigate this though
2017-01-26 18:56:52 +01:00
/* settings to determine if cache is invalid */
Cleanup: naming for mesh dirty flags - NOCHECK -> ALL - ALL -> MAYBE_ALL Where 'MAYBE_ALL' checks to see if the mesh has changed. This is clearer that `BKE_MESH_BATCH_DIRTY_ALL` is dirty and going to be updated without any guess-work.
2017-08-22 22:04:40 +10:00
bool is_maybe_dirty;
bool is_dirty; /* Instantly invalidates cache, skipping mesh check */
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
int edge_len;
int tri_len;
int poly_len;
int vert_len;
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
int mat_len;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
bool is_editmode;
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
VertexWeightSelection vertex_weight_selection;
DwM: Option to use final material over mode shading Support using full material shading in sculpt & paint modes mode. Access 'Full Shading' from the display panel when in paint modes.
2017-07-13 00:27:06 +10:00
/* XXX, only keep for as long as sculpt mode uses shaded drawing. */
bool is_sculpt_points_tag;
Workbench: Shadow: Use depth fail method for manifold objects. Since this method have no failure case for manifold objects, use it.
2018-05-21 13:21:26 +02:00
/* Valid only if edges_adjacency is up to date. */
bool is_manifold;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
} MeshBatchCache;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
/* GPUBatch cache management. */
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
static bool mesh_batch_cache_valid(Mesh *me)
{
Mesh: move runtime members to own struct
2018-05-02 15:47:45 +02:00
MeshBatchCache *cache = me->runtime.batch_cache;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
if (cache == NULL) {
return false;
}
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
/* XXX find another place for this */
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
if (cache->mat_len != mesh_render_mat_len_get(me)) {
Cleanup: naming for mesh dirty flags - NOCHECK -> ALL - ALL -> MAYBE_ALL Where 'MAYBE_ALL' checks to see if the mesh has changed. This is clearer that `BKE_MESH_BATCH_DIRTY_ALL` is dirty and going to be updated without any guess-work.
2017-08-22 22:04:40 +10:00
cache->is_maybe_dirty = true;
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
}
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
if (cache->is_editmode != (me->edit_btmesh != NULL)) {
return false;
}
Cleanup: naming for mesh dirty flags - NOCHECK -> ALL - ALL -> MAYBE_ALL Where 'MAYBE_ALL' checks to see if the mesh has changed. This is clearer that `BKE_MESH_BATCH_DIRTY_ALL` is dirty and going to be updated without any guess-work.
2017-08-22 22:04:40 +10:00
if (cache->is_dirty) {
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
return false;
}
Cleanup: naming for mesh dirty flags - NOCHECK -> ALL - ALL -> MAYBE_ALL Where 'MAYBE_ALL' checks to see if the mesh has changed. This is clearer that `BKE_MESH_BATCH_DIRTY_ALL` is dirty and going to be updated without any guess-work.
2017-08-22 22:04:40 +10:00
if (cache->is_maybe_dirty == false) {
Use the ultimate depsgraph callback function Note: when in edit mode this depsgraph update is not being called. We are using DerivedMesh in those cases, so it is fine. I would like to investigate this though
2017-01-26 18:56:52 +01:00
return true;
}
else {
Mesh batch caches update from depsgraph We no longer need to rely on Derived mesh flag since the mesh is properly flushed from the depsgraph
2017-01-26 19:08:27 +01:00
if (cache->is_editmode) {
return false;
}
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
else if ((cache->vert_len != mesh_render_verts_len_get(me)) ||
(cache->edge_len != mesh_render_edges_len_get(me)) ||
(cache->tri_len != mesh_render_looptri_len_get(me)) ||
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
(cache->poly_len != mesh_render_polys_len_get(me)) ||
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
(cache->mat_len != mesh_render_mat_len_get(me)))
Use the ultimate depsgraph callback function Note: when in edit mode this depsgraph update is not being called. We are using DerivedMesh in those cases, so it is fine. I would like to investigate this though
2017-01-26 18:56:52 +01:00
{
return false;
}
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
return true;
}
static void mesh_batch_cache_init(Mesh *me)
{
Mesh: move runtime members to own struct
2018-05-02 15:47:45 +02:00
MeshBatchCache *cache = me->runtime.batch_cache;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
if (!cache) {
Mesh: move runtime members to own struct
2018-05-02 15:47:45 +02:00
cache = me->runtime.batch_cache = MEM_callocN(sizeof(*cache), __func__);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
else {
memset(cache, 0, sizeof(*cache));
}
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
cache->is_editmode = me->edit_btmesh != NULL;
Mesh batch caches update from depsgraph We no longer need to rely on Derived mesh flag since the mesh is properly flushed from the depsgraph
2017-01-26 19:08:27 +01:00
if (cache->is_editmode == false) {
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
cache->edge_len = mesh_render_edges_len_get(me);
cache->tri_len = mesh_render_looptri_len_get(me);
cache->poly_len = mesh_render_polys_len_get(me);
cache->vert_len = mesh_render_verts_len_get(me);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Use the ultimate depsgraph callback function Note: when in edit mode this depsgraph update is not being called. We are using DerivedMesh in those cases, so it is fine. I would like to investigate this though
2017-01-26 18:56:52 +01:00
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
cache->mat_len = mesh_render_mat_len_get(me);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
Cleanup: naming for mesh dirty flags - NOCHECK -> ALL - ALL -> MAYBE_ALL Where 'MAYBE_ALL' checks to see if the mesh has changed. This is clearer that `BKE_MESH_BATCH_DIRTY_ALL` is dirty and going to be updated without any guess-work.
2017-08-22 22:04:40 +10:00
cache->is_maybe_dirty = false;
Use the ultimate depsgraph callback function Note: when in edit mode this depsgraph update is not being called. We are using DerivedMesh in those cases, so it is fine. I would like to investigate this though
2017-01-26 18:56:52 +01:00
cache->is_dirty = false;
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
DRW_vweight_selection_clear(&cache->vertex_weight_selection);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
static MeshBatchCache *mesh_batch_cache_get(Mesh *me)
{
if (!mesh_batch_cache_valid(me)) {
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
mesh_batch_cache_clear(me);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
mesh_batch_cache_init(me);
}
Mesh: move runtime members to own struct
2018-05-02 15:47:45 +02:00
return me->runtime.batch_cache;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
static void mesh_batch_cache_check_vertex_group(MeshBatchCache *cache, const VertexWeightSelection *vwsel)
Fix: missing cache invalidation when the active vertex group changed Reviewers: brecht Differential Revision: https://developer.blender.org/D3716
2018-09-21 16:19:34 +02:00
{
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
if (!DRW_vweight_selection_compare(&cache->vertex_weight_selection, vwsel)) {
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_weights);
DRW_vweight_selection_clear(&cache->vertex_weight_selection);
Fix: missing cache invalidation when the active vertex group changed Reviewers: brecht Differential Revision: https://developer.blender.org/D3716
2018-09-21 16:19:34 +02:00
}
}
DRW: Only trash UV and tangent data when using BKE_MESH_BATCH_DIRTY_SHADING This improves the problem encountered when animating materials on static meshes but does not fix the core issue. See T55326.
2018-09-19 19:36:25 +02:00
static void mesh_batch_cache_discard_shaded_tri(MeshBatchCache *cache)
{
GPU_VERTBUF_DISCARD_SAFE(cache->shaded_triangles_data);
if (cache->shaded_triangles_in_order) {
for (int i = 0; i < cache->mat_len; ++i) {
GPU_INDEXBUF_DISCARD_SAFE(cache->shaded_triangles_in_order[i]);
}
}
if (cache->shaded_triangles) {
for (int i = 0; i < cache->mat_len; ++i) {
GPU_BATCH_DISCARD_SAFE(cache->shaded_triangles[i]);
}
}
MEM_SAFE_FREE(cache->shaded_triangles_in_order);
MEM_SAFE_FREE(cache->shaded_triangles);
MEM_SAFE_FREE(cache->auto_layer_names);
MEM_SAFE_FREE(cache->auto_layer_is_srgb);
}
Rename: *_batch_cache_dirty > *_batch_cache_dirty_tag
2018-08-23 10:14:29 -03:00
void DRW_mesh_batch_cache_dirty_tag(Mesh *me, int mode)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Mesh: move runtime members to own struct
2018-05-02 15:47:45 +02:00
MeshBatchCache *cache = me->runtime.batch_cache;
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
if (cache == NULL) {
return;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
switch (mode) {
Cleanup: naming for mesh dirty flags - NOCHECK -> ALL - ALL -> MAYBE_ALL Where 'MAYBE_ALL' checks to see if the mesh has changed. This is clearer that `BKE_MESH_BATCH_DIRTY_ALL` is dirty and going to be updated without any guess-work.
2017-08-22 22:04:40 +10:00
case BKE_MESH_BATCH_DIRTY_MAYBE_ALL:
cache->is_maybe_dirty = true;
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
break;
case BKE_MESH_BATCH_DIRTY_SELECT:
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_VERTBUF_DISCARD_SAFE(cache->ed_tri_data);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_ledge_data);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_lvert_data);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_fcenter_pos_with_nor_and_sel); /* Contains select flag */
GPU_VERTBUF_DISCARD_SAFE(cache->ed_edge_pos);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_vert_pos);
GPU_BATCH_DISCARD_SAFE(cache->overlay_triangles);
GPU_BATCH_DISCARD_SAFE(cache->overlay_loose_verts);
GPU_BATCH_DISCARD_SAFE(cache->overlay_loose_edges);
GPU_BATCH_DISCARD_SAFE(cache->overlay_facedots);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
/* Edit mode selection. */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->facedot_with_select_id);
GPU_BATCH_DISCARD_SAFE(cache->edges_with_select_id);
GPU_BATCH_DISCARD_SAFE(cache->verts_with_select_id);
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
break;
Cleanup: naming for mesh dirty flags - NOCHECK -> ALL - ALL -> MAYBE_ALL Where 'MAYBE_ALL' checks to see if the mesh has changed. This is clearer that `BKE_MESH_BATCH_DIRTY_ALL` is dirty and going to be updated without any guess-work.
2017-08-22 22:04:40 +10:00
case BKE_MESH_BATCH_DIRTY_ALL:
cache->is_dirty = true;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
break;
Fix T51931: VBO not updating when UVs are added to shader node tree UVs need specific data in the VBO, which is not computed unless the shaders assigned to the mesh actually use UVs. When adding UVs to the shader, the VBOs were not being recomputed to include the required data. This adds a DEG relation between the shader and the mesh, and recomputes the required data if the shader changed. Thanks Sergey, for all the DEG stuff...
2017-07-10 14:43:57 +02:00
case BKE_MESH_BATCH_DIRTY_SHADING:
DRW: Only trash UV and tangent data when using BKE_MESH_BATCH_DIRTY_SHADING This improves the problem encountered when animating materials on static meshes but does not fix the core issue. See T55326.
2018-09-19 19:36:25 +02:00
mesh_batch_cache_discard_shaded_tri(cache);
Fix T51931: VBO not updating when UVs are added to shader node tree UVs need specific data in the VBO, which is not computed unless the shaders assigned to the mesh actually use UVs. When adding UVs to the shader, the VBOs were not being recomputed to include the required data. This adds a DEG relation between the shader and the mesh, and recomputes the required data if the shader changed. Thanks Sergey, for all the DEG stuff...
2017-07-10 14:43:57 +02:00
break;
DwM: Option to use final material over mode shading Support using full material shading in sculpt & paint modes mode. Access 'Full Shading' from the display panel when in paint modes.
2017-07-13 00:27:06 +10:00
case BKE_MESH_BATCH_DIRTY_SCULPT_COORDS:
cache->is_sculpt_points_tag = true;
break;
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
default:
BLI_assert(0);
Edit Mode overlay: Update cache on selection
2017-03-06 03:58:08 +01:00
}
}
Mesh: Batch cache: Fix sculpt update issue. Old solution was to create a new vbo and copy it to the location of the old vbo hoping for the batches to update their vaos before drawing. The issue is that the new VAO caching is not updating the VAOs at all unless the shader interface changes. So unless we expand gawain to support updating of vertex buffers (in a better way than the current "dynamic" buffer) we need to delete every batch linked to the vbo we want to recreate. This solution might have performance implications.
2018-03-15 13:55:20 +01:00
/**
* This only clear the batches associated to the given vertex buffer.
**/
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static void mesh_batch_cache_clear_selective(Mesh *me, GPUVertBuf *vert)
Mesh: Batch cache: Fix sculpt update issue. Old solution was to create a new vbo and copy it to the location of the old vbo hoping for the batches to update their vaos before drawing. The issue is that the new VAO caching is not updating the VAOs at all unless the shader interface changes. So unless we expand gawain to support updating of vertex buffers (in a better way than the current "dynamic" buffer) we need to delete every batch linked to the vbo we want to recreate. This solution might have performance implications.
2018-03-15 13:55:20 +01:00
{
Mesh: move runtime members to own struct
2018-05-02 15:47:45 +02:00
MeshBatchCache *cache = me->runtime.batch_cache;
Mesh: Batch cache: Fix sculpt update issue. Old solution was to create a new vbo and copy it to the location of the old vbo hoping for the batches to update their vaos before drawing. The issue is that the new VAO caching is not updating the VAOs at all unless the shader interface changes. So unless we expand gawain to support updating of vertex buffers (in a better way than the current "dynamic" buffer) we need to delete every batch linked to the vbo we want to recreate. This solution might have performance implications.
2018-03-15 13:55:20 +01:00
if (!cache) {
return;
}
BLI_assert(vert != NULL);
if (cache->pos_with_normals == vert) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_normals);
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_weights);
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_vert_colors);
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_select_id);
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_select_mask);
GPU_BATCH_DISCARD_SAFE(cache->points_with_normals);
GPU_BATCH_DISCARD_SAFE(cache->ledges_with_normals);
Mesh: Batch cache: Fix sculpt update issue. Old solution was to create a new vbo and copy it to the location of the old vbo hoping for the batches to update their vaos before drawing. The issue is that the new VAO caching is not updating the VAOs at all unless the shader interface changes. So unless we expand gawain to support updating of vertex buffers (in a better way than the current "dynamic" buffer) we need to delete every batch linked to the vbo we want to recreate. This solution might have performance implications.
2018-03-15 13:55:20 +01:00
if (cache->shaded_triangles) {
for (int i = 0; i < cache->mat_len; ++i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->shaded_triangles[i]);
Mesh: Batch cache: Fix sculpt update issue. Old solution was to create a new vbo and copy it to the location of the old vbo hoping for the batches to update their vaos before drawing. The issue is that the new VAO caching is not updating the VAOs at all unless the shader interface changes. So unless we expand gawain to support updating of vertex buffers (in a better way than the current "dynamic" buffer) we need to delete every batch linked to the vbo we want to recreate. This solution might have performance implications.
2018-03-15 13:55:20 +01:00
}
}
MEM_SAFE_FREE(cache->shaded_triangles);
if (cache->texpaint_triangles) {
for (int i = 0; i < cache->mat_len; ++i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->texpaint_triangles[i]);
Mesh: Batch cache: Fix sculpt update issue. Old solution was to create a new vbo and copy it to the location of the old vbo hoping for the batches to update their vaos before drawing. The issue is that the new VAO caching is not updating the VAOs at all unless the shader interface changes. So unless we expand gawain to support updating of vertex buffers (in a better way than the current "dynamic" buffer) we need to delete every batch linked to the vbo we want to recreate. This solution might have performance implications.
2018-03-15 13:55:20 +01:00
}
}
MEM_SAFE_FREE(cache->texpaint_triangles);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->texpaint_triangles_single);
Mesh: Batch cache: Fix sculpt update issue. Old solution was to create a new vbo and copy it to the location of the old vbo hoping for the batches to update their vaos before drawing. The issue is that the new VAO caching is not updating the VAOs at all unless the shader interface changes. So unless we expand gawain to support updating of vertex buffers (in a better way than the current "dynamic" buffer) we need to delete every batch linked to the vbo we want to recreate. This solution might have performance implications.
2018-03-15 13:55:20 +01:00
}
/* TODO: add the other ones if needed. */
else {
/* Does not match any vertbuf in the batch cache! */
BLI_assert(0);
}
}
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
static void mesh_batch_cache_clear(Mesh *me)
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
{
Mesh: move runtime members to own struct
2018-05-02 15:47:45 +02:00
MeshBatchCache *cache = me->runtime.batch_cache;
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
if (!cache) {
return;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->all_verts);
GPU_BATCH_DISCARD_SAFE(cache->all_edges);
GPU_BATCH_DISCARD_SAFE(cache->all_triangles);
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_VERTBUF_DISCARD_SAFE(cache->pos_in_order);
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
DRW_TEXTURE_FREE_SAFE(cache->pos_in_order_tx);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_INDEXBUF_DISCARD_SAFE(cache->edges_in_order);
GPU_INDEXBUF_DISCARD_SAFE(cache->triangles_in_order);
GPU_INDEXBUF_DISCARD_SAFE(cache->ledges_in_order);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_tri_pos);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_tri_nor);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_tri_data);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_ledge_pos);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_ledge_nor);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_ledge_data);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_lvert_pos);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_lvert_nor);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_lvert_data);
GPU_BATCH_DISCARD_SAFE(cache->overlay_triangles);
GPU_BATCH_DISCARD_SAFE(cache->overlay_triangles_nor);
GPU_BATCH_DISCARD_SAFE(cache->overlay_loose_verts);
GPU_BATCH_DISCARD_SAFE(cache->overlay_loose_edges);
GPU_BATCH_DISCARD_SAFE(cache->overlay_loose_edges_nor);
GPU_BATCH_DISCARD_SAFE(cache->overlay_weight_faces);
GPU_BATCH_DISCARD_SAFE(cache->overlay_weight_verts);
GPU_BATCH_DISCARD_SAFE(cache->overlay_paint_edges);
GPU_BATCH_DISCARD_SAFE(cache->overlay_facedots);
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_normals);
GPU_BATCH_DISCARD_SAFE(cache->points_with_normals);
GPU_BATCH_DISCARD_SAFE(cache->ledges_with_normals);
GPU_VERTBUF_DISCARD_SAFE(cache->pos_with_normals);
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_weights);
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_vert_colors);
GPU_VERTBUF_DISCARD_SAFE(cache->tri_aligned_uv);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_fcenter_pos_with_nor_and_sel);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_edge_pos);
GPU_VERTBUF_DISCARD_SAFE(cache->ed_vert_pos);
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_select_mask);
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_select_id);
GPU_BATCH_DISCARD_SAFE(cache->facedot_with_select_id);
GPU_BATCH_DISCARD_SAFE(cache->edges_with_select_id);
GPU_BATCH_DISCARD_SAFE(cache->verts_with_select_id);
GPU_BATCH_DISCARD_SAFE(cache->fancy_edges);
GPU_INDEXBUF_DISCARD_SAFE(cache->edges_adjacency);
GPU_BATCH_DISCARD_SAFE(cache->edge_detection);
GPU_VERTBUF_DISCARD_SAFE(cache->edges_face_overlay);
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
DRW_TEXTURE_FREE_SAFE(cache->edges_face_overlay_tx);
DRW: Only trash UV and tangent data when using BKE_MESH_BATCH_DIRTY_SHADING This improves the problem encountered when animating materials on static meshes but does not fix the core issue. See T55326.
2018-09-19 19:36:25 +02:00
mesh_batch_cache_discard_shaded_tri(cache);
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
if (cache->texpaint_triangles) {
for (int i = 0; i < cache->mat_len; ++i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->texpaint_triangles[i]);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
}
}
MEM_SAFE_FREE(cache->texpaint_triangles);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->texpaint_triangles_single);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
DRW_vweight_selection_clear(&cache->vertex_weight_selection);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
void DRW_mesh_batch_cache_free(Mesh *me)
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
{
Cleanup: move draw-cache creation from BKE to DRW Creating draw-cache should only ever be used by the draw-manager.
2017-04-21 21:14:11 +10:00
mesh_batch_cache_clear(me);
Mesh: move runtime members to own struct
2018-05-02 15:47:45 +02:00
MEM_SAFE_FREE(me->runtime.batch_cache);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
/* GPUBatch cache usage. */
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_tri_shading_data(MeshRenderData *rdata, MeshBatchCache *cache)
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
Cleanup: minor edits
2017-05-22 16:20:54 +10:00
#define USE_COMP_MESH_DATA
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
if (cache->shaded_triangles_data == NULL) {
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
const uint uv_len = rdata->cd.layers.uv_len;
const uint tangent_len = rdata->cd.layers.tangent_len;
const uint vcol_len = rdata->cd.layers.vcol_len;
const uint layers_combined_len = uv_len + vcol_len + tangent_len;
DRW: Fix crash when new shader requires 0 customdata layers It was using last cache->auto_layer_len which led to a buffer overflow.
2018-09-19 20:02:03 +02:00
cache->auto_layer_len = 0;
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
if (layers_combined_len == 0) {
Mesh Batch Cache: get rid of the ORCO VBO data, and reconstruct it in shader. With only one MADD instruction we recover the orco data and reduce both the storage and the fetching cost of an attrib layer.
2017-05-15 16:12:51 +02:00
return NULL;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertFormat *format = &cache->shaded_triangles_format;
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertformat_clear(format);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
/* initialize vertex format */
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
uint *layers_combined_id = BLI_array_alloca(layers_combined_id, layers_combined_len);
uint *uv_id = layers_combined_id;
uint *tangent_id = uv_id + uv_len;
uint *vcol_id = tangent_id + tangent_len;
/* Not needed, just for sanity. */
if (uv_len == 0) { uv_id = NULL; }
if (tangent_len == 0) { tangent_id = NULL; }
if (vcol_len == 0) { vcol_id = NULL; }
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
/* Count number of auto layer and allocate big enough name buffer. */
uint auto_names_len = 0;
uint auto_ofs = 0;
uint auto_id = 0;
for (uint i = 0; i < uv_len; i++) {
const char *attrib_name = mesh_render_data_uv_auto_layer_uuid_get(rdata, i);
auto_names_len += strlen(attrib_name) + 2; /* include null terminator and b prefix. */
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
cache->auto_layer_len++;
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
}
for (uint i = 0; i < vcol_len; i++) {
if (rdata->cd.layers.auto_vcol[i]) {
const char *attrib_name = mesh_render_data_vcol_auto_layer_uuid_get(rdata, i);
auto_names_len += strlen(attrib_name) + 2; /* include null terminator and b prefix. */
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
cache->auto_layer_len++;
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
}
}
auto_names_len += 1; /* add an ultimate '\0' terminator */
cache->auto_layer_names = MEM_callocN(auto_names_len * sizeof(char), "Auto layer name buf");
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
cache->auto_layer_is_srgb = MEM_mallocN(cache->auto_layer_len * sizeof(int), "Auto layer value buf");
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
for (uint i = 0; i < uv_len; i++) {
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
/* UV */
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
const char *attrib_name = mesh_render_data_uv_layer_uuid_get(rdata, i);
Mesh Batch Cache: Use compressed format. We don't compress UV by default because that would mean restricting them to [0, 1] Leaving all other code for later settings switch.
2017-05-15 17:55:02 +02:00
#if defined(USE_COMP_MESH_DATA) && 0 /* these are clamped. Maybe use them as an option in the future */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
uv_id[i] = GPU_vertformat_attr_add(format, attrib_name, GPU_COMP_I16, 2, GPU_FETCH_INT_TO_FLOAT_UNIT);
Mesh Batch Cache: Define Compressed format for shading data. Deactivated by default. All shading attribs can be packed to take less VRAM at the cost of precision (not noticable in this case). UVs can be packed into I16 but that limits their positions into the [-1, +1] range. This could be a setting option in the future.
2017-05-14 16:13:00 +02:00
#else
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
uv_id[i] = GPU_vertformat_attr_add(format, attrib_name, GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
Mesh Batch Cache: Define Compressed format for shading data. Deactivated by default. All shading attribs can be packed to take less VRAM at the cost of precision (not noticable in this case). UVs can be packed into I16 but that limits their positions into the [-1, +1] range. This could be a setting option in the future.
2017-05-14 16:13:00 +02:00
#endif
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
/* Auto Name */
Cleanup: rename layer-names -> layer-uuid These names are created from a hash, don't confuse with actual layer names.
2017-05-09 10:38:52 +10:00
attrib_name = mesh_render_data_uv_auto_layer_uuid_get(rdata, i);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertformat_alias_add(format, attrib_name);
Mesh Batch Cache: Optimization, make use of gawain attrib aliases.
2017-05-13 22:53:11 +02:00
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
/* +1 include null terminator. */
Cleanup: whitespace, long lines, duplicate include
2018-05-26 10:41:25 +02:00
auto_ofs += 1 + BLI_snprintf_rlen(
cache->auto_layer_names + auto_ofs, auto_names_len - auto_ofs, "b%s", attrib_name);
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
cache->auto_layer_is_srgb[auto_id++] = 0; /* tag as not srgb */
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
if (i == rdata->cd.layers.uv_active) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertformat_alias_add(format, "u");
Mesh Batch Cache: Optimization, make use of gawain attrib aliases.
2017-05-13 22:53:11 +02:00
}
DWM: separate tangents from UV conversion Prepare for different number of UV/Tangent layers.
2017-06-28 09:55:40 +10:00
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
for (uint i = 0; i < tangent_len; i++) {
const char *attrib_name = mesh_render_data_tangent_layer_uuid_get(rdata, i);
GPUMaterial: Add support for tangent node.
2017-05-18 14:29:57 +02:00
/* WATCH IT : only specifying 3 component instead of 4 (4th is sign).
* That may cause some problem but I could not make it to fail (fclem) */
Mesh Batch Cache: Define Compressed format for shading data. Deactivated by default. All shading attribs can be packed to take less VRAM at the cost of precision (not noticable in this case). UVs can be packed into I16 but that limits their positions into the [-1, +1] range. This could be a setting option in the future.
2017-05-14 16:13:00 +02:00
#ifdef USE_COMP_MESH_DATA
Gawain: promote 10_10_10 to first-class vertex format This format is part of OpenGL 3.3, and one of the reasons for choosing 3.3 over 3.2. Instead of checking #if USE_10_10_10 just use it wherever needed.
2017-05-21 15:59:34 -04:00
/* Tangents need more precision than 10_10_10 */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
tangent_id[i] = GPU_vertformat_attr_add(format, attrib_name, GPU_COMP_I16, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
Mesh Batch Cache: Define Compressed format for shading data. Deactivated by default. All shading attribs can be packed to take less VRAM at the cost of precision (not noticable in this case). UVs can be packed into I16 but that limits their positions into the [-1, +1] range. This could be a setting option in the future.
2017-05-14 16:13:00 +02:00
#else
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
tangent_id[i] = GPU_vertformat_attr_add(format, attrib_name, GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
Mesh Batch Cache: Define Compressed format for shading data. Deactivated by default. All shading attribs can be packed to take less VRAM at the cost of precision (not noticable in this case). UVs can be packed into I16 but that limits their positions into the [-1, +1] range. This could be a setting option in the future.
2017-05-14 16:13:00 +02:00
#endif
Mesh Batch Cache: Optimization, make use of gawain attrib aliases.
2017-05-13 22:53:11 +02:00
DWM: separate tangents from UV conversion Prepare for different number of UV/Tangent layers.
2017-06-28 09:55:40 +10:00
if (i == rdata->cd.layers.tangent_active) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertformat_alias_add(format, "t");
Mesh Batch Cache: Optimization, make use of gawain attrib aliases.
2017-05-13 22:53:11 +02:00
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
for (uint i = 0; i < vcol_len; i++) {
const char *attrib_name = mesh_render_data_vcol_layer_uuid_get(rdata, i);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vcol_id[i] = GPU_vertformat_attr_add(format, attrib_name, GPU_COMP_U8, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
/* Auto layer */
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
if (rdata->cd.layers.auto_vcol[i]) {
Cleanup: rename layer-names -> layer-uuid These names are created from a hash, don't confuse with actual layer names.
2017-05-09 10:38:52 +10:00
attrib_name = mesh_render_data_vcol_auto_layer_uuid_get(rdata, i);
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertformat_alias_add(format, attrib_name);
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
/* +1 include null terminator. */
Cleanup: whitespace, long lines, duplicate include
2018-05-26 10:41:25 +02:00
auto_ofs += 1 + BLI_snprintf_rlen(
cache->auto_layer_names + auto_ofs, auto_names_len - auto_ofs, "b%s", attrib_name);
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
cache->auto_layer_is_srgb[auto_id++] = 1; /* tag as srgb */
Mesh Batch Cache: Optimization, make use of gawain attrib aliases.
2017-05-13 22:53:11 +02:00
}
Cleanup: move custom-data layers into a struct Changed because the values co-exist with active layers (Mesh.mloopuv, Mesh.mloopcol).
2017-05-22 17:21:22 +10:00
if (i == rdata->cd.layers.vcol_active) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertformat_alias_add(format, "c");
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
}
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
const uint tri_len = mesh_render_data_looptri_len_get(rdata);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = cache->shaded_triangles_data = GPU_vertbuf_create_with_format(format);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
const int vbo_len_capacity = tri_len * 3;
int vbo_len_used = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBufRaw *layers_combined_step = BLI_array_alloca(layers_combined_step, layers_combined_len);
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBufRaw *uv_step = layers_combined_step;
GPUVertBufRaw *tangent_step = uv_step + uv_len;
GPUVertBufRaw *vcol_step = tangent_step + tangent_len;
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
/* Not needed, just for sanity. */
if (uv_len == 0) { uv_step = NULL; }
if (tangent_len == 0) { tangent_step = NULL; }
if (vcol_len == 0) { vcol_step = NULL; }
for (uint i = 0; i < uv_len; i++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_get_raw_data(vbo, uv_id[i], &uv_step[i]);
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
}
for (uint i = 0; i < tangent_len; i++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_get_raw_data(vbo, tangent_id[i], &tangent_step[i]);
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
}
for (uint i = 0; i < vcol_len; i++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_get_raw_data(vbo, vcol_id[i], &vcol_step[i]);
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
/* TODO deduplicate all verts and make use of GPUIndexBuf in
Cleanup: use more generic naming Can be used by any user that needs faces split by materials.
2017-05-23 17:48:05 +10:00
* mesh_batch_cache_get_triangles_in_order_split_by_material. */
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
if (rdata->edit_bmesh) {
for (uint i = 0; i < tri_len; i++) {
const BMLoop **bm_looptri = (const BMLoop **)rdata->edit_bmesh->looptris[i];
if (BM_elem_flag_test(bm_looptri[0]->f, BM_ELEM_HIDDEN)) {
continue;
}
DWM: separate tangents from UV conversion Prepare for different number of UV/Tangent layers.
2017-06-28 09:55:40 +10:00
/* UVs */
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
for (uint j = 0; j < uv_len; j++) {
const uint layer_offset = rdata->cd.offset.uv[j];
for (uint t = 0; t < 3; t++) {
const float *elem = ((MLoopUV *)BM_ELEM_CD_GET_VOID_P(bm_looptri[t], layer_offset))->uv;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
copy_v2_v2(GPU_vertbuf_raw_step(&uv_step[j]), elem);
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
}
DWM: separate tangents from UV conversion Prepare for different number of UV/Tangent layers.
2017-06-28 09:55:40 +10:00
}
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
/* TANGENTs */
for (uint j = 0; j < tangent_len; j++) {
float (*layer_data)[4] = rdata->cd.layers.tangent[j];
for (uint t = 0; t < 3; t++) {
const float *elem = layer_data[BM_elem_index_get(bm_looptri[t])];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
normal_float_to_short_v3(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
}
}
/* VCOLs */
for (uint j = 0; j < vcol_len; j++) {
const uint layer_offset = rdata->cd.offset.vcol[j];
for (uint t = 0; t < 3; t++) {
const uchar *elem = &((MLoopCol *)BM_ELEM_CD_GET_VOID_P(bm_looptri[t], layer_offset))->r;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
copy_v3_v3_uchar(GPU_vertbuf_raw_step(&vcol_step[j]), elem);
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
}
}
}
}
else {
for (uint i = 0; i < tri_len; i++) {
const MLoopTri *mlt = &rdata->mlooptri[i];
DWM: separate tangents from UV conversion Prepare for different number of UV/Tangent layers.
2017-06-28 09:55:40 +10:00
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
/* UVs */
for (uint j = 0; j < uv_len; j++) {
const MLoopUV *layer_data = rdata->cd.layers.uv[j];
for (uint t = 0; t < 3; t++) {
const float *elem = layer_data[mlt->tri[t]].uv;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
copy_v2_v2(GPU_vertbuf_raw_step(&uv_step[j]), elem);
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
}
}
DWM: separate tangents from UV conversion Prepare for different number of UV/Tangent layers.
2017-06-28 09:55:40 +10:00
/* TANGENTs */
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
for (uint j = 0; j < tangent_len; j++) {
float (*layer_data)[4] = rdata->cd.layers.tangent[j];
for (uint t = 0; t < 3; t++) {
const float *elem = layer_data[mlt->tri[t]];
Mesh Batch Cache: Define Compressed format for shading data. Deactivated by default. All shading attribs can be packed to take less VRAM at the cost of precision (not noticable in this case). UVs can be packed into I16 but that limits their positions into the [-1, +1] range. This could be a setting option in the future.
2017-05-14 16:13:00 +02:00
#ifdef USE_COMP_MESH_DATA
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
normal_float_to_short_v3(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
Mesh Batch Cache: Define Compressed format for shading data. Deactivated by default. All shading attribs can be packed to take less VRAM at the cost of precision (not noticable in this case). UVs can be packed into I16 but that limits their positions into the [-1, +1] range. This could be a setting option in the future.
2017-05-14 16:13:00 +02:00
#else
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
copy_v3_v3(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
Mesh Batch Cache: Define Compressed format for shading data. Deactivated by default. All shading attribs can be packed to take less VRAM at the cost of precision (not noticable in this case). UVs can be packed into I16 but that limits their positions into the [-1, +1] range. This could be a setting option in the future.
2017-05-14 16:13:00 +02:00
#endif
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
/* VCOLs */
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
for (uint j = 0; j < vcol_len; j++) {
const MLoopCol *layer_data = rdata->cd.layers.vcol[j];
for (uint t = 0; t < 3; t++) {
const uchar *elem = &layer_data[mlt->tri[t]].r;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
copy_v3_v3_uchar(GPU_vertbuf_raw_step(&vcol_step[j]), elem);
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
}
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
}
}
Mesh Batch Cache: Add support for uv/vcol/tangent data layers. This is a bad implementation waiting for some improvement that are : - Gawain support for multiple names. -> will remove duplication of attribute alloc - Glsl safe name string escaping. -> will remove any risk of hash colision. Old glsl drawing was relying on attribute being choosen by DerivedMesh at drawing time. For this reason, we declare all possible attrib "name" for each data layer inside the batches. In the glsl code, we declare required data by type and name. Then Gawain only bind vbos if names correspond. This is way cleaner as we do not need to access the CD itself when drawing. One other problem is that the hash maybe 11 caracters long and rapidly overload gawain's attrib name buffer.
2017-05-01 17:58:15 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vbo_len_used = GPU_vertbuf_raw_used(&layers_combined_step[0]);
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
#ifndef NDEBUG
/* Check all layers are write aligned. */
if (layers_combined_len > 1) {
for (uint i = 1; i < layers_combined_len; i++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
BLI_assert(vbo_len_used == GPU_vertbuf_raw_used(&layers_combined_step[i]));
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
}
}
DwM: Use GWN_vertbuf_raw_* access for shading data Gives approx 14% speedup here.
2017-06-30 18:01:20 +10:00
#endif
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
if (vbo_len_capacity != vbo_len_used) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
}
}
Cleanup: minor edits
2017-05-22 16:20:54 +10:00
#undef USE_COMP_MESH_DATA
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
return cache->shaded_triangles_data;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_tri_uv_active(
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPUV));
Workbench: Fix crash editing in texture modes without uv layer When meshes has no uv layer, but has a texture assigned there was a uv layer allocated which was corrupt. When no uv layer is available now there won't be a vbo created. This might impact performance as the draw cache does not cache this result.
2018-06-28 10:38:00 +02:00
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
if (cache->tri_aligned_uv == NULL) {
Workbench: Fix crash editing in texture modes without uv layer When meshes has no uv layer, but has a texture assigned there was a uv layer allocated which was corrupt. When no uv layer is available now there won't be a vbo created. This might impact performance as the draw cache does not cache this result.
2018-06-28 10:38:00 +02:00
const MLoopUV *mloopuv = rdata->mloopuv;
if (mloopuv == NULL) {
return NULL;
}
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint vidx = 0;
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
static struct { uint uv; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.uv = GPU_vertformat_attr_add(&format, "uv", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
}
const int tri_len = mesh_render_data_looptri_len_get(rdata);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = cache->tri_aligned_uv = GPU_vertbuf_create_with_format(&format);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
const int vbo_len_capacity = tri_len * 3;
int vbo_len_used = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
Workbench: Enable Textures in Edit Mesh Mode Constructed UV out of BMesh data layers.
2018-05-15 08:56:45 +02:00
BMEditMesh *embm = rdata->edit_bmesh;
/* get uv's from active UVMap */
if (rdata->edit_bmesh) {
/* edit mode */
BMesh *bm = embm->bm;
const int layer_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
for (uint i = 0; i < tri_len; i++) {
const BMLoop **bm_looptri = (const BMLoop **)embm->looptris[i];
if (BM_elem_flag_test(bm_looptri[0]->f, BM_ELEM_HIDDEN)) {
continue;
}
for (uint t = 0; t < 3; t++) {
const BMLoop *loop = bm_looptri[t];
const int index = BM_elem_index_get(loop);
if (index != -1) {
const float *elem = ((MLoopUV *)BM_ELEM_CD_GET_VOID_P(loop, layer_offset))->uv;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.uv, vidx++, elem);
Workbench: Enable Textures in Edit Mesh Mode Constructed UV out of BMesh data layers.
2018-05-15 08:56:45 +02:00
}
}
}
}
else {
/* object mode */
for (int i = 0; i < tri_len; i++) {
const MLoopTri *mlt = &rdata->mlooptri[i];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.uv, vidx++, mloopuv[mlt->tri[0]].uv);
GPU_vertbuf_attr_set(vbo, attr_id.uv, vidx++, mloopuv[mlt->tri[1]].uv);
GPU_vertbuf_attr_set(vbo, attr_id.uv, vidx++, mloopuv[mlt->tri[2]].uv);
Workbench: Enable Textures in Edit Mesh Mode Constructed UV out of BMesh data layers.
2018-05-15 08:56:45 +02:00
}
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
}
Workbench: Enable Textures in Edit Mesh Mode Constructed UV out of BMesh data layers.
2018-05-15 08:56:45 +02:00
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
vbo_len_used = vidx;
BLI_assert(vbo_len_capacity == vbo_len_used);
Fix warnings in draw_cache_impl files
2017-06-29 15:46:00 +02:00
UNUSED_VARS_NDEBUG(vbo_len_used);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
}
return cache->tri_aligned_uv;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_tri_pos_and_normals_ex(
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
MeshRenderData *rdata, const bool use_hide,
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf **r_vbo)
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
if (*r_vbo == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
static struct { uint pos, nor; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
attr_id.nor = GPU_vertformat_attr_add(&format, "nor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
}
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
const int tri_len = mesh_render_data_looptri_len_get(rdata);
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = *r_vbo = GPU_vertbuf_create_with_format(&format);
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
const int vbo_len_capacity = tri_len * 3;
int vbo_len_used = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBufRaw pos_step, nor_step;
GPU_vertbuf_attr_get_raw_data(vbo, attr_id.pos, &pos_step);
GPU_vertbuf_attr_get_raw_data(vbo, attr_id.nor, &nor_step);
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
float (*lnors)[3] = rdata->loop_normals;
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
if (rdata->edit_bmesh) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUPackedNormal *pnors_pack, *vnors_pack;
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
if (lnors == NULL) {
mesh_render_data_ensure_poly_normals_pack(rdata);
mesh_render_data_ensure_vert_normals_pack(rdata);
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
pnors_pack = rdata->poly_normals_pack;
vnors_pack = rdata->vert_normals_pack;
}
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
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;
}
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
if (lnors) {
for (uint t = 0; t < 3; t++) {
const float *nor = lnors[BM_elem_index_get(bm_looptri[t])];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
*((GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step)) = GPU_normal_convert_i10_v3(nor);
Fix T51604: Support Auto-Smooth in Edit-Mesh and allocate loop_normals in MeshRenderData instead of CustomData Differential Revision: D2907
2017-11-06 14:14:07 -02:00
}
}
else if (BM_elem_flag_test(bm_face, BM_ELEM_SMOOTH)) {
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
for (uint t = 0; t < 3; t++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
*((GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step)) = vnors_pack[BM_elem_index_get(bm_looptri[t]->v)];
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
}
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
}
else {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
const GPUPackedNormal *snor_pack = &pnors_pack[BM_elem_index_get(bm_face)];
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
for (uint t = 0; t < 3; t++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
*((GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step)) = *snor_pack;
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
}
}
Gawain: promote 10_10_10 to first-class vertex format This format is part of OpenGL 3.3, and one of the reasons for choosing 3.3 over 3.2. Instead of checking #if USE_10_10_10 just use it wherever needed.
2017-05-21 15:59:34 -04:00
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
/* 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];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), pos);
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
}
}
else {
for (uint t = 0; t < 3; t++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), bm_looptri[t]->v->co);
Modifiers: Simple Deform & Build, DerivedMesh → Mesh This commit introduces `EditMeshData`. The fields in this struct are extracted from `EditDerivedBMesh` into their own struct `EditMeshData`, which can then also be used by the `Mesh` struct. This allows passing deformed vertices efficiently to the draw routines. The modifier code constructs a new Mesh instead of writing to ob->data; even when ob->data is a CoW copy, it can still be used by different objects and thus shouldn't be modified by a modifier.
2018-04-19 11:03:58 +02:00
}
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
}
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
}
}
else {
Mesh Auto-Smooth Split Normal Support From D2906 with few changes
2017-10-31 15:15:14 -02:00
if (lnors == NULL) {
/* Use normals from vertex. */
mesh_render_data_ensure_poly_normals_pack(rdata);
}
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
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,
};
Mesh Auto-Smooth Split Normal Support From D2906 with few changes
2017-10-31 15:15:14 -02:00
if (lnors) {
for (uint t = 0; t < 3; t++) {
const float *nor = lnors[mlt->tri[t]];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
*((GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step)) = GPU_normal_convert_i10_v3(nor);
Mesh Auto-Smooth Split Normal Support From D2906 with few changes
2017-10-31 15:15:14 -02:00
}
}
else if (mp->flag & ME_SMOOTH) {
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
for (uint t = 0; t < 3; t++) {
const MVert *mv = &rdata->mvert[vtri[t]];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
*((GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step)) = GPU_normal_convert_i10_s3(mv->no);
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
}
}
else {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
const GPUPackedNormal *pnors_pack = &rdata->poly_normals_pack[mlt->poly];
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
for (uint t = 0; t < 3; t++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
*((GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step)) = *pnors_pack;
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
}
}
for (uint t = 0; t < 3; t++) {
const MVert *mv = &rdata->mvert[vtri[t]];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), mv->co);
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
}
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
}
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
}
DwM: optimize mesh batch conversion - Replace GWN_vertbuf_attr_set with Gwn_VertBufRaw & GWN_vertbuf_raw_step to avoid intermediate copy. - Avoid extra conversion step with: float[3] -> short[3] -> Gwn_PackedNormal. We can skip the short[3]. Gives approx 6% speedup here.
2017-06-29 20:11:16 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vbo_len_used = GPU_vertbuf_raw_used(&pos_step);
BLI_assert(vbo_len_used == GPU_vertbuf_raw_used(&nor_step));
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
if (vbo_len_capacity != vbo_len_used) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
}
}
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
return *r_vbo;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_tri_pos_and_normals(
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
return mesh_batch_cache_get_tri_pos_and_normals_ex(
rdata, false,
&cache->pos_with_normals);
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_create_tri_pos_and_normals_visible_only(
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
MeshRenderData *rdata)
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
{
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_dummy = NULL;
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
return mesh_batch_cache_get_tri_pos_and_normals_ex(
rdata, true,
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
&vbo_dummy);
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
}
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_facedot_pos_with_normals_and_flag(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
if (cache->ed_fcenter_pos_with_nor_and_sel == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
static struct { uint pos, data; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
attr_id.data = GPU_vertformat_attr_add(&format, "norAndFlag", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
const int vbo_len_capacity = mesh_render_data_polys_len_get(rdata);
int vidx = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = cache->ed_fcenter_pos_with_nor_and_sel = GPU_vertbuf_create_with_format(&format);
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
for (int i = 0; i < vbo_len_capacity; ++i) {
float pcenter[3], pnor[3];
bool selected = false;
if (mesh_render_data_pnors_pcenter_select_get(rdata, i, pnor, pcenter, &selected)) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUPackedNormal nor = { .x = 0, .y = 0, .z = -511 };
nor = GPU_normal_convert_i10_v3(pnor);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
nor.w = selected ? 1 : 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.data, vidx, &nor);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.pos, vidx, pcenter);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
vidx += 1;
}
}
const int vbo_len_used = vidx;
Fix assert in mesh batch conversion
2018-01-17 19:54:13 +11:00
BLI_assert(vbo_len_used <= vbo_len_capacity);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
if (vbo_len_used != vbo_len_capacity) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
}
return cache->ed_fcenter_pos_with_nor_and_sel;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_edges_visible(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_EDGE));
if (cache->ed_edge_pos == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
static struct { uint pos, data; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
const int vbo_len_capacity = mesh_render_data_edges_len_get(rdata) * 2;
int vidx = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = cache->ed_edge_pos = GPU_vertbuf_create_with_format(&format);
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter iter;
BMEdge *eed;
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.pos, vidx, eed->v1->co);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
vidx += 1;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.pos, vidx, eed->v2->co);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
vidx += 1;
}
}
}
else {
/* not yet done! */
BLI_assert(0);
}
const int vbo_len_used = vidx;
if (vbo_len_used != vbo_len_capacity) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
UNUSED_VARS_NDEBUG(vbo_len_used);
}
return cache->ed_edge_pos;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_verts_visible(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & MR_DATATYPE_VERT);
if (cache->ed_vert_pos == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
static struct { uint pos, data; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
const int vbo_len_capacity = mesh_render_data_verts_len_get(rdata);
uint vidx = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = cache->ed_vert_pos = GPU_vertbuf_create_with_format(&format);
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter iter;
BMVert *eve;
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.pos, vidx, eve->co);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
vidx += 1;
}
}
}
else {
DwM: use batch select for vertex paint mode
2017-08-17 07:13:02 +10:00
for (int i = 0; i < vbo_len_capacity; i++) {
const MVert *mv = &rdata->mvert[i];
if (!(mv->flag & ME_HIDE)) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.pos, vidx, mv->co);
DwM: use batch select for vertex paint mode
2017-08-17 07:13:02 +10:00
vidx += 1;
}
}
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
const uint vbo_len_used = vidx;
if (vbo_len_used != vbo_len_capacity) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
UNUSED_VARS_NDEBUG(vbo_len_used);
}
return cache->ed_vert_pos;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_create_facedot_select_id(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
MeshRenderData *rdata, uint select_id_offset)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo;
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
{
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
static struct { uint pos, col; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.col = GPU_vertformat_attr_add(&format, "color", GPU_COMP_I32, 1, GPU_FETCH_INT);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
const int vbo_len_capacity = mesh_render_data_polys_len_get(rdata);
int vidx = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vbo = GPU_vertbuf_create_with_format(&format);
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
uint select_index = select_id_offset;
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter iter;
BMEdge *efa;
BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
int select_id;
GPU_select_index_get(select_index, &select_id);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, vidx, &select_id);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
vidx += 1;
}
select_index += 1;
}
}
else {
/* not yet done! */
BLI_assert(0);
}
const int vbo_len_used = vidx;
if (vbo_len_used != vbo_len_capacity) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
}
return vbo;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_create_edges_select_id(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
MeshRenderData *rdata, uint select_id_offset)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_EDGE));
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo;
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
{
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
static struct { uint pos, col; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.col = GPU_vertformat_attr_add(&format, "color", GPU_COMP_I32, 1, GPU_FETCH_INT);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
const int vbo_len_capacity = mesh_render_data_edges_len_get(rdata) * 2;
int vidx = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vbo = GPU_vertbuf_create_with_format(&format);
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
uint select_index = select_id_offset;
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter iter;
BMEdge *eed;
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
int select_id;
GPU_select_index_get(select_index, &select_id);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, vidx, &select_id);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
vidx += 1;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, vidx, &select_id);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
vidx += 1;
}
select_index += 1;
}
}
else {
/* not yet done! */
BLI_assert(0);
}
const int vbo_len_used = vidx;
if (vbo_len_used != vbo_len_capacity) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
}
return vbo;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_create_verts_select_id(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
MeshRenderData *rdata, uint select_id_offset)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo;
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
{
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
static struct { uint pos, col; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.col = GPU_vertformat_attr_add(&format, "color", GPU_COMP_I32, 1, GPU_FETCH_INT);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
const int vbo_len_capacity = mesh_render_data_verts_len_get(rdata);
int vidx = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vbo = GPU_vertbuf_create_with_format(&format);
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
uint select_index = select_id_offset;
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter iter;
BMVert *eve;
BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
int select_id;
GPU_select_index_get(select_index, &select_id);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, vidx, &select_id);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
vidx += 1;
}
select_index += 1;
}
}
else {
DwM: use batch select for vertex paint mode
2017-08-17 07:13:02 +10:00
for (int i = 0; i < vbo_len_capacity; i++) {
const MVert *mv = &rdata->mvert[i];
if (!(mv->flag & ME_HIDE)) {
int select_id;
GPU_select_index_get(select_index, &select_id);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, vidx, &select_id);
DwM: use batch select for vertex paint mode
2017-08-17 07:13:02 +10:00
vidx += 1;
}
select_index += 1;
}
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
const int vbo_len_used = vidx;
if (vbo_len_used != vbo_len_capacity) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
}
return vbo;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_create_tri_weights(
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
MeshRenderData *rdata, bool use_hide, const VertexWeightSelection *vwsel)
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
{
Cleanup: line length
2017-05-04 03:35:01 +10:00
BLI_assert(
rdata->types &
(MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY | MR_DATATYPE_DVERT));
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo;
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
{
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint cidx = 0;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
static struct { uint col; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.col = GPU_vertformat_attr_add(&format, "color", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vbo = GPU_vertbuf_create_with_format(&format);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
const int tri_len = mesh_render_data_looptri_len_get(rdata);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
const int vbo_len_capacity = tri_len * 3;
int vbo_len_used = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
mesh_render_data_ensure_vert_weight_color(rdata, vwsel);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
const float (*vert_weight_color)[3] = rdata->vert_weight_color;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
if (rdata->edit_bmesh) {
for (int i = 0; i < tri_len; i++) {
const BMLoop **ltri = (const BMLoop **)rdata->edit_bmesh->looptris[i];
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
/* Assume 'use_hide' */
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
if (!BM_elem_flag_test(ltri[0]->f, BM_ELEM_HIDDEN)) {
for (uint tri_corner = 0; tri_corner < 3; tri_corner++) {
const int v_index = BM_elem_index_get(ltri[tri_corner]->v);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, cidx++, vert_weight_color[v_index]);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
}
}
}
else {
for (int i = 0; i < tri_len; i++) {
const MLoopTri *mlt = &rdata->mlooptri[i];
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
if (!(use_hide && (rdata->mpoly[mlt->poly].flag & ME_HIDE))) {
for (uint tri_corner = 0; tri_corner < 3; tri_corner++) {
const uint v_index = rdata->mloop[mlt->tri[tri_corner]].v;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, cidx++, vert_weight_color[v_index]);
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
}
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
}
DWM: Share VBO positions & normals for mesh cache Select, weight & color cache included redundant position and normals. Use multiple VBO's per batch for more efficient storage.
2017-05-08 16:25:29 +10:00
vbo_len_used = cidx;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
if (vbo_len_capacity != vbo_len_used) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
}
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
return vbo;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_create_tri_vert_colors(
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
MeshRenderData *rdata, bool use_hide)
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
{
BLI_assert(
rdata->types &
(MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY | MR_DATATYPE_LOOPCOL));
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo;
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
{
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint cidx = 0;
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
static struct { uint col; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.col = GPU_vertformat_attr_add(&format, "color", GPU_COMP_U8, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
}
const int tri_len = mesh_render_data_looptri_len_get(rdata);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vbo = GPU_vertbuf_create_with_format(&format);
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
DWM: Share VBO positions & normals for mesh cache Select, weight & color cache included redundant position and normals. Use multiple VBO's per batch for more efficient storage.
2017-05-08 16:25:29 +10:00
const uint vbo_len_capacity = tri_len * 3;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
mesh_render_data_ensure_vert_color(rdata);
const char (*vert_color)[3] = rdata->vert_color;
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
if (rdata->edit_bmesh) {
for (int i = 0; i < tri_len; i++) {
const BMLoop **ltri = (const BMLoop **)rdata->edit_bmesh->looptris[i];
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
/* Assume 'use_hide' */
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
if (!BM_elem_flag_test(ltri[0]->f, BM_ELEM_HIDDEN)) {
for (uint tri_corner = 0; tri_corner < 3; tri_corner++) {
Correct own error in copying vertex color to VBO's
2017-05-17 17:14:10 +10:00
const int l_index = BM_elem_index_get(ltri[tri_corner]);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, cidx++, vert_color[l_index]);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
}
}
}
else {
for (int i = 0; i < tri_len; i++) {
const MLoopTri *mlt = &rdata->mlooptri[i];
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
if (!(use_hide && (rdata->mpoly[mlt->poly].flag & ME_HIDE))) {
for (uint tri_corner = 0; tri_corner < 3; tri_corner++) {
Correct own error in copying vertex color to VBO's
2017-05-17 17:14:10 +10:00
const uint l_index = mlt->tri[tri_corner];
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, cidx++, vert_color[l_index]);
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
}
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
}
}
DWM: Share VBO positions & normals for mesh cache Select, weight & color cache included redundant position and normals. Use multiple VBO's per batch for more efficient storage.
2017-05-08 16:25:29 +10:00
const uint vbo_len_used = cidx;
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
if (vbo_len_capacity != vbo_len_used) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
}
}
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
return vbo;
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_create_tri_select_id(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
MeshRenderData *rdata, bool use_hide, uint select_id_offset)
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
{
BLI_assert(
rdata->types &
(MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo;
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
{
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint cidx = 0;
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
static struct { uint col; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.col = GPU_vertformat_attr_add(&format, "color", GPU_COMP_I32, 1, GPU_FETCH_INT);
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
}
const int tri_len = mesh_render_data_looptri_len_get(rdata);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vbo = GPU_vertbuf_create_with_format(&format);
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
const int vbo_len_capacity = tri_len * 3;
int vbo_len_used = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
if (rdata->edit_bmesh) {
for (int i = 0; i < tri_len; i++) {
const BMLoop **ltri = (const BMLoop **)rdata->edit_bmesh->looptris[i];
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
/* Assume 'use_hide' */
if (!BM_elem_flag_test(ltri[0]->f, BM_ELEM_HIDDEN)) {
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
const int poly_index = BM_elem_index_get(ltri[0]->f);
int select_id;
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
GPU_select_index_get(poly_index + select_id_offset, &select_id);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
for (uint tri_corner = 0; tri_corner < 3; tri_corner++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, cidx++, &select_id);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
}
}
}
else {
for (int i = 0; i < tri_len; i++) {
const MLoopTri *mlt = &rdata->mlooptri[i];
const int poly_index = mlt->poly;
if (!(use_hide && (rdata->mpoly[poly_index].flag & ME_HIDE))) {
int select_id;
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
GPU_select_index_get(poly_index + select_id_offset, &select_id);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
for (uint tri_corner = 0; tri_corner < 3; tri_corner++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.col, cidx++, &select_id);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
}
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
}
}
DWM: Share VBO positions & normals for mesh cache Select, weight & color cache included redundant position and normals. Use multiple VBO's per batch for more efficient storage.
2017-05-08 16:25:29 +10:00
vbo_len_used = cidx;
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
if (vbo_len_capacity != vbo_len_used) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
}
}
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
return vbo;
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_vert_pos_and_nor_in_order(
Cleanup: include the type of data in function name Was confusing, some functions return vert or triangle data but naming wasn't very clear.
2017-05-05 05:41:30 +10:00
MeshRenderData *rdata, MeshBatchCache *cache)
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & MR_DATATYPE_VERT);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
if (cache->pos_in_order == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
static struct { uint pos, nor; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
/* Normal is padded so that the vbo can be used as a buffer texture */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
attr_id.nor = GPU_vertformat_attr_add(&format, "nor", GPU_COMP_I16, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = cache->pos_in_order = GPU_vertbuf_create_with_format(&format);
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
const int vbo_len_capacity = mesh_render_data_verts_len_get(rdata);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter iter;
BMVert *eve;
uint i;
BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
static short no_short[4];
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
normal_float_to_short_v3(no_short, eve->no);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.pos, i, eve->co);
GPU_vertbuf_attr_set(vbo, attr_id.nor, i, no_short);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
BLI_assert(i == vbo_len_capacity);
}
else {
for (int i = 0; i < vbo_len_capacity; ++i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.pos, i, rdata->mvert[i].co);
GPU_vertbuf_attr_set(vbo, attr_id.nor, i, rdata->mvert[i].no); /* XXX actually reading 4 shorts */
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
}
return cache->pos_in_order;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat *edit_mesh_overlay_pos_format(uint *r_pos_id)
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
{
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format_pos = { 0 };
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
static uint pos_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format_pos.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
pos_id = GPU_vertformat_attr_add(&format_pos, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
*r_pos_id = pos_id;
return &format_pos;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat *edit_mesh_overlay_nor_format(uint *r_vnor_id, uint *r_lnor_id)
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
{
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format_nor = { 0 };
static GPUVertFormat format_nor_loop = { 0 };
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
static uint vnor_id, vnor_loop_id, lnor_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format_nor.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vnor_id = GPU_vertformat_attr_add(&format_nor, "vnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
vnor_loop_id = GPU_vertformat_attr_add(&format_nor_loop, "vnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
lnor_id = GPU_vertformat_attr_add(&format_nor_loop, "lnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
if (r_lnor_id) {
*r_vnor_id = vnor_loop_id;
*r_lnor_id = lnor_id;
return &format_nor_loop;
}
else {
*r_vnor_id = vnor_id;
return &format_nor;
}
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat *edit_mesh_overlay_data_format(uint *r_data_id)
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
{
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format_flag = { 0 };
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
static uint data_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format_flag.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
data_id = GPU_vertformat_attr_add(&format_flag, "data", GPU_COMP_U8, 4, GPU_FETCH_INT);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
*r_data_id = data_id;
return &format_flag;
}
static void mesh_batch_cache_create_overlay_tri_buffers(
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI));
const int tri_len = mesh_render_data_looptri_len_get(rdata);
const int vbo_len_capacity = tri_len * 3;
int vbo_len_used = 0;
/* Positions */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_pos = NULL;
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
static struct { uint pos, vnor, lnor, data; } attr_id;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (cache->ed_tri_pos == NULL) {
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
vbo_pos = cache->ed_tri_pos =
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_create_with_format(edit_mesh_overlay_pos_format(&attr_id.pos));
GPU_vertbuf_data_alloc(vbo_pos, vbo_len_capacity);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
/* Normals */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_nor = NULL;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (cache->ed_tri_nor == NULL) {
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
vbo_nor = cache->ed_tri_nor =
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_create_with_format(edit_mesh_overlay_nor_format(&attr_id.vnor, &attr_id.lnor));
GPU_vertbuf_data_alloc(vbo_nor, vbo_len_capacity);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
/* Data */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_data = NULL;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (cache->ed_tri_data == NULL) {
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
vbo_data = cache->ed_tri_data =
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_create_with_format(edit_mesh_overlay_data_format(&attr_id.data));
GPU_vertbuf_data_alloc(vbo_data, vbo_len_capacity);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
for (int i = 0; i < tri_len; i++) {
const BMLoop **bm_looptri = (const BMLoop **)rdata->edit_bmesh->looptris[i];
if (!BM_elem_flag_test(bm_looptri[0]->f, BM_ELEM_HIDDEN)) {
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
add_overlay_tri(
rdata, vbo_pos, vbo_nor, vbo_data,
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
attr_id.pos, attr_id.vnor, attr_id.lnor, attr_id.data,
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
bm_looptri, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
vbo_len_used += 3;
}
}
/* Finish */
if (vbo_len_used != vbo_len_capacity) {
if (vbo_pos != NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo_pos, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
if (vbo_nor != NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo_nor, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
if (vbo_data != NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo_data, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
}
}
static void mesh_batch_cache_create_overlay_ledge_buffers(
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI));
const int ledge_len = mesh_render_data_loose_edges_len_get(rdata);
const int vbo_len_capacity = ledge_len * 2;
int vbo_len_used = 0;
/* Positions */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_pos = NULL;
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
static struct { uint pos, vnor, data; } attr_id;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (cache->ed_ledge_pos == NULL) {
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
vbo_pos = cache->ed_ledge_pos =
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_create_with_format(edit_mesh_overlay_pos_format(&attr_id.pos));
GPU_vertbuf_data_alloc(vbo_pos, vbo_len_capacity);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
/* Normals */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_nor = NULL;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (cache->ed_ledge_nor == NULL) {
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
vbo_nor = cache->ed_ledge_nor =
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_create_with_format(edit_mesh_overlay_nor_format(&attr_id.vnor, NULL));
GPU_vertbuf_data_alloc(vbo_nor, vbo_len_capacity);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
/* Data */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_data = NULL;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (cache->ed_ledge_data == NULL) {
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
vbo_data = cache->ed_ledge_data =
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_create_with_format(edit_mesh_overlay_data_format(&attr_id.data));
GPU_vertbuf_data_alloc(vbo_data, vbo_len_capacity);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
for (uint i = 0; i < ledge_len; i++) {
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
const BMEdge *eed = BM_edge_at_index(bm, rdata->loose_edges[i]);
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
add_overlay_loose_edge(
rdata, vbo_pos, vbo_nor, vbo_data,
attr_id.pos, attr_id.vnor, attr_id.data,
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
eed, vbo_len_used);
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
vbo_len_used += 2;
}
}
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
/* Finish */
if (vbo_len_used != vbo_len_capacity) {
if (vbo_pos != NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo_pos, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
if (vbo_nor != NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo_nor, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
if (vbo_data != NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo_data, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
}
}
static void mesh_batch_cache_create_overlay_lvert_buffers(
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI));
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
BMesh *bm = rdata->edit_bmesh->bm;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
const int lvert_len = mesh_render_data_loose_verts_len_get(rdata);
const int vbo_len_capacity = lvert_len;
int vbo_len_used = 0;
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
static struct { uint pos, vnor, data; } attr_id;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
/* Positions */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_pos = NULL;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (cache->ed_lvert_pos == NULL) {
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
vbo_pos = cache->ed_lvert_pos =
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_create_with_format(edit_mesh_overlay_pos_format(&attr_id.pos));
GPU_vertbuf_data_alloc(vbo_pos, vbo_len_capacity);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
/* Normals */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_nor = NULL;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (cache->ed_lvert_nor == NULL) {
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
vbo_nor = cache->ed_lvert_nor =
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_create_with_format(edit_mesh_overlay_nor_format(&attr_id.vnor, NULL));
GPU_vertbuf_data_alloc(vbo_nor, vbo_len_capacity);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
/* Data */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_data = NULL;
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (cache->ed_lvert_data == NULL) {
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
vbo_data = cache->ed_lvert_data =
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_create_with_format(edit_mesh_overlay_data_format(&attr_id.data));
GPU_vertbuf_data_alloc(vbo_data, vbo_len_capacity);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
for (uint i = 0; i < lvert_len; i++) {
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BMVert *eve = BM_vert_at_index(bm, rdata->loose_verts[i]);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
add_overlay_loose_vert(
rdata, vbo_pos, vbo_nor, vbo_data,
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
attr_id.pos, attr_id.vnor, attr_id.data,
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
eve, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
vbo_len_used += 1;
}
/* Finish */
if (vbo_len_used != vbo_len_capacity) {
if (vbo_pos != NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo_pos, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
if (vbo_nor != NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo_nor, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
if (vbo_data != NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo_data, vbo_len_used);
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
}
}
/* Position */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_edit_tri_pos(
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & MR_DATATYPE_VERT);
if (cache->ed_tri_pos == NULL) {
mesh_batch_cache_create_overlay_tri_buffers(rdata, cache);
}
return cache->ed_tri_pos;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_edit_ledge_pos(
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & MR_DATATYPE_VERT);
if (cache->ed_ledge_pos == NULL) {
mesh_batch_cache_create_overlay_ledge_buffers(rdata, cache);
}
return cache->ed_ledge_pos;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_edit_lvert_pos(
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & MR_DATATYPE_VERT);
if (cache->ed_lvert_pos == NULL) {
mesh_batch_cache_create_overlay_lvert_buffers(rdata, cache);
}
return cache->ed_lvert_pos;
}
/* Normal */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_edit_tri_nor(
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & MR_DATATYPE_VERT);
if (cache->ed_tri_nor == NULL) {
mesh_batch_cache_create_overlay_tri_buffers(rdata, cache);
}
return cache->ed_tri_nor;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_edit_ledge_nor(
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & MR_DATATYPE_VERT);
if (cache->ed_ledge_nor == NULL) {
mesh_batch_cache_create_overlay_ledge_buffers(rdata, cache);
}
return cache->ed_ledge_nor;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_edit_lvert_nor(
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & MR_DATATYPE_VERT);
if (cache->ed_lvert_nor == NULL) {
mesh_batch_cache_create_overlay_lvert_buffers(rdata, cache);
}
return cache->ed_lvert_nor;
}
/* Data */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_edit_tri_data(
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & MR_DATATYPE_VERT);
if (cache->ed_tri_data == NULL) {
mesh_batch_cache_create_overlay_tri_buffers(rdata, cache);
}
return cache->ed_tri_data;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_edit_ledge_data(
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & MR_DATATYPE_VERT);
if (cache->ed_ledge_data == NULL) {
mesh_batch_cache_create_overlay_ledge_buffers(rdata, cache);
}
return cache->ed_ledge_data;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_get_edit_lvert_data(
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & MR_DATATYPE_VERT);
if (cache->ed_lvert_data == NULL) {
mesh_batch_cache_create_overlay_lvert_buffers(rdata, cache);
}
return cache->ed_lvert_data;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUIndexBuf *mesh_batch_cache_get_edges_in_order(MeshRenderData *rdata, MeshBatchCache *cache)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_EDGE));
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
if (cache->edges_in_order == NULL) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
const int vert_len = mesh_render_data_verts_len_get(rdata);
const int edge_len = mesh_render_data_edges_len_get(rdata);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUIndexBufBuilder elb;
GPU_indexbuf_init(&elb, GPU_PRIM_LINES, edge_len, vert_len);
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
BLI_assert(rdata->types & MR_DATATYPE_EDGE);
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter eiter;
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BMEdge *eed;
BM_ITER_MESH(eed, &eiter, bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_line_verts(&elb, BM_elem_index_get(eed->v1), BM_elem_index_get(eed->v2));
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
}
}
}
else {
const MEdge *ed = rdata->medge;
for (int i = 0; i < edge_len; i++, ed++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_line_verts(&elb, ed->v1, ed->v2);
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
}
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->edges_in_order = GPU_indexbuf_build(&elb);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
return cache->edges_in_order;
}
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
#define NO_EDGE INT_MAX
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUIndexBuf *mesh_batch_cache_get_edges_adjacency(MeshRenderData *rdata, MeshBatchCache *cache)
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI));
if (cache->edges_adjacency == NULL) {
const int vert_len = mesh_render_data_verts_len_get(rdata);
const int tri_len = mesh_render_data_looptri_len_get(rdata);
Workbench: Shadow: Use depth fail method for manifold objects. Since this method have no failure case for manifold objects, use it.
2018-05-21 13:21:26 +02:00
cache->is_manifold = true;
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
/* Allocate max but only used indices are sent to GPU. */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUIndexBufBuilder elb;
GPU_indexbuf_init(&elb, GPU_PRIM_LINES_ADJ, tri_len * 3, vert_len);
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
EdgeHash *eh = BLI_edgehash_new_ex(__func__, tri_len * 3);
/* Create edges for each pair of triangles sharing an edge. */
for (int i = 0; i < tri_len; i++) {
for (int e = 0; e < 3; ++e) {
Cleanup: style/whitespace Also use 'uint'.
2018-05-30 19:45:03 +02:00
uint v0, v1, v2;
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
if (rdata->edit_bmesh) {
const BMLoop **bm_looptri = (const BMLoop **)rdata->edit_bmesh->looptris[i];
if (BM_elem_flag_test(bm_looptri[0]->f, BM_ELEM_HIDDEN)) {
break;
}
v0 = BM_elem_index_get(bm_looptri[e]->v);
Cleanup: style, whitespace
2018-05-22 07:31:11 +02:00
v1 = BM_elem_index_get(bm_looptri[(e + 1) % 3]->v);
v2 = BM_elem_index_get(bm_looptri[(e + 2) % 3]->v);
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
}
else {
MLoop *mloop = rdata->mloop;
MLoopTri *mlt = rdata->mlooptri + i;
v0 = mloop[mlt->tri[e]].v;
Cleanup: style, whitespace
2018-05-22 07:31:11 +02:00
v1 = mloop[mlt->tri[(e + 1) % 3]].v;
v2 = mloop[mlt->tri[(e + 2) % 3]].v;
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
}
bool inv_indices = (v1 > v2);
void **pval;
bool value_is_init = BLI_edgehash_ensure_p(eh, v1, v2, &pval);
Merge branch 'master' into blender2.8
2018-09-19 12:14:36 +10:00
int v_data = POINTER_AS_INT(*pval);
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
if (!value_is_init || v_data == NO_EDGE) {
/* Save the winding order inside the sign bit. Because the
* edgehash sort the keys and we need to compare winding later. */
int value = (int)v0 + 1; /* Int 0 cannot be signed */
Merge branch 'master' into blender2.8
2018-09-19 12:14:36 +10:00
*pval = POINTER_FROM_INT((inv_indices) ? -value : value);
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
}
else {
/* HACK Tag as not used. Prevent overhead of BLI_edgehash_remove. */
Merge branch 'master' into blender2.8
2018-09-19 12:14:36 +10:00
*pval = POINTER_FROM_INT(NO_EDGE);
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
bool inv_opposite = (v_data < 0);
Cleanup: style/whitespace Also use 'uint'.
2018-05-30 19:45:03 +02:00
uint v_opposite = (uint)abs(v_data) - 1;
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
if (inv_opposite == inv_indices) {
/* Don't share edge if triangles have non matching winding. */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_line_adj_verts(&elb, v0, v1, v2, v0);
GPU_indexbuf_add_line_adj_verts(&elb, v_opposite, v1, v2, v_opposite);
Workbench: Shadow: Use depth fail method for manifold objects. Since this method have no failure case for manifold objects, use it.
2018-05-21 13:21:26 +02:00
cache->is_manifold = false;
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
}
else {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_line_adj_verts(&elb, v0, v1, v2, v_opposite);
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
}
Cleanup: replace MEM_SAFE_FREE -> MEM_freeN No need to check for NULL in this case.
2018-05-22 07:26:45 +02:00
}
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
}
}
/* Create edges for remaning non manifold edges. */
EdgeHashIterator *ehi;
for (ehi = BLI_edgehashIterator_new(eh);
BLI_edgehashIterator_isDone(ehi) == false;
BLI_edgehashIterator_step(ehi))
{
Cleanup: style/whitespace Also use 'uint'.
2018-05-30 19:45:03 +02:00
uint v1, v2;
Merge branch 'master' into blender2.8
2018-09-19 12:14:36 +10:00
int v_data = POINTER_AS_INT(BLI_edgehashIterator_getValue(ehi));
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
if (v_data == NO_EDGE) {
continue;
}
BLI_edgehashIterator_getKey(ehi, &v1, &v2);
Cleanup: style/whitespace Also use 'uint'.
2018-05-30 19:45:03 +02:00
uint v0 = (uint)abs(v_data) - 1;
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
if (v_data < 0) { /* inv_opposite */
Cleanup: style/whitespace Also use 'uint'.
2018-05-30 19:45:03 +02:00
SWAP(uint, v1, v2);
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_line_adj_verts(&elb, v0, v1, v2, v0);
Workbench: Shadow: Use depth fail method for manifold objects. Since this method have no failure case for manifold objects, use it.
2018-05-21 13:21:26 +02:00
cache->is_manifold = false;
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
}
BLI_edgehashIterator_free(ehi);
BLI_edgehash_free(eh, NULL);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->edges_adjacency = GPU_indexbuf_build(&elb);
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
}
return cache->edges_adjacency;
}
#undef NO_EDGE
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
static EdgeHash *create_looptri_edge_adjacency_hash(MeshRenderData *rdata)
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
{
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
const int tri_len = mesh_render_data_looptri_len_get(rdata);
/* Create adjacency info in looptri */
EdgeHash *eh = BLI_edgehash_new_ex(__func__, tri_len * 3);
/* Create edges for each pair of triangles sharing an edge. */
for (int i = 0; i < tri_len; i++) {
for (int e = 0; e < 3; ++e) {
uint v0, v1, v2;
if (rdata->edit_bmesh) {
const BMLoop **bm_looptri = (const BMLoop **)rdata->edit_bmesh->looptris[i];
if (BM_elem_flag_test(bm_looptri[0]->f, BM_ELEM_HIDDEN)) {
break;
}
v0 = BM_elem_index_get(bm_looptri[e]->v);
v1 = BM_elem_index_get(bm_looptri[(e + 1) % 3]->v);
v2 = BM_elem_index_get(bm_looptri[(e + 2) % 3]->v);
}
else {
MLoop *mloop = rdata->mloop;
MLoopTri *mlt = rdata->mlooptri + i;
v0 = mloop[mlt->tri[e]].v;
v1 = mloop[mlt->tri[(e + 1) % 3]].v;
v2 = mloop[mlt->tri[(e + 2) % 3]].v;
}
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
EdgeAdjacentVerts **eav;
bool value_is_init = BLI_edgehash_ensure_p(eh, v1, v2, (void ***)&eav);
if (!value_is_init) {
*eav = MEM_mallocN(sizeof(**eav), "EdgeAdjacentVerts");
(*eav)->vert_index[0] = v0;
(*eav)->vert_index[1] = -1;
}
else {
if ((*eav)->vert_index[1] == -1) {
(*eav)->vert_index[1] = v0;
}
else {
/* Not a manifold edge. */
}
}
}
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
}
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
return eh;
}
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_batch_cache_create_edges_overlay_texture_buf(MeshRenderData *rdata)
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
{
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
const int tri_len = mesh_render_data_looptri_len_get(rdata);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertFormat format = {0};
uint index_id = GPU_vertformat_attr_add(&format, "index", GPU_COMP_U32, 1, GPU_FETCH_INT);
GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
Wireframe: Fix edges or non manifold meshes not showing. This will show the associated edges to the vertices but that's the only workaround I can think of right now.
2018-06-07 18:01:29 +02:00
int vbo_len_capacity = tri_len * 3;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
int vidx = 0;
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
EdgeHash *eh = NULL;
Wireframe: Fix edges or non manifold meshes not showing. This will show the associated edges to the vertices but that's the only workaround I can think of right now.
2018-06-07 18:01:29 +02:00
eh = create_looptri_edge_adjacency_hash(rdata);
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
for (int i = 0; i < tri_len; i++) {
bool edge_is_real[3] = {false, false, false};
MEdge *medge = rdata->medge;
MLoop *mloop = rdata->mloop;
MLoopTri *mlt = rdata->mlooptri + i;
int j, j_next;
for (j = 2, j_next = 0; j_next < 3; j = j_next++) {
MEdge *ed = &medge[mloop[mlt->tri[j]].e];
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
uint tri_edge[2] = {mloop[mlt->tri[j]].v, mloop[mlt->tri[j_next]].v};
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
if (((ed->v1 == tri_edge[0]) && (ed->v2 == tri_edge[1])) ||
((ed->v1 == tri_edge[1]) && (ed->v2 == tri_edge[0])))
{
edge_is_real[j] = true;
}
}
for (int e = 0; e < 3; ++e) {
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
int v0 = mloop[mlt->tri[e]].v;
Wireframe: Fix edges or non manifold meshes not showing. This will show the associated edges to the vertices but that's the only workaround I can think of right now.
2018-06-07 18:01:29 +02:00
int v1 = mloop[mlt->tri[(e + 1) % 3]].v;
EdgeAdjacentVerts *eav = BLI_edgehash_lookup(eh, v0, v1);
uint value = (uint)v0;
/* Real edge */
if (edge_is_real[e]) {
value |= (1 << 30);
}
/* Non-manifold edge */
if (eav->vert_index[1] == -1) {
value |= (1 << 31);
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, index_id, vidx++, &value);
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
}
}
Wireframe: Fix edges or non manifold meshes not showing. This will show the associated edges to the vertices but that's the only workaround I can think of right now.
2018-06-07 18:01:29 +02:00
BLI_edgehash_free(eh, MEM_freeN);
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
int vbo_len_used = vidx;
if (vbo_len_capacity != vbo_len_used) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
}
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
return vbo;
}
static GPUTexture *mesh_batch_cache_get_edges_overlay_texture_buf(MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI));
BLI_assert(rdata->edit_bmesh == NULL); /* Not supported in edit mode */
if (cache->edges_face_overlay_tx != NULL) {
return cache->edges_face_overlay_tx;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = cache->edges_face_overlay = mesh_batch_cache_create_edges_overlay_texture_buf(rdata);
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
/* Upload data early because we need to create the texture for it. */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_use(vbo);
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
cache->edges_face_overlay_tx = GPU_texture_create_from_vertbuf(vbo);
Wireframe: Add slider to hide edges from coplanar faces The default behaviour is to show the same amount of edges as 2.7. The slider makes it possible to show all edges or even less.
2018-06-05 19:35:08 +02:00
cache->edges_face_overlay_tri_count = vbo->vertex_alloc / 3;
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
return cache->edges_face_overlay_tx;
}
static GPUTexture *mesh_batch_cache_get_vert_pos_and_nor_in_order_buf(MeshRenderData *rdata, MeshBatchCache *cache)
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI));
if (cache->pos_in_order_tx == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *pos_in_order = mesh_batch_cache_get_vert_pos_and_nor_in_order(rdata, cache);
GPU_vertbuf_use(pos_in_order); /* Upload early for buffer texture creation. */
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
cache->pos_in_order_tx = GPU_texture_create_buffer(GPU_R32F, pos_in_order->vbo_id);
}
return cache->pos_in_order_tx;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUIndexBuf *mesh_batch_cache_get_triangles_in_order(MeshRenderData *rdata, MeshBatchCache *cache)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI));
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
if (cache->triangles_in_order == NULL) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
const int vert_len = mesh_render_data_verts_len_get(rdata);
const int tri_len = mesh_render_data_looptri_len_get(rdata);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUIndexBufBuilder elb;
GPU_indexbuf_init(&elb, GPU_PRIM_TRIS, tri_len, vert_len);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
if (rdata->edit_bmesh) {
for (int i = 0; i < tri_len; ++i) {
const BMLoop **ltri = (const BMLoop **)rdata->edit_bmesh->looptris[i];
if (!BM_elem_flag_test(ltri[0]->f, BM_ELEM_HIDDEN)) {
for (uint tri_corner = 0; tri_corner < 3; tri_corner++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_generic_vert(&elb, BM_elem_index_get(ltri[tri_corner]->v));
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
}
}
}
else {
for (int i = 0; i < tri_len; ++i) {
const MLoopTri *mlt = &rdata->mlooptri[i];
for (uint tri_corner = 0; tri_corner < 3; tri_corner++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_generic_vert(&elb, mlt->tri[tri_corner]);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
}
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->triangles_in_order = GPU_indexbuf_build(&elb);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
return cache->triangles_in_order;
}
Object Mode: Display loose edges if overlays are enables. This fix T55280 Loose edges not visible in object mode
2018-06-01 11:35:51 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUIndexBuf *mesh_batch_cache_get_loose_edges(MeshRenderData *rdata, MeshBatchCache *cache)
Object Mode: Display loose edges if overlays are enables. This fix T55280 Loose edges not visible in object mode
2018-06-01 11:35:51 +02:00
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI));
if (cache->ledges_in_order == NULL) {
const int vert_len = mesh_render_data_verts_len_get(rdata);
const int edge_len = mesh_render_data_edges_len_get(rdata);
/* Alloc max (edge_len) and upload only needed range. */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUIndexBufBuilder elb;
GPU_indexbuf_init(&elb, GPU_PRIM_LINES, edge_len, vert_len);
Object Mode: Display loose edges if overlays are enables. This fix T55280 Loose edges not visible in object mode
2018-06-01 11:35:51 +02:00
if (rdata->edit_bmesh) {
/* No need to support since edit mesh already draw them.
* But some engines may want them ... */
BMesh *bm = rdata->edit_bmesh->bm;
BMIter eiter;
BMEdge *eed;
BM_ITER_MESH(eed, &eiter, bm, BM_EDGES_OF_MESH) {
if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && BM_edge_is_wire(eed)) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_line_verts(&elb, BM_elem_index_get(eed->v1), BM_elem_index_get(eed->v2));
Object Mode: Display loose edges if overlays are enables. This fix T55280 Loose edges not visible in object mode
2018-06-01 11:35:51 +02:00
}
}
}
else {
for (int i = 0; i < edge_len; ++i) {
const MEdge *medge = &rdata->medge[i];
if (medge->flag & ME_LOOSEEDGE) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_line_verts(&elb, medge->v1, medge->v2);
Object Mode: Display loose edges if overlays are enables. This fix T55280 Loose edges not visible in object mode
2018-06-01 11:35:51 +02:00
}
}
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->ledges_in_order = GPU_indexbuf_build(&elb);
Object Mode: Display loose edges if overlays are enables. This fix T55280 Loose edges not visible in object mode
2018-06-01 11:35:51 +02:00
}
return cache->ledges_in_order;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUIndexBuf **mesh_batch_cache_get_triangles_in_order_split_by_material(
Cleanup: use more generic naming Can be used by any user that needs faces split by materials.
2017-05-23 17:48:05 +10:00
MeshRenderData *rdata, MeshBatchCache *cache)
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
{
DwM: optimize material access - Split BMesh/Mesh loops. - Loop over faces instead of tris. - Add out-of-bounds check for material index (rare but can happen).
2017-05-23 18:23:18 +10:00
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_POLY));
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
if (cache->shaded_triangles_in_order == NULL) {
DwM: optimize material access - Split BMesh/Mesh loops. - Loop over faces instead of tris. - Add out-of-bounds check for material index (rare but can happen).
2017-05-23 18:23:18 +10:00
const int poly_len = mesh_render_data_polys_len_get(rdata);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
const int tri_len = mesh_render_data_looptri_len_get(rdata);
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
const int mat_len = mesh_render_data_mat_len_get(rdata);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
int *mat_tri_len = MEM_callocN(sizeof(*mat_tri_len) * mat_len, __func__);
cache->shaded_triangles_in_order = MEM_callocN(sizeof(*cache->shaded_triangles) * mat_len, __func__);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUIndexBufBuilder *elb = MEM_callocN(sizeof(*elb) * mat_len, __func__);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
DwM: optimize material access - Split BMesh/Mesh loops. - Loop over faces instead of tris. - Add out-of-bounds check for material index (rare but can happen).
2017-05-23 18:23:18 +10:00
/* Note that polygons (not triangles) are used here.
* This OK because result is _guaranteed_ to be the same. */
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter fiter;
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BMFace *efa;
DwM: optimize material access - Split BMesh/Mesh loops. - Loop over faces instead of tris. - Add out-of-bounds check for material index (rare but can happen).
2017-05-23 18:23:18 +10:00
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BM_ITER_MESH(efa, &fiter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
const short ma_id = efa->mat_nr < mat_len ? efa->mat_nr : 0;
mat_tri_len[ma_id] += (efa->len - 2);
DwM: optimize material access - Split BMesh/Mesh loops. - Loop over faces instead of tris. - Add out-of-bounds check for material index (rare but can happen).
2017-05-23 18:23:18 +10:00
}
}
}
else {
for (uint i = 0; i < poly_len; i++) {
const MPoly *mp = &rdata->mpoly[i]; ;
const short ma_id = mp->mat_nr < mat_len ? mp->mat_nr : 0;
mat_tri_len[ma_id] += (mp->totloop - 2);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
}
}
/* Init ELBs. */
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
for (int i = 0; i < mat_len; ++i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_init(&elb[i], GPU_PRIM_TRIS, mat_tri_len[i], tri_len * 3);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
}
/* Populate ELBs. */
DwM: optimize material access - Split BMesh/Mesh loops. - Loop over faces instead of tris. - Add out-of-bounds check for material index (rare but can happen).
2017-05-23 18:23:18 +10:00
uint nidx = 0;
if (rdata->edit_bmesh) {
BMesh *bm = rdata->edit_bmesh->bm;
BMIter fiter;
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BMFace *efa;
DwM: optimize material access - Split BMesh/Mesh loops. - Loop over faces instead of tris. - Add out-of-bounds check for material index (rare but can happen).
2017-05-23 18:23:18 +10:00
Cleanup: bmesh var naming
2017-05-24 13:33:48 +10:00
BM_ITER_MESH(efa, &fiter, bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
const short ma_id = efa->mat_nr < mat_len ? efa->mat_nr : 0;
for (int j = 2; j < efa->len; j++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_tri_verts(&elb[ma_id], nidx + 0, nidx + 1, nidx + 2);
Stupid mistake in material access optimization
2017-05-23 21:52:18 +10:00
nidx += 3;
}
DwM: optimize material access - Split BMesh/Mesh loops. - Loop over faces instead of tris. - Add out-of-bounds check for material index (rare but can happen).
2017-05-23 18:23:18 +10:00
}
}
}
else {
for (uint i = 0; i < poly_len; i++) {
const MPoly *mp = &rdata->mpoly[i]; ;
const short ma_id = mp->mat_nr < mat_len ? mp->mat_nr : 0;
Stupid mistake in material access optimization
2017-05-23 21:52:18 +10:00
for (int j = 2; j < mp->totloop; j++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_tri_verts(&elb[ma_id], nidx + 0, nidx + 1, nidx + 2);
Stupid mistake in material access optimization
2017-05-23 21:52:18 +10:00
nidx += 3;
}
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
}
}
/* Build ELBs. */
Cleanup: rename ct -> len Also use 'defgroup' instead of 'index' for passing weight arg.
2017-05-04 23:35:50 +10:00
for (int i = 0; i < mat_len; ++i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->shaded_triangles_in_order[i] = GPU_indexbuf_build(&elb[i]);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
}
MEM_freeN(mat_tri_len);
MEM_freeN(elb);
}
return cache->shaded_triangles_in_order;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_create_edge_pos_with_sel(
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
MeshRenderData *rdata, bool use_wire, bool use_select_bool)
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_POLY | MR_DATATYPE_LOOP));
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
BLI_assert(rdata->edit_bmesh == NULL);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo;
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
{
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint vidx = 0, cidx = 0;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
static struct { uint pos, sel; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
attr_id.sel = GPU_vertformat_attr_add(&format, "select", GPU_COMP_U8, 1, GPU_FETCH_INT);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
const int edge_len = mesh_render_data_edges_len_get(rdata);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vbo = GPU_vertbuf_create_with_format(&format);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
const int vbo_len_capacity = edge_len * 2;
int vbo_len_used = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
Cleanup: clarify select terminology In mesh cache we have select: color, id, bool. Current naming didn't make this clear.
2017-05-17 11:46:26 +10:00
if (use_select_bool) {
mesh_render_data_ensure_edge_select_bool(rdata, use_wire);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
Cleanup: clarify select terminology In mesh cache we have select: color, id, bool. Current naming didn't make this clear.
2017-05-17 11:46:26 +10:00
bool *edge_select_bool = use_select_bool ? rdata->edge_select_bool : NULL;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
for (int i = 0; i < edge_len; i++) {
const MEdge *ed = &rdata->medge[i];
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
uchar edge_vert_sel;
Cleanup: clarify select terminology In mesh cache we have select: color, id, bool. Current naming didn't make this clear.
2017-05-17 11:46:26 +10:00
if (use_select_bool && edge_select_bool[i]) {
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
edge_vert_sel = true;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
else if (use_wire) {
edge_vert_sel = false;
}
else {
continue;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.sel, cidx++, &edge_vert_sel);
GPU_vertbuf_attr_set(vbo, attr_id.sel, cidx++, &edge_vert_sel);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.pos, vidx++, rdata->mvert[ed->v1].co);
GPU_vertbuf_attr_set(vbo, attr_id.pos, vidx++, rdata->mvert[ed->v2].co);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
vbo_len_used = vidx;
if (vbo_len_capacity != vbo_len_used) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
}
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
return vbo;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUIndexBuf *mesh_create_tri_overlay_weight_faces(
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
MeshRenderData *rdata)
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
{
DWM: reuse position VBO for vpaint select overlay
2017-05-17 19:21:16 +10:00
BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI));
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
{
DWM: reuse position VBO for vpaint select overlay
2017-05-17 19:21:16 +10:00
const int vert_len = mesh_render_data_verts_len_get(rdata);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
const int tri_len = mesh_render_data_looptri_len_get(rdata);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUIndexBufBuilder elb;
GPU_indexbuf_init(&elb, GPU_PRIM_TRIS, tri_len, vert_len);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
DWM: reuse position VBO for vpaint select overlay
2017-05-17 19:21:16 +10:00
for (int i = 0; i < tri_len; ++i) {
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
const MLoopTri *mlt = &rdata->mlooptri[i];
DWM: correct unselected face overlay
2017-05-17 16:41:21 +10:00
if (!(rdata->mpoly[mlt->poly].flag & (ME_FACE_SEL | ME_HIDE))) {
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
for (uint tri_corner = 0; tri_corner < 3; tri_corner++) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_indexbuf_add_generic_vert(&elb, rdata->mloop[mlt->tri[tri_corner]].v);
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
}
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
return GPU_indexbuf_build(&elb);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
}
DWM: hide hidden verts in weight-paint mode
2017-05-17 18:09:40 +10:00
/**
* Non-edit mode vertices (only used for weight-paint mode).
*/
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertBuf *mesh_create_vert_pos_with_overlay_data(
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
MeshRenderData *rdata)
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
{
BLI_assert(rdata->types & (MR_DATATYPE_VERT));
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
BLI_assert(rdata->edit_bmesh == NULL);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo;
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
{
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint cidx = 0;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
Re-use vertex position VBO in weight-paint mode
2017-05-18 14:53:43 +10:00
static struct { uint data; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.data = GPU_vertformat_attr_add(&format, "data", GPU_COMP_I8, 1, GPU_FETCH_INT);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
const int vert_len = mesh_render_data_verts_len_get(rdata);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
vbo = GPU_vertbuf_create_with_format(&format);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
const int vbo_len_capacity = vert_len;
int vbo_len_used = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
for (int i = 0; i < vert_len; i++) {
DWM: write mesh data to the VBO directly Was using intermediate functions to store each data type. This is still done in some places (for more involved access). For basic data: coords, normals, colors..etc this is unnecessarily indirect.
2017-05-17 11:28:44 +10:00
const MVert *mv = &rdata->mvert[i];
DWM: hide hidden verts in weight-paint mode
2017-05-17 18:09:40 +10:00
const char data = mv->flag & (SELECT | ME_HIDE);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.data, cidx++, &data);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
Re-use vertex position VBO in weight-paint mode
2017-05-18 14:53:43 +10:00
vbo_len_used = cidx;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
if (vbo_len_capacity != vbo_len_used) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
}
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
return vbo;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
/** \} */
/* ---------------------------------------------------------------------- */
/** \name Public API
* \{ */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_all_edges(Mesh *me)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->all_edges == NULL) {
/* create batch from Mesh */
Cleanup: line length
2017-05-04 03:35:01 +10:00
const int datatype = MR_DATATYPE_VERT | MR_DATATYPE_EDGE;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->all_edges = GPU_batch_create(
GPU_PRIM_LINES, mesh_batch_cache_get_vert_pos_and_nor_in_order(rdata, cache),
Object Mode: Display loose edges if overlays are enables. This fix T55280 Loose edges not visible in object mode
2018-06-01 11:35:51 +02:00
mesh_batch_cache_get_edges_in_order(rdata, cache));
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
mesh_render_data_free(rdata);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
return cache->all_edges;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_all_triangles(Mesh *me)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->all_triangles == NULL) {
/* create batch from DM */
Cleanup: line length
2017-05-04 03:35:01 +10:00
const int datatype = MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->all_triangles = GPU_batch_create(
GPU_PRIM_TRIS, mesh_batch_cache_get_vert_pos_and_nor_in_order(rdata, cache),
Cleanup: line length
2017-05-04 03:35:01 +10:00
mesh_batch_cache_get_triangles_in_order(rdata, cache));
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
mesh_render_data_free(rdata);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
return cache->all_triangles;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals(Mesh *me)
Clay Engine: Support vertex normals (smooth shading), no face normals yet.
2017-02-15 13:32:35 +01:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->triangles_with_normals == NULL) {
Cleanup: line length
2017-05-04 03:35:01 +10:00
const int datatype = MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
Clay Engine: Support vertex normals (smooth shading), no face normals yet.
2017-02-15 13:32:35 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->triangles_with_normals = GPU_batch_create(
GPU_PRIM_TRIS, mesh_batch_cache_get_tri_pos_and_normals(rdata, cache), NULL);
Clay Engine: Support vertex normals (smooth shading), no face normals yet.
2017-02-15 13:32:35 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
mesh_render_data_free(rdata);
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
}
Clay Engine: Support vertex normals (smooth shading), no face normals yet.
2017-02-15 13:32:35 +01:00
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
return cache->triangles_with_normals;
}
Clay Engine: Correct Mesh Normals
2017-02-16 16:19:48 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_loose_edges_with_normals(Mesh *me)
Object Mode: Display loose edges if overlays are enables. This fix T55280 Loose edges not visible in object mode
2018-06-01 11:35:51 +02:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->ledges_with_normals == NULL) {
const int datatype = MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->ledges_with_normals = GPU_batch_create(
GPU_PRIM_LINES, mesh_batch_cache_get_vert_pos_and_nor_in_order(rdata, cache),
Object Mode: Display loose edges if overlays are enables. This fix T55280 Loose edges not visible in object mode
2018-06-01 11:35:51 +02:00
mesh_batch_cache_get_loose_edges(rdata, cache));
mesh_render_data_free(rdata);
}
return cache->ledges_with_normals;
}
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals_and_weights(Mesh *me, const VertexWeightSelection *vwsel)
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
{
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
MeshBatchCache *cache = mesh_batch_cache_get(me);
mesh_batch_cache_check_vertex_group(cache, vwsel);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
if (cache->triangles_with_weights == NULL) {
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
const bool use_hide = (me->editflag & (ME_EDIT_PAINT_VERT_SEL | ME_EDIT_PAINT_FACE_SEL)) != 0;
Cleanup: line length
2017-05-04 03:35:01 +10:00
const int datatype =
MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY | MR_DATATYPE_DVERT;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->triangles_with_weights = GPU_batch_create_ex(
Implement correct drawing of advanced Weight display features. This adds existing behavior from calc_weightpaint_vert_array that was missing from the new rendering code: - No selected Vertex Group displays as a solid pink color. - Zero weight displays as alert color depending on Options. - Multipaint mode correctly displays collective weight. In order to properly implement this variety, a data structure holding all relevant parameters is introduced. Reviewers: fclem, campbellbarton Subscribers: jbakker Differential Revision: https://developer.blender.org/D3722
2018-09-23 20:41:10 +03:00
GPU_PRIM_TRIS, mesh_create_tri_weights(rdata, use_hide, vwsel), NULL, GPU_BATCH_OWNS_VBO);
DRW_vweight_selection_copy(&cache->vertex_weight_selection, vwsel);
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_tris = use_hide ?
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
mesh_create_tri_pos_and_normals_visible_only(rdata) :
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
DWM: Share VBO positions & normals for mesh cache Select, weight & color cache included redundant position and normals. Use multiple VBO's per batch for more efficient storage.
2017-05-08 16:25:29 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_batch_vertbuf_add_ex(cache->triangles_with_weights, vbo_tris, use_hide);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
mesh_render_data_free(rdata);
}
return cache->triangles_with_weights;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_triangles_with_normals_and_vert_colors(Mesh *me)
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->triangles_with_vert_colors == NULL) {
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
const bool use_hide = (me->editflag & (ME_EDIT_PAINT_VERT_SEL | ME_EDIT_PAINT_FACE_SEL)) != 0;
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
const int datatype =
MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY | MR_DATATYPE_LOOPCOL;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->triangles_with_vert_colors = GPU_batch_create_ex(
GPU_PRIM_TRIS, mesh_create_tri_vert_colors(rdata, use_hide), NULL, GPU_BATCH_OWNS_VBO);
DWM: Share VBO positions & normals for mesh cache Select, weight & color cache included redundant position and normals. Use multiple VBO's per batch for more efficient storage.
2017-05-08 16:25:29 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_tris = use_hide ?
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
mesh_create_tri_pos_and_normals_visible_only(rdata) :
DWM: Initial support vert & weight hidden faces
2017-05-17 16:01:18 +10:00
mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_batch_vertbuf_add_ex(cache->triangles_with_vert_colors, vbo_tris, use_hide);
Vertex paint with draw manager Reviewers: fclem Subscribers: campbellbarton, dfelinto Differential Revision: https://developer.blender.org/D2658
2017-05-04 19:59:27 +02:00
mesh_render_data_free(rdata);
}
return cache->triangles_with_vert_colors;
}
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
struct GPUBatch *DRW_mesh_batch_cache_get_triangles_with_select_id(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
struct Mesh *me, bool use_hide, uint select_id_offset)
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
if (cache->triangles_with_select_id_offset != select_id_offset) {
cache->triangles_with_select_id_offset = select_id_offset;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->triangles_with_select_id);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
if (cache->triangles_with_select_id == NULL) {
const int datatype =
MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->triangles_with_select_id = GPU_batch_create_ex(
GPU_PRIM_TRIS, mesh_create_tri_select_id(rdata, use_hide, select_id_offset), NULL, GPU_BATCH_OWNS_VBO);
DWM: Share VBO positions & normals for mesh cache Select, weight & color cache included redundant position and normals. Use multiple VBO's per batch for more efficient storage.
2017-05-08 16:25:29 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_tris = use_hide ?
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
mesh_create_tri_pos_and_normals_visible_only(rdata) :
Fix weight-painting out of facemask mode w/ hidden faces Own error in recent commit
2017-05-17 19:07:31 +10:00
mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_batch_vertbuf_add_ex(cache->triangles_with_select_id, vbo_tris, use_hide);
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
mesh_render_data_free(rdata);
}
return cache->triangles_with_select_id;
}
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
/**
* Same as #DRW_mesh_batch_cache_get_triangles_with_select_id
* without the ID's, use to mask out geometry, eg - dont select face-dots behind other faces.
*/
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
struct GPUBatch *DRW_mesh_batch_cache_get_triangles_with_select_mask(struct Mesh *me, bool use_hide)
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->triangles_with_select_mask == NULL) {
const int datatype =
MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo_tris = use_hide ?
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
mesh_create_tri_pos_and_normals_visible_only(rdata) :
mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->triangles_with_select_mask = GPU_batch_create_ex(
GPU_PRIM_TRIS, vbo_tris, NULL, use_hide ? GPU_BATCH_OWNS_VBO : 0);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
mesh_render_data_free(rdata);
}
return cache->triangles_with_select_mask;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_points_with_normals(Mesh *me)
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
Clay Engine: Support vertex normals (smooth shading), no face normals yet.
2017-02-15 13:32:35 +01:00
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
if (cache->points_with_normals == NULL) {
Cleanup: line length
2017-05-04 03:35:01 +10:00
const int datatype = MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOP | MR_DATATYPE_POLY;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
Clay Engine: Support vertex normals (smooth shading), no face normals yet.
2017-02-15 13:32:35 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->points_with_normals = GPU_batch_create(
GPU_PRIM_POINTS, mesh_batch_cache_get_tri_pos_and_normals(rdata, cache), NULL);
Clay Engine: Correct Mesh Normals
2017-02-16 16:19:48 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
mesh_render_data_free(rdata);
Clay Engine: Support vertex normals (smooth shading), no face normals yet.
2017-02-15 13:32:35 +01:00
}
Edit Mesh overlay: Ported Display Normals option
2017-03-09 01:29:58 +01:00
return cache->points_with_normals;
Clay Engine: Support vertex normals (smooth shading), no face normals yet.
2017-02-15 13:32:35 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_all_verts(Mesh *me)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->all_verts == NULL) {
/* create batch from DM */
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
MeshRenderData *rdata = mesh_render_data_create(me, MR_DATATYPE_VERT);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->all_verts = GPU_batch_create(
GPU_PRIM_POINTS, mesh_batch_cache_get_vert_pos_and_nor_in_order(rdata, cache), NULL);
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
mesh_render_data_free(rdata);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
return cache->all_verts;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_fancy_edges(Mesh *me)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->fancy_edges == NULL) {
/* create batch from DM */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
static GPUVertFormat format = { 0 };
Cleanup: group VBO attributes in a struct Some names are a bit arbitrary, this makes it clear which names are VBO attributes.
2017-05-17 12:22:22 +10:00
static struct { uint pos, n1, n2; } attr_id;
Cleanup: rename 'ct' to 'len' for gawain
2018-07-08 13:05:41 +02:00
if (format.attr_len == 0) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
attr_id.n1 = GPU_vertformat_attr_add(&format, "N1", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
attr_id.n2 = GPU_vertformat_attr_add(&format, "N2", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Cleanup: line length
2017-05-04 03:35:01 +10:00
MeshRenderData *rdata = mesh_render_data_create(
me, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_POLY);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
const int edge_len = mesh_render_data_edges_len_get(rdata);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
const int vbo_len_capacity = edge_len * 2; /* these are PRIM_LINE verts, not mesh verts */
int vbo_len_used = 0;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
for (int i = 0; i < edge_len; ++i) {
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
float *vcos1, *vcos2;
float *pnor1 = NULL, *pnor2 = NULL;
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
bool is_manifold;
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
if (mesh_render_data_edge_vcos_manifold_pnors(rdata, i, &vcos1, &vcos2, &pnor1, &pnor2, &is_manifold)) {
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUPackedNormal n1value = { .x = 0, .y = 0, .z = +511 };
GPUPackedNormal n2value = { .x = 0, .y = 0, .z = -511 };
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
if (is_manifold) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
n1value = GPU_normal_convert_i10_v3(pnor1);
n2value = GPU_normal_convert_i10_v3(pnor2);
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
}
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
const GPUPackedNormal *n1 = &n1value;
const GPUPackedNormal *n2 = &n2value;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.pos, 2 * i, vcos1);
GPU_vertbuf_attr_set(vbo, attr_id.n1, 2 * i, n1);
GPU_vertbuf_attr_set(vbo, attr_id.n2, 2 * i, n2);
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_attr_set(vbo, attr_id.pos, 2 * i + 1, vcos2);
GPU_vertbuf_attr_set(vbo, attr_id.n1, 2 * i + 1, n1);
GPU_vertbuf_attr_set(vbo, attr_id.n2, 2 * i + 1, n2);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
vbo_len_used += 2;
Draw Manager: T51218 Support edit-mesh hide
2017-04-18 23:29:55 +10:00
}
}
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
if (vbo_len_used != vbo_len_capacity) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_vertbuf_data_resize(vbo, vbo_len_used);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->fancy_edges = GPU_batch_create_ex(GPU_PRIM_LINES, vbo, NULL, GPU_BATCH_OWNS_VBO);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
mesh_render_data_free(rdata);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Rework of BKE's mesh_render to support BMesh directly. Note that since there is no (efficient) ways to get arrays of MVert/MEdge/etc. out of a BMesh, I refactored quite heavily internals of BKE_mesh_render. Now, when you do need acess to mesh data to generate cached batches, you create an abstract struct from mesh (either Mesh or BMesh if available), and then use advanced helpers to extract needed data, on a per-item basis (no more handling of arrays of verts/edges/... in batches code). This allows to: * Avoid having to create arrays of BMesh elements. * Take advantage of existing advanced BMesh topology and connectivity data. Reviewers: dfelinto, fclem, merwin Differential Revision: https://developer.blender.org/D2521
2017-02-23 11:54:40 +01:00
return cache->fancy_edges;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_edge_detection(Mesh *me, bool *r_is_manifold)
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->edge_detection == NULL) {
const int options = MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI;
MeshRenderData *rdata = mesh_render_data_create(me, options);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->edge_detection = GPU_batch_create_ex(
GPU_PRIM_LINES_ADJ, mesh_batch_cache_get_vert_pos_and_nor_in_order(rdata, cache),
Cleanup: whitespace, long lines, duplicate include
2018-05-26 10:41:25 +02:00
mesh_batch_cache_get_edges_adjacency(rdata, cache), 0);
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
mesh_render_data_free(rdata);
}
Workbench: Shadow: Use depth fail method for manifold objects. Since this method have no failure case for manifold objects, use it.
2018-05-21 13:21:26 +02:00
if (r_is_manifold) {
*r_is_manifold = cache->is_manifold;
}
Workbench: Optimize Shadows. This makes the shadows ~10 times faster in the general case. This only create extrusion geometry on the outline edges. Also we increment or decrement the stencil buffer by 2 for each manifold edge and only by 1 for non manifold. This make the algorithm robust yet less heavy than creating one prism for each triangles.
2018-05-19 13:31:44 +02:00
return cache->edge_detection;
}
DRW: Add wireframe buffer texture generation for wireframe drawing. Only OB_MESH is supported for now. Creates a simple index buffer with negative indices if the edges is not a real edge. Also create the buffer texture representation of this buffer along with the pos_in_order buffer texture.
2018-05-31 18:43:19 +02:00
void DRW_mesh_batch_cache_get_wireframes_face_texbuf(
Mesh *me, GPUTexture **verts_data, GPUTexture **face_indices, int *tri_count)
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->edges_face_overlay_tx == NULL || cache->pos_in_order_tx == NULL) {
const int options = MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI;
MeshRenderData *rdata = mesh_render_data_create(me, options);
mesh_batch_cache_get_edges_overlay_texture_buf(rdata, cache);
mesh_batch_cache_get_vert_pos_and_nor_in_order_buf(rdata, cache);
mesh_render_data_free(rdata);
}
*tri_count = cache->edges_face_overlay_tri_count;
*face_indices = cache->edges_face_overlay_tx;
*verts_data = cache->pos_in_order_tx;
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
static void mesh_batch_cache_create_overlay_batches(Mesh *me)
Clay Engine: Edit mesh overlays Based on the previous overlay shader from merwin. This shader takes care of clipped vertex cases and do all edit mode face info in one pass (except face centers). As the shading is done one the triangle itself the visual can't go beyond the surface of the mesh. That leads to half displayed edges on the outline of the mesh. This problem can be fixed by a second pass. This is work in progress.
2017-02-26 21:07:37 +01:00
{
DwM: avoid indirect edit-mesh conversion Storing edit-mesh data as indices for passing only to get back edit-mesh data. This also complicated checks for real edges in tessellation tris. Simpler to pass data directly.
2017-05-24 11:43:55 +10:00
BLI_assert(me->edit_btmesh != NULL);
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
/* Since MR_DATATYPE_OVERLAY is slow to generate, generate them all at once */
Cleanup: line length
2017-05-22 16:23:25 +10:00
const int options =
MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_POLY |
MR_DATATYPE_LOOPTRI | MR_DATATYPE_OVERLAY;
Clay Engine: Edit mesh overlays Based on the previous overlay shader from merwin. This shader takes care of clipped vertex cases and do all edit mode face info in one pass (except face centers). As the shading is done one the triangle itself the visual can't go beyond the surface of the mesh. That leads to half displayed edges on the outline of the mesh. This problem can be fixed by a second pass. This is work in progress.
2017-02-26 21:07:37 +01:00
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
MeshBatchCache *cache = mesh_batch_cache_get(me);
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
MeshRenderData *rdata = mesh_render_data_create(me, options);
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
if (cache->overlay_triangles == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->overlay_triangles = GPU_batch_create(
GPU_PRIM_TRIS, mesh_batch_cache_get_edit_tri_pos(rdata, cache), NULL);
GPU_batch_vertbuf_add(cache->overlay_triangles, mesh_batch_cache_get_edit_tri_nor(rdata, cache));
GPU_batch_vertbuf_add(cache->overlay_triangles, mesh_batch_cache_get_edit_tri_data(rdata, cache));
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
}
Clay Engine: Edit mesh overlays Based on the previous overlay shader from merwin. This shader takes care of clipped vertex cases and do all edit mode face info in one pass (except face centers). As the shading is done one the triangle itself the visual can't go beyond the surface of the mesh. That leads to half displayed edges on the outline of the mesh. This problem can be fixed by a second pass. This is work in progress.
2017-02-26 21:07:37 +01:00
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
if (cache->overlay_loose_edges == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->overlay_loose_edges = GPU_batch_create(
GPU_PRIM_LINES, mesh_batch_cache_get_edit_ledge_pos(rdata, cache), NULL);
GPU_batch_vertbuf_add(cache->overlay_loose_edges, mesh_batch_cache_get_edit_ledge_nor(rdata, cache));
GPU_batch_vertbuf_add(cache->overlay_loose_edges, mesh_batch_cache_get_edit_ledge_data(rdata, cache));
Clay Engine: Edit mesh overlays Based on the previous overlay shader from merwin. This shader takes care of clipped vertex cases and do all edit mode face info in one pass (except face centers). As the shading is done one the triangle itself the visual can't go beyond the surface of the mesh. That leads to half displayed edges on the outline of the mesh. This problem can be fixed by a second pass. This is work in progress.
2017-02-26 21:07:37 +01:00
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
if (cache->overlay_loose_verts == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->overlay_loose_verts = GPU_batch_create(
GPU_PRIM_POINTS, mesh_batch_cache_get_edit_lvert_pos(rdata, cache), NULL);
GPU_batch_vertbuf_add(cache->overlay_loose_verts, mesh_batch_cache_get_edit_lvert_nor(rdata, cache));
GPU_batch_vertbuf_add(cache->overlay_loose_verts, mesh_batch_cache_get_edit_lvert_data(rdata, cache));
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
if (cache->overlay_triangles_nor == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->overlay_triangles_nor = GPU_batch_create(
GPU_PRIM_POINTS, mesh_batch_cache_get_edit_tri_pos(rdata, cache), NULL);
GPU_batch_vertbuf_add(cache->overlay_triangles_nor, mesh_batch_cache_get_edit_tri_nor(rdata, cache));
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
}
if (cache->overlay_loose_edges_nor == NULL) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->overlay_loose_edges_nor = GPU_batch_create(
GPU_PRIM_POINTS, mesh_batch_cache_get_edit_ledge_pos(rdata, cache), NULL);
GPU_batch_vertbuf_add(cache->overlay_loose_edges_nor, mesh_batch_cache_get_edit_ledge_nor(rdata, cache));
Clay Engine: Edit mesh overlays Based on the previous overlay shader from merwin. This shader takes care of clipped vertex cases and do all edit mode face info in one pass (except face centers). As the shading is done one the triangle itself the visual can't go beyond the surface of the mesh. That leads to half displayed edges on the outline of the mesh. This problem can be fixed by a second pass. This is work in progress.
2017-02-26 21:07:37 +01:00
}
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
mesh_render_data_free(rdata);
Clay Engine: Edit mesh overlays Based on the previous overlay shader from merwin. This shader takes care of clipped vertex cases and do all edit mode face info in one pass (except face centers). As the shading is done one the triangle itself the visual can't go beyond the surface of the mesh. That leads to half displayed edges on the outline of the mesh. This problem can be fixed by a second pass. This is work in progress.
2017-02-26 21:07:37 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_overlay_triangles(Mesh *me)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
MeshBatchCache *cache = mesh_batch_cache_get(me);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
if (cache->overlay_triangles == NULL) {
mesh_batch_cache_create_overlay_batches(me);
}
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
return cache->overlay_triangles;
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_overlay_loose_edges(Mesh *me)
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
{
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
MeshBatchCache *cache = mesh_batch_cache_get(me);
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
if (cache->overlay_loose_edges == NULL) {
mesh_batch_cache_create_overlay_batches(me);
}
Edit Mesh overlays: added looses edges and verts as triangle. We loose a bit of memory for (more?) performance.
2017-02-28 14:30:34 +01:00
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
return cache->overlay_loose_edges;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_overlay_loose_verts(Mesh *me)
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
if (cache->overlay_loose_verts == NULL) {
mesh_batch_cache_create_overlay_batches(me);
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
Edit Mode overlays: separate multiple shaders for loose edges and verts
2017-03-01 14:07:04 +01:00
return cache->overlay_loose_verts;
Convert MBC_ API to Mesh (instead of derived mesh) and move it to mesh_render This includes a few fixes in the MBC_ api. The idea here is for this to be the only interface the render engines will deal with for the meshes. If we need to expose special options for sculpting engine we refactor this accordingly. But for now we are shaping this in a per-case base. Note: * We still need to hook up to the depsgraph to force clear/update of batch_cache when mesh changes (I'm waiting for Sergey Sharybin's depsgraph update for this though) * Also ideally we could/should use BMesh directly instead of DerivedMesh, but this will do for now. Note 2: In the end I renamed the `BKE_mesh_render` functions to `static mesh_render`. We can re-expose them as BKE_* later once we need it. Reviewers: merwin Subscribers: fclem Differential Revision: https://developer.blender.org/D2476
2017-01-25 09:16:29 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_overlay_triangles_nor(Mesh *me)
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->overlay_triangles_nor == NULL) {
mesh_batch_cache_create_overlay_batches(me);
}
return cache->overlay_triangles_nor;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_overlay_loose_edges_nor(Mesh *me)
Mesh Batch Cache: Split Edit Mesh mode Vertex Buffers for faster update.
2017-05-13 16:45:06 +02:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->overlay_loose_edges_nor == NULL) {
mesh_batch_cache_create_overlay_batches(me);
}
return cache->overlay_loose_edges_nor;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_overlay_facedots(Mesh *me)
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->overlay_facedots == NULL) {
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
MeshRenderData *rdata = mesh_render_data_create(me, MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY);
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->overlay_facedots = GPU_batch_create(
GPU_PRIM_POINTS, mesh_batch_cache_get_facedot_pos_with_normals_and_flag(rdata, cache), NULL);
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
mesh_render_data_free(rdata);
}
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
return cache->overlay_facedots;
}
Edit Mesh overlay: pack normals with face centers. Needed for face normals.
2017-03-02 15:03:40 +01:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_facedots_with_select_id(Mesh *me, uint select_id_offset)
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
Edit Mesh overlay: pack normals with face centers. Needed for face normals.
2017-03-02 15:03:40 +01:00
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
if (cache->facedot_with_select_id_offset != select_id_offset) {
cache->facedot_with_select_id_offset = select_id_offset;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->edges_with_select_id);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
Edit Mesh overlay: pack normals with face centers. Needed for face normals.
2017-03-02 15:03:40 +01:00
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
if (cache->facedot_with_select_id == NULL) {
MeshRenderData *rdata = mesh_render_data_create(me, MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY);
DWM: Fix face center's not working w/ hidden faces
2017-05-08 16:16:28 +10:00
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
/* We only want the 'pos', not the normals or flag.
* Use since this is almost certainly already created. */
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->facedot_with_select_id = GPU_batch_create(
GPU_PRIM_POINTS, mesh_batch_cache_get_facedot_pos_with_normals_and_flag(rdata, cache), NULL);
Cleanup: replace num/ct/tot with 'len'
2017-04-19 00:10:32 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_batch_vertbuf_add_ex(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
cache->facedot_with_select_id,
mesh_create_facedot_select_id(rdata, select_id_offset), true);
mesh_render_data_free(rdata);
}
return cache->facedot_with_select_id;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_edges_with_select_id(Mesh *me, uint select_id_offset)
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
if (cache->edges_with_select_id_offset != select_id_offset) {
cache->edges_with_select_id_offset = select_id_offset;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->edges_with_select_id);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
if (cache->edges_with_select_id == NULL) {
MeshRenderData *rdata = mesh_render_data_create(me, MR_DATATYPE_VERT | MR_DATATYPE_EDGE);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->edges_with_select_id = GPU_batch_create(
GPU_PRIM_LINES, mesh_batch_cache_get_edges_visible(rdata, cache), NULL);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_batch_vertbuf_add_ex(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
cache->edges_with_select_id,
mesh_create_edges_select_id(rdata, select_id_offset), true);
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
Cleanup: remove type prefix from render-data vars Render data is never mixed with other object types, no need to make a distinction.
2017-04-20 16:24:35 +10:00
mesh_render_data_free(rdata);
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
}
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
return cache->edges_with_select_id;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_verts_with_select_id(Mesh *me, uint select_id_offset)
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->verts_with_select_id_offset != select_id_offset) {
cache->verts_with_select_id_offset = select_id_offset;
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_BATCH_DISCARD_SAFE(cache->verts_with_select_id);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
}
if (cache->verts_with_select_id == NULL) {
MeshRenderData *rdata = mesh_render_data_create(me, MR_DATATYPE_VERT);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->verts_with_select_id = GPU_batch_create(
GPU_PRIM_POINTS, mesh_batch_cache_get_verts_visible(rdata, cache), NULL);
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_batch_vertbuf_add_ex(
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
cache->verts_with_select_id,
mesh_create_verts_select_id(rdata, select_id_offset), true);
mesh_render_data_free(rdata);
}
return cache->verts_with_select_id;
Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue. We don't want to clutter gpu_shader.c with engine specific code Added face's center dot Simplified loose vert shader
2017-03-02 01:07:03 +01:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch **DRW_mesh_batch_cache_get_surface_shaded(
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
Mesh *me, struct GPUMaterial **gpumat_array, uint gpumat_array_len,
char **auto_layer_names, int **auto_layer_is_srgb, int *auto_layer_count)
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->shaded_triangles == NULL) {
/* create batch from DM */
Cleanup: line length
2017-05-04 03:35:01 +10:00
const int datatype =
MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI |
MR_DATATYPE_POLY | MR_DATATYPE_SHADING;
DwM: mesh data now only creates data thats used Read from the GPUMaterial to find custom-data layers used for drawing. This resolves problem where having UV's would always calculate tangents causing noticeable slow down compared to 2.7x.
2017-06-28 13:38:24 +10:00
MeshRenderData *rdata = mesh_render_data_create_ex(me, datatype, gpumat_array, gpumat_array_len);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
Cleanup: naming
2017-05-05 11:31:42 +10:00
const int mat_len = mesh_render_data_mat_len_get(rdata);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
Cleanup: naming
2017-05-05 11:31:42 +10:00
cache->shaded_triangles = MEM_callocN(sizeof(*cache->shaded_triangles) * mat_len, __func__);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUIndexBuf **el = mesh_batch_cache_get_triangles_in_order_split_by_material(rdata, cache);
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
GPUVertBuf *vbo_shading = mesh_batch_cache_get_tri_shading_data(rdata, cache);
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
Cleanup: naming
2017-05-05 11:31:42 +10:00
for (int i = 0; i < mat_len; ++i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->shaded_triangles[i] = GPU_batch_create(
GPU_PRIM_TRIS, vbo, el[i]);
Mesh Batch Cache: get rid of the ORCO VBO data, and reconstruct it in shader. With only one MADD instruction we recover the orco data and reduce both the storage and the fetching cost of an attrib layer.
2017-05-15 16:12:51 +02:00
if (vbo_shading) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_batch_vertbuf_add(cache->shaded_triangles[i], vbo_shading);
Mesh Batch Cache: get rid of the ORCO VBO data, and reconstruct it in shader. With only one MADD instruction we recover the orco data and reduce both the storage and the fetching cost of an attrib layer.
2017-05-15 16:12:51 +02:00
}
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
}
mesh_render_data_free(rdata);
}
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
if (auto_layer_names) {
*auto_layer_names = cache->auto_layer_names;
*auto_layer_is_srgb = cache->auto_layer_is_srgb;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
*auto_layer_count = cache->auto_layer_len;
Eevee: Fix vertex color being in srgb space. Now they are properly converted to Linear space before interpolation. Since the only way to get vertex color in eevee and cycles is via the attribute node with the CD_AUTO_FROM_NAME flag, we have to know at binding time which type of buffer will be connected to this auto input. We store this information inside the batch cache (together with the according uniform name) and pass it as uniform to the shader which does conversion if needed. The same shader can then be reused to draw another mesh with different auto layers configuration.
2018-05-02 15:36:09 +02:00
}
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
return cache->shaded_triangles;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch **DRW_mesh_batch_cache_get_surface_texpaint(Mesh *me)
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->texpaint_triangles == NULL) {
/* create batch from DM */
const int datatype =
MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOPUV;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
const int mat_len = mesh_render_data_mat_len_get(rdata);
cache->texpaint_triangles = MEM_callocN(sizeof(*cache->texpaint_triangles) * mat_len, __func__);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUIndexBuf **el = mesh_batch_cache_get_triangles_in_order_split_by_material(rdata, cache);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
for (int i = 0; i < mat_len; ++i) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->texpaint_triangles[i] = GPU_batch_create(
GPU_PRIM_TRIS, vbo, el[i]);
GPUVertBuf *vbo_uv = mesh_batch_cache_get_tri_uv_active(rdata, cache);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
if (vbo_uv) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_batch_vertbuf_add(cache->texpaint_triangles[i], vbo_uv);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
}
}
mesh_render_data_free(rdata);
}
return cache->texpaint_triangles;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_surface_texpaint_single(Mesh *me)
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->texpaint_triangles_single == NULL) {
/* create batch from DM */
const int datatype =
MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY | MR_DATATYPE_LOOPTRI | MR_DATATYPE_LOOPUV;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUVertBuf *vbo = mesh_batch_cache_get_tri_pos_and_normals(rdata, cache);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->texpaint_triangles_single = GPU_batch_create(
GPU_PRIM_TRIS, vbo, NULL);
GPUVertBuf *vbo_uv = mesh_batch_cache_get_tri_uv_active(rdata, cache);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
if (vbo_uv) {
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_batch_vertbuf_add(cache->texpaint_triangles_single, vbo_uv);
DwM: texture paint support & mask mode Uses workaround so material slots are used when neither blender-internal or cycles are enabled.
2017-05-22 23:31:46 +10:00
}
mesh_render_data_free(rdata);
}
return cache->texpaint_triangles_single;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_weight_overlay_edges(Mesh *me, bool use_wire, bool use_sel)
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
Clean up weight/vertex painting code Now passing selection state instead of colors for the wire/face mask overlay thing. Also added masking indication on the faces in vertex paint.
2017-05-05 14:25:43 +02:00
if (cache->overlay_paint_edges == NULL) {
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
/* create batch from Mesh */
Cleanup: line length
2017-05-04 03:35:01 +10:00
const int datatype = MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_POLY | MR_DATATYPE_LOOP;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->overlay_paint_edges = GPU_batch_create_ex(
GPU_PRIM_LINES, mesh_create_edge_pos_with_sel(rdata, use_wire, use_sel), NULL, GPU_BATCH_OWNS_VBO);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
mesh_render_data_free(rdata);
}
Clean up weight/vertex painting code Now passing selection state instead of colors for the wire/face mask overlay thing. Also added masking indication on the faces in vertex paint.
2017-05-05 14:25:43 +02:00
return cache->overlay_paint_edges;
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_weight_overlay_faces(Mesh *me)
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->overlay_weight_faces == NULL) {
/* create batch from Mesh */
Cleanup: line length
2017-05-04 03:35:01 +10:00
const int datatype = MR_DATATYPE_VERT | MR_DATATYPE_POLY | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI;
MeshRenderData *rdata = mesh_render_data_create(me, datatype);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->overlay_weight_faces = GPU_batch_create_ex(
GPU_PRIM_TRIS, mesh_batch_cache_get_vert_pos_and_nor_in_order(rdata, cache),
mesh_create_tri_overlay_weight_faces(rdata), GPU_BATCH_OWNS_INDEX);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
mesh_render_data_free(rdata);
}
return cache->overlay_weight_faces;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPUBatch *DRW_mesh_batch_cache_get_weight_overlay_verts(Mesh *me)
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
{
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache->overlay_weight_verts == NULL) {
/* create batch from Mesh */
MeshRenderData *rdata = mesh_render_data_create(me, MR_DATATYPE_VERT);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
cache->overlay_weight_verts = GPU_batch_create(
GPU_PRIM_POINTS, mesh_batch_cache_get_vert_pos_and_nor_in_order(rdata, cache), NULL);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_batch_vertbuf_add_ex(
Re-use vertex position VBO in weight-paint mode
2017-05-18 14:53:43 +10:00
cache->overlay_weight_verts,
DwM: use gawain ownership flags for mesh drawing
2017-08-16 17:47:58 +10:00
mesh_create_vert_pos_with_overlay_data(rdata), true);
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
mesh_render_data_free(rdata);
}
return cache->overlay_weight_verts;
}
DwM: Option to use final material over mode shading Support using full material shading in sculpt & paint modes mode. Access 'Full Shading' from the display panel when in paint modes.
2017-07-13 00:27:06 +10:00
/**
* Needed for when we draw with shaded data.
*/
void DRW_mesh_cache_sculpt_coords_ensure(Mesh *me)
{
Mesh: move runtime members to own struct
2018-05-02 15:47:45 +02:00
if (me->runtime.batch_cache) {
DwM: Option to use final material over mode shading Support using full material shading in sculpt & paint modes mode. Access 'Full Shading' from the display panel when in paint modes.
2017-07-13 00:27:06 +10:00
MeshBatchCache *cache = mesh_batch_cache_get(me);
if (cache && cache->pos_with_normals && cache->is_sculpt_points_tag) {
Mesh: Batch cache: Fix sculpt update issue. Old solution was to create a new vbo and copy it to the location of the old vbo hoping for the batches to update their vaos before drawing. The issue is that the new VAO caching is not updating the VAOs at all unless the shader interface changes. So unless we expand gawain to support updating of vertex buffers (in a better way than the current "dynamic" buffer) we need to delete every batch linked to the vbo we want to recreate. This solution might have performance implications.
2018-03-15 13:55:20 +01:00
/* XXX Force update of all the batches that contains the pos_with_normals buffer.
* TODO(fclem): Ideally, Gawain should provide a way to update a buffer without destroying it. */
mesh_batch_cache_clear_selective(me, cache->pos_with_normals);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_VERTBUF_DISCARD_SAFE(cache->pos_with_normals);
DwM: Option to use final material over mode shading Support using full material shading in sculpt & paint modes mode. Access 'Full Shading' from the display panel when in paint modes.
2017-07-13 00:27:06 +10:00
}
cache->is_sculpt_points_tag = false;
}
}
Cleanup: use doxy categories
2017-05-05 05:07:52 +10:00
/** \} */
Copy Permalink