bartvdbraak/blender
1
0
Fork 4
Code Issues 4 Pull Requests 1 Actions 1 Packages Projects Releases Wiki Activity
eb837ba17e
blender/intern/cycles/subd/split.cpp
Brecht Van Lommel 9cfc7967dd Cycles: use SPDX license headers 
* Replace license text in headers with SPDX identifiers.
* Remove specific license info from outdated readme.txt, instead leave details
  to the source files.
* Add list of SPDX license identifiers used, and corresponding license texts.
* Update copyright dates while we're at it.

Ref D14069, T95597
2022-02-11 17:47:34 +01:00

736 lines
21 KiB
C++
Raw Blame History

/* SPDX-License-Identifier: Apache-2.0
* Copyright 2011-2022 Blender Foundation */
#include "scene/camera.h"
#include "scene/mesh.h"
#include "subd/dice.h"
#include "subd/patch.h"
#include "subd/split.h"
#include "util/algorithm.h"
#include "util/foreach.h"
#include "util/hash.h"
#include "util/math.h"
#include "util/types.h"
CCL_NAMESPACE_BEGIN
/* DiagSplit */
#define DSPLIT_NON_UNIFORM -1
#define STITCH_NGON_CENTER_VERT_INDEX_OFFSET 0x60000000
#define STITCH_NGON_SPLIT_EDGE_CENTER_VERT_TAG (0x60000000 - 1)
DiagSplit::DiagSplit(const SubdParams &params_) : params(params_)
{
}
float3 DiagSplit::to_world(Patch *patch, float2 uv)
{
float3 P;
patch->eval(&P, NULL, NULL, NULL, uv.x, uv.y);
if (params.camera)
P = transform_point(&params.objecttoworld, P);
return P;
}
static void order_float2(float2 &a, float2 &b)
{
if (b.x < a.x || b.y < a.y) {
swap(a, b);
}
}
int DiagSplit::T(Patch *patch, float2 Pstart, float2 Pend, bool recursive_resolve)
{
order_float2(Pstart, Pend); /* May not be necessary, but better to be safe. */
float Lsum = 0.0f;
float Lmax = 0.0f;
float3 Plast = to_world(patch, Pstart);
for (int i = 1; i < params.test_steps; i++) {
float t = i / (float)(params.test_steps - 1);
float3 P = to_world(patch, Pstart + t * (Pend - Pstart));
float L;
if (!params.camera) {
L = len(P - Plast);
}
else {
Camera *cam = params.camera;
float pixel_width = cam->world_to_raster_size((P + Plast) * 0.5f);
L = len(P - Plast) / pixel_width;
}
Lsum += L;
Lmax = max(L, Lmax);
Plast = P;
}
int tmin = (int)ceilf(Lsum / params.dicing_rate);
int tmax = (int)ceilf((params.test_steps - 1) * Lmax /
params.dicing_rate); // XXX paper says N instead of N-1, seems wrong?
int res = max(tmax, 1);
if (tmax - tmin > params.split_threshold) {
if (!recursive_resolve) {
res = DSPLIT_NON_UNIFORM;
}
else {
float2 P = (Pstart + Pend) * 0.5f;
res = T(patch, Pstart, P, true) + T(patch, P, Pend, true);
}
}
limit_edge_factor(res, patch, Pstart, Pend);
return res;
}
void DiagSplit::partition_edge(
Patch *patch, float2 *P, int *t0, int *t1, float2 Pstart, float2 Pend, int t)
{
if (t == DSPLIT_NON_UNIFORM) {
*P = (Pstart + Pend) * 0.5f;
*t0 = T(patch, Pstart, *P);
*t1 = T(patch, *P, Pend);
}
else {
assert(t >= 2); /* Need at least two segments to partition into. */
int I = (int)floorf((float)t * 0.5f);
*P = interp(Pstart, Pend, I / (float)t);
*t0 = I;
*t1 = t - I;
}
}
void DiagSplit::limit_edge_factor(int &T, Patch *patch, float2 Pstart, float2 Pend)
{
int max_t = 1 << params.max_level;
int max_t_for_edge = int(max_t * len(Pstart - Pend));
if (patch->from_ngon) {
max_t_for_edge >>= 1; /* Initial split of ngon causes edges to extend half the distance. */
}
T = (max_t_for_edge <= 1) ? 1 : min(T, max_t_for_edge);
assert(T >= 1 || T == DSPLIT_NON_UNIFORM);
}
void DiagSplit::resolve_edge_factors(Subpatch &sub)
{
/* Resolve DSPLIT_NON_UNIFORM to actual T value if splitting is no longer possible. */
if (sub.edge_u0.T == 1 && sub.edge_u1.T == DSPLIT_NON_UNIFORM) {
sub.edge_u1.T = T(sub.patch, sub.c01, sub.c11, true);
}
if (sub.edge_u1.T == 1 && sub.edge_u0.T == DSPLIT_NON_UNIFORM) {
sub.edge_u0.T = T(sub.patch, sub.c00, sub.c10, true);
}
if (sub.edge_v0.T == 1 && sub.edge_v1.T == DSPLIT_NON_UNIFORM) {
sub.edge_v1.T = T(sub.patch, sub.c11, sub.c10, true);
}
if (sub.edge_v1.T == 1 && sub.edge_v0.T == DSPLIT_NON_UNIFORM) {
sub.edge_v0.T = T(sub.patch, sub.c01, sub.c00, true);
}
}
void DiagSplit::split(Subpatch &sub, int depth)
{
if (depth > 32) {
/* We should never get here, but just in case end recursion safely. */
assert(!"diagsplit recursion limit reached");
sub.edge_u0.T = 1;
sub.edge_u1.T = 1;
sub.edge_v0.T = 1;
sub.edge_v1.T = 1;
subpatches.push_back(sub);
return;
}
bool split_u = (sub.edge_u0.T == DSPLIT_NON_UNIFORM || sub.edge_u1.T == DSPLIT_NON_UNIFORM);
bool split_v = (sub.edge_v0.T == DSPLIT_NON_UNIFORM || sub.edge_v1.T == DSPLIT_NON_UNIFORM);
/* Split subpatches such that the ratio of T for opposite edges doesn't
* exceed 1.5, this reduces over tessellation for some patches
*/
/* clang-format off */
if (min(sub.edge_u0.T, sub.edge_u1.T) > 8 && /* Must be uniform and preferably greater than 8 to split. */
min(sub.edge_v0.T, sub.edge_v1.T) >= 2 && /* Must be uniform and at least 2 to split. */
max(sub.edge_u0.T, sub.edge_u1.T) / min(sub.edge_u0.T, sub.edge_u1.T) > 1.5f)
{
split_v = true;
}
if (min(sub.edge_v0.T, sub.edge_v1.T) > 8 &&
min(sub.edge_u0.T, sub.edge_u1.T) >= 2 &&
max(sub.edge_v0.T, sub.edge_v1.T) / min(sub.edge_v0.T, sub.edge_v1.T) > 1.5f)
{
split_u = true;
}
/* clang-format on */
/* Alternate axis. */
if (split_u && split_v) {
split_u = depth % 2;
}
if (!split_u && !split_v) {
/* Add the unsplit subpatch. */
subpatches.push_back(sub);
Subpatch &subpatch = subpatches[subpatches.size() - 1];
/* Update T values and offsets. */
for (int i = 0; i < 4; i++) {
Subpatch::edge_t &edge = subpatch.edges[i];
edge.offset = edge.edge->T;
edge.edge->T += edge.T;
}
}
else {
/* Copy into new subpatches. */
Subpatch sub_a = sub;
Subpatch sub_b = sub;
/* Pointers to various subpatch elements. */
Subpatch::edge_t *sub_across_0, *sub_across_1;
Subpatch::edge_t *sub_a_across_0, *sub_a_across_1;
Subpatch::edge_t *sub_b_across_0, *sub_b_across_1;
Subpatch::edge_t *sub_a_split, *sub_b_split;
float2 *Pa, *Pb, *Pc, *Pd;
/* Set pointers based on split axis. */
if (split_u) {
sub_across_0 = &sub.edge_u0;
sub_across_1 = &sub.edge_u1;
sub_a_across_0 = &sub_a.edge_u0;
sub_a_across_1 = &sub_a.edge_u1;
sub_b_across_0 = &sub_b.edge_u0;
sub_b_across_1 = &sub_b.edge_u1;
sub_a_split = &sub_a.edge_v1;
sub_b_split = &sub_b.edge_v0;
Pa = &sub_a.c11;
Pb = &sub_a.c10;
Pc = &sub_b.c01;
Pd = &sub_b.c00;
}
else {
sub_across_0 = &sub.edge_v0;
sub_across_1 = &sub.edge_v1;
sub_a_across_0 = &sub_a.edge_v0;
sub_a_across_1 = &sub_a.edge_v1;
sub_b_across_0 = &sub_b.edge_v0;
sub_b_across_1 = &sub_b.edge_v1;
sub_a_split = &sub_a.edge_u0;
sub_b_split = &sub_b.edge_u1;
Pa = &sub_a.c10;
Pb = &sub_a.c00;
Pc = &sub_b.c11;
Pd = &sub_b.c01;
}
/* Partition edges */
float2 P0, P1;
partition_edge(
sub.patch, &P0, &sub_a_across_0->T, &sub_b_across_0->T, *Pd, *Pb, sub_across_0->T);
partition_edge(
sub.patch, &P1, &sub_a_across_1->T, &sub_b_across_1->T, *Pc, *Pa, sub_across_1->T);
/* Split */
*Pa = P1;
*Pb = P0;
*Pc = P1;
*Pd = P0;
int tsplit = T(sub.patch, P0, P1);
if (depth == -2 && tsplit == 1) {
tsplit = 2; /* Ensure we can always split at depth -1. */
}
sub_a_split->T = tsplit;
sub_b_split->T = tsplit;
resolve_edge_factors(sub_a);
resolve_edge_factors(sub_b);
/* Create new edge */
Edge &edge = *alloc_edge();
sub_a_split->edge = &edge;
sub_b_split->edge = &edge;
sub_a_split->offset = 0;
sub_b_split->offset = 0;
sub_a_split->indices_decrease_along_edge = false;
sub_b_split->indices_decrease_along_edge = true;
sub_a_split->sub_edges_created_in_reverse_order = !split_u;
sub_b_split->sub_edges_created_in_reverse_order = !split_u;
edge.top_indices_decrease = sub_across_1->sub_edges_created_in_reverse_order;
edge.bottom_indices_decrease = sub_across_0->sub_edges_created_in_reverse_order;
/* Recurse */
edge.T = 0;
split(sub_a, depth + 1);
int edge_t = edge.T;
(void)edge_t;
edge.top_offset = sub_across_1->edge->T;
edge.bottom_offset = sub_across_0->edge->T;
edge.T = 0; /* We calculate T twice along each edge. :/ */
split(sub_b, depth + 1);
assert(edge.T == edge_t); /* If this fails we will crash at some later point! */
edge.top = sub_across_1->edge;
edge.bottom = sub_across_0->edge;
}
}
int DiagSplit::alloc_verts(int n)
{
int a = num_alloced_verts;
num_alloced_verts += n;
return a;
}
Edge *DiagSplit::alloc_edge()
{
edges.emplace_back();
return &edges.back();
}
void DiagSplit::split_patches(Patch *patches, size_t patches_byte_stride)
{
int patch_index = 0;
for (int f = 0; f < params.mesh->get_num_subd_faces(); f++) {
Mesh::SubdFace face = params.mesh->get_subd_face(f);
Patch *patch = (Patch *)(((char *)patches) + patch_index * patches_byte_stride);
if (face.is_quad()) {
patch_index++;
split_quad(face, patch);
}
else {
patch_index += face.num_corners;
split_ngon(face, patch, patches_byte_stride);
}
}
params.mesh->vert_to_stitching_key_map.clear();
params.mesh->vert_stitching_map.clear();
post_split();
}
static Edge *create_edge_from_corner(DiagSplit *split,
const Mesh *mesh,
const Mesh::SubdFace &face,
int corner,
bool &reversed,
int v0,
int v1)
{
int a = mesh->get_subd_face_corners()[face.start_corner + mod(corner + 0, face.num_corners)];
int b = mesh->get_subd_face_corners()[face.start_corner + mod(corner + 1, face.num_corners)];
reversed = !(b < a);
if (b < a) {
swap(a, b);
swap(v0, v1);
}
Edge *edge = split->alloc_edge();
edge->is_stitch_edge = true;
edge->stitch_start_vert_index = a;
edge->stitch_end_vert_index = b;
edge->start_vert_index = v0;
edge->end_vert_index = v1;
edge->stitch_edge_key = {a, b};
return edge;
}
void DiagSplit::split_quad(const Mesh::SubdFace &face, Patch *patch)
{
Subpatch subpatch(patch);
int v = alloc_verts(4);
bool v0_reversed, u1_reversed, v1_reversed, u0_reversed;
subpatch.edge_v0.edge = create_edge_from_corner(
this, params.mesh, face, 3, v0_reversed, v + 3, v + 0);
subpatch.edge_u1.edge = create_edge_from_corner(
this, params.mesh, face, 2, u1_reversed, v + 2, v + 3);
subpatch.edge_v1.edge = create_edge_from_corner(
this, params.mesh, face, 1, v1_reversed, v + 1, v + 2);
subpatch.edge_u0.edge = create_edge_from_corner(
this, params.mesh, face, 0, u0_reversed, v + 0, v + 1);
subpatch.edge_v0.sub_edges_created_in_reverse_order = !v0_reversed;
subpatch.edge_u1.sub_edges_created_in_reverse_order = u1_reversed;
subpatch.edge_v1.sub_edges_created_in_reverse_order = v1_reversed;
subpatch.edge_u0.sub_edges_created_in_reverse_order = !u0_reversed;
subpatch.edge_v0.indices_decrease_along_edge = v0_reversed;
subpatch.edge_u1.indices_decrease_along_edge = u1_reversed;
subpatch.edge_v1.indices_decrease_along_edge = v1_reversed;
subpatch.edge_u0.indices_decrease_along_edge = u0_reversed;
/* Forces a split in both axis for quads, needed to match split of ngons into quads. */
subpatch.edge_u0.T = DSPLIT_NON_UNIFORM;
subpatch.edge_u1.T = DSPLIT_NON_UNIFORM;
subpatch.edge_v0.T = DSPLIT_NON_UNIFORM;
subpatch.edge_v1.T = DSPLIT_NON_UNIFORM;
split(subpatch, -2);
}
static Edge *create_split_edge_from_corner(DiagSplit *split,
const Mesh *mesh,
const Mesh::SubdFace &face,
int corner,
int side,
bool &reversed,
int v0,
int v1,
int vc)
{
Edge *edge = split->alloc_edge();
int a = mesh->get_subd_face_corners()[face.start_corner + mod(corner + 0, face.num_corners)];
int b = mesh->get_subd_face_corners()[face.start_corner + mod(corner + 1, face.num_corners)];
if (b < a) {
edge->stitch_edge_key = {b, a};
}
else {
edge->stitch_edge_key = {a, b};
}
reversed = !(b < a);
if (side == 0) {
a = vc;
}
else {
b = vc;
}
if (!reversed) {
swap(a, b);
swap(v0, v1);
}
edge->is_stitch_edge = true;
edge->stitch_start_vert_index = a;
edge->stitch_end_vert_index = b;
edge->start_vert_index = v0;
edge->end_vert_index = v1;
return edge;
}
void DiagSplit::split_ngon(const Mesh::SubdFace &face, Patch *patches, size_t patches_byte_stride)
{
Edge *prev_edge_u0 = nullptr;
Edge *first_edge_v0 = nullptr;
for (int corner = 0; corner < face.num_corners; corner++) {
Patch *patch = (Patch *)(((char *)patches) + corner * patches_byte_stride);
Subpatch subpatch(patch);
int v = alloc_verts(4);
/* Setup edges. */
Edge *edge_u1 = alloc_edge();
Edge *edge_v1 = alloc_edge();
edge_v1->is_stitch_edge = true;
edge_u1->is_stitch_edge = true;
edge_u1->stitch_start_vert_index = -(face.start_corner + mod(corner + 0, face.num_corners)) -
1;
edge_u1->stitch_end_vert_index = STITCH_NGON_CENTER_VERT_INDEX_OFFSET + face.ptex_offset;
edge_u1->start_vert_index = v + 3;
edge_u1->end_vert_index = v + 2;
edge_u1->stitch_edge_key = {edge_u1->stitch_start_vert_index, edge_u1->stitch_end_vert_index};
edge_v1->stitch_start_vert_index = -(face.start_corner + mod(corner + 1, face.num_corners)) -
1;
edge_v1->stitch_end_vert_index = STITCH_NGON_CENTER_VERT_INDEX_OFFSET + face.ptex_offset;
edge_v1->start_vert_index = v + 1;
edge_v1->end_vert_index = v + 2;
edge_v1->stitch_edge_key = {edge_v1->stitch_start_vert_index, edge_v1->stitch_end_vert_index};
bool v0_reversed, u0_reversed;
subpatch.edge_v0.edge = create_split_edge_from_corner(this,
params.mesh,
face,
corner - 1,
0,
v0_reversed,
v + 3,
v + 0,
STITCH_NGON_SPLIT_EDGE_CENTER_VERT_TAG);
subpatch.edge_u1.edge = edge_u1;
subpatch.edge_v1.edge = edge_v1;
subpatch.edge_u0.edge = create_split_edge_from_corner(this,
params.mesh,
face,
corner + 0,
1,
u0_reversed,
v + 0,
v + 1,
STITCH_NGON_SPLIT_EDGE_CENTER_VERT_TAG);
subpatch.edge_v0.sub_edges_created_in_reverse_order = !v0_reversed;
subpatch.edge_u1.sub_edges_created_in_reverse_order = false;
subpatch.edge_v1.sub_edges_created_in_reverse_order = true;
subpatch.edge_u0.sub_edges_created_in_reverse_order = !u0_reversed;
subpatch.edge_v0.indices_decrease_along_edge = v0_reversed;
subpatch.edge_u1.indices_decrease_along_edge = false;
subpatch.edge_v1.indices_decrease_along_edge = true;
subpatch.edge_u0.indices_decrease_along_edge = u0_reversed;
/* Perform split. */
{
subpatch.edge_u0.T = T(subpatch.patch, subpatch.c00, subpatch.c10);
subpatch.edge_u1.T = T(subpatch.patch, subpatch.c01, subpatch.c11);
subpatch.edge_v0.T = T(subpatch.patch, subpatch.c00, subpatch.c01);
subpatch.edge_v1.T = T(subpatch.patch, subpatch.c10, subpatch.c11);
resolve_edge_factors(subpatch);
split(subpatch, 0);
}
/* Update offsets after T is known from split. */
edge_u1->top = subpatch.edge_v0.edge;
edge_u1->stitch_top_offset = edge_u1->top->T * (v0_reversed ? -1 : 1);
edge_v1->top = subpatch.edge_u0.edge;
edge_v1->stitch_top_offset = edge_v1->top->T * (!u0_reversed ? -1 : 1);
if (corner == 0) {
first_edge_v0 = subpatch.edge_v0.edge;
}
if (prev_edge_u0) {
if (v0_reversed) {
subpatch.edge_v0.edge->stitch_offset = prev_edge_u0->T;
}
else {
prev_edge_u0->stitch_offset = subpatch.edge_v0.edge->T;
}
int T = subpatch.edge_v0.edge->T + prev_edge_u0->T;
subpatch.edge_v0.edge->stitch_edge_T = T;
prev_edge_u0->stitch_edge_T = T;
}
if (corner == face.num_corners - 1) {
if (v0_reversed) {
subpatch.edge_u0.edge->stitch_offset = first_edge_v0->T;
}
else {
first_edge_v0->stitch_offset = subpatch.edge_u0.edge->T;
}
int T = first_edge_v0->T + subpatch.edge_u0.edge->T;
first_edge_v0->stitch_edge_T = T;
subpatch.edge_u0.edge->stitch_edge_T = T;
}
prev_edge_u0 = subpatch.edge_u0.edge;
}
}
void DiagSplit::post_split()
{
int num_stitch_verts = 0;
/* All patches are now split, and all T values known. */
foreach (Edge &edge, edges) {
if (edge.second_vert_index < 0) {
edge.second_vert_index = alloc_verts(edge.T - 1);
}
if (edge.is_stitch_edge) {
num_stitch_verts = max(num_stitch_verts,
max(edge.stitch_start_vert_index, edge.stitch_end_vert_index));
}
}
num_stitch_verts += 1;
/* Map of edge key to edge stitching vert offset. */
struct pair_hasher {
size_t operator()(const pair<int, int> &k) const
{
return hash_uint2(k.first, k.second);
}
};
typedef unordered_map<pair<int, int>, int, pair_hasher> edge_stitch_verts_map_t;
edge_stitch_verts_map_t edge_stitch_verts_map;
foreach (Edge &edge, edges) {
if (edge.is_stitch_edge) {
if (edge.stitch_edge_T == 0) {
edge.stitch_edge_T = edge.T;
}
if (edge_stitch_verts_map.find(edge.stitch_edge_key) == edge_stitch_verts_map.end()) {
edge_stitch_verts_map[edge.stitch_edge_key] = num_stitch_verts;
num_stitch_verts += edge.stitch_edge_T - 1;
}
}
}
/* Set start and end indices for edges generated from a split. */
foreach (Edge &edge, edges) {
if (edge.start_vert_index < 0) {
/* Fix up offsets. */
if (edge.top_indices_decrease) {
edge.top_offset = edge.top->T - edge.top_offset;
}
edge.start_vert_index = edge.top->get_vert_along_edge(edge.top_offset);
}
if (edge.end_vert_index < 0) {
if (edge.bottom_indices_decrease) {
edge.bottom_offset = edge.bottom->T - edge.bottom_offset;
}
edge.end_vert_index = edge.bottom->get_vert_along_edge(edge.bottom_offset);
}
}
int vert_offset = params.mesh->verts.size();
/* Add verts to stitching map. */
foreach (const Edge &edge, edges) {
if (edge.is_stitch_edge) {
int second_stitch_vert_index = edge_stitch_verts_map[edge.stitch_edge_key];
for (int i = 0; i <= edge.T; i++) {
/* Get proper stitching key. */
int key;
if (i == 0) {
key = edge.stitch_start_vert_index;
}
else if (i == edge.T) {
key = edge.stitch_end_vert_index;
}
else {
key = second_stitch_vert_index + i - 1 + edge.stitch_offset;
}
if (key == STITCH_NGON_SPLIT_EDGE_CENTER_VERT_TAG) {
if (i == 0) {
key = second_stitch_vert_index - 1 + edge.stitch_offset;
}
else if (i == edge.T) {
key = second_stitch_vert_index - 1 + edge.T;
}
}
else if (key < 0 && edge.top) { /* ngon spoke edge */
int s = edge_stitch_verts_map[edge.top->stitch_edge_key];
if (edge.stitch_top_offset >= 0) {
key = s - 1 + edge.stitch_top_offset;
}
else {
key = s - 1 + edge.top->stitch_edge_T + edge.stitch_top_offset;
}
}
/* Get real vert index. */
int vert = edge.get_vert_along_edge(i) + vert_offset;
/* Add to map */
if (params.mesh->vert_to_stitching_key_map.find(vert) ==
params.mesh->vert_to_stitching_key_map.end()) {
params.mesh->vert_to_stitching_key_map[vert] = key;
params.mesh->vert_stitching_map.insert({key, vert});
}
}
}
}
/* Dice; TODO(mai): Move this out of split. */
QuadDice dice(params);
int num_verts = num_alloced_verts;
int num_triangles = 0;
for (size_t i = 0; i < subpatches.size(); i++) {
subpatches[i].inner_grid_vert_offset = num_verts;
num_verts += subpatches[i].calc_num_inner_verts();
num_triangles += subpatches[i].calc_num_triangles();
}
dice.reserve(num_verts, num_triangles);
for (size_t i = 0; i < subpatches.size(); i++) {
Subpatch &sub = subpatches[i];
sub.edge_u0.T = max(sub.edge_u0.T, 1);
sub.edge_u1.T = max(sub.edge_u1.T, 1);
sub.edge_v0.T = max(sub.edge_v0.T, 1);
sub.edge_v1.T = max(sub.edge_v1.T, 1);
dice.dice(sub);
}
/* Cleanup */
subpatches.clear();
edges.clear();
}
CCL_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink