Vulkan: Clearing Framebuffer + Scissors #106044
|
@ -78,12 +78,7 @@ include(cmake/tbb.cmake)
|
|||
include(cmake/python.cmake)
|
||||
include(cmake/llvm.cmake)
|
||||
include(cmake/osl.cmake)
|
||||
option(USE_PIP_NUMPY "Install NumPy using pip wheel instead of building from source" OFF)
|
||||
if(APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "x86_64"))
|
||||
set(USE_PIP_NUMPY ON)
|
||||
else()
|
||||
include(cmake/numpy.cmake)
|
||||
endif()
|
||||
include(cmake/numpy.cmake)
|
||||
include(cmake/python_site_packages.cmake)
|
||||
include(cmake/package_python.cmake)
|
||||
include(cmake/openimageio.cmake)
|
||||
|
|
|
@ -38,15 +38,6 @@ ExternalProject_Add(external_python_site_packages
|
|||
--no-binary :all:
|
||||
)
|
||||
|
||||
if(USE_PIP_NUMPY)
|
||||
# Use only wheel (and not build from source) to stop NumPy from linking against buggy
|
||||
# Accelerate framework backend on macOS. Official wheels are built with OpenBLAS.
|
||||
ExternalProject_Add_Step(external_python_site_packages after_install
|
||||
COMMAND ${PYTHON_BINARY} -m pip install --no-cache-dir numpy==${NUMPY_VERSION} --only-binary :all:
|
||||
DEPENDEES install
|
||||
)
|
||||
endif()
|
||||
|
||||
add_dependencies(
|
||||
external_python_site_packages
|
||||
external_python
|
||||
|
|
|
@ -165,9 +165,9 @@ set(OPENMP_URI https://github.com/llvm/llvm-project/releases/download/llvmorg-${
|
|||
set(OPENMP_HASH_TYPE MD5)
|
||||
set(OPENMP_FILE openmp-${OPENMP_VERSION}.src.tar.xz)
|
||||
|
||||
set(OPENIMAGEIO_VERSION v2.4.6.0)
|
||||
set(OPENIMAGEIO_VERSION v2.4.9.0)
|
||||
set(OPENIMAGEIO_URI https://github.com/OpenImageIO/oiio/archive/refs/tags/${OPENIMAGEIO_VERSION}.tar.gz)
|
||||
set(OPENIMAGEIO_HASH c7acc1b9a8fda04ef48f7de1feda4dae)
|
||||
set(OPENIMAGEIO_HASH 7da92a7d6029921a8599a977ff1efa2a)
|
||||
set(OPENIMAGEIO_HASH_TYPE MD5)
|
||||
set(OPENIMAGEIO_FILE OpenImageIO-${OPENIMAGEIO_VERSION}.tar.gz)
|
||||
|
||||
|
|
|
@ -517,7 +517,7 @@ OPENEXR_FORCE_REBUILD=false
|
|||
OPENEXR_SKIP=false
|
||||
_with_built_openexr=false
|
||||
|
||||
OIIO_VERSION="2.4.6.0"
|
||||
OIIO_VERSION="2.4.9.0"
|
||||
OIIO_VERSION_SHORT="2.4"
|
||||
OIIO_VERSION_MIN="2.2.0"
|
||||
OIIO_VERSION_MEX="2.5.0"
|
||||
|
|
|
@ -80,6 +80,7 @@ set(_CLANG_FIND_COMPONENTS
|
|||
clangAST
|
||||
clangLex
|
||||
clangBasic
|
||||
clangSupport
|
||||
)
|
||||
|
||||
set(_CLANG_LIBRARIES)
|
||||
|
@ -94,7 +95,9 @@ foreach(COMPONENT ${_CLANG_FIND_COMPONENTS})
|
|||
PATH_SUFFIXES
|
||||
lib64 lib
|
||||
)
|
||||
list(APPEND _CLANG_LIBRARIES "${CLANG_${UPPERCOMPONENT}_LIBRARY}")
|
||||
if(CLANG_${UPPERCOMPONENT}_LIBRARY)
|
||||
list(APPEND _CLANG_LIBRARIES "${CLANG_${UPPERCOMPONENT}_LIBRARY}")
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
|
||||
|
|
|
@ -178,8 +178,8 @@ if(NOT MSVC_CLANG)
|
|||
endif()
|
||||
|
||||
if(WITH_WINDOWS_SCCACHE AND CMAKE_VS_MSBUILD_COMMAND)
|
||||
message(WARNING "Disabling sccache, sccache is not supported with msbuild")
|
||||
set(WITH_WINDOWS_SCCACHE OFF)
|
||||
message(WARNING "Disabling sccache, sccache is not supported with msbuild")
|
||||
set(WITH_WINDOWS_SCCACHE OFF)
|
||||
endif()
|
||||
|
||||
# Debug Symbol format
|
||||
|
|
|
@ -7,7 +7,7 @@ set(INC
|
|||
)
|
||||
|
||||
set(INC_SYS
|
||||
|
||||
${X11_X11_INCLUDE_PATH}
|
||||
)
|
||||
|
||||
set(SRC
|
||||
|
|
|
@ -204,7 +204,7 @@ ccl_device bool integrator_init_from_bake(KernelGlobals kg,
|
|||
ray.time = 0.5f;
|
||||
ray.dP = differential_zero_compact();
|
||||
ray.dD = differential_zero_compact();
|
||||
integrator_state_write_ray(kg, state, &ray);
|
||||
integrator_state_write_ray(state, &ray);
|
||||
|
||||
/* Setup next kernel to execute. */
|
||||
integrator_path_init(kg, state, DEVICE_KERNEL_INTEGRATOR_SHADE_BACKGROUND);
|
||||
|
@ -299,7 +299,7 @@ ccl_device bool integrator_init_from_bake(KernelGlobals kg,
|
|||
ray.dD = differential_zero_compact();
|
||||
|
||||
/* Write ray. */
|
||||
integrator_state_write_ray(kg, state, &ray);
|
||||
integrator_state_write_ray(state, &ray);
|
||||
|
||||
/* Setup and write intersection. */
|
||||
Intersection isect ccl_optional_struct_init;
|
||||
|
@ -309,7 +309,7 @@ ccl_device bool integrator_init_from_bake(KernelGlobals kg,
|
|||
isect.v = v;
|
||||
isect.t = 1.0f;
|
||||
isect.type = PRIMITIVE_TRIANGLE;
|
||||
integrator_state_write_isect(kg, state, &isect);
|
||||
integrator_state_write_isect(state, &isect);
|
||||
|
||||
/* Setup next kernel to execute. */
|
||||
const bool use_caustics = kernel_data.integrator.use_caustics &&
|
||||
|
|
|
@ -85,7 +85,7 @@ ccl_device bool integrator_init_from_camera(KernelGlobals kg,
|
|||
}
|
||||
|
||||
/* Write camera ray to state. */
|
||||
integrator_state_write_ray(kg, state, &ray);
|
||||
integrator_state_write_ray(state, &ray);
|
||||
}
|
||||
|
||||
/* Initialize path state for path integration. */
|
||||
|
|
|
@ -150,7 +150,7 @@ ccl_device_forceinline void integrator_intersect_next_kernel_after_shadow_catche
|
|||
/* Continue with shading shadow catcher surface. Same as integrator_split_shadow_catcher, but
|
||||
* using NEXT instead of INIT. */
|
||||
Intersection isect ccl_optional_struct_init;
|
||||
integrator_state_read_isect(kg, state, &isect);
|
||||
integrator_state_read_isect(state, &isect);
|
||||
|
||||
const int shader = intersection_get_shader(kg, &isect);
|
||||
const int flags = kernel_data_fetch(shaders, shader).flags;
|
||||
|
@ -326,7 +326,7 @@ ccl_device void integrator_intersect_closest(KernelGlobals kg,
|
|||
|
||||
/* Read ray from integrator state into local memory. */
|
||||
Ray ray ccl_optional_struct_init;
|
||||
integrator_state_read_ray(kg, state, &ray);
|
||||
integrator_state_read_ray(state, &ray);
|
||||
kernel_assert(ray.tmax != 0.0f);
|
||||
|
||||
const uint visibility = path_state_ray_visibility(state);
|
||||
|
@ -397,7 +397,7 @@ ccl_device void integrator_intersect_closest(KernelGlobals kg,
|
|||
}
|
||||
|
||||
/* Write intersection result into global integrator state memory. */
|
||||
integrator_state_write_isect(kg, state, &isect);
|
||||
integrator_state_write_isect(state, &isect);
|
||||
|
||||
/* Setup up next kernel to be executed. */
|
||||
integrator_intersect_next_kernel<DEVICE_KERNEL_INTEGRATOR_INTERSECT_CLOSEST>(
|
||||
|
|
|
@ -142,7 +142,7 @@ ccl_device void integrator_intersect_shadow(KernelGlobals kg, IntegratorShadowSt
|
|||
|
||||
/* Read ray from integrator state into local memory. */
|
||||
Ray ray ccl_optional_struct_init;
|
||||
integrator_state_read_shadow_ray(kg, state, &ray);
|
||||
integrator_state_read_shadow_ray(state, &ray);
|
||||
ray.self.object = INTEGRATOR_STATE_ARRAY(state, shadow_isect, 0, object);
|
||||
ray.self.prim = INTEGRATOR_STATE_ARRAY(state, shadow_isect, 0, prim);
|
||||
ray.self.light_object = INTEGRATOR_STATE_ARRAY(state, shadow_isect, 1, object);
|
||||
|
|
|
@ -73,7 +73,7 @@ ccl_device void integrator_volume_stack_init(KernelGlobals kg, IntegratorState s
|
|||
ccl_private ShaderData *stack_sd = AS_SHADER_DATA(&stack_sd_storage);
|
||||
|
||||
Ray volume_ray ccl_optional_struct_init;
|
||||
integrator_state_read_ray(kg, state, &volume_ray);
|
||||
integrator_state_read_ray(state, &volume_ray);
|
||||
|
||||
/* Trace ray in random direction. Any direction works, Z up is a guess to get the
|
||||
* fewest hits. */
|
||||
|
|
|
@ -16,7 +16,7 @@ ccl_device_inline void integrate_light(KernelGlobals kg,
|
|||
{
|
||||
/* Setup light sample. */
|
||||
Intersection isect ccl_optional_struct_init;
|
||||
integrator_state_read_isect(kg, state, &isect);
|
||||
integrator_state_read_isect(state, &isect);
|
||||
|
||||
guiding_record_light_surface_segment(kg, state, &isect);
|
||||
|
||||
|
|
|
@ -35,7 +35,7 @@ ccl_device_inline Spectrum integrate_transparent_surface_shadow(KernelGlobals kg
|
|||
integrator_state_read_shadow_isect(state, &isect, hit);
|
||||
|
||||
Ray ray ccl_optional_struct_init;
|
||||
integrator_state_read_shadow_ray(kg, state, &ray);
|
||||
integrator_state_read_shadow_ray(state, &ray);
|
||||
|
||||
shader_setup_from_ray(kg, shadow_sd, &ray, &isect);
|
||||
|
||||
|
@ -70,7 +70,7 @@ ccl_device_inline void integrate_transparent_volume_shadow(KernelGlobals kg,
|
|||
|
||||
/* Setup shader data. */
|
||||
Ray ray ccl_optional_struct_init;
|
||||
integrator_state_read_shadow_ray(kg, state, &ray);
|
||||
integrator_state_read_shadow_ray(state, &ray);
|
||||
ray.self.object = OBJECT_NONE;
|
||||
ray.self.prim = PRIM_NONE;
|
||||
ray.self.light_object = OBJECT_NONE;
|
||||
|
|
|
@ -24,10 +24,10 @@ ccl_device_forceinline void integrate_surface_shader_setup(KernelGlobals kg,
|
|||
ccl_private ShaderData *sd)
|
||||
{
|
||||
Intersection isect ccl_optional_struct_init;
|
||||
integrator_state_read_isect(kg, state, &isect);
|
||||
integrator_state_read_isect(state, &isect);
|
||||
|
||||
Ray ray ccl_optional_struct_init;
|
||||
integrator_state_read_ray(kg, state, &ray);
|
||||
integrator_state_read_ray(state, &ray);
|
||||
|
||||
shader_setup_from_ray(kg, sd, &ray, &isect);
|
||||
}
|
||||
|
@ -253,7 +253,7 @@ ccl_device_forceinline void integrate_surface_direct_light(KernelGlobals kg,
|
|||
}
|
||||
|
||||
/* Write shadow ray and associated state to global memory. */
|
||||
integrator_state_write_shadow_ray(kg, shadow_state, &ray);
|
||||
integrator_state_write_shadow_ray(shadow_state, &ray);
|
||||
// Save memory by storing the light and object indices in the shadow_isect
|
||||
INTEGRATOR_STATE_ARRAY_WRITE(shadow_state, shadow_isect, 0, object) = ray.self.object;
|
||||
INTEGRATOR_STATE_ARRAY_WRITE(shadow_state, shadow_isect, 0, prim) = ray.self.prim;
|
||||
|
@ -548,7 +548,7 @@ ccl_device_forceinline void integrate_surface_ao(KernelGlobals kg,
|
|||
integrator_state_copy_volume_stack_to_shadow(kg, shadow_state, state);
|
||||
|
||||
/* Write shadow ray and associated state to global memory. */
|
||||
integrator_state_write_shadow_ray(kg, shadow_state, &ray);
|
||||
integrator_state_write_shadow_ray(shadow_state, &ray);
|
||||
INTEGRATOR_STATE_ARRAY_WRITE(shadow_state, shadow_isect, 0, object) = ray.self.object;
|
||||
INTEGRATOR_STATE_ARRAY_WRITE(shadow_state, shadow_isect, 0, prim) = ray.self.prim;
|
||||
INTEGRATOR_STATE_ARRAY_WRITE(shadow_state, shadow_isect, 1, object) = ray.self.light_object;
|
||||
|
|
|
@ -827,7 +827,7 @@ ccl_device_forceinline void integrate_volume_direct_light(
|
|||
kg, state, DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW, false);
|
||||
|
||||
/* Write shadow ray and associated state to global memory. */
|
||||
integrator_state_write_shadow_ray(kg, shadow_state, &ray);
|
||||
integrator_state_write_shadow_ray(shadow_state, &ray);
|
||||
INTEGRATOR_STATE_ARRAY_WRITE(shadow_state, shadow_isect, 0, object) = ray.self.object;
|
||||
INTEGRATOR_STATE_ARRAY_WRITE(shadow_state, shadow_isect, 0, prim) = ray.self.prim;
|
||||
INTEGRATOR_STATE_ARRAY_WRITE(shadow_state, shadow_isect, 1, object) = ray.self.light_object;
|
||||
|
@ -1172,10 +1172,10 @@ ccl_device void integrator_shade_volume(KernelGlobals kg,
|
|||
#ifdef __VOLUME__
|
||||
/* Setup shader data. */
|
||||
Ray ray ccl_optional_struct_init;
|
||||
integrator_state_read_ray(kg, state, &ray);
|
||||
integrator_state_read_ray(state, &ray);
|
||||
|
||||
Intersection isect ccl_optional_struct_init;
|
||||
integrator_state_read_isect(kg, state, &isect);
|
||||
integrator_state_read_isect(state, &isect);
|
||||
|
||||
/* Set ray length to current segment. */
|
||||
ray.tmax = (isect.prim != PRIM_NONE) ? isect.t : FLT_MAX;
|
||||
|
|
|
@ -11,8 +11,7 @@ CCL_NAMESPACE_BEGIN
|
|||
|
||||
/* Ray */
|
||||
|
||||
ccl_device_forceinline void integrator_state_write_ray(KernelGlobals kg,
|
||||
IntegratorState state,
|
||||
ccl_device_forceinline void integrator_state_write_ray(IntegratorState state,
|
||||
ccl_private const Ray *ccl_restrict ray)
|
||||
{
|
||||
INTEGRATOR_STATE_WRITE(state, ray, P) = ray->P;
|
||||
|
@ -24,8 +23,7 @@ ccl_device_forceinline void integrator_state_write_ray(KernelGlobals kg,
|
|||
INTEGRATOR_STATE_WRITE(state, ray, dD) = ray->dD;
|
||||
}
|
||||
|
||||
ccl_device_forceinline void integrator_state_read_ray(KernelGlobals kg,
|
||||
ConstIntegratorState state,
|
||||
ccl_device_forceinline void integrator_state_read_ray(ConstIntegratorState state,
|
||||
ccl_private Ray *ccl_restrict ray)
|
||||
{
|
||||
ray->P = INTEGRATOR_STATE(state, ray, P);
|
||||
|
@ -40,7 +38,7 @@ ccl_device_forceinline void integrator_state_read_ray(KernelGlobals kg,
|
|||
/* Shadow Ray */
|
||||
|
||||
ccl_device_forceinline void integrator_state_write_shadow_ray(
|
||||
KernelGlobals kg, IntegratorShadowState state, ccl_private const Ray *ccl_restrict ray)
|
||||
IntegratorShadowState state, ccl_private const Ray *ccl_restrict ray)
|
||||
{
|
||||
INTEGRATOR_STATE_WRITE(state, shadow_ray, P) = ray->P;
|
||||
INTEGRATOR_STATE_WRITE(state, shadow_ray, D) = ray->D;
|
||||
|
@ -50,8 +48,7 @@ ccl_device_forceinline void integrator_state_write_shadow_ray(
|
|||
INTEGRATOR_STATE_WRITE(state, shadow_ray, dP) = ray->dP;
|
||||
}
|
||||
|
||||
ccl_device_forceinline void integrator_state_read_shadow_ray(KernelGlobals kg,
|
||||
ConstIntegratorShadowState state,
|
||||
ccl_device_forceinline void integrator_state_read_shadow_ray(ConstIntegratorShadowState state,
|
||||
ccl_private Ray *ccl_restrict ray)
|
||||
{
|
||||
ray->P = INTEGRATOR_STATE(state, shadow_ray, P);
|
||||
|
@ -66,7 +63,7 @@ ccl_device_forceinline void integrator_state_read_shadow_ray(KernelGlobals kg,
|
|||
/* Intersection */
|
||||
|
||||
ccl_device_forceinline void integrator_state_write_isect(
|
||||
KernelGlobals kg, IntegratorState state, ccl_private const Intersection *ccl_restrict isect)
|
||||
IntegratorState state, ccl_private const Intersection *ccl_restrict isect)
|
||||
{
|
||||
INTEGRATOR_STATE_WRITE(state, isect, t) = isect->t;
|
||||
INTEGRATOR_STATE_WRITE(state, isect, u) = isect->u;
|
||||
|
@ -77,7 +74,7 @@ ccl_device_forceinline void integrator_state_write_isect(
|
|||
}
|
||||
|
||||
ccl_device_forceinline void integrator_state_read_isect(
|
||||
KernelGlobals kg, ConstIntegratorState state, ccl_private Intersection *ccl_restrict isect)
|
||||
ConstIntegratorState state, ccl_private Intersection *ccl_restrict isect)
|
||||
{
|
||||
isect->prim = INTEGRATOR_STATE(state, isect, prim);
|
||||
isect->object = INTEGRATOR_STATE(state, isect, object);
|
||||
|
|
|
@ -162,8 +162,8 @@ ccl_device_inline bool subsurface_scatter(KernelGlobals kg, IntegratorState stat
|
|||
ray.P += ray.D * ray.tmax * 2.0f;
|
||||
ray.D = -ray.D;
|
||||
|
||||
integrator_state_write_isect(kg, state, &ss_isect.hits[0]);
|
||||
integrator_state_write_ray(kg, state, &ray);
|
||||
integrator_state_write_isect(state, &ss_isect.hits[0]);
|
||||
integrator_state_write_ray(state, &ray);
|
||||
|
||||
/* Advance random number offset for bounce. */
|
||||
INTEGRATOR_STATE_WRITE(state, path, rng_offset) += PRNG_BOUNCE_NUM;
|
||||
|
|
|
@ -161,7 +161,11 @@ ccl_device_inline void osl_eval_nodes(KernelGlobals kg,
|
|||
/* shadeindex = */ 0);
|
||||
# endif
|
||||
|
||||
# if __cplusplus < 201703L
|
||||
if (type == SHADER_TYPE_DISPLACEMENT) {
|
||||
# else
|
||||
if constexpr (type == SHADER_TYPE_DISPLACEMENT) {
|
||||
# endif
|
||||
sd->P = globals.P;
|
||||
}
|
||||
else if (globals.Ci) {
|
||||
|
|
|
@ -1646,8 +1646,8 @@ enum KernelFeatureFlag : uint32_t {
|
|||
|
||||
/* Must be constexpr on the CPU to avoid compile errors because the state types
|
||||
* are different depending on the main, shadow or null path. For GPU we don't have
|
||||
* C++17 everywhere so can't use it. */
|
||||
#ifdef __KERNEL_GPU__
|
||||
* C++17 everywhere so need to check it. */
|
||||
#if __cplusplus < 201703L
|
||||
# define IF_KERNEL_FEATURE(feature) if ((node_feature_mask & (KERNEL_FEATURE_##feature)) != 0U)
|
||||
# define IF_KERNEL_NODES_FEATURE(feature) \
|
||||
if ((node_feature_mask & (KERNEL_FEATURE_NODE_##feature)) != 0U)
|
||||
|
|
|
@ -577,14 +577,14 @@ void LightManager::device_update_tree(Device *,
|
|||
int stack_id = 0;
|
||||
const LightTreeNode *node = light_tree.get_root();
|
||||
for (int index = 0; index < light_tree.size(); index++) {
|
||||
light_tree_nodes[index].energy = node->energy;
|
||||
light_tree_nodes[index].energy = node->measure.energy;
|
||||
|
||||
light_tree_nodes[index].bbox.min = node->bbox.min;
|
||||
light_tree_nodes[index].bbox.max = node->bbox.max;
|
||||
light_tree_nodes[index].bbox.min = node->measure.bbox.min;
|
||||
light_tree_nodes[index].bbox.max = node->measure.bbox.max;
|
||||
|
||||
light_tree_nodes[index].bcone.axis = node->bcone.axis;
|
||||
light_tree_nodes[index].bcone.theta_o = node->bcone.theta_o;
|
||||
light_tree_nodes[index].bcone.theta_e = node->bcone.theta_e;
|
||||
light_tree_nodes[index].bcone.axis = node->measure.bcone.axis;
|
||||
light_tree_nodes[index].bcone.theta_o = node->measure.bcone.theta_o;
|
||||
light_tree_nodes[index].bcone.theta_e = node->measure.bcone.theta_e;
|
||||
|
||||
light_tree_nodes[index].bit_trail = node->bit_trail;
|
||||
light_tree_nodes[index].num_prims = node->num_prims;
|
||||
|
@ -597,9 +597,9 @@ void LightManager::device_update_tree(Device *,
|
|||
int emitter_index = i + node->first_prim_index;
|
||||
LightTreePrimitive &prim = light_prims[emitter_index];
|
||||
|
||||
light_tree_emitters[emitter_index].energy = prim.energy;
|
||||
light_tree_emitters[emitter_index].theta_o = prim.bcone.theta_o;
|
||||
light_tree_emitters[emitter_index].theta_e = prim.bcone.theta_e;
|
||||
light_tree_emitters[emitter_index].energy = prim.measure.energy;
|
||||
light_tree_emitters[emitter_index].theta_o = prim.measure.bcone.theta_o;
|
||||
light_tree_emitters[emitter_index].theta_e = prim.measure.bcone.theta_e;
|
||||
|
||||
if (prim.is_triangle()) {
|
||||
light_tree_emitters[emitter_index].mesh_light.object_id = prim.object_id;
|
||||
|
|
|
@ -9,6 +9,10 @@ CCL_NAMESPACE_BEGIN
|
|||
|
||||
float OrientationBounds::calculate_measure() const
|
||||
{
|
||||
if (this->is_empty()) {
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
float theta_w = fminf(M_PI_F, theta_o + theta_e);
|
||||
float cos_theta_o = cosf(theta_o);
|
||||
float sin_theta_o = sinf(theta_o);
|
||||
|
@ -20,10 +24,10 @@ float OrientationBounds::calculate_measure() const
|
|||
|
||||
OrientationBounds merge(const OrientationBounds &cone_a, const OrientationBounds &cone_b)
|
||||
{
|
||||
if (is_zero(cone_a.axis)) {
|
||||
if (cone_a.is_empty()) {
|
||||
return cone_b;
|
||||
}
|
||||
if (is_zero(cone_b.axis)) {
|
||||
if (cone_b.is_empty()) {
|
||||
return cone_a;
|
||||
}
|
||||
|
||||
|
@ -62,9 +66,6 @@ OrientationBounds merge(const OrientationBounds &cone_a, const OrientationBounds
|
|||
LightTreePrimitive::LightTreePrimitive(Scene *scene, int prim_id, int object_id)
|
||||
: prim_id(prim_id), object_id(object_id)
|
||||
{
|
||||
bcone = OrientationBounds::empty;
|
||||
bbox = BoundBox::empty;
|
||||
|
||||
if (is_triangle()) {
|
||||
float3 vertices[3];
|
||||
Object *object = scene->objects[object_id];
|
||||
|
@ -88,7 +89,7 @@ LightTreePrimitive::LightTreePrimitive(Scene *scene, int prim_id, int object_id)
|
|||
|
||||
/* TODO: need a better way to handle this when textures are used. */
|
||||
float area = triangle_area(vertices[0], vertices[1], vertices[2]);
|
||||
energy = area * average(shader->emission_estimate);
|
||||
measure.energy = area * average(shader->emission_estimate);
|
||||
|
||||
/* NOTE: the original implementation used the bounding box centroid, but primitive centroid
|
||||
* seems to work fine */
|
||||
|
@ -98,24 +99,25 @@ LightTreePrimitive::LightTreePrimitive(Scene *scene, int prim_id, int object_id)
|
|||
const bool is_back_only = (shader->emission_sampling == EMISSION_SAMPLING_BACK);
|
||||
if (is_front_only || is_back_only) {
|
||||
/* One-sided. */
|
||||
bcone.axis = safe_normalize(cross(vertices[1] - vertices[0], vertices[2] - vertices[0]));
|
||||
measure.bcone.axis = safe_normalize(
|
||||
cross(vertices[1] - vertices[0], vertices[2] - vertices[0]));
|
||||
if (is_back_only) {
|
||||
bcone.axis = -bcone.axis;
|
||||
measure.bcone.axis = -measure.bcone.axis;
|
||||
}
|
||||
if (transform_negative_scale(object->get_tfm())) {
|
||||
bcone.axis = -bcone.axis;
|
||||
measure.bcone.axis = -measure.bcone.axis;
|
||||
}
|
||||
bcone.theta_o = 0;
|
||||
measure.bcone.theta_o = 0;
|
||||
}
|
||||
else {
|
||||
/* Double sided: any vector in the plane. */
|
||||
bcone.axis = safe_normalize(vertices[0] - vertices[1]);
|
||||
bcone.theta_o = M_PI_2_F;
|
||||
measure.bcone.axis = safe_normalize(vertices[0] - vertices[1]);
|
||||
measure.bcone.theta_o = M_PI_2_F;
|
||||
}
|
||||
bcone.theta_e = M_PI_2_F;
|
||||
measure.bcone.theta_e = M_PI_2_F;
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
bbox.grow(vertices[i]);
|
||||
measure.bbox.grow(vertices[i]);
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
@ -125,74 +127,75 @@ LightTreePrimitive::LightTreePrimitive(Scene *scene, int prim_id, int object_id)
|
|||
float3 strength = lamp->get_strength();
|
||||
|
||||
centroid = scene->lights[object_id]->get_co();
|
||||
bcone.axis = normalize(lamp->get_dir());
|
||||
measure.bcone.axis = normalize(lamp->get_dir());
|
||||
|
||||
if (type == LIGHT_AREA) {
|
||||
bcone.theta_o = 0;
|
||||
bcone.theta_e = lamp->get_spread() * 0.5f;
|
||||
measure.bcone.theta_o = 0;
|
||||
measure.bcone.theta_e = lamp->get_spread() * 0.5f;
|
||||
|
||||
/* For an area light, sizeu and sizev determine the 2 dimensions of the area light,
|
||||
* while axisu and axisv determine the orientation of the 2 dimensions.
|
||||
* We want to add all 4 corners to our bounding box. */
|
||||
const float3 half_extentu = 0.5f * lamp->get_sizeu() * lamp->get_axisu() * size;
|
||||
const float3 half_extentv = 0.5f * lamp->get_sizev() * lamp->get_axisv() * size;
|
||||
bbox.grow(centroid + half_extentu + half_extentv);
|
||||
bbox.grow(centroid + half_extentu - half_extentv);
|
||||
bbox.grow(centroid - half_extentu + half_extentv);
|
||||
bbox.grow(centroid - half_extentu - half_extentv);
|
||||
measure.bbox.grow(centroid + half_extentu + half_extentv);
|
||||
measure.bbox.grow(centroid + half_extentu - half_extentv);
|
||||
measure.bbox.grow(centroid - half_extentu + half_extentv);
|
||||
measure.bbox.grow(centroid - half_extentu - half_extentv);
|
||||
|
||||
strength *= 0.25f; /* eval_fac scaling in `area.h` */
|
||||
}
|
||||
else if (type == LIGHT_POINT) {
|
||||
bcone.theta_o = M_PI_F;
|
||||
bcone.theta_e = M_PI_2_F;
|
||||
measure.bcone.theta_o = M_PI_F;
|
||||
measure.bcone.theta_e = M_PI_2_F;
|
||||
|
||||
/* Point and spot lights can emit light from any point within its radius. */
|
||||
const float3 radius = make_float3(size);
|
||||
bbox.grow(centroid - radius);
|
||||
bbox.grow(centroid + radius);
|
||||
measure.bbox.grow(centroid - radius);
|
||||
measure.bbox.grow(centroid + radius);
|
||||
|
||||
strength *= 0.25f * M_1_PI_F; /* eval_fac scaling in `spot.h` and `point.h` */
|
||||
}
|
||||
else if (type == LIGHT_SPOT) {
|
||||
bcone.theta_o = 0;
|
||||
measure.bcone.theta_o = 0;
|
||||
|
||||
const float unscaled_theta_e = lamp->get_spot_angle() * 0.5f;
|
||||
const float len_u = len(lamp->get_axisu());
|
||||
const float len_v = len(lamp->get_axisv());
|
||||
const float len_w = len(lamp->get_dir());
|
||||
|
||||
bcone.theta_e = fast_atanf(fast_tanf(unscaled_theta_e) * fmaxf(len_u, len_v) / len_w);
|
||||
measure.bcone.theta_e = fast_atanf(fast_tanf(unscaled_theta_e) * fmaxf(len_u, len_v) /
|
||||
len_w);
|
||||
|
||||
/* Point and spot lights can emit light from any point within its radius. */
|
||||
const float3 radius = make_float3(size);
|
||||
bbox.grow(centroid - radius);
|
||||
bbox.grow(centroid + radius);
|
||||
measure.bbox.grow(centroid - radius);
|
||||
measure.bbox.grow(centroid + radius);
|
||||
|
||||
strength *= 0.25f * M_1_PI_F; /* eval_fac scaling in `spot.h` and `point.h` */
|
||||
}
|
||||
else if (type == LIGHT_BACKGROUND) {
|
||||
/* Set an arbitrary direction for the background light. */
|
||||
bcone.axis = make_float3(0.0f, 0.0f, 1.0f);
|
||||
measure.bcone.axis = make_float3(0.0f, 0.0f, 1.0f);
|
||||
/* TODO: this may depend on portal lights as well. */
|
||||
bcone.theta_o = M_PI_F;
|
||||
bcone.theta_e = 0;
|
||||
measure.bcone.theta_o = M_PI_F;
|
||||
measure.bcone.theta_e = 0;
|
||||
|
||||
/* integrate over cosine-weighted hemisphere */
|
||||
strength *= lamp->get_average_radiance() * M_PI_F;
|
||||
}
|
||||
else if (type == LIGHT_DISTANT) {
|
||||
bcone.theta_o = 0;
|
||||
bcone.theta_e = 0.5f * lamp->get_angle();
|
||||
measure.bcone.theta_o = 0;
|
||||
measure.bcone.theta_e = 0.5f * lamp->get_angle();
|
||||
}
|
||||
|
||||
if (lamp->get_shader()) {
|
||||
strength *= lamp->get_shader()->emission_estimate;
|
||||
}
|
||||
|
||||
/* Use absolute value of energy so lights with negative strength are properly
|
||||
* supported in the light tree. */
|
||||
energy = fabsf(average(strength));
|
||||
/* Use absolute value of energy so lights with negative strength are properly supported in the
|
||||
* light tree. */
|
||||
measure.energy = fabsf(average(strength));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -208,22 +211,18 @@ LightTree::LightTree(vector<LightTreePrimitive> &prims,
|
|||
const int num_prims = prims.size();
|
||||
const int num_local_lights = num_prims - num_distant_lights;
|
||||
|
||||
root = create_node(BoundBox::empty, OrientationBounds::empty, 0.0f, 0);
|
||||
root_ = create_node(LightTreePrimitivesMeasure::empty, 0);
|
||||
|
||||
/* All local lights are grouped to the left child as an inner node. */
|
||||
recursive_build(left, root.get(), 0, num_local_lights, &prims, 0, 1);
|
||||
recursive_build(left, root_.get(), 0, num_local_lights, &prims, 0, 1);
|
||||
task_pool.wait_work();
|
||||
|
||||
OrientationBounds bcone = OrientationBounds::empty;
|
||||
float energy_total = 0.0;
|
||||
/* All distant lights are grouped to the right child as a leaf node. */
|
||||
root_->children[right] = create_node(LightTreePrimitivesMeasure::empty, 1);
|
||||
for (int i = num_local_lights; i < num_prims; i++) {
|
||||
const LightTreePrimitive &prim = prims.at(i);
|
||||
bcone = merge(bcone, prim.bcone);
|
||||
energy_total += prim.energy;
|
||||
root_->children[right]->add(prims[i]);
|
||||
}
|
||||
|
||||
root->children[right] = create_node(BoundBox::empty, bcone, energy_total, 1);
|
||||
root->children[right]->make_leaf(num_local_lights, num_distant_lights);
|
||||
root_->children[right]->make_leaf(num_local_lights, num_distant_lights);
|
||||
}
|
||||
|
||||
void LightTree::recursive_build(const Child child,
|
||||
|
@ -234,41 +233,21 @@ void LightTree::recursive_build(const Child child,
|
|||
const uint bit_trail,
|
||||
const int depth)
|
||||
{
|
||||
BoundBox bbox = BoundBox::empty;
|
||||
OrientationBounds bcone = OrientationBounds::empty;
|
||||
BoundBox centroid_bounds = BoundBox::empty;
|
||||
float energy_total = 0.0f;
|
||||
const int num_prims = end - start;
|
||||
|
||||
for (int i = start; i < end; i++) {
|
||||
const LightTreePrimitive &prim = (*prims)[i];
|
||||
bbox.grow(prim.bbox);
|
||||
bcone = merge(bcone, prim.bcone);
|
||||
centroid_bounds.grow(prim.centroid);
|
||||
|
||||
energy_total += prim.energy;
|
||||
centroid_bounds.grow((*prims)[i].centroid);
|
||||
}
|
||||
|
||||
parent->children[child] = create_node(bbox, bcone, energy_total, bit_trail);
|
||||
LightTreeNode *current_node = parent->children[child].get();
|
||||
parent->children[child] = create_node(LightTreePrimitivesMeasure::empty, bit_trail);
|
||||
LightTreeNode *node = parent->children[child].get();
|
||||
|
||||
const bool try_splitting = num_prims > 1 && len(centroid_bounds.size()) > 0.0f;
|
||||
int split_dim = -1, split_bucket = 0, num_left_prims = 0;
|
||||
bool should_split = false;
|
||||
if (try_splitting) {
|
||||
/* Find the best place to split the primitives into 2 nodes.
|
||||
* If the best split cost is no better than making a leaf node, make a leaf instead. */
|
||||
const float min_cost = min_split_saoh(
|
||||
centroid_bounds, start, end, bbox, bcone, split_dim, split_bucket, num_left_prims, *prims);
|
||||
should_split = num_prims > max_lights_in_leaf_ || min_cost < energy_total;
|
||||
}
|
||||
if (should_split) {
|
||||
int middle;
|
||||
/* Find the best place to split the primitives into 2 nodes.
|
||||
* If the best split cost is no better than making a leaf node, make a leaf instead. */
|
||||
int split_dim = -1, middle;
|
||||
if (should_split(*prims, start, middle, end, node->measure, centroid_bounds, split_dim)) {
|
||||
|
||||
if (split_dim != -1) {
|
||||
/* Partition the primitives between start and end based on the split dimension and bucket
|
||||
* calculated by `split_saoh` */
|
||||
middle = start + num_left_prims;
|
||||
/* Partition the primitives between start and end based on the centroids. */
|
||||
std::nth_element(prims->begin() + start,
|
||||
prims->begin() + middle,
|
||||
prims->begin() + end,
|
||||
|
@ -276,141 +255,131 @@ void LightTree::recursive_build(const Child child,
|
|||
return l.centroid[split_dim] < r.centroid[split_dim];
|
||||
});
|
||||
}
|
||||
else {
|
||||
/* Degenerate case with many lights in the same place. */
|
||||
middle = (start + end) / 2;
|
||||
}
|
||||
|
||||
/* Recursively build the left branch. */
|
||||
if (middle - start > MIN_PRIMS_PER_THREAD) {
|
||||
task_pool.push([=] {
|
||||
recursive_build(left, current_node, start, middle, prims, bit_trail, depth + 1);
|
||||
});
|
||||
task_pool.push(
|
||||
[=] { recursive_build(left, node, start, middle, prims, bit_trail, depth + 1); });
|
||||
}
|
||||
else {
|
||||
recursive_build(left, current_node, start, middle, prims, bit_trail, depth + 1);
|
||||
recursive_build(left, node, start, middle, prims, bit_trail, depth + 1);
|
||||
}
|
||||
|
||||
/* Recursively build the right branch. */
|
||||
if (end - middle > MIN_PRIMS_PER_THREAD) {
|
||||
task_pool.push([=] {
|
||||
recursive_build(
|
||||
right, current_node, middle, end, prims, bit_trail | (1u << depth), depth + 1);
|
||||
recursive_build(right, node, middle, end, prims, bit_trail | (1u << depth), depth + 1);
|
||||
});
|
||||
}
|
||||
else {
|
||||
recursive_build(
|
||||
right, current_node, middle, end, prims, bit_trail | (1u << depth), depth + 1);
|
||||
recursive_build(right, node, middle, end, prims, bit_trail | (1u << depth), depth + 1);
|
||||
}
|
||||
}
|
||||
else {
|
||||
current_node->make_leaf(start, num_prims);
|
||||
node->make_leaf(start, end - start);
|
||||
}
|
||||
}
|
||||
|
||||
float LightTree::min_split_saoh(const BoundBox ¢roid_bbox,
|
||||
const int start,
|
||||
const int end,
|
||||
const BoundBox &bbox,
|
||||
const OrientationBounds &bcone,
|
||||
int &split_dim,
|
||||
int &split_bucket,
|
||||
int &num_left_prims,
|
||||
const vector<LightTreePrimitive> &prims)
|
||||
bool LightTree::should_split(const vector<LightTreePrimitive> &prims,
|
||||
const int start,
|
||||
int &middle,
|
||||
const int end,
|
||||
LightTreePrimitivesMeasure &measure,
|
||||
const BoundBox ¢roid_bbox,
|
||||
int &split_dim)
|
||||
{
|
||||
/* Even though this factor is used for every bucket, we use it to compare
|
||||
* the min_cost and total_energy (when deciding between creating a leaf or interior node. */
|
||||
const float bbox_area = bbox.area();
|
||||
const bool has_area = bbox_area != 0.0f;
|
||||
const float total_area = has_area ? bbox_area : len(bbox.size());
|
||||
const float total_cost = total_area * bcone.calculate_measure();
|
||||
if (total_cost == 0.0f) {
|
||||
return FLT_MAX;
|
||||
}
|
||||
|
||||
const float inv_total_cost = 1.0f / total_cost;
|
||||
middle = (start + end) / 2;
|
||||
const int num_prims = end - start;
|
||||
const float3 extent = centroid_bbox.size();
|
||||
const float max_extent = max4(extent.x, extent.y, extent.z, 0.0f);
|
||||
|
||||
/* Check each dimension to find the minimum splitting cost. */
|
||||
float total_cost = 0.0f;
|
||||
float min_cost = FLT_MAX;
|
||||
for (int dim = 0; dim < 3; dim++) {
|
||||
/* If the centroid bounding box is 0 along a given dimension, skip it. */
|
||||
if (centroid_bbox.size()[dim] == 0.0f) {
|
||||
if (centroid_bbox.size()[dim] == 0.0f && dim != 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const float inv_extent = 1 / (centroid_bbox.size()[dim]);
|
||||
|
||||
/* Fill in buckets with primitives. */
|
||||
std::array<LightTreeBucketInfo, LightTreeBucketInfo::num_buckets> buckets;
|
||||
std::array<LightTreeBucket, LightTreeBucket::num_buckets> buckets;
|
||||
for (int i = start; i < end; i++) {
|
||||
const LightTreePrimitive &prim = prims[i];
|
||||
|
||||
/* Place primitive into the appropriate bucket,
|
||||
* where the centroid box is split into equal partitions. */
|
||||
int bucket_idx = LightTreeBucketInfo::num_buckets *
|
||||
/* Place primitive into the appropriate bucket, where the centroid box is split into equal
|
||||
* partitions. */
|
||||
int bucket_idx = LightTreeBucket::num_buckets *
|
||||
(prim.centroid[dim] - centroid_bbox.min[dim]) * inv_extent;
|
||||
if (bucket_idx == LightTreeBucketInfo::num_buckets) {
|
||||
bucket_idx = LightTreeBucketInfo::num_buckets - 1;
|
||||
bucket_idx = clamp(bucket_idx, 0, LightTreeBucket::num_buckets - 1);
|
||||
|
||||
buckets[bucket_idx].add(prim);
|
||||
}
|
||||
|
||||
/* Precompute the left bucket measure cumulatively. */
|
||||
std::array<LightTreeBucket, LightTreeBucket::num_buckets - 1> left_buckets;
|
||||
left_buckets.front() = buckets.front();
|
||||
for (int i = 1; i < LightTreeBucket::num_buckets - 1; i++) {
|
||||
left_buckets[i] = left_buckets[i - 1] + buckets[i];
|
||||
}
|
||||
|
||||
if (dim == 0) {
|
||||
/* Calculate node measure by summing up the bucket measure. */
|
||||
measure = left_buckets.back().measure + buckets.back().measure;
|
||||
|
||||
/* Do not try to split if there are only one primitive. */
|
||||
if (num_prims < 2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
buckets[bucket_idx].count++;
|
||||
buckets[bucket_idx].energy += prim.energy;
|
||||
buckets[bucket_idx].bbox.grow(prim.bbox);
|
||||
buckets[bucket_idx].bcone = merge(buckets[bucket_idx].bcone, prim.bcone);
|
||||
/* Degenerate case with co-located primitives. */
|
||||
if (is_zero(centroid_bbox.size())) {
|
||||
break;
|
||||
}
|
||||
|
||||
total_cost = measure.calculate();
|
||||
if (total_cost == 0.0f) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Precompute the right bucket measure cumulatively. */
|
||||
std::array<LightTreeBucket, LightTreeBucket::num_buckets - 1> right_buckets;
|
||||
right_buckets.back() = buckets.back();
|
||||
for (int i = LightTreeBucket::num_buckets - 3; i >= 0; i--) {
|
||||
right_buckets[i] = right_buckets[i + 1] + buckets[i + 1];
|
||||
}
|
||||
|
||||
/* Calculate the cost of splitting at each point between partitions. */
|
||||
std::array<float, LightTreeBucketInfo::num_buckets - 1> bucket_costs;
|
||||
float energy_L, energy_R;
|
||||
BoundBox bbox_L, bbox_R;
|
||||
OrientationBounds bcone_L, bcone_R;
|
||||
for (int split = 0; split < LightTreeBucketInfo::num_buckets - 1; split++) {
|
||||
energy_L = 0;
|
||||
energy_R = 0;
|
||||
bbox_L = BoundBox::empty;
|
||||
bbox_R = BoundBox::empty;
|
||||
bcone_L = OrientationBounds::empty;
|
||||
bcone_R = OrientationBounds::empty;
|
||||
const float regularization = max_extent * inv_extent;
|
||||
for (int split = 0; split < LightTreeBucket::num_buckets - 1; split++) {
|
||||
const float left_cost = left_buckets[split].measure.calculate();
|
||||
const float right_cost = right_buckets[split].measure.calculate();
|
||||
const float cost = regularization * (left_cost + right_cost);
|
||||
|
||||
for (int left = 0; left <= split; left++) {
|
||||
if (buckets[left].bbox.valid()) {
|
||||
energy_L += buckets[left].energy;
|
||||
bbox_L.grow(buckets[left].bbox);
|
||||
bcone_L = merge(bcone_L, buckets[left].bcone);
|
||||
}
|
||||
}
|
||||
|
||||
for (int right = split + 1; right < LightTreeBucketInfo::num_buckets; right++) {
|
||||
if (buckets[right].bbox.valid()) {
|
||||
energy_R += buckets[right].energy;
|
||||
bbox_R.grow(buckets[right].bbox);
|
||||
bcone_R = merge(bcone_R, buckets[right].bcone);
|
||||
}
|
||||
}
|
||||
|
||||
/* Calculate the cost of splitting using the heuristic as described in the paper. */
|
||||
const float area_L = has_area ? bbox_L.area() : len(bbox_L.size());
|
||||
const float area_R = has_area ? bbox_R.area() : len(bbox_R.size());
|
||||
const float left = (bbox_L.valid()) ? energy_L * area_L * bcone_L.calculate_measure() : 0.0f;
|
||||
const float right = (bbox_R.valid()) ? energy_R * area_R * bcone_R.calculate_measure() :
|
||||
0.0f;
|
||||
const float regularization = max_extent * inv_extent;
|
||||
bucket_costs[split] = regularization * (left + right) * inv_total_cost;
|
||||
|
||||
if (bucket_costs[split] < min_cost) {
|
||||
min_cost = bucket_costs[split];
|
||||
if (cost < total_cost && cost < min_cost) {
|
||||
min_cost = cost;
|
||||
split_dim = dim;
|
||||
split_bucket = split;
|
||||
num_left_prims = 0;
|
||||
for (int i = 0; i <= split_bucket; i++) {
|
||||
num_left_prims += buckets[i].count;
|
||||
}
|
||||
middle = start + left_buckets[split].count;
|
||||
}
|
||||
}
|
||||
}
|
||||
return min_cost;
|
||||
return min_cost < total_cost || num_prims > max_lights_in_leaf_;
|
||||
}
|
||||
|
||||
__forceinline LightTreePrimitivesMeasure operator+(const LightTreePrimitivesMeasure &a,
|
||||
const LightTreePrimitivesMeasure &b)
|
||||
{
|
||||
LightTreePrimitivesMeasure c(a);
|
||||
c.add(b);
|
||||
return c;
|
||||
}
|
||||
|
||||
LightTreeBucket operator+(const LightTreeBucket &a, const LightTreeBucket &b)
|
||||
{
|
||||
return LightTreeBucket(a.measure + b.measure, a.count + b.count);
|
||||
}
|
||||
|
||||
CCL_NAMESPACE_END
|
||||
|
|
|
@ -42,6 +42,11 @@ struct OrientationBounds {
|
|||
{
|
||||
}
|
||||
|
||||
__forceinline bool is_empty() const
|
||||
{
|
||||
return is_zero(axis);
|
||||
}
|
||||
|
||||
float calculate_measure() const;
|
||||
};
|
||||
|
||||
|
@ -53,6 +58,59 @@ OrientationBounds merge(const OrientationBounds &cone_a, const OrientationBounds
|
|||
* The light tree construction is based on PBRT's BVH construction.
|
||||
*/
|
||||
|
||||
/* Light Tree uses the bounding box, the orientation bounding cone, and the energy of a cluster to
|
||||
* compute the Surface Area Orientation Heuristic (SAOH). */
|
||||
struct LightTreePrimitivesMeasure {
|
||||
BoundBox bbox = BoundBox::empty;
|
||||
OrientationBounds bcone = OrientationBounds::empty;
|
||||
float energy = 0.0f;
|
||||
|
||||
enum empty_t { empty = 0 };
|
||||
|
||||
__forceinline LightTreePrimitivesMeasure() = default;
|
||||
|
||||
__forceinline LightTreePrimitivesMeasure(empty_t)
|
||||
{
|
||||
}
|
||||
|
||||
__forceinline LightTreePrimitivesMeasure(const BoundBox &bbox,
|
||||
const OrientationBounds &bcone,
|
||||
const float &energy)
|
||||
: bbox(bbox), bcone(bcone), energy(energy)
|
||||
{
|
||||
}
|
||||
|
||||
__forceinline LightTreePrimitivesMeasure(const LightTreePrimitivesMeasure &other)
|
||||
: bbox(other.bbox), bcone(other.bcone), energy(other.energy)
|
||||
{
|
||||
}
|
||||
|
||||
__forceinline bool is_zero() const
|
||||
{
|
||||
return energy == 0;
|
||||
}
|
||||
|
||||
__forceinline void add(const LightTreePrimitivesMeasure &measure)
|
||||
{
|
||||
if (!measure.is_zero()) {
|
||||
bbox.grow(measure.bbox);
|
||||
bcone = merge(bcone, measure.bcone);
|
||||
energy += measure.energy;
|
||||
}
|
||||
}
|
||||
|
||||
/* Taken from Eq. 2 in the paper. */
|
||||
__forceinline float calculate()
|
||||
{
|
||||
float area = bbox.area();
|
||||
float area_measure = area == 0 ? len(bbox.size()) : area;
|
||||
return energy * area_measure * bcone.calculate_measure();
|
||||
}
|
||||
};
|
||||
|
||||
LightTreePrimitivesMeasure operator+(const LightTreePrimitivesMeasure &a,
|
||||
const LightTreePrimitivesMeasure &b);
|
||||
|
||||
/* Light Tree Primitive
|
||||
* Struct that indexes into the scene's triangle and light arrays. */
|
||||
struct LightTreePrimitive {
|
||||
|
@ -60,64 +118,69 @@ struct LightTreePrimitive {
|
|||
* otherwise `-prim_id-1`(`~prim`) is an index into device lights array. */
|
||||
int prim_id;
|
||||
int object_id;
|
||||
|
||||
float energy;
|
||||
float3 centroid;
|
||||
OrientationBounds bcone;
|
||||
BoundBox bbox;
|
||||
|
||||
LightTreePrimitivesMeasure measure;
|
||||
|
||||
LightTreePrimitive(Scene *scene, int prim_id, int object_id);
|
||||
|
||||
inline bool is_triangle() const
|
||||
__forceinline bool is_triangle() const
|
||||
{
|
||||
return prim_id >= 0;
|
||||
};
|
||||
};
|
||||
|
||||
/* Light Tree Bucket Info
|
||||
/* Light Tree Bucket
|
||||
* Struct used to determine splitting costs in the light BVH. */
|
||||
struct LightTreeBucketInfo {
|
||||
LightTreeBucketInfo()
|
||||
: energy(0.0f), bbox(BoundBox::empty), bcone(OrientationBounds::empty), count(0)
|
||||
struct LightTreeBucket {
|
||||
LightTreePrimitivesMeasure measure;
|
||||
int count = 0;
|
||||
static const int num_buckets = 12;
|
||||
|
||||
LightTreeBucket() = default;
|
||||
|
||||
LightTreeBucket(const LightTreePrimitivesMeasure &measure, const int &count)
|
||||
: measure(measure), count(count)
|
||||
{
|
||||
}
|
||||
|
||||
float energy; /* Total energy in the partition */
|
||||
BoundBox bbox;
|
||||
OrientationBounds bcone;
|
||||
int count;
|
||||
|
||||
static const int num_buckets = 12;
|
||||
void add(const LightTreePrimitive &prim)
|
||||
{
|
||||
measure.add(prim.measure);
|
||||
count++;
|
||||
}
|
||||
};
|
||||
|
||||
LightTreeBucket operator+(const LightTreeBucket &a, const LightTreeBucket &b);
|
||||
|
||||
/* Light Tree Node */
|
||||
struct LightTreeNode {
|
||||
BoundBox bbox;
|
||||
OrientationBounds bcone;
|
||||
float energy;
|
||||
LightTreePrimitivesMeasure measure;
|
||||
uint bit_trail;
|
||||
int num_prims = -1; /* The number of primitives a leaf node stores. A negative
|
||||
number indicates it is an inner node. */
|
||||
int first_prim_index; /* Leaf nodes contain an index to first primitive. */
|
||||
unique_ptr<LightTreeNode> children[2]; /* Inner node. */
|
||||
unique_ptr<LightTreeNode> children[2]; /* Inner node has two children. */
|
||||
|
||||
LightTreeNode() = default;
|
||||
|
||||
LightTreeNode(const BoundBox &bbox,
|
||||
const OrientationBounds &bcone,
|
||||
const float &energy,
|
||||
const uint &bit_trial)
|
||||
: bbox(bbox), bcone(bcone), energy(energy), bit_trail(bit_trial)
|
||||
LightTreeNode(const LightTreePrimitivesMeasure &measure, const uint &bit_trial)
|
||||
: measure(measure), bit_trail(bit_trial)
|
||||
{
|
||||
}
|
||||
|
||||
void make_leaf(const uint &first_prim_index, const int &num_prims)
|
||||
__forceinline void add(const LightTreePrimitive &prim)
|
||||
{
|
||||
measure.add(prim.measure);
|
||||
}
|
||||
|
||||
void make_leaf(const int &first_prim_index, const int &num_prims)
|
||||
{
|
||||
this->first_prim_index = first_prim_index;
|
||||
this->num_prims = num_prims;
|
||||
}
|
||||
|
||||
inline bool is_leaf() const
|
||||
__forceinline bool is_leaf() const
|
||||
{
|
||||
return num_prims >= 0;
|
||||
}
|
||||
|
@ -128,8 +191,8 @@ struct LightTreeNode {
|
|||
* BVH-like data structure that keeps track of lights
|
||||
* and considers additional orientation and energy information */
|
||||
class LightTree {
|
||||
unique_ptr<LightTreeNode> root;
|
||||
atomic<int> num_nodes = 0;
|
||||
unique_ptr<LightTreeNode> root_;
|
||||
std::atomic<int> num_nodes_ = 0;
|
||||
uint max_lights_in_leaf_;
|
||||
|
||||
public:
|
||||
|
@ -145,22 +208,20 @@ class LightTree {
|
|||
|
||||
int size() const
|
||||
{
|
||||
return num_nodes;
|
||||
return num_nodes_;
|
||||
};
|
||||
|
||||
LightTreeNode *get_root() const
|
||||
{
|
||||
return root.get();
|
||||
return root_.get();
|
||||
};
|
||||
|
||||
/* NOTE: Always use this function to create a new node so the number of nodes is in sync. */
|
||||
unique_ptr<LightTreeNode> create_node(const BoundBox &bbox,
|
||||
const OrientationBounds &bcone,
|
||||
const float &energy,
|
||||
unique_ptr<LightTreeNode> create_node(const LightTreePrimitivesMeasure &measure,
|
||||
const uint &bit_trial)
|
||||
{
|
||||
num_nodes++;
|
||||
return make_unique<LightTreeNode>(bbox, bcone, energy, bit_trial);
|
||||
num_nodes_++;
|
||||
return make_unique<LightTreeNode>(measure, bit_trial);
|
||||
}
|
||||
|
||||
private:
|
||||
|
@ -176,15 +237,14 @@ class LightTree {
|
|||
vector<LightTreePrimitive> *prims,
|
||||
uint bit_trail,
|
||||
int depth);
|
||||
float min_split_saoh(const BoundBox ¢roid_bbox,
|
||||
int start,
|
||||
int end,
|
||||
const BoundBox &bbox,
|
||||
const OrientationBounds &bcone,
|
||||
int &split_dim,
|
||||
int &split_bucket,
|
||||
int &num_left_prims,
|
||||
const vector<LightTreePrimitive> &prims);
|
||||
|
||||
bool should_split(const vector<LightTreePrimitive> &prims,
|
||||
const int start,
|
||||
int &middle,
|
||||
const int end,
|
||||
LightTreePrimitivesMeasure &measure,
|
||||
const BoundBox ¢roid_bbox,
|
||||
int &split_dim);
|
||||
};
|
||||
|
||||
CCL_NAMESPACE_END
|
||||
|
|
|
@ -557,7 +557,7 @@ if(WITH_XR_OPENXR)
|
|||
# Header only library.
|
||||
../../extern/tinygltf/tiny_gltf.h
|
||||
)
|
||||
list(APPEND INC
|
||||
list(APPEND INC_SYS
|
||||
../../extern/json/include
|
||||
../../extern/tinygltf
|
||||
)
|
||||
|
|
|
@ -2664,13 +2664,7 @@ static void pointer_handle_enter(void *data,
|
|||
|
||||
/* Resetting scroll events is likely unnecessary,
|
||||
* do this to avoid any possible problems as it's harmless. */
|
||||
seat->pointer_scroll.smooth_xy[0] = 0;
|
||||
seat->pointer_scroll.smooth_xy[1] = 0;
|
||||
seat->pointer_scroll.discrete_xy[0] = 0;
|
||||
seat->pointer_scroll.discrete_xy[1] = 0;
|
||||
seat->pointer_scroll.inverted_xy[0] = false;
|
||||
seat->pointer_scroll.inverted_xy[1] = false;
|
||||
seat->pointer_scroll.axis_source = WL_POINTER_AXIS_SOURCE_WHEEL;
|
||||
seat->pointer_scroll = GWL_SeatStatePointerScroll{};
|
||||
|
||||
seat->pointer.wl_surface_window = wl_surface;
|
||||
|
||||
|
@ -4275,8 +4269,26 @@ static void gwl_seat_capability_pointer_enable(GWL_Seat *seat)
|
|||
seat->cursor.visible = true;
|
||||
seat->cursor.wl_buffer = nullptr;
|
||||
if (!get_cursor_settings(seat->cursor.theme_name, seat->cursor.theme_size)) {
|
||||
seat->cursor.theme_name = std::string();
|
||||
/* Use environment variables, falling back to defaults.
|
||||
* These environment variables are used by enough WAYLAND applications
|
||||
* that it makes sense to check them (see `Xcursor` man page). */
|
||||
const char *env;
|
||||
|
||||
env = getenv("XCURSOR_THEME");
|
||||
seat->cursor.theme_name = std::string(env ? env : "");
|
||||
|
||||
env = getenv("XCURSOR_SIZE");
|
||||
seat->cursor.theme_size = default_cursor_size;
|
||||
|
||||
if (env && (*env != '\0')) {
|
||||
char *env_end = nullptr;
|
||||
/* While clamping is not needed on the WAYLAND side,
|
||||
* GHOST's internal logic may get confused by negative values, so ensure it's at least 1. */
|
||||
const long value = strtol(env, &env_end, 10);
|
||||
if ((*env_end == '\0') && (value > 0)) {
|
||||
seat->cursor.theme_size = int(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
wl_pointer_add_listener(seat->wl_pointer, &pointer_listener, seat);
|
||||
|
||||
|
|
|
@ -224,28 +224,30 @@ string(APPEND CMAKE_CXX_FLAGS " ${PLATFORM_CFLAGS}")
|
|||
|
||||
# Gears (C)
|
||||
add_executable(gears_c
|
||||
${CMAKE_SOURCE_DIR}/gears/GHOST_C-Test.c)
|
||||
${CMAKE_SOURCE_DIR}/gears/GHOST_C-Test.c
|
||||
)
|
||||
|
||||
target_link_libraries(gears_c
|
||||
ghost_lib
|
||||
string_lib
|
||||
${OPENGL_gl_LIBRARY}
|
||||
${CMAKE_DL_LIBS}
|
||||
${PLATFORM_LINKLIBS}
|
||||
)
|
||||
ghost_lib
|
||||
string_lib
|
||||
${OPENGL_gl_LIBRARY}
|
||||
${CMAKE_DL_LIBS}
|
||||
${PLATFORM_LINKLIBS}
|
||||
)
|
||||
|
||||
|
||||
# Gears (C++)
|
||||
add_executable(gears_cpp
|
||||
${CMAKE_SOURCE_DIR}/gears/GHOST_Test.cpp)
|
||||
${CMAKE_SOURCE_DIR}/gears/GHOST_Test.cpp
|
||||
)
|
||||
|
||||
target_link_libraries(gears_cpp
|
||||
ghost_lib
|
||||
string_lib
|
||||
${OPENGL_gl_LIBRARY}
|
||||
${CMAKE_DL_LIBS}
|
||||
${PLATFORM_LINKLIBS}
|
||||
)
|
||||
ghost_lib
|
||||
string_lib
|
||||
${OPENGL_gl_LIBRARY}
|
||||
${CMAKE_DL_LIBS}
|
||||
${PLATFORM_LINKLIBS}
|
||||
)
|
||||
|
||||
|
||||
# MultiTest (C)
|
||||
|
|
|
@ -450,10 +450,10 @@ void *MEM_guarded_mallocN(size_t len, const char *str)
|
|||
#endif
|
||||
return (++memh);
|
||||
}
|
||||
print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total %u\n",
|
||||
print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total " SIZET_FORMAT "\n",
|
||||
SIZET_ARG(len),
|
||||
str,
|
||||
(uint)mem_in_use);
|
||||
mem_in_use);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -463,11 +463,11 @@ void *MEM_guarded_malloc_arrayN(size_t len, size_t size, const char *str)
|
|||
if (UNLIKELY(!MEM_size_safe_multiply(len, size, &total_size))) {
|
||||
print_error(
|
||||
"Malloc array aborted due to integer overflow: "
|
||||
"len=" SIZET_FORMAT "x" SIZET_FORMAT " in %s, total %u\n",
|
||||
"len=" SIZET_FORMAT "x" SIZET_FORMAT " in %s, total " SIZET_FORMAT "\n",
|
||||
SIZET_ARG(len),
|
||||
SIZET_ARG(size),
|
||||
str,
|
||||
(uint)mem_in_use);
|
||||
mem_in_use);
|
||||
abort();
|
||||
return NULL;
|
||||
}
|
||||
|
@ -523,10 +523,10 @@ void *MEM_guarded_mallocN_aligned(size_t len, size_t alignment, const char *str)
|
|||
#endif
|
||||
return (++memh);
|
||||
}
|
||||
print_error("aligned_malloc returns null: len=" SIZET_FORMAT " in %s, total %u\n",
|
||||
print_error("aligned_malloc returns null: len=" SIZET_FORMAT " in %s, total " SIZET_FORMAT "\n",
|
||||
SIZET_ARG(len),
|
||||
str,
|
||||
(uint)mem_in_use);
|
||||
mem_in_use);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -547,10 +547,10 @@ void *MEM_guarded_callocN(size_t len, const char *str)
|
|||
#endif
|
||||
return (++memh);
|
||||
}
|
||||
print_error("Calloc returns null: len=" SIZET_FORMAT " in %s, total %u\n",
|
||||
print_error("Calloc returns null: len=" SIZET_FORMAT " in %s, total " SIZET_FORMAT "\n",
|
||||
SIZET_ARG(len),
|
||||
str,
|
||||
(uint)mem_in_use);
|
||||
mem_in_use);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -560,11 +560,11 @@ void *MEM_guarded_calloc_arrayN(size_t len, size_t size, const char *str)
|
|||
if (UNLIKELY(!MEM_size_safe_multiply(len, size, &total_size))) {
|
||||
print_error(
|
||||
"Calloc array aborted due to integer overflow: "
|
||||
"len=" SIZET_FORMAT "x" SIZET_FORMAT " in %s, total %u\n",
|
||||
"len=" SIZET_FORMAT "x" SIZET_FORMAT " in %s, total " SIZET_FORMAT "\n",
|
||||
SIZET_ARG(len),
|
||||
SIZET_ARG(size),
|
||||
str,
|
||||
(uint)mem_in_use);
|
||||
mem_in_use);
|
||||
abort();
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
@ -213,10 +213,10 @@ void *MEM_lockfree_callocN(size_t len, const char *str)
|
|||
|
||||
return PTR_FROM_MEMHEAD(memh);
|
||||
}
|
||||
print_error("Calloc returns null: len=" SIZET_FORMAT " in %s, total %u\n",
|
||||
print_error("Calloc returns null: len=" SIZET_FORMAT " in %s, total " SIZET_FORMAT "\n",
|
||||
SIZET_ARG(len),
|
||||
str,
|
||||
(uint)memory_usage_current());
|
||||
memory_usage_current());
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -226,11 +226,11 @@ void *MEM_lockfree_calloc_arrayN(size_t len, size_t size, const char *str)
|
|||
if (UNLIKELY(!MEM_size_safe_multiply(len, size, &total_size))) {
|
||||
print_error(
|
||||
"Calloc array aborted due to integer overflow: "
|
||||
"len=" SIZET_FORMAT "x" SIZET_FORMAT " in %s, total %u\n",
|
||||
"len=" SIZET_FORMAT "x" SIZET_FORMAT " in %s, total " SIZET_FORMAT "\n",
|
||||
SIZET_ARG(len),
|
||||
SIZET_ARG(size),
|
||||
str,
|
||||
(unsigned int)memory_usage_current());
|
||||
memory_usage_current());
|
||||
abort();
|
||||
return NULL;
|
||||
}
|
||||
|
@ -256,10 +256,10 @@ void *MEM_lockfree_mallocN(size_t len, const char *str)
|
|||
|
||||
return PTR_FROM_MEMHEAD(memh);
|
||||
}
|
||||
print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total %u\n",
|
||||
print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total " SIZET_FORMAT "\n",
|
||||
SIZET_ARG(len),
|
||||
str,
|
||||
(uint)memory_usage_current());
|
||||
memory_usage_current());
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -269,11 +269,11 @@ void *MEM_lockfree_malloc_arrayN(size_t len, size_t size, const char *str)
|
|||
if (UNLIKELY(!MEM_size_safe_multiply(len, size, &total_size))) {
|
||||
print_error(
|
||||
"Malloc array aborted due to integer overflow: "
|
||||
"len=" SIZET_FORMAT "x" SIZET_FORMAT " in %s, total %u\n",
|
||||
"len=" SIZET_FORMAT "x" SIZET_FORMAT " in %s, total " SIZET_FORMAT "\n",
|
||||
SIZET_ARG(len),
|
||||
SIZET_ARG(size),
|
||||
str,
|
||||
(uint)memory_usage_current());
|
||||
memory_usage_current());
|
||||
abort();
|
||||
return NULL;
|
||||
}
|
||||
|
@ -325,10 +325,10 @@ void *MEM_lockfree_mallocN_aligned(size_t len, size_t alignment, const char *str
|
|||
|
||||
return PTR_FROM_MEMHEAD(memh);
|
||||
}
|
||||
print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total %u\n",
|
||||
print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total " SIZET_FORMAT "\n",
|
||||
SIZET_ARG(len),
|
||||
str,
|
||||
(uint)memory_usage_current());
|
||||
memory_usage_current());
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
|
@ -40,6 +40,25 @@
|
|||
</screenshot>
|
||||
</screenshots>
|
||||
<releases>
|
||||
<release version="3.5" date="2023-03-29">
|
||||
<description>
|
||||
<p>New features:</p>
|
||||
<ul>
|
||||
<li>Real-Time compositor</li>
|
||||
<li>Vector displacement sculpting</li>
|
||||
<li>Built-in hair node groups</li>
|
||||
<li>Cycles many light sampling</li>
|
||||
<li>Metal Viewport for macOS</li>
|
||||
</ul>
|
||||
<p>Enhancements:</p>
|
||||
<ul>
|
||||
<li>Support for importing and exporting compressed .USDZ files</li>
|
||||
<li>New Ease operator in the graph editor</li>
|
||||
<li>New Geometry Nodes, like Image Info and Blur Attribute</li>
|
||||
<li>Font previews now differentiate better between Korean, Japanese, Simplified and Traditional Chinese</li>
|
||||
</ul>
|
||||
</description>
|
||||
</release>
|
||||
<release version="3.4" date="2022-12-07">
|
||||
<description>
|
||||
<p>New features:</p>
|
||||
|
|
|
@ -28,6 +28,9 @@ https://github.com/intel/llvm#oneapi-dpc-compiler
|
|||
** Intel® Open Path Guiding Library; version v0.4.1-beta --
|
||||
http://www.openpgl.org/
|
||||
** Mantaflow; version 0.13 -- http://mantaflow.com/
|
||||
** materialX; version 1.38.6 --
|
||||
https://github.com/AcademySoftwareFoundation/MaterialX
|
||||
** meson; version 0.63 -- https://github.com/mesonbuild/meson
|
||||
** oneAPI Threading Building Block; version 2020_U3 --
|
||||
https://software.intel.com/en-us/oneapi/onetbb
|
||||
** OpenCL Wrangler; version 27a6867 -- https://github.com/OpenCLWrangler/clew
|
||||
|
@ -37,6 +40,9 @@ https://software.intel.com/en-us/oneapi/onetbb
|
|||
** RangeTree; version 40ebed8aa209 -- https://github.com/ideasman42/rangetree-c
|
||||
** SDL Extension Wrangler; version 15edf8e --
|
||||
https://github.com/SDLWrangler/sdlew
|
||||
** ShaderC; version 2022.3 -- https://github.com/google/shaderc
|
||||
** Vulkan Loader; version 1.2.198 --
|
||||
https://github.com/KhronosGroup/Vulkan-Loader
|
||||
|
||||
Apache License
|
||||
|
||||
|
@ -251,6 +257,11 @@ limitations under the License.
|
|||
* For Mantaflow see also this required NOTICE:
|
||||
MantaFlow fluid solver framework
|
||||
Copyright 2011 Tobias Pfaff, Nils Thuerey
|
||||
* For materialX see also this required NOTICE:
|
||||
Copyright Contributors to the MaterialX Project
|
||||
* For meson see also this required NOTICE:
|
||||
Jussi Pakkanen
|
||||
https://github.com/mesonbuild/meson/blob/master/CODEOWNERS
|
||||
* For oneAPI Threading Building Block see also this required NOTICE:
|
||||
Copyright (c) 2005-2020 Intel Corporation
|
||||
* For OpenCL Wrangler see also this required NOTICE:
|
||||
|
@ -270,6 +281,49 @@ limitations under the License.
|
|||
Copyright (c) 2016, Campbell Barton.
|
||||
* For SDL Extension Wrangler see also this required NOTICE:
|
||||
Copyright 2014 Blender Foundation
|
||||
* For ShaderC see also this required NOTICE:
|
||||
Copyright 2015 The Shaderc Authors. All rights reserved.
|
||||
* For Vulkan Loader see also this required NOTICE:
|
||||
Copyright (c) 2019 The Khronos Group Inc.
|
||||
Copyright (c) 2019 Valve Corporation
|
||||
Copyright (c) 2019 LunarG, Inc.
|
||||
Copyright (c) 2019 Google Inc.
|
||||
|
||||
------
|
||||
|
||||
** pybind11; version 2.10.1 -- https://github.com/pybind/pybind11
|
||||
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.
|
||||
|
||||
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the copyright holder nor the names of its contributors
|
||||
may be used to endorse or promote products derived from this software
|
||||
without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
Please also refer to the file .github/CONTRIBUTING.md, which clarifies
|
||||
licensing of
|
||||
external contributions to this project including patches, pull requests, etc.
|
||||
|
||||
------
|
||||
|
||||
|
@ -330,20 +384,21 @@ All rights reserved.
|
|||
Contributors to the OpenEXR Project.
|
||||
** ISPC; version 1.17.0 -- https://github.com/ispc/ispc
|
||||
Copyright Intel Corporation
|
||||
** NumPy; version 1.22.0 -- https://numpy.org/
|
||||
** NumPy; version 1.23.5 -- https://numpy.org/
|
||||
Copyright (c) 2005-2021, NumPy Developers.
|
||||
** Ogg; version 1.3.5 -- https://www.xiph.org/ogg/
|
||||
COPYRIGHT (C) 1994-2019 by the Xiph.Org Foundation https://www.xiph.org/
|
||||
** Open Shading Language; version 1.12.6.2 --
|
||||
** Open Shading Language; version
|
||||
1.13-dev-1a7670600c8b08c2443a78d03c8c27e9a1149140 --
|
||||
https://github.com/imageworks/OpenShadingLanguage
|
||||
Copyright Contributors to the Open Shading Language project.
|
||||
** OpenColorIO; version 2.1.1 --
|
||||
** OpenColorIO; version 2.2.0 --
|
||||
https://github.com/AcademySoftwareFoundation/OpenColorIO
|
||||
Copyright Contributors to the OpenColorIO Project.
|
||||
** OpenEXR; version 3.1.5 --
|
||||
https://github.com/AcademySoftwareFoundation/openexr
|
||||
Copyright Contributors to the OpenEXR Project. All rights reserved.
|
||||
** OpenImageIO; version 2.3.20.0 -- http://www.openimageio.org
|
||||
** OpenImageIO; version 2.4.6.0 -- http://www.openimageio.org
|
||||
Copyright (c) 2008-present by Contributors to the OpenImageIO project. All
|
||||
Rights Reserved.
|
||||
** Pystring; version 1.1.3 -- https://github.com/imageworks/pystring
|
||||
|
@ -1533,6 +1588,9 @@ License.
|
|||
** Eigen, template library for linear algebra: matrices, vectors, numerical
|
||||
solvers, and related algorithms; version 3.2.7 --
|
||||
http://eigen.tuxfamily.org/index.php?title=Main_Page
|
||||
Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>, Copyright
|
||||
(C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com
|
||||
|
||||
This file is part of Eigen, a lightweight C++ template library for linear
|
||||
algebra.
|
||||
** Free Spacenav; version 0.2.3 --
|
||||
|
@ -2190,8 +2248,557 @@ of this License. But first, please read <http s ://www.gnu.org/ licenses
|
|||
|
||||
------
|
||||
|
||||
** Fribidi ; version 1.0.12 -- https://github.com/fribidi/fribidi
|
||||
Behdad Esfahbod <behdad@gnu.org>
|
||||
#
|
||||
# Behdad Esfahbod maintained the entire 0.19 series. He designed, and
|
||||
# implemented most of what is in FriBidi today.
|
||||
#
|
||||
|
||||
Dov Grobgeld <dov.grobgeld@gmail.com>
|
||||
#
|
||||
# Dov Grobgeld originally wrote FriBidi. The 0.1.* releases were all done
|
||||
# by him. After the a long time of not being involved, Dov received
|
||||
# back the maintenance of the package in time for the 1.0 release.
|
||||
# He did the entire algorithmic work to support the changes made
|
||||
# to the Unicode algorithm in the Unicode 6.3 standard.
|
||||
#
|
||||
|
||||
Roozbeh Pournader <roozbeh@gnu.org>
|
||||
#
|
||||
# Roozbeh Pournader hasn't contributed much code to FriBidi personally; but
|
||||
# has maintained, promoted, and supported the project for a while. He has
|
||||
# helped with making GNU FriBidi standards compliant, and has sometimes
|
||||
# lobbied with the Unicode Consortium when needed. Roozbeh was supposed to
|
||||
# be a co-maintainer of GNU FriBidi, but he's not doing that yet.
|
||||
#
|
||||
|
||||
Khaled Hosny <khaledhosny@eglug.org>
|
||||
#
|
||||
# Khaled Hosny has done lots of cleanup and autoconfig work.
|
||||
|
||||
# Note: Other people have contributed significant amounts of code, but
|
||||
# usually the code has faded out because of restructuring and redesigning
|
||||
# things around GNU FriBidi. As an example, the FriBidiEnv patch by Omer
|
||||
# Zak, made itself into FriBidi CVS for a couple of years, but was finally
|
||||
# implemented in a better way by Behdad.
|
||||
#
|
||||
# Note: GNU getopt is distributed with and used in GNU FriBidi under bin/, but
|
||||
# is not part of GNU FriBidi.
|
||||
#
|
||||
# Note: Parts of the Unicode Character Database are distributed with and used
|
||||
# in GNU FriBidi under gen.tab/unidata/, but are not part of GNU FriBidi.
|
||||
#
|
||||
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
Version 2.1, February 1999
|
||||
|
||||
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
[This is the first released version of the Lesser GPL. It also counts
|
||||
as the successor of the GNU Library Public License, version 2, hence
|
||||
the version number 2.1.]
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
Licenses are intended to guarantee your freedom to share and change
|
||||
free software--to make sure the software is free for all its users.
|
||||
|
||||
This license, the Lesser General Public License, applies to some
|
||||
specially designated software packages--typically libraries--of the
|
||||
Free Software Foundation and other authors who decide to use it. You
|
||||
can use it too, but we suggest you first think carefully about whether
|
||||
this license or the ordinary General Public License is the better
|
||||
strategy to use in any particular case, based on the explanations below.
|
||||
|
||||
When we speak of free software, we are referring to freedom of use,
|
||||
not price. Our General Public Licenses are designed to make sure that
|
||||
you have the freedom to distribute copies of free software (and charge
|
||||
for this service if you wish); that you receive source code or can get
|
||||
it if you want it; that you can change the software and use pieces of
|
||||
it in new free programs; and that you are informed that you can do
|
||||
these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
distributors to deny you these rights or to ask you to surrender these
|
||||
rights. These restrictions translate to certain responsibilities for
|
||||
you if you distribute copies of the library or if you modify it.
|
||||
|
||||
For example, if you distribute copies of the library, whether gratis
|
||||
or for a fee, you must give the recipients all the rights that we gave
|
||||
you. You must make sure that they, too, receive or can get the source
|
||||
code. If you link other code with the library, you must provide
|
||||
complete object files to the recipients, so that they can relink them
|
||||
with the library after making changes to the library and recompiling
|
||||
it. And you must show them these terms so they know their rights.
|
||||
|
||||
We protect your rights with a two-step method: (1) we copyright the
|
||||
library, and (2) we offer you this license, which gives you legal
|
||||
permission to copy, distribute and/or modify the library.
|
||||
|
||||
To protect each distributor, we want to make it very clear that
|
||||
there is no warranty for the free library. Also, if the library is
|
||||
modified by someone else and passed on, the recipients should know
|
||||
that what they have is not the original version, so that the original
|
||||
author's reputation will not be affected by problems that might be
|
||||
introduced by others.
|
||||
|
||||
Finally, software patents pose a constant threat to the existence of
|
||||
any free program. We wish to make sure that a company cannot
|
||||
effectively restrict the users of a free program by obtaining a
|
||||
restrictive license from a patent holder. Therefore, we insist that
|
||||
any patent license obtained for a version of the library must be
|
||||
consistent with the full freedom of use specified in this license.
|
||||
|
||||
Most GNU software, including some libraries, is covered by the
|
||||
ordinary GNU General Public License. This license, the GNU Lesser
|
||||
General Public License, applies to certain designated libraries, and
|
||||
is quite different from the ordinary General Public License. We use
|
||||
this license for certain libraries in order to permit linking those
|
||||
libraries into non-free programs.
|
||||
|
||||
When a program is linked with a library, whether statically or using
|
||||
a shared library, the combination of the two is legally speaking a
|
||||
combined work, a derivative of the original library. The ordinary
|
||||
General Public License therefore permits such linking only if the
|
||||
entire combination fits its criteria of freedom. The Lesser General
|
||||
Public License permits more lax criteria for linking other code with
|
||||
the library.
|
||||
|
||||
We call this license the "Lesser" General Public License because it
|
||||
does Less to protect the user's freedom than the ordinary General
|
||||
Public License. It also provides other free software developers Less
|
||||
of an advantage over competing non-free programs. These disadvantages
|
||||
are the reason we use the ordinary General Public License for many
|
||||
libraries. However, the Lesser license provides advantages in certain
|
||||
special circumstances.
|
||||
|
||||
For example, on rare occasions, there may be a special need to
|
||||
encourage the widest possible use of a certain library, so that it becomes
|
||||
a de-facto standard. To achieve this, non-free programs must be
|
||||
allowed to use the library. A more frequent case is that a free
|
||||
library does the same job as widely used non-free libraries. In this
|
||||
case, there is little to gain by limiting the free library to free
|
||||
software only, so we use the Lesser General Public License.
|
||||
|
||||
In other cases, permission to use a particular library in non-free
|
||||
programs enables a greater number of people to use a large body of
|
||||
free software. For example, permission to use the GNU C Library in
|
||||
non-free programs enables many more people to use the whole GNU
|
||||
operating system, as well as its variant, the GNU/Linux operating
|
||||
system.
|
||||
|
||||
Although the Lesser General Public License is Less protective of the
|
||||
users' freedom, it does ensure that the user of a program that is
|
||||
linked with the Library has the freedom and the wherewithal to run
|
||||
that program using a modified version of the Library.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow. Pay close attention to the difference between a
|
||||
"work based on the library" and a "work that uses the library". The
|
||||
former contains code derived from the library, whereas the latter must
|
||||
be combined with the library in order to run.
|
||||
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License Agreement applies to any software library or other
|
||||
program which contains a notice placed by the copyright holder or
|
||||
other authorized party saying it may be distributed under the terms of
|
||||
this Lesser General Public License (also called "this License").
|
||||
Each licensee is addressed as "you".
|
||||
|
||||
A "library" means a collection of software functions and/or data
|
||||
prepared so as to be conveniently linked with application programs
|
||||
(which use some of those functions and data) to form executables.
|
||||
|
||||
The "Library", below, refers to any such software library or work
|
||||
which has been distributed under these terms. A "work based on the
|
||||
Library" means either the Library or any derivative work under
|
||||
copyright law: that is to say, a work containing the Library or a
|
||||
portion of it, either verbatim or with modifications and/or translated
|
||||
straightforwardly into another language. (Hereinafter, translation is
|
||||
included without limitation in the term "modification".)
|
||||
|
||||
"Source code" for a work means the preferred form of the work for
|
||||
making modifications to it. For a library, complete source code means
|
||||
all the source code for all modules it contains, plus any associated
|
||||
interface definition files, plus the scripts used to control compilation
|
||||
and installation of the library.
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running a program using the Library is not restricted, and output from
|
||||
such a program is covered only if its contents constitute a work based
|
||||
on the Library (independent of the use of the Library in a tool for
|
||||
writing it). Whether that is true depends on what the Library does
|
||||
and what the program that uses the Library does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Library's
|
||||
complete source code as you receive it, in any medium, provided that
|
||||
you conspicuously and appropriately publish on each copy an
|
||||
appropriate copyright notice and disclaimer of warranty; keep intact
|
||||
all the notices that refer to this License and to the absence of any
|
||||
warranty; and distribute a copy of this License along with the
|
||||
Library.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy,
|
||||
and you may at your option offer warranty protection in exchange for a
|
||||
fee.
|
||||
|
||||
2. You may modify your copy or copies of the Library or any portion
|
||||
of it, thus forming a work based on the Library, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) The modified work must itself be a software library.
|
||||
|
||||
b) You must cause the files modified to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
c) You must cause the whole of the work to be licensed at no
|
||||
charge to all third parties under the terms of this License.
|
||||
|
||||
d) If a facility in the modified Library refers to a function or a
|
||||
table of data to be supplied by an application program that uses
|
||||
the facility, other than as an argument passed when the facility
|
||||
is invoked, then you must make a good faith effort to ensure that,
|
||||
in the event an application does not supply such function or
|
||||
table, the facility still operates, and performs whatever part of
|
||||
its purpose remains meaningful.
|
||||
|
||||
(For example, a function in a library to compute square roots has
|
||||
a purpose that is entirely well-defined independent of the
|
||||
application. Therefore, Subsection 2d requires that any
|
||||
application-supplied function or table used by this function must
|
||||
be optional: if the application does not supply it, the square
|
||||
root function must still compute square roots.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Library,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Library, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote
|
||||
it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Library.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Library
|
||||
with the Library (or with a work based on the Library) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may opt to apply the terms of the ordinary GNU General Public
|
||||
License instead of this License to a given copy of the Library. To do
|
||||
this, you must alter all the notices that refer to this License, so
|
||||
that they refer to the ordinary GNU General Public License, version 2,
|
||||
instead of to this License. (If a newer version than version 2 of the
|
||||
ordinary GNU General Public License has appeared, then you can specify
|
||||
that version instead if you wish.) Do not make any other change in
|
||||
these notices.
|
||||
|
||||
Once this change is made in a given copy, it is irreversible for
|
||||
that copy, so the ordinary GNU General Public License applies to all
|
||||
subsequent copies and derivative works made from that copy.
|
||||
|
||||
This option is useful when you wish to copy part of the code of
|
||||
the Library into a program that is not a library.
|
||||
|
||||
4. You may copy and distribute the Library (or a portion or
|
||||
derivative of it, under Section 2) in object code or executable form
|
||||
under the terms of Sections 1 and 2 above provided that you accompany
|
||||
it with the complete corresponding machine-readable source code, which
|
||||
must be distributed under the terms of Sections 1 and 2 above on a
|
||||
medium customarily used for software interchange.
|
||||
|
||||
If distribution of object code is made by offering access to copy
|
||||
from a designated place, then offering equivalent access to copy the
|
||||
source code from the same place satisfies the requirement to
|
||||
distribute the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
5. A program that contains no derivative of any portion of the
|
||||
Library, but is designed to work with the Library by being compiled or
|
||||
linked with it, is called a "work that uses the Library". Such a
|
||||
work, in isolation, is not a derivative work of the Library, and
|
||||
therefore falls outside the scope of this License.
|
||||
|
||||
However, linking a "work that uses the Library" with the Library
|
||||
creates an executable that is a derivative of the Library (because it
|
||||
contains portions of the Library), rather than a "work that uses the
|
||||
library". The executable is therefore covered by this License.
|
||||
Section 6 states terms for distribution of such executables.
|
||||
|
||||
When a "work that uses the Library" uses material from a header file
|
||||
that is part of the Library, the object code for the work may be a
|
||||
derivative work of the Library even though the source code is not.
|
||||
Whether this is true is especially significant if the work can be
|
||||
linked without the Library, or if the work is itself a library. The
|
||||
threshold for this to be true is not precisely defined by law.
|
||||
|
||||
If such an object file uses only numerical parameters, data
|
||||
structure layouts and accessors, and small macros and small inline
|
||||
functions (ten lines or less in length), then the use of the object
|
||||
file is unrestricted, regardless of whether it is legally a derivative
|
||||
work. (Executables containing this object code plus portions of the
|
||||
Library will still fall under Section 6.)
|
||||
|
||||
Otherwise, if the work is a derivative of the Library, you may
|
||||
distribute the object code for the work under the terms of Section 6.
|
||||
Any executables containing that work also fall under Section 6,
|
||||
whether or not they are linked directly with the Library itself.
|
||||
|
||||
6. As an exception to the Sections above, you may also combine or
|
||||
link a "work that uses the Library" with the Library to produce a
|
||||
work containing portions of the Library, and distribute that work
|
||||
under terms of your choice, provided that the terms permit
|
||||
modification of the work for the customer's own use and reverse
|
||||
engineering for debugging such modifications.
|
||||
|
||||
You must give prominent notice with each copy of the work that the
|
||||
Library is used in it and that the Library and its use are covered by
|
||||
this License. You must supply a copy of this License. If the work
|
||||
during execution displays copyright notices, you must include the
|
||||
copyright notice for the Library among them, as well as a reference
|
||||
directing the user to the copy of this License. Also, you must do one
|
||||
of these things:
|
||||
|
||||
a) Accompany the work with the complete corresponding
|
||||
machine-readable source code for the Library including whatever
|
||||
changes were used in the work (which must be distributed under
|
||||
Sections 1 and 2 above); and, if the work is an executable linked
|
||||
with the Library, with the complete machine-readable "work that
|
||||
uses the Library", as object code and/or source code, so that the
|
||||
user can modify the Library and then relink to produce a modified
|
||||
executable containing the modified Library. (It is understood
|
||||
that the user who changes the contents of definitions files in the
|
||||
Library will not necessarily be able to recompile the application
|
||||
to use the modified definitions.)
|
||||
|
||||
b) Use a suitable shared library mechanism for linking with the
|
||||
Library. A suitable mechanism is one that (1) uses at run time a
|
||||
copy of the library already present on the user's computer system,
|
||||
rather than copying library functions into the executable, and (2)
|
||||
will operate properly with a modified version of the library, if
|
||||
the user installs one, as long as the modified version is
|
||||
interface-compatible with the version that the work was made with.
|
||||
|
||||
c) Accompany the work with a written offer, valid for at
|
||||
least three years, to give the same user the materials
|
||||
specified in Subsection 6a, above, for a charge no more
|
||||
than the cost of performing this distribution.
|
||||
|
||||
d) If distribution of the work is made by offering access to copy
|
||||
from a designated place, offer equivalent access to copy the above
|
||||
specified materials from the same place.
|
||||
|
||||
e) Verify that the user has already received a copy of these
|
||||
materials or that you have already sent this user a copy.
|
||||
|
||||
For an executable, the required form of the "work that uses the
|
||||
Library" must include any data and utility programs needed for
|
||||
reproducing the executable from it. However, as a special exception,
|
||||
the materials to be distributed need not include anything that is
|
||||
normally distributed (in either source or binary form) with the major
|
||||
components (compiler, kernel, and so on) of the operating system on
|
||||
which the executable runs, unless that component itself accompanies
|
||||
the executable.
|
||||
|
||||
It may happen that this requirement contradicts the license
|
||||
restrictions of other proprietary libraries that do not normally
|
||||
accompany the operating system. Such a contradiction means you cannot
|
||||
use both them and the Library together in an executable that you
|
||||
distribute.
|
||||
|
||||
7. You may place library facilities that are a work based on the
|
||||
Library side-by-side in a single library together with other library
|
||||
facilities not covered by this License, and distribute such a combined
|
||||
library, provided that the separate distribution of the work based on
|
||||
the Library and of the other library facilities is otherwise
|
||||
permitted, and provided that you do these two things:
|
||||
|
||||
a) Accompany the combined library with a copy of the same work
|
||||
based on the Library, uncombined with any other library
|
||||
facilities. This must be distributed under the terms of the
|
||||
Sections above.
|
||||
|
||||
b) Give prominent notice with the combined library of the fact
|
||||
that part of it is a work based on the Library, and explaining
|
||||
where to find the accompanying uncombined form of the same work.
|
||||
|
||||
8. You may not copy, modify, sublicense, link with, or distribute
|
||||
the Library except as expressly provided under this License. Any
|
||||
attempt otherwise to copy, modify, sublicense, link with, or
|
||||
distribute the Library is void, and will automatically terminate your
|
||||
rights under this License. However, parties who have received copies,
|
||||
or rights, from you under this License will not have their licenses
|
||||
terminated so long as such parties remain in full compliance.
|
||||
|
||||
9. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Library or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Library (or any work based on the
|
||||
Library), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Library or works based on it.
|
||||
|
||||
10. Each time you redistribute the Library (or any work based on the
|
||||
Library), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute, link with or modify the Library
|
||||
subject to these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties with
|
||||
this License.
|
||||
|
||||
11. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Library at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Library by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Library.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under any
|
||||
particular circumstance, the balance of the section is intended to apply,
|
||||
and the section as a whole is intended to apply in other circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
12. If the distribution and/or use of the Library is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Library under this License may add
|
||||
an explicit geographical distribution limitation excluding those countries,
|
||||
so that distribution is permitted only in or among countries not thus
|
||||
excluded. In such case, this License incorporates the limitation as if
|
||||
written in the body of this License.
|
||||
|
||||
13. The Free Software Foundation may publish revised and/or new
|
||||
versions of the Lesser General Public License from time to time.
|
||||
Such new versions will be similar in spirit to the present version,
|
||||
but may differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Library
|
||||
specifies a version number of this License which applies to it and
|
||||
"any later version", you have the option of following the terms and
|
||||
conditions either of that version or of any later version published by
|
||||
the Free Software Foundation. If the Library does not specify a
|
||||
license version number, you may choose any version ever published by
|
||||
the Free Software Foundation.
|
||||
|
||||
14. If you wish to incorporate parts of the Library into other free
|
||||
programs whose distribution conditions are incompatible with these,
|
||||
write to the author to ask for permission. For software which is
|
||||
copyrighted by the Free Software Foundation, write to the Free
|
||||
Software Foundation; we sometimes make exceptions for this. Our
|
||||
decision will be guided by the two goals of preserving the free status
|
||||
of all derivatives of our free software and of promoting the sharing
|
||||
and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
|
||||
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
|
||||
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
|
||||
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
|
||||
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
|
||||
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
|
||||
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
|
||||
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
|
||||
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
|
||||
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
|
||||
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
|
||||
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
|
||||
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
|
||||
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
|
||||
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
||||
DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Libraries
|
||||
|
||||
If you develop a new library, and you want it to be of the greatest
|
||||
possible use to the public, we recommend making it free software that
|
||||
everyone can redistribute and change. You can do so by permitting
|
||||
redistribution under these terms (or, alternatively, under the terms of the
|
||||
ordinary General Public License).
|
||||
|
||||
To apply these terms, attach the following notices to the library. It is
|
||||
safest to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least the
|
||||
"copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the library's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library 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
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the library, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the
|
||||
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1990
|
||||
Ty Coon, President of Vice
|
||||
|
||||
That's all there is to it!
|
||||
|
||||
------
|
||||
|
||||
** FFmpeg; version 5.1.2 -- http://ffmpeg.org/
|
||||
-
|
||||
Copyright: The FFmpeg contributors
|
||||
https://github.com/FFmpeg/FFmpeg/blob/master/CREDITS
|
||||
** Libsndfile; version 1.1.0 -- http://libsndfile.github.io/libsndfile/
|
||||
Copyright (C) 2011-2016 Erik de Castro Lopo <erikd@mega-nerd.com>
|
||||
|
||||
|
@ -2899,7 +3506,71 @@ SOFTWARE.
|
|||
|
||||
------
|
||||
|
||||
** OpenVDB; version 9.0.0 -- http://www.openvdb.org/
|
||||
** Harfbuzz; version 5.1.0 -- https://github.com/harfbuzz/harfbuzz
|
||||
Copyright © 2010-2022 Google, Inc.
|
||||
Copyright © 2015-2020 Ebrahim Byagowi
|
||||
Copyright © 2019,2020 Facebook, Inc.
|
||||
Copyright © 2012,2015 Mozilla Foundation
|
||||
Copyright © 2011 Codethink Limited
|
||||
Copyright © 2008,2010 Nokia Corporation and/or its subsidiary(-ies)
|
||||
Copyright © 2009 Keith Stribley
|
||||
Copyright © 2011 Martin Hosken and SIL International
|
||||
Copyright © 2007 Chris Wilson
|
||||
Copyright © 2005,2006,2020,2021,2022,2023 Behdad Esfahbod
|
||||
Copyright © 2004,2007,2008,2009,2010,2013,2021,2022,2023 Red Hat, Inc.
|
||||
Copyright © 1998-2005 David Turner and Werner Lemberg
|
||||
Copyright © 2016 Igalia S.L.
|
||||
Copyright © 2022 Matthias Clasen
|
||||
Copyright © 2018,2021 Khaled Hosny
|
||||
Copyright © 2018,2019,2020 Adobe, Inc
|
||||
Copyright © 2013-2015 Alexei Podtelezhnikov
|
||||
|
||||
HarfBuzz is licensed under the so-called "Old MIT" license. Details follow.
|
||||
For parts of HarfBuzz that are licensed under different licenses see individual
|
||||
files names COPYING in subdirectories where applicable.
|
||||
|
||||
Copyright © 2010-2022 Google, Inc.
|
||||
Copyright © 2015-2020 Ebrahim Byagowi
|
||||
Copyright © 2019,2020 Facebook, Inc.
|
||||
Copyright © 2012,2015 Mozilla Foundation
|
||||
Copyright © 2011 Codethink Limited
|
||||
Copyright © 2008,2010 Nokia Corporation and/or its subsidiary(-ies)
|
||||
Copyright © 2009 Keith Stribley
|
||||
Copyright © 2011 Martin Hosken and SIL International
|
||||
Copyright © 2007 Chris Wilson
|
||||
Copyright © 2005,2006,2020,2021,2022,2023 Behdad Esfahbod
|
||||
Copyright © 2004,2007,2008,2009,2010,2013,2021,2022,2023 Red Hat, Inc.
|
||||
Copyright © 1998-2005 David Turner and Werner Lemberg
|
||||
Copyright © 2016 Igalia S.L.
|
||||
Copyright © 2022 Matthias Clasen
|
||||
Copyright © 2018,2021 Khaled Hosny
|
||||
Copyright © 2018,2019,2020 Adobe, Inc
|
||||
Copyright © 2013-2015 Alexei Podtelezhnikov
|
||||
|
||||
For full copyright notices consult the individual files in the package.
|
||||
|
||||
|
||||
Permission is hereby granted, without written agreement and without
|
||||
license or royalty fees, to use, copy, modify, and distribute this
|
||||
software and its documentation for any purpose, provided that the
|
||||
above copyright notice and the following two paragraphs appear in
|
||||
all copies of this software.
|
||||
|
||||
IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
|
||||
DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
||||
ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
|
||||
IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
||||
DAMAGE.
|
||||
|
||||
THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
|
||||
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
|
||||
ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
|
||||
PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
|
||||
|
||||
------
|
||||
|
||||
** OpenVDB; version 10.0.0 -- http://www.openvdb.org/
|
||||
Copyright Contributors to the OpenVDB Project
|
||||
|
||||
Mozilla Public License Version 2.0
|
||||
|
@ -3238,6 +3909,32 @@ the Mozilla Public License, v. 2.0.
|
|||
|
||||
------
|
||||
|
||||
** minizip-ng; version 3.0.7 -- https://github.com/zlib-ng/minizip-ng
|
||||
Copyright (C) Nathan Moinvaziri
|
||||
https://github.com/zlib-ng/minizip-ng
|
||||
Copyright (C) 1998-2010 Gilles Vollant
|
||||
https://www.winimage.com/zLibDll/minizip.html
|
||||
|
||||
Condition of use and distribution are the same as zlib:
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgement in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
------
|
||||
|
||||
** Bullet Continuous Collision Detection and Physics Library; version 3.07 --
|
||||
http://continuousphysics.com/Bullet/
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
|
@ -3330,9 +4027,9 @@ Software.
|
|||
|
||||
------
|
||||
|
||||
** OpenSubdiv; version 3.4.4 -- http://graphics.pixar.com/opensubdiv
|
||||
** OpenSubdiv; version 3.5.0 -- http://graphics.pixar.com/opensubdiv
|
||||
Copyright 2013 Pixar
|
||||
** Universal Scene Description; version 22.03 -- http://www.openusd.org/
|
||||
** Universal Scene Description; version 22.11 -- http://www.openusd.org/
|
||||
Copyright 2016 Pixar
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "Apache License") with the
|
||||
|
@ -3377,8 +4074,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
------
|
||||
|
||||
** Boost C++ Libraries; version 1.78.0 -- https://www.boost.org/
|
||||
-
|
||||
** Boost C++ Libraries; version 1.80.0 -- https://www.boost.org/
|
||||
The Boost license encourages both commercial and non-commercial use and does
|
||||
not require attribution for binary use.
|
||||
|
||||
Boost Software License - Version 1.0 - August 17th, 2003
|
||||
|
||||
|
@ -3542,7 +4240,7 @@ MIT Expat
|
|||
|
||||
------
|
||||
|
||||
** Python; version 3.10.8 -- https://www.python.org
|
||||
** Python; version 3.10.9 -- https://www.python.org
|
||||
Copyright (c) 2001-2021 Python Software Foundation. All rights reserved.
|
||||
|
||||
A. HISTORY OF THE SOFTWARE
|
||||
|
|
|
@ -928,6 +928,55 @@ def dump_template_messages(msgs, reports, settings):
|
|||
reports, None, settings)
|
||||
|
||||
|
||||
def dump_asset_messages(msgs, reports, settings):
|
||||
# Where to search for assets, relative to the local user resources.
|
||||
assets_dir = os.path.join(bpy.utils.resource_path('LOCAL'), "datafiles", "assets")
|
||||
|
||||
# Parse the catalog sidecar file
|
||||
catalog_file = os.path.join(assets_dir, settings.ASSET_CATALOG_FILE)
|
||||
with open(catalog_file, encoding="utf8") as f:
|
||||
data = f.readlines()
|
||||
|
||||
catalogs = set()
|
||||
|
||||
for line in data:
|
||||
if (line == "\n" or line.startswith("VERSION") or line.startswith("#")):
|
||||
continue
|
||||
_UUID, catalog_path, _simple_catalog_name = line.split(":")
|
||||
catalogs.update(catalog_path.split("/"))
|
||||
|
||||
msgsrc = "Asset catalog from " + settings.ASSET_CATALOG_FILE
|
||||
for catalog in sorted(catalogs):
|
||||
process_msg(msgs, settings.DEFAULT_CONTEXT, catalog, msgsrc,
|
||||
reports, None, settings)
|
||||
|
||||
# Parse the asset blend files
|
||||
asset_files = {}
|
||||
|
||||
bfiles = glob.glob(assets_dir + "/**/*.blend", recursive=True)
|
||||
for bfile in bfiles:
|
||||
basename = os.path.basename(bfile)
|
||||
bpy.ops.wm.open_mainfile(filepath=bfile)
|
||||
# For now, only parse node groups.
|
||||
# Perhaps some other assets will need to be extracted later?
|
||||
for asset_type in ("node_groups",):
|
||||
for asset in getattr(bpy.data, asset_type):
|
||||
if asset.asset_data is None: # Not an asset
|
||||
continue
|
||||
assets = asset_files.setdefault(basename, [])
|
||||
assets.append((asset.name, asset.asset_data.description))
|
||||
|
||||
for asset_file in sorted(asset_files):
|
||||
for asset in sorted(asset_files[asset_file]):
|
||||
name, description = asset
|
||||
msgsrc = "Asset name from file " + asset_file
|
||||
process_msg(msgs, settings.DEFAULT_CONTEXT, name, msgsrc,
|
||||
reports, None, settings)
|
||||
msgsrc = "Asset description from file " + asset_file
|
||||
process_msg(msgs, settings.DEFAULT_CONTEXT, description, msgsrc,
|
||||
reports, None, settings)
|
||||
|
||||
|
||||
def dump_addon_bl_info(msgs, reports, module, settings):
|
||||
for prop in ('name', 'location', 'description', 'warning'):
|
||||
process_msg(
|
||||
|
@ -980,6 +1029,7 @@ def dump_messages(do_messages, do_checks, settings):
|
|||
dump_preset_messages(msgs, reports, settings)
|
||||
|
||||
# Get strings from startup templates.
|
||||
# This loads each startup blend file in turn.
|
||||
dump_template_messages(msgs, reports, settings)
|
||||
|
||||
# Get strings from addons' bl_info.
|
||||
|
@ -1019,6 +1069,10 @@ def dump_messages(do_messages, do_checks, settings):
|
|||
process_msg(msgs, settings.DEFAULT_CONTEXT, cat[1],
|
||||
"Language categories’ labels from bl_i18n_utils/settings.py", reports, None, settings)
|
||||
|
||||
# Get strings from asset catalogs and blend files.
|
||||
# This loads each asset blend file in turn.
|
||||
dump_asset_messages(msgs, reports, settings)
|
||||
|
||||
# pot.check()
|
||||
pot.unescape() # Strings gathered in py/C source code may contain escaped chars...
|
||||
print_info(reports, pot)
|
||||
|
|
|
@ -527,6 +527,9 @@ REL_PRESETS_DIR = os.path.join("scripts", "presets")
|
|||
# Where to search for templates (relative to SOURCE_DIR).
|
||||
REL_TEMPLATES_DIR = os.path.join("scripts", "startup", "bl_app_templates_system")
|
||||
|
||||
# Name of the built-in asset catalog file.
|
||||
ASSET_CATALOG_FILE = "blender_assets.cats.txt"
|
||||
|
||||
# The template messages file (relative to I18N_DIR).
|
||||
REL_FILE_NAME_POT = os.path.join(REL_BRANCHES_DIR, DOMAIN + ".pot")
|
||||
|
||||
|
|
|
@ -21,10 +21,7 @@ __all__ = (
|
|||
"ImagePreviewCollection",
|
||||
)
|
||||
|
||||
import _bpy
|
||||
_utils_previews = _bpy._utils_previews
|
||||
del _bpy
|
||||
|
||||
from _bpy import _utils_previews
|
||||
|
||||
_uuid_open = set()
|
||||
|
||||
|
|
|
@ -379,7 +379,7 @@ class NODE_MT_geometry_node_GEO_MESH_OPERATIONS(Menu):
|
|||
bl_idname = "NODE_MT_geometry_node_GEO_MESH_OPERATIONS"
|
||||
bl_label = "Operations"
|
||||
|
||||
def draw(self, _context):
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeDualMesh")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeEdgePathsToCurves")
|
||||
|
@ -389,7 +389,7 @@ class NODE_MT_geometry_node_GEO_MESH_OPERATIONS(Menu):
|
|||
node_add_menu.add_node_type(layout, "GeometryNodeMeshBoolean")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeMeshToCurve")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeMeshToPoints")
|
||||
if _context.preferences.experimental.use_new_volume_nodes:
|
||||
if context.preferences.experimental.use_new_volume_nodes:
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeMeshToSDFVolume")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeMeshToVolume")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeScaleElements")
|
||||
|
@ -448,14 +448,14 @@ class NODE_MT_category_GEO_POINT(Menu):
|
|||
bl_idname = "NODE_MT_category_GEO_POINT"
|
||||
bl_label = "Point"
|
||||
|
||||
def draw(self, _context):
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeDistributePointsInVolume")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeDistributePointsOnFaces")
|
||||
layout.separator()
|
||||
node_add_menu.add_node_type(layout, "GeometryNodePoints")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodePointsToVertices")
|
||||
if _context.preferences.experimental.use_new_volume_nodes:
|
||||
if context.preferences.experimental.use_new_volume_nodes:
|
||||
node_add_menu.add_node_type(layout, "GeometryNodePointsToSDFVolume")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodePointsToVolume")
|
||||
layout.separator()
|
||||
|
@ -593,11 +593,11 @@ class NODE_MT_category_GEO_VOLUME(Menu):
|
|||
bl_idname = "NODE_MT_category_GEO_VOLUME"
|
||||
bl_label = "Volume"
|
||||
|
||||
def draw(self, _context):
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeVolumeCube")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeVolumeToMesh")
|
||||
if _context.preferences.experimental.use_new_volume_nodes:
|
||||
if context.preferences.experimental.use_new_volume_nodes:
|
||||
layout.separator()
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeMeanFilterSDFVolume")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeOffsetSDFVolume")
|
||||
|
|
|
@ -81,6 +81,9 @@ class DATA_PT_display(ArmatureButtonsPanel, Panel):
|
|||
sub.active = arm.show_axes
|
||||
sub.prop(arm, "axes_position", text="Position")
|
||||
|
||||
sub = col.row(align=True)
|
||||
sub.prop(arm, "relation_line_position", text="Relations", expand=True)
|
||||
|
||||
|
||||
class DATA_MT_bone_group_context_menu(Menu):
|
||||
bl_label = "Bone Group Specials"
|
||||
|
|
|
@ -8,34 +8,34 @@
|
|||
*
|
||||
* Basic design of the DerivedMesh system:
|
||||
*
|
||||
* DerivedMesh is a common set of interfaces for mesh systems.
|
||||
* #DerivedMesh is a common set of interfaces for mesh systems.
|
||||
*
|
||||
* There are three main mesh data structures in Blender:
|
||||
* #Mesh, #CDDerivedMesh and #BMesh.
|
||||
*
|
||||
* These, and a few others, all implement DerivedMesh interfaces,
|
||||
* These, and a few others, all implement #DerivedMesh interfaces,
|
||||
* which contains unified drawing interfaces, a few utility interfaces,
|
||||
* and a bunch of read-only interfaces intended mostly for conversion from
|
||||
* one format to another.
|
||||
*
|
||||
* All Mesh structures in blender make use of CustomData, which is used to store
|
||||
* per-element attributes and interpolate them (e.g. uvs, vcols, vgroups, etc).
|
||||
* All Mesh structures in blender make use of #CustomData, which is used to store
|
||||
* per-element attributes and interpolate them (e.g. UVs, vertex-colors, vertex-groups, etc).
|
||||
*
|
||||
* Mesh is the "serialized" structure, used for storing object-mode mesh data
|
||||
* and also for saving stuff to disk. Its interfaces are also what DerivedMesh
|
||||
* and also for saving stuff to disk. Its interfaces are also what #DerivedMesh
|
||||
* uses to communicate with.
|
||||
*
|
||||
* CDDM is a little mesh library, that uses Mesh data structures in the backend.
|
||||
* #CDDM is a little mesh library, that uses Mesh data structures in the backend.
|
||||
* It's mostly used for modifiers, and has the advantages of not taking much
|
||||
* resources.
|
||||
*
|
||||
* BMesh is a full-on BREP, used for edit-mode, some modifiers, etc. It's much
|
||||
* more capable (if memory-intensive) then CDDM.
|
||||
* #BMesh is a full-on BREP, used for edit-mode, some modifiers, etc.
|
||||
* It's much more capable (if memory-intensive) then CDDM.
|
||||
*
|
||||
* DerivedMesh is somewhat hackish. Many places assumes that a DerivedMesh is
|
||||
* #DerivedMesh is somewhat hackish. Many places assumes that a #DerivedMesh is
|
||||
* a CDDM (most of the time by simply copying it and converting it to one).
|
||||
* CDDM is the original structure for modifiers, but has since been superseded
|
||||
* by BMesh, at least for the foreseeable future.
|
||||
* by #BMesh, at least for the foreseeable future.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
|
|
@ -217,7 +217,11 @@ bool BKE_collection_object_cyclic_check(struct Main *bmain,
|
|||
|
||||
struct ListBase BKE_collection_object_cache_get(struct Collection *collection);
|
||||
ListBase BKE_collection_object_cache_instanced_get(struct Collection *collection);
|
||||
/** Free the object cache of given `collection` and all of its ancestors (recursively). */
|
||||
void BKE_collection_object_cache_free(struct Collection *collection);
|
||||
/** Free the object cache of all collections in given `bmain`, including master collections of
|
||||
* scenes. */
|
||||
void BKE_main_collections_object_cache_free(const struct Main *bmain);
|
||||
|
||||
struct Base *BKE_collection_or_layer_objects(const struct Scene *scene,
|
||||
struct ViewLayer *view_layer,
|
||||
|
|
|
@ -493,11 +493,34 @@ struct ImBuf *BKE_image_get_first_ibuf(struct Image *image);
|
|||
*/
|
||||
struct GPUTexture *BKE_image_create_gpu_texture_from_ibuf(struct Image *image, struct ImBuf *ibuf);
|
||||
|
||||
/**
|
||||
* Ensure that the cached GPU texture inside the image matches the pass, layer, and view of the
|
||||
* given image user, if not, invalidate the cache such that the next call to the GPU texture
|
||||
* retrieval functions such as BKE_image_get_gpu_texture updates the cache with an image that
|
||||
* matches the give image user.
|
||||
*
|
||||
* This is provided as a separate function and not implemented as part of the GPU texture retrieval
|
||||
* functions because the current cache system only allows a single pass, layer, and stereo view to
|
||||
* be cached, so possible frequent invalidations of the cache can have performance implications,
|
||||
* and making invalidation explicit by calling this function will help make that clear and pave the
|
||||
* way for a more complete cache system in the future.
|
||||
*/
|
||||
void BKE_image_ensure_gpu_texture(struct Image *image, struct ImageUser *iuser);
|
||||
|
||||
/**
|
||||
* Get the #GPUTexture for a given `Image`.
|
||||
*
|
||||
* `iuser` and `ibuf` are mutual exclusive parameters. The caller can pass the `ibuf` when already
|
||||
* available. It is also required when requesting the #GPUTexture for a render result.
|
||||
*
|
||||
* The requested GPU texture will be cached for subsequent calls, but only a single layer, pass,
|
||||
* and view can be cached at a time, so the cache should be invalidated in operators and RNA
|
||||
* callbacks that change the layer, pass, or view of the image to maintain a correct cache state.
|
||||
* However, in some cases, multiple layers, passes, or views might be needed at the same time, like
|
||||
* is the case for the realtime compositor. This is currently not supported, so the caller should
|
||||
* ensure that the requested layer is indeed the cached one and invalidated the cached otherwise by
|
||||
* calling BKE_image_ensure_gpu_texture. This is a workaround until image can support a more
|
||||
* complete caching system.
|
||||
*/
|
||||
struct GPUTexture *BKE_image_get_gpu_texture(struct Image *image,
|
||||
struct ImageUser *iuser,
|
||||
|
|
|
@ -104,26 +104,6 @@ void BKE_mesh_ensure_default_orig_index_customdata(struct Mesh *mesh);
|
|||
*/
|
||||
void BKE_mesh_ensure_default_orig_index_customdata_no_check(struct Mesh *mesh);
|
||||
|
||||
/**
|
||||
* Find the index of the loop in 'poly' which references vertex,
|
||||
* returns -1 if not found
|
||||
*/
|
||||
int poly_find_loop_from_vert(const struct MPoly *poly, const int *poly_verts, int vert);
|
||||
/**
|
||||
* Fill \a r_adj with the loop indices in \a poly adjacent to the
|
||||
* vertex. Returns the index of the loop matching vertex, or -1 if the
|
||||
* vertex is not in \a poly
|
||||
*/
|
||||
int poly_get_adj_loops_from_vert(const struct MPoly *poly,
|
||||
const int *corner_verts,
|
||||
int vert,
|
||||
int r_adj[2]);
|
||||
|
||||
/**
|
||||
* Return the index of the edge vert that is not equal to \a v. If
|
||||
* neither edge vertex is equal to \a v, returns -1.
|
||||
*/
|
||||
int BKE_mesh_edge_other_vert(const struct MEdge *e, int v);
|
||||
/**
|
||||
* Sets each output array element to the edge index if it is a real edge, or -1.
|
||||
*/
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-or-later. */
|
||||
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
||||
|
||||
#pragma once
|
||||
|
||||
|
@ -142,7 +142,71 @@ void edges_sharp_from_angle_set(Span<MPoly> polys,
|
|||
const float split_angle,
|
||||
MutableSpan<bool> sharp_edges);
|
||||
|
||||
} // namespace blender::bke::mesh
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Topology Queries
|
||||
* \{ */
|
||||
|
||||
/**
|
||||
* Find the index of the next corner in the polygon, looping to the start if necessary.
|
||||
* The indices are into the entire corners array, not just the polygon's corners.
|
||||
*/
|
||||
inline int poly_corner_prev(const MPoly &poly, const int corner)
|
||||
{
|
||||
return corner - 1 + (corner == poly.loopstart) * poly.totloop;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find the index of the previous corner in the polygon, looping to the end if necessary.
|
||||
* The indices are into the entire corners array, not just the polygon's corners.
|
||||
*/
|
||||
inline int poly_corner_next(const MPoly &poly, const int corner)
|
||||
{
|
||||
if (corner == poly.loopstart + poly.totloop - 1) {
|
||||
return poly.loopstart;
|
||||
}
|
||||
return corner + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find the index of the corner in the polygon that uses the given vertex.
|
||||
* The index is into the entire corners array, not just the polygon's corners.
|
||||
*/
|
||||
inline int poly_find_corner_from_vert(const MPoly &poly,
|
||||
const Span<int> corner_verts,
|
||||
const int vert)
|
||||
{
|
||||
return poly.loopstart + corner_verts.slice(poly.loopstart, poly.totloop).first_index(vert);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the vertex indices on either side of the given vertex, ordered based on the winding
|
||||
* direction of the polygon. The vertex must be in the polygon.
|
||||
*/
|
||||
inline int2 poly_find_adjecent_verts(const MPoly &poly,
|
||||
const Span<int> corner_verts,
|
||||
const int vert)
|
||||
{
|
||||
const int corner = poly_find_corner_from_vert(poly, corner_verts, vert);
|
||||
return {corner_verts[poly_corner_prev(poly, corner)],
|
||||
corner_verts[poly_corner_next(poly, corner)]};
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the index of the edge's vertex that is not the \a vert.
|
||||
* If neither edge vertex is equal to \a v, returns -1.
|
||||
*/
|
||||
inline int edge_other_vert(const MEdge &edge, const int vert)
|
||||
{
|
||||
if (edge.v1 == vert) {
|
||||
return edge.v2;
|
||||
}
|
||||
if (edge.v2 == vert) {
|
||||
return edge.v1;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/** \} */
|
||||
|
||||
|
@ -150,6 +214,8 @@ void edges_sharp_from_angle_set(Span<MPoly> polys,
|
|||
/** \name Inline Mesh Data Access
|
||||
* \{ */
|
||||
|
||||
} // namespace blender::bke::mesh
|
||||
|
||||
inline blender::Span<blender::float3> Mesh::vert_positions() const
|
||||
{
|
||||
return {reinterpret_cast<const blender::float3 *>(BKE_mesh_vert_positions(this)), this->totvert};
|
||||
|
|
|
@ -363,18 +363,5 @@ Array<Vector<int, 2>> build_edge_to_poly_map(Span<MPoly> polys,
|
|||
int edges_num);
|
||||
Vector<Vector<int>> build_edge_to_loop_map_resizable(Span<int> corner_edges, int edges_num);
|
||||
|
||||
inline int poly_loop_prev(const MPoly &poly, int loop_i)
|
||||
{
|
||||
return loop_i - 1 + (loop_i == poly.loopstart) * poly.totloop;
|
||||
}
|
||||
|
||||
inline int poly_loop_next(const MPoly &poly, int loop_i)
|
||||
{
|
||||
if (loop_i == poly.loopstart + poly.totloop - 1) {
|
||||
return poly.loopstart;
|
||||
}
|
||||
return loop_i + 1;
|
||||
}
|
||||
|
||||
} // namespace blender::bke::mesh_topology
|
||||
#endif
|
||||
|
|
|
@ -51,6 +51,7 @@ struct PaletteColor;
|
|||
struct Scene;
|
||||
struct StrokeCache;
|
||||
struct Sculpt;
|
||||
struct SculptSession;
|
||||
struct SubdivCCG;
|
||||
struct Tex;
|
||||
struct ToolSettings;
|
||||
|
@ -563,6 +564,8 @@ typedef struct SculptAttributePointers {
|
|||
SculptAttribute *dyntopo_node_id_face;
|
||||
} SculptAttributePointers;
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
typedef struct SculptSession {
|
||||
/* Mesh data (not copied) can come either directly from a Mesh, or from a MultiresDM */
|
||||
struct { /* Special handling for multires meshes */
|
||||
|
@ -576,8 +579,8 @@ typedef struct SculptSession {
|
|||
|
||||
/* These are always assigned to base mesh data when using PBVH_FACES and PBVH_GRIDS. */
|
||||
float (*vert_positions)[3];
|
||||
const struct MPoly *polys;
|
||||
const int *corner_verts;
|
||||
blender::Span<MPoly> polys;
|
||||
blender::Span<int> corner_verts;
|
||||
|
||||
/* These contain the vertex and poly counts of the final mesh. */
|
||||
int totvert, totpoly;
|
||||
|
@ -758,12 +761,14 @@ typedef struct SculptSession {
|
|||
bool islands_valid; /* Is attrs.topology_island_key valid? */
|
||||
} SculptSession;
|
||||
|
||||
#endif
|
||||
|
||||
void BKE_sculptsession_free(struct Object *ob);
|
||||
void BKE_sculptsession_free_deformMats(struct SculptSession *ss);
|
||||
void BKE_sculptsession_free_vwpaint_data(struct SculptSession *ss);
|
||||
void BKE_sculptsession_bm_to_me(struct Object *ob, bool reorder);
|
||||
void BKE_sculptsession_bm_to_me_for_render(struct Object *object);
|
||||
int BKE_sculptsession_vertex_count(const SculptSession *ss);
|
||||
int BKE_sculptsession_vertex_count(const struct SculptSession *ss);
|
||||
|
||||
/* Ensure an attribute layer exists. */
|
||||
SculptAttribute *BKE_sculpt_attribute_ensure(struct Object *ob,
|
||||
|
@ -911,6 +916,11 @@ bool BKE_object_attributes_active_color_fill(struct Object *ob,
|
|||
const float fill_color[4],
|
||||
bool only_selected);
|
||||
|
||||
/** C accessor for #Object::sculpt::pbvh. */
|
||||
struct PBVH *BKE_object_sculpt_pbvh_get(struct Object *object);
|
||||
bool BKE_object_sculpt_use_dyntopo(const struct Object *object);
|
||||
void BKE_object_sculpt_dyntopo_smooth_shading_set(struct Object *object, bool value);
|
||||
|
||||
/* paint_canvas.cc */
|
||||
|
||||
/**
|
||||
|
|
|
@ -37,6 +37,7 @@ struct PBVH;
|
|||
struct PBVHBatches;
|
||||
struct PBVHNode;
|
||||
struct PBVH_GPU_Args;
|
||||
struct SculptSession;
|
||||
struct SubdivCCG;
|
||||
struct TaskParallelSettings;
|
||||
struct Image;
|
||||
|
|
|
@ -310,6 +310,7 @@ typedef enum SubdivCCGAdjacencyType {
|
|||
SubdivCCGAdjacencyType BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(const SubdivCCG *subdiv_ccg,
|
||||
const SubdivCCGCoord *coord,
|
||||
const int *corner_verts,
|
||||
int corners_num,
|
||||
const struct MPoly *mpoly,
|
||||
int *r_v1,
|
||||
int *r_v2);
|
||||
|
|
|
@ -54,6 +54,9 @@ const char *no_procedural_access_message =
|
|||
|
||||
bool allow_procedural_attribute_access(StringRef attribute_name)
|
||||
{
|
||||
if (attribute_name.startswith(".corner")) {
|
||||
return false;
|
||||
}
|
||||
if (attribute_name.startswith(".select")) {
|
||||
return false;
|
||||
}
|
||||
|
|
|
@ -82,6 +82,8 @@ static CollectionParent *collection_find_parent(Collection *child, Collection *c
|
|||
static bool collection_find_child_recursive(const Collection *parent,
|
||||
const Collection *collection);
|
||||
|
||||
static void collection_object_cache_free(Collection *collection);
|
||||
|
||||
static void collection_gobject_hash_ensure(Collection *collection);
|
||||
static void collection_gobject_hash_update_object(Collection *collection,
|
||||
Object *ob_old,
|
||||
|
@ -160,7 +162,7 @@ static void collection_free_data(ID *id)
|
|||
BLI_freelistN(&collection->children);
|
||||
BLI_freelistN(&collection->runtime.parents);
|
||||
|
||||
BKE_collection_object_cache_free(collection);
|
||||
collection_object_cache_free(collection);
|
||||
}
|
||||
|
||||
static void collection_foreach_id(ID *id, LibraryForeachIDData *data)
|
||||
|
@ -887,15 +889,27 @@ static void collection_object_cache_free(Collection *collection)
|
|||
collection->flag &= ~(COLLECTION_HAS_OBJECT_CACHE | COLLECTION_HAS_OBJECT_CACHE_INSTANCED);
|
||||
BLI_freelistN(&collection->runtime.object_cache);
|
||||
BLI_freelistN(&collection->runtime.object_cache_instanced);
|
||||
}
|
||||
|
||||
void BKE_collection_object_cache_free(Collection *collection)
|
||||
{
|
||||
collection_object_cache_free(collection);
|
||||
|
||||
LISTBASE_FOREACH (CollectionParent *, parent, &collection->runtime.parents) {
|
||||
collection_object_cache_free(parent->collection);
|
||||
}
|
||||
}
|
||||
|
||||
void BKE_collection_object_cache_free(Collection *collection)
|
||||
void BKE_main_collections_object_cache_free(const Main *bmain)
|
||||
{
|
||||
collection_object_cache_free(collection);
|
||||
for (Scene *scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) {
|
||||
collection_object_cache_free(scene->master_collection);
|
||||
}
|
||||
|
||||
for (Collection *collection = bmain->collections.first; collection != NULL;
|
||||
collection = collection->id.next) {
|
||||
collection_object_cache_free(collection);
|
||||
}
|
||||
}
|
||||
|
||||
Base *BKE_collection_or_layer_objects(const Scene *scene,
|
||||
|
|
|
@ -2583,8 +2583,12 @@ const char *CustomData_get_render_layer_name(const CustomData *data, const int t
|
|||
|
||||
void CustomData_set_layer_active(CustomData *data, const int type, const int n)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
const int layer_num = CustomData_number_of_layers(data, type);
|
||||
#endif
|
||||
for (int i = 0; i < data->totlayer; i++) {
|
||||
if (data->layers[i].type == type) {
|
||||
BLI_assert(uint(n) < uint(layer_num));
|
||||
data->layers[i].active = n;
|
||||
}
|
||||
}
|
||||
|
@ -2592,8 +2596,12 @@ void CustomData_set_layer_active(CustomData *data, const int type, const int n)
|
|||
|
||||
void CustomData_set_layer_render(CustomData *data, const int type, const int n)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
const int layer_num = CustomData_number_of_layers(data, type);
|
||||
#endif
|
||||
for (int i = 0; i < data->totlayer; i++) {
|
||||
if (data->layers[i].type == type) {
|
||||
BLI_assert(uint(n) < uint(layer_num));
|
||||
data->layers[i].active_rnd = n;
|
||||
}
|
||||
}
|
||||
|
@ -2601,8 +2609,12 @@ void CustomData_set_layer_render(CustomData *data, const int type, const int n)
|
|||
|
||||
void CustomData_set_layer_clone(CustomData *data, const int type, const int n)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
const int layer_num = CustomData_number_of_layers(data, type);
|
||||
#endif
|
||||
for (int i = 0; i < data->totlayer; i++) {
|
||||
if (data->layers[i].type == type) {
|
||||
BLI_assert(uint(n) < uint(layer_num));
|
||||
data->layers[i].active_clone = n;
|
||||
}
|
||||
}
|
||||
|
@ -2610,8 +2622,12 @@ void CustomData_set_layer_clone(CustomData *data, const int type, const int n)
|
|||
|
||||
void CustomData_set_layer_stencil(CustomData *data, const int type, const int n)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
const int layer_num = CustomData_number_of_layers(data, type);
|
||||
#endif
|
||||
for (int i = 0; i < data->totlayer; i++) {
|
||||
if (data->layers[i].type == type) {
|
||||
BLI_assert(uint(n) < uint(layer_num));
|
||||
data->layers[i].active_mask = n;
|
||||
}
|
||||
}
|
||||
|
@ -2619,48 +2635,64 @@ void CustomData_set_layer_stencil(CustomData *data, const int type, const int n)
|
|||
|
||||
void CustomData_set_layer_active_index(CustomData *data, const int type, const int n)
|
||||
{
|
||||
const int layer_index = data->typemap[type];
|
||||
#ifndef NDEBUG
|
||||
const int layer_num = CustomData_number_of_layers(data, type);
|
||||
#endif
|
||||
const int layer_index = n - data->typemap[type];
|
||||
BLI_assert(customdata_typemap_is_valid(data));
|
||||
|
||||
for (int i = 0; i < data->totlayer; i++) {
|
||||
if (data->layers[i].type == type) {
|
||||
data->layers[i].active = n - layer_index;
|
||||
BLI_assert(uint(layer_index) < uint(layer_num));
|
||||
data->layers[i].active = layer_index;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CustomData_set_layer_render_index(CustomData *data, const int type, const int n)
|
||||
{
|
||||
const int layer_index = data->typemap[type];
|
||||
#ifndef NDEBUG
|
||||
const int layer_num = CustomData_number_of_layers(data, type);
|
||||
#endif
|
||||
const int layer_index = n - data->typemap[type];
|
||||
BLI_assert(customdata_typemap_is_valid(data));
|
||||
|
||||
for (int i = 0; i < data->totlayer; i++) {
|
||||
if (data->layers[i].type == type) {
|
||||
data->layers[i].active_rnd = n - layer_index;
|
||||
BLI_assert(uint(layer_index) < uint(layer_num));
|
||||
data->layers[i].active_rnd = layer_index;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CustomData_set_layer_clone_index(CustomData *data, const int type, const int n)
|
||||
{
|
||||
const int layer_index = data->typemap[type];
|
||||
#ifndef NDEBUG
|
||||
const int layer_num = CustomData_number_of_layers(data, type);
|
||||
#endif
|
||||
const int layer_index = n - data->typemap[type];
|
||||
BLI_assert(customdata_typemap_is_valid(data));
|
||||
|
||||
for (int i = 0; i < data->totlayer; i++) {
|
||||
if (data->layers[i].type == type) {
|
||||
data->layers[i].active_clone = n - layer_index;
|
||||
BLI_assert(uint(layer_index) < uint(layer_num));
|
||||
data->layers[i].active_clone = layer_index;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CustomData_set_layer_stencil_index(CustomData *data, const int type, const int n)
|
||||
{
|
||||
const int layer_index = data->typemap[type];
|
||||
#ifndef NDEBUG
|
||||
const int layer_num = CustomData_number_of_layers(data, type);
|
||||
#endif
|
||||
const int layer_index = n - data->typemap[type];
|
||||
BLI_assert(customdata_typemap_is_valid(data));
|
||||
|
||||
for (int i = 0; i < data->totlayer; i++) {
|
||||
if (data->layers[i].type == type) {
|
||||
data->layers[i].active_mask = n - layer_index;
|
||||
BLI_assert(uint(layer_index) < uint(layer_num));
|
||||
data->layers[i].active_mask = layer_index;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -606,7 +606,7 @@ void adapt_mesh_domain_edge_to_corner_impl(const Mesh &mesh,
|
|||
|
||||
/* For every corner, mix the values from the adjacent edges on the face. */
|
||||
for (const int loop_index : IndexRange(poly.loopstart, poly.totloop)) {
|
||||
const int loop_index_prev = mesh_topology::poly_loop_prev(poly, loop_index);
|
||||
const int loop_index_prev = mesh::poly_corner_prev(poly, loop_index);
|
||||
const int edge = corner_edges[loop_index];
|
||||
const int edge_prev = corner_edges[loop_index_prev];
|
||||
mixer.mix_in(loop_index, old_values[edge]);
|
||||
|
@ -633,7 +633,7 @@ void adapt_mesh_domain_edge_to_corner_impl(const Mesh &mesh,
|
|||
for (const int poly_index : range) {
|
||||
const MPoly &poly = polys[poly_index];
|
||||
for (const int loop_index : IndexRange(poly.loopstart, poly.totloop)) {
|
||||
const int loop_index_prev = mesh_topology::poly_loop_prev(poly, loop_index);
|
||||
const int loop_index_prev = mesh::poly_corner_prev(poly, loop_index);
|
||||
const int edge = corner_edges[loop_index];
|
||||
const int edge_prev = corner_edges[loop_index_prev];
|
||||
if (old_values[edge] && old_values[edge_prev]) {
|
||||
|
|
|
@ -336,6 +336,20 @@ static void image_gpu_texture_try_partial_update(Image *image, ImageUser *iuser)
|
|||
}
|
||||
}
|
||||
|
||||
void BKE_image_ensure_gpu_texture(Image *image, ImageUser *image_user)
|
||||
{
|
||||
if (!image) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* Note that the image can cache both stereo views, so we only invalidate the cache if the view
|
||||
* index is more than 2. */
|
||||
if (image->gpu_pass != image_user->pass || image->gpu_layer != image_user->layer ||
|
||||
(image->gpu_view != image_user->multi_index && image_user->multi_index >= 2)) {
|
||||
BKE_image_partial_update_mark_full_update(image);
|
||||
}
|
||||
}
|
||||
|
||||
static GPUTexture *image_get_gpu_texture(Image *ima,
|
||||
ImageUser *iuser,
|
||||
ImBuf *ibuf,
|
||||
|
@ -365,6 +379,9 @@ static GPUTexture *image_get_gpu_texture(Image *ima,
|
|||
ima->gpu_pass = requested_pass;
|
||||
ima->gpu_layer = requested_layer;
|
||||
ima->gpu_view = requested_view;
|
||||
/* The cache should be invalidated here, but it is intentionally isn't due to possible
|
||||
* performance implications, see the BKE_image_ensure_gpu_texture function for more
|
||||
* information. */
|
||||
}
|
||||
#undef GPU_FLAGS_TO_CHECK
|
||||
|
||||
|
|
|
@ -1431,6 +1431,8 @@ void BKE_main_collection_sync_remap(const Main *bmain)
|
|||
/* On remapping of object or collection pointers free caches. */
|
||||
/* TODO: try to make this faster */
|
||||
|
||||
BKE_main_collections_object_cache_free(bmain);
|
||||
|
||||
for (Scene *scene = static_cast<Scene *>(bmain->scenes.first); scene;
|
||||
scene = static_cast<Scene *>(scene->id.next)) {
|
||||
LISTBASE_FOREACH (ViewLayer *, view_layer, &scene->view_layers) {
|
||||
|
@ -1447,14 +1449,12 @@ void BKE_main_collection_sync_remap(const Main *bmain)
|
|||
view_layer_bases_hash_create(view_layer, true);
|
||||
}
|
||||
|
||||
BKE_collection_object_cache_free(scene->master_collection);
|
||||
DEG_id_tag_update_ex((Main *)bmain, &scene->master_collection->id, ID_RECALC_COPY_ON_WRITE);
|
||||
DEG_id_tag_update_ex((Main *)bmain, &scene->id, ID_RECALC_COPY_ON_WRITE);
|
||||
}
|
||||
|
||||
for (Collection *collection = static_cast<Collection *>(bmain->collections.first); collection;
|
||||
collection = static_cast<Collection *>(collection->id.next)) {
|
||||
BKE_collection_object_cache_free(collection);
|
||||
DEG_id_tag_update_ex((Main *)bmain, &collection->id, ID_RECALC_COPY_ON_WRITE);
|
||||
}
|
||||
|
||||
|
@ -2514,9 +2514,8 @@ ViewLayerAOV *BKE_view_layer_add_aov(ViewLayer *view_layer)
|
|||
|
||||
void BKE_view_layer_remove_aov(ViewLayer *view_layer, ViewLayerAOV *aov)
|
||||
{
|
||||
if (aov == nullptr || BLI_findindex(&view_layer->aovs, aov) == -1) {
|
||||
return;
|
||||
}
|
||||
BLI_assert(BLI_findindex(&view_layer->aovs, aov) != -1);
|
||||
BLI_assert(aov != nullptr);
|
||||
if (view_layer->active_aov == aov) {
|
||||
if (aov->next) {
|
||||
viewlayer_aov_active_set(view_layer, aov->next);
|
||||
|
|
|
@ -1505,45 +1505,6 @@ void BKE_mesh_auto_smooth_flag_set(Mesh *me,
|
|||
}
|
||||
}
|
||||
|
||||
int poly_find_loop_from_vert(const MPoly *poly, const int *poly_corner_verts, int vert)
|
||||
{
|
||||
for (int j = 0; j < poly->totloop; j++) {
|
||||
if (poly_corner_verts[j] == vert) {
|
||||
return j;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int poly_get_adj_loops_from_vert(const MPoly *poly,
|
||||
const int *corner_verts,
|
||||
int vert,
|
||||
int r_adj[2])
|
||||
{
|
||||
int corner = poly_find_loop_from_vert(poly, &corner_verts[poly->loopstart], vert);
|
||||
|
||||
if (corner != -1) {
|
||||
/* vertex was found */
|
||||
r_adj[0] = corner_verts[ME_POLY_LOOP_PREV(poly, corner)];
|
||||
r_adj[1] = corner_verts[ME_POLY_LOOP_NEXT(poly, corner)];
|
||||
}
|
||||
|
||||
return corner;
|
||||
}
|
||||
|
||||
int BKE_mesh_edge_other_vert(const MEdge *edge, int v)
|
||||
{
|
||||
if (edge->v1 == v) {
|
||||
return edge->v2;
|
||||
}
|
||||
if (edge->v2 == v) {
|
||||
return edge->v1;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
void BKE_mesh_looptri_get_real_edges(const MEdge *edges,
|
||||
const int *corner_verts,
|
||||
const int *corner_edges,
|
||||
|
|
|
@ -603,8 +603,7 @@ static void copy_or_interp_loop_attributes(Mesh *dest_mesh,
|
|||
}
|
||||
for (int source_layer_i = 0; source_layer_i < source_cd->totlayer; ++source_layer_i) {
|
||||
int ty = source_cd->layers[source_layer_i].type;
|
||||
if (STREQ(source_cd->layers[source_layer_i].name, ".corner_vert") ||
|
||||
STREQ(source_cd->layers[source_layer_i].name, ".corner_edge")) {
|
||||
if (STR_ELEM(source_cd->layers[source_layer_i].name, ".corner_vert", ".corner_edge")) {
|
||||
continue;
|
||||
}
|
||||
const char *name = source_cd->layers[source_layer_i].name;
|
||||
|
|
|
@ -237,11 +237,12 @@ class MeshFairingContext : public FairingContext {
|
|||
float r_adj_next[3],
|
||||
float r_adj_prev[3]) override
|
||||
{
|
||||
using namespace blender;
|
||||
const int vert = corner_verts_[loop];
|
||||
const MPoly &poly = polys[loop_to_poly_map_[loop]];
|
||||
const int corner = poly_find_loop_from_vert(&poly, &corner_verts_[poly.loopstart], vert);
|
||||
copy_v3_v3(r_adj_next, co_[corner_verts_[ME_POLY_LOOP_NEXT(&poly, corner)]]);
|
||||
copy_v3_v3(r_adj_prev, co_[corner_verts_[ME_POLY_LOOP_PREV(&poly, corner)]]);
|
||||
const int2 adjecent_verts = bke::mesh::poly_find_adjecent_verts(poly, corner_verts_, vert);
|
||||
copy_v3_v3(r_adj_next, co_[adjecent_verts[0]]);
|
||||
copy_v3_v3(r_adj_prev, co_[adjecent_verts[1]]);
|
||||
}
|
||||
|
||||
int other_vertex_index_from_loop(const int loop, const uint v) override
|
||||
|
|
|
@ -1284,7 +1284,7 @@ static void loop_split_generator(TaskPool *pool, LoopSplitTaskDataCommon *common
|
|||
const MPoly &poly = polys[poly_index];
|
||||
|
||||
for (const int ml_curr_index : IndexRange(poly.loopstart, poly.totloop)) {
|
||||
const int ml_prev_index = mesh_topology::poly_loop_prev(poly, ml_curr_index);
|
||||
const int ml_prev_index = mesh::poly_corner_prev(poly, ml_curr_index);
|
||||
|
||||
#if 0
|
||||
printf("Checking loop %d / edge %u / vert %u (sharp edge: %d, skiploop: %d)",
|
||||
|
|
|
@ -740,13 +740,13 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
|
|||
nearest.index = -1;
|
||||
|
||||
for (i = 0; i < numedges_dst; i++) {
|
||||
const MEdge *e_dst = &edges_dst[i];
|
||||
const MEdge &e_dst = edges_dst[i];
|
||||
float best_totdist = FLT_MAX;
|
||||
int best_eidx_src = -1;
|
||||
int j = 2;
|
||||
|
||||
while (j--) {
|
||||
const uint vidx_dst = j ? e_dst->v1 : e_dst->v2;
|
||||
const uint vidx_dst = j ? e_dst.v1 : e_dst.v2;
|
||||
|
||||
/* Compute closest verts only once! */
|
||||
if (v_dst_to_src_map[vidx_dst].hit_dist == -1.0f) {
|
||||
|
@ -772,7 +772,7 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
|
|||
/* Now, check all source edges of closest sources vertices,
|
||||
* and select the one giving the smallest total verts-to-verts distance. */
|
||||
for (j = 2; j--;) {
|
||||
const uint vidx_dst = j ? e_dst->v1 : e_dst->v2;
|
||||
const uint vidx_dst = j ? e_dst.v1 : e_dst.v2;
|
||||
const float first_dist = v_dst_to_src_map[vidx_dst].hit_dist;
|
||||
const int vidx_src = v_dst_to_src_map[vidx_dst].index;
|
||||
int *eidx_src, k;
|
||||
|
@ -785,10 +785,11 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
|
|||
k = vert_to_edge_src_map[vidx_src].count;
|
||||
|
||||
for (; k--; eidx_src++) {
|
||||
const MEdge *edge_src = &edges_src[*eidx_src];
|
||||
const float *other_co_src = vcos_src[BKE_mesh_edge_other_vert(edge_src, vidx_src)];
|
||||
const MEdge &edge_src = edges_src[*eidx_src];
|
||||
const float *other_co_src =
|
||||
vcos_src[blender::bke::mesh::edge_other_vert(edge_src, vidx_src)];
|
||||
const float *other_co_dst =
|
||||
vert_positions_dst[BKE_mesh_edge_other_vert(e_dst, int(vidx_dst))];
|
||||
vert_positions_dst[blender::bke::mesh::edge_other_vert(e_dst, int(vidx_dst))];
|
||||
const float totdist = first_dist + len_v3v3(other_co_src, other_co_dst);
|
||||
|
||||
if (totdist < best_totdist) {
|
||||
|
@ -801,8 +802,8 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
|
|||
if (best_eidx_src >= 0) {
|
||||
const float *co1_src = vcos_src[edges_src[best_eidx_src].v1];
|
||||
const float *co2_src = vcos_src[edges_src[best_eidx_src].v2];
|
||||
const float *co1_dst = vert_positions_dst[e_dst->v1];
|
||||
const float *co2_dst = vert_positions_dst[e_dst->v2];
|
||||
const float *co1_dst = vert_positions_dst[e_dst.v1];
|
||||
const float *co2_dst = vert_positions_dst[e_dst.v2];
|
||||
float co_src[3], co_dst[3];
|
||||
|
||||
/* TODO: would need an isect_seg_seg_v3(), actually! */
|
||||
|
|
|
@ -929,16 +929,57 @@ static bool mesh_validate_customdata(CustomData *data,
|
|||
|
||||
PRINT_MSG("%s: Checking %d CD layers...\n", __func__, data->totlayer);
|
||||
|
||||
/* Set dummy values so the layer-type is always initialized on first access. */
|
||||
int layer_num = -1;
|
||||
int layer_num_type = -1;
|
||||
|
||||
while (i < data->totlayer) {
|
||||
CustomDataLayer *layer = &data->layers[i];
|
||||
bool ok = true;
|
||||
|
||||
/* Count layers when the type changes. */
|
||||
if (layer_num_type != layer->type) {
|
||||
layer_num = CustomData_number_of_layers(data, layer->type);
|
||||
layer_num_type = layer->type;
|
||||
}
|
||||
|
||||
/* Validate active index, for a time this could be set to a negative value, see: #105860. */
|
||||
int *active_index_array[] = {
|
||||
&layer->active,
|
||||
&layer->active_rnd,
|
||||
&layer->active_clone,
|
||||
&layer->active_mask,
|
||||
};
|
||||
for (int *active_index : Span(active_index_array, ARRAY_SIZE(active_index_array))) {
|
||||
if (*active_index < 0) {
|
||||
PRINT_ERR("\tCustomDataLayer type %d has a negative active index (%d)\n",
|
||||
layer->type,
|
||||
*active_index);
|
||||
if (do_fixes) {
|
||||
*active_index = 0;
|
||||
has_fixes = true;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (*active_index >= layer_num) {
|
||||
PRINT_ERR("\tCustomDataLayer type %d has an out of bounds active index (%d >= %d)\n",
|
||||
layer->type,
|
||||
*active_index,
|
||||
layer_num);
|
||||
if (do_fixes) {
|
||||
BLI_assert(layer_num > 0);
|
||||
*active_index = layer_num - 1;
|
||||
has_fixes = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (CustomData_layertype_is_singleton(layer->type)) {
|
||||
const int layer_tot = CustomData_number_of_layers(data, layer->type);
|
||||
if (layer_tot > 1) {
|
||||
if (layer_num > 1) {
|
||||
PRINT_ERR("\tCustomDataLayer type %d is a singleton, found %d in Mesh structure\n",
|
||||
layer->type,
|
||||
layer_tot);
|
||||
layer_num);
|
||||
ok = false;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -4357,7 +4357,7 @@ void BKE_object_handle_update(Depsgraph *depsgraph, Scene *scene, Object *ob)
|
|||
void BKE_object_sculpt_data_create(Object *ob)
|
||||
{
|
||||
BLI_assert((ob->sculpt == nullptr) && (ob->mode & OB_MODE_ALL_SCULPT));
|
||||
ob->sculpt = MEM_cnew<SculptSession>(__func__);
|
||||
ob->sculpt = MEM_new<SculptSession>(__func__);
|
||||
ob->sculpt->mode_type = (eObjectMode)ob->mode;
|
||||
}
|
||||
|
||||
|
|
|
@ -1696,16 +1696,16 @@ static void sculpt_update_object(
|
|||
/* These are assigned to the base mesh in Multires. This is needed because Face Sets operators
|
||||
* and tools use the Face Sets data from the base mesh when Multires is active. */
|
||||
ss->vert_positions = BKE_mesh_vert_positions_for_write(me);
|
||||
ss->polys = me->polys().data();
|
||||
ss->corner_verts = me->corner_verts().data();
|
||||
ss->polys = me->polys();
|
||||
ss->corner_verts = me->corner_verts();
|
||||
}
|
||||
else {
|
||||
ss->totvert = me->totvert;
|
||||
ss->totpoly = me->totpoly;
|
||||
ss->totfaces = me->totpoly;
|
||||
ss->vert_positions = BKE_mesh_vert_positions_for_write(me);
|
||||
ss->polys = me->polys().data();
|
||||
ss->corner_verts = me->corner_verts().data();
|
||||
ss->polys = me->polys();
|
||||
ss->corner_verts = me->corner_verts();
|
||||
ss->multires.active = false;
|
||||
ss->multires.modifier = nullptr;
|
||||
ss->multires.level = 0;
|
||||
|
@ -1999,12 +1999,11 @@ int BKE_sculpt_mask_layers_ensure(Depsgraph *depsgraph,
|
|||
int level = max_ii(1, mmd->sculptlvl);
|
||||
int gridsize = BKE_ccg_gridsize(level);
|
||||
int gridarea = gridsize * gridsize;
|
||||
int i, j;
|
||||
|
||||
gmask = static_cast<GridPaintMask *>(
|
||||
CustomData_add_layer(&me->ldata, CD_GRID_PAINT_MASK, CD_SET_DEFAULT, me->totloop));
|
||||
|
||||
for (i = 0; i < me->totloop; i++) {
|
||||
for (int i = 0; i < me->totloop; i++) {
|
||||
GridPaintMask *gpm = &gmask[i];
|
||||
|
||||
gpm->level = level;
|
||||
|
@ -2012,29 +2011,28 @@ int BKE_sculpt_mask_layers_ensure(Depsgraph *depsgraph,
|
|||
MEM_callocN(sizeof(float) * gridarea, "GridPaintMask.data"));
|
||||
}
|
||||
|
||||
/* if vertices already have mask, copy into multires data */
|
||||
/* If vertices already have mask, copy into multires data. */
|
||||
if (paint_mask) {
|
||||
for (i = 0; i < me->totpoly; i++) {
|
||||
for (const int i : polys.index_range()) {
|
||||
const MPoly &poly = polys[i];
|
||||
float avg = 0;
|
||||
|
||||
/* mask center */
|
||||
for (j = 0; j < poly.totloop; j++) {
|
||||
const int vert = corner_verts[poly.loopstart + j];
|
||||
/* Mask center. */
|
||||
float avg = 0.0f;
|
||||
for (const int vert : corner_verts.slice(poly.loopstart, poly.totloop)) {
|
||||
avg += paint_mask[vert];
|
||||
}
|
||||
avg /= float(poly.totloop);
|
||||
|
||||
/* fill in multires mask corner */
|
||||
for (j = 0; j < poly.totloop; j++) {
|
||||
GridPaintMask *gpm = &gmask[poly.loopstart + j];
|
||||
const int vert = corner_verts[poly.loopstart + j];
|
||||
const int prev = ME_POLY_LOOP_PREV(&poly, j);
|
||||
const int next = ME_POLY_LOOP_NEXT(&poly, j);
|
||||
/* Fill in multires mask corner. */
|
||||
for (const int corner : blender::IndexRange(poly.loopstart, poly.totloop)) {
|
||||
GridPaintMask *gpm = &gmask[corner];
|
||||
const int vert = corner_verts[corner];
|
||||
const int prev = corner_verts[blender::bke::mesh::poly_corner_prev(poly, vert)];
|
||||
const int next = corner_verts[blender::bke::mesh::poly_corner_next(poly, vert)];
|
||||
|
||||
gpm->data[0] = avg;
|
||||
gpm->data[1] = (paint_mask[vert] + paint_mask[corner_verts[next]]) * 0.5f;
|
||||
gpm->data[2] = (paint_mask[vert] + paint_mask[corner_verts[prev]]) * 0.5f;
|
||||
gpm->data[1] = (paint_mask[vert] + paint_mask[next]) * 0.5f;
|
||||
gpm->data[2] = (paint_mask[vert] + paint_mask[prev]) * 0.5f;
|
||||
gpm->data[3] = paint_mask[vert];
|
||||
}
|
||||
}
|
||||
|
@ -2285,6 +2283,24 @@ PBVH *BKE_sculpt_object_pbvh_ensure(Depsgraph *depsgraph, Object *ob)
|
|||
return pbvh;
|
||||
}
|
||||
|
||||
PBVH *BKE_object_sculpt_pbvh_get(Object *object)
|
||||
{
|
||||
if (!object->sculpt) {
|
||||
return nullptr;
|
||||
}
|
||||
return object->sculpt->pbvh;
|
||||
}
|
||||
|
||||
bool BKE_object_sculpt_use_dyntopo(const Object *object)
|
||||
{
|
||||
return object->sculpt && object->sculpt->bm;
|
||||
}
|
||||
|
||||
void BKE_object_sculpt_dyntopo_smooth_shading_set(Object *object, const bool value)
|
||||
{
|
||||
object->sculpt->bm_smooth_shading = value;
|
||||
}
|
||||
|
||||
void BKE_sculpt_bvh_update_from_ccg(PBVH *pbvh, SubdivCCG *subdiv_ccg)
|
||||
{
|
||||
CCGKey key;
|
||||
|
|
|
@ -3598,9 +3598,9 @@ void sbObjectStep(struct Depsgraph *depsgraph,
|
|||
/* pass */
|
||||
}
|
||||
else if (/*ob->id.lib || */
|
||||
/* "library linking & pointcaches" has to be solved properly at some point */
|
||||
/* "library linking & point-caches" has to be solved properly at some point. */
|
||||
(cache->flag & PTCACHE_BAKED)) {
|
||||
/* if baked and nothing in cache, do nothing */
|
||||
/* If baked and nothing in cache, do nothing. */
|
||||
if (can_write_cache) {
|
||||
BKE_ptcache_invalidate(cache);
|
||||
}
|
||||
|
|
|
@ -1986,7 +1986,7 @@ const int *BKE_subdiv_ccg_start_face_grid_index_get(const SubdivCCG *subdiv_ccg)
|
|||
|
||||
static void adjacet_vertices_index_from_adjacent_edge(const SubdivCCG *subdiv_ccg,
|
||||
const SubdivCCGCoord *coord,
|
||||
const int *corner_verts,
|
||||
const blender::Span<int> corner_verts,
|
||||
const MPoly *polys,
|
||||
int *r_v1,
|
||||
int *r_v2)
|
||||
|
@ -1996,13 +1996,13 @@ static void adjacet_vertices_index_from_adjacent_edge(const SubdivCCG *subdiv_cc
|
|||
const MPoly &poly = polys[poly_index];
|
||||
*r_v1 = corner_verts[coord->grid_index];
|
||||
|
||||
const int corner = poly_find_loop_from_vert(&poly, &corner_verts[poly.loopstart], *r_v1);
|
||||
const int corner = blender::bke::mesh::poly_find_corner_from_vert(poly, corner_verts, *r_v1);
|
||||
if (coord->x == grid_size_1) {
|
||||
const int next = ME_POLY_LOOP_NEXT(&poly, corner);
|
||||
const int next = blender::bke::mesh::poly_corner_next(poly, corner);
|
||||
*r_v2 = corner_verts[next];
|
||||
}
|
||||
if (coord->y == grid_size_1) {
|
||||
const int prev = ME_POLY_LOOP_PREV(&poly, corner);
|
||||
const int prev = blender::bke::mesh::poly_corner_prev(poly, corner);
|
||||
*r_v2 = corner_verts[prev];
|
||||
}
|
||||
}
|
||||
|
@ -2010,6 +2010,7 @@ static void adjacet_vertices_index_from_adjacent_edge(const SubdivCCG *subdiv_cc
|
|||
SubdivCCGAdjacencyType BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(const SubdivCCG *subdiv_ccg,
|
||||
const SubdivCCGCoord *coord,
|
||||
const int *corner_verts,
|
||||
const int corners_num,
|
||||
const MPoly *polys,
|
||||
int *r_v1,
|
||||
int *r_v2)
|
||||
|
@ -2027,7 +2028,8 @@ SubdivCCGAdjacencyType BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(const Subdi
|
|||
return SUBDIV_CCG_ADJACENT_VERTEX;
|
||||
}
|
||||
/* Grid corner adjacent to the middle of a coarse mesh edge. */
|
||||
adjacet_vertices_index_from_adjacent_edge(subdiv_ccg, coord, corner_verts, polys, r_v1, r_v2);
|
||||
adjacet_vertices_index_from_adjacent_edge(
|
||||
subdiv_ccg, coord, {corner_verts, corners_num}, polys, r_v1, r_v2);
|
||||
return SUBDIV_CCG_ADJACENT_EDGE;
|
||||
}
|
||||
|
||||
|
@ -2035,7 +2037,7 @@ SubdivCCGAdjacencyType BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(const Subdi
|
|||
if (!is_inner_edge_grid_coordinate(subdiv_ccg, coord)) {
|
||||
/* Grid boundary adjacent to a coarse mesh edge. */
|
||||
adjacet_vertices_index_from_adjacent_edge(
|
||||
subdiv_ccg, coord, corner_verts, polys, r_v1, r_v2);
|
||||
subdiv_ccg, coord, {corner_verts, corners_num}, polys, r_v1, r_v2);
|
||||
return SUBDIV_CCG_ADJACENT_EDGE;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -312,7 +312,7 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
|
|||
int nverts = poly.totloop;
|
||||
int j, j_next;
|
||||
CCGFace *origf = ccgSubSurf_getFace(origss, POINTER_FROM_INT(i));
|
||||
/* uint *fv = &poly.v1; */
|
||||
// uint *fv = &poly.v1;
|
||||
|
||||
fverts.reinitialize(nverts);
|
||||
|
||||
|
@ -1041,7 +1041,7 @@ static void ccgDM_copyFinalCornerVertArray(DerivedMesh *dm, int *r_corner_verts)
|
|||
CopyFinalLoopArrayData data;
|
||||
data.ccgdm = ccgdm;
|
||||
data.corner_verts = r_corner_verts;
|
||||
data.corner_edges = NULL;
|
||||
data.corner_edges = nullptr;
|
||||
data.grid_size = ccgSubSurf_getGridSize(ss);
|
||||
data.grid_offset = dm->getGridOffset(dm);
|
||||
data.edge_size = ccgSubSurf_getEdgeSize(ss);
|
||||
|
@ -1085,7 +1085,7 @@ static void ccgDM_copyFinalCornerEdgeArray(DerivedMesh *dm, int *r_corner_edges)
|
|||
|
||||
CopyFinalLoopArrayData data;
|
||||
data.ccgdm = ccgdm;
|
||||
data.corner_verts = NULL;
|
||||
data.corner_verts = nullptr;
|
||||
data.corner_edges = r_corner_edges;
|
||||
data.grid_size = ccgSubSurf_getGridSize(ss);
|
||||
data.grid_offset = dm->getGridOffset(dm);
|
||||
|
|
|
@ -19,12 +19,13 @@
|
|||
# undef NOMINMAX
|
||||
# endif
|
||||
# endif
|
||||
#else
|
||||
# include <atomic>
|
||||
# include <mutex>
|
||||
|
||||
# include "BLI_map.hh"
|
||||
#endif
|
||||
|
||||
#include <atomic>
|
||||
#include <mutex>
|
||||
|
||||
#include "BLI_map.hh"
|
||||
#include "BLI_utility_mixins.hh"
|
||||
|
||||
namespace blender::threading {
|
||||
|
|
|
@ -24,6 +24,7 @@ template<typename T> class OffsetIndices {
|
|||
Span<T> offsets_;
|
||||
|
||||
public:
|
||||
OffsetIndices() = default;
|
||||
OffsetIndices(const Span<T> offsets) : offsets_(offsets)
|
||||
{
|
||||
BLI_assert(std::is_sorted(offsets_.begin(), offsets_.end()));
|
||||
|
|
|
@ -64,6 +64,22 @@ template<typename T> class SharedCache {
|
|||
BLI_assert(cache_->mutex.is_cached());
|
||||
return cache_->data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return true if the cache currently does not exist or has been invalidated.
|
||||
*/
|
||||
bool is_dirty() const
|
||||
{
|
||||
return cache_->mutex.is_dirty();
|
||||
}
|
||||
|
||||
/**
|
||||
* Return true if the cache exists and is valid.
|
||||
*/
|
||||
bool is_cached() const
|
||||
{
|
||||
return cache_->mutex.is_cached();
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace blender
|
||||
|
|
|
@ -13,11 +13,12 @@ set(INC
|
|||
../../../intern/atomic
|
||||
../../../intern/eigen
|
||||
../../../intern/guardedalloc
|
||||
../../../extern/wcwidth
|
||||
../../../extern/json/include
|
||||
)
|
||||
|
||||
set(INC_SYS
|
||||
../../../extern/wcwidth
|
||||
../../../extern/json/include
|
||||
|
||||
${EIGEN3_INCLUDE_DIRS}
|
||||
${ZLIB_INCLUDE_DIRS}
|
||||
${ZSTD_INCLUDE_DIRS}
|
||||
|
|
|
@ -5,10 +5,11 @@
|
|||
* \brief Array storage to minimize duplication.
|
||||
*
|
||||
* This is done by splitting arrays into chunks and using copy-on-write (COW),
|
||||
* to de-duplicate chunks,
|
||||
* from the users perspective this is an implementation detail.
|
||||
* to de-duplicate chunks, from the users perspective this is an implementation detail.
|
||||
*
|
||||
* Overview
|
||||
* ========
|
||||
*
|
||||
* Data Structure
|
||||
* --------------
|
||||
*
|
||||
|
@ -16,51 +17,52 @@
|
|||
*
|
||||
* \note The only 2 structures here which are referenced externally are the.
|
||||
*
|
||||
* - BArrayStore: The whole array store.
|
||||
* - BArrayState: Represents a single state (array) of data.
|
||||
* - #BArrayStore: The whole array store.
|
||||
* - #BArrayState: Represents a single state (array) of data.
|
||||
* These can be add using a reference state,
|
||||
* while this could be considered the previous or parent state.
|
||||
* no relationship is kept,
|
||||
* so the caller is free to add any state from the same BArrayStore as a reference.
|
||||
* so the caller is free to add any state from the same #BArrayStore as a reference.
|
||||
*
|
||||
* <pre>
|
||||
* <+> BArrayStore: root data-structure,
|
||||
* <+> #BArrayStore: root data-structure,
|
||||
* | can store many 'states', which share memory.
|
||||
* |
|
||||
* | This can store many arrays, however they must share the same 'stride'.
|
||||
* | Arrays of different types will need to use a new BArrayStore.
|
||||
* | Arrays of different types will need to use a new #BArrayStore.
|
||||
* |
|
||||
* +- <+> states (Collection of BArrayState's):
|
||||
* +- <+> states (Collection of #BArrayState's):
|
||||
* | | Each represents an array added by the user of this API.
|
||||
* | | and references a chunk_list (each state is a chunk_list user).
|
||||
* | | Note that the list order has no significance.
|
||||
* | |
|
||||
* | +- <+> chunk_list (BChunkList):
|
||||
* | +- <+> chunk_list (#BChunkList):
|
||||
* | | The chunks that make up this state.
|
||||
* | | Each state is a chunk_list user,
|
||||
* | | avoids duplicating lists when there is no change between states.
|
||||
* | |
|
||||
* | +- chunk_refs (List of BChunkRef): Each chunk_ref links to a BChunk.
|
||||
* | +- chunk_refs (List of #BChunkRef): Each chunk_ref links to a #BChunk.
|
||||
* | Each reference is a chunk user,
|
||||
* | avoids duplicating smaller chunks of memory found in multiple states.
|
||||
* |
|
||||
* +- info (BArrayInfo):
|
||||
* +- info (#BArrayInfo):
|
||||
* | Sizes and offsets for this array-store.
|
||||
* | Also caches some variables for reuse.
|
||||
* |
|
||||
* +- <+> memory (BArrayMemory):
|
||||
* | Memory pools for storing BArrayStore data.
|
||||
* +- <+> memory (#BArrayMemory):
|
||||
* | Memory pools for storing #BArrayStore data.
|
||||
* |
|
||||
* +- chunk_list (Pool of BChunkList):
|
||||
* | All chunk_lists, (reference counted, used by BArrayState).
|
||||
* +- chunk_list (Pool of #BChunkList):
|
||||
* | All chunk_lists, (reference counted, used by #BArrayState).
|
||||
* |
|
||||
* +- chunk_ref (Pool of BChunkRef):
|
||||
* | All chunk_refs (link between BChunkList & BChunk).
|
||||
* +- chunk_ref (Pool of #BChunkRef):
|
||||
* | All chunk_refs (link between #BChunkList & #BChunk).
|
||||
* |
|
||||
* +- chunks (Pool of BChunk):
|
||||
* All chunks, (reference counted, used by BChunkList).
|
||||
* +- chunks (Pool of #BChunk):
|
||||
* All chunks, (reference counted, used by #BChunkList).
|
||||
* These have their headers hashed for reuse so we can quickly check for duplicates.
|
||||
* </pre>
|
||||
*
|
||||
* De-Duplication
|
||||
* --------------
|
||||
*
|
||||
|
@ -71,7 +73,7 @@
|
|||
* For identical arrays this is all that's needed.
|
||||
*
|
||||
* De-duplication is performed on any remaining chunks, by hashing the first few bytes of the chunk
|
||||
* (see: BCHUNK_HASH_TABLE_ACCUMULATE_STEPS).
|
||||
* (see: #BCHUNK_HASH_TABLE_ACCUMULATE_STEPS).
|
||||
*
|
||||
* \note This is cached for reuse since the referenced data never changes.
|
||||
*
|
||||
|
@ -93,9 +95,9 @@
|
|||
|
||||
#include "BLI_strict_flags.h"
|
||||
|
||||
#include "BLI_array_store.h" /* own include */
|
||||
#include "BLI_array_store.h" /* Own include. */
|
||||
|
||||
/* only for BLI_array_store_is_valid */
|
||||
/* Only for #BLI_array_store_is_valid. */
|
||||
#include "BLI_ghash.h"
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
@ -169,7 +171,7 @@
|
|||
#endif
|
||||
|
||||
/**
|
||||
* Calculate the key once and reuse it
|
||||
* Calculate the key once and reuse it.
|
||||
*/
|
||||
#define USE_HASH_TABLE_KEY_CACHE
|
||||
#ifdef USE_HASH_TABLE_KEY_CACHE
|
||||
|
@ -177,6 +179,16 @@
|
|||
# define HASH_TABLE_KEY_FALLBACK ((hash_key)-2)
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Ensure duplicate entries aren't added to temporary hash table
|
||||
* needed for arrays where many values match (an array of booleans all true/false for e.g.).
|
||||
*
|
||||
* Without this, a huge number of duplicates are added a single bucket, making hash lookups slow.
|
||||
* While de-duplication adds some cost, it's only performed with other chunks in the same bucket
|
||||
* so cases when all chunks are unique will quickly detect and exit the `memcmp` in most cases.
|
||||
*/
|
||||
#define USE_HASH_TABLE_DEDUPLICATE
|
||||
|
||||
/**
|
||||
* How much larger the table is then the total number of chunks.
|
||||
*/
|
||||
|
@ -209,7 +221,7 @@
|
|||
# define BCHUNK_SIZE_MAX_MUL 2
|
||||
#endif /* USE_MERGE_CHUNKS */
|
||||
|
||||
/** Slow (keep disabled), but handy for debugging */
|
||||
/** Slow (keep disabled), but handy for debugging. */
|
||||
// #define USE_VALIDATE_LIST_SIZE
|
||||
|
||||
// #define USE_VALIDATE_LIST_DATA_PARTIAL
|
||||
|
@ -228,9 +240,9 @@ typedef struct BArrayInfo {
|
|||
size_t chunk_stride;
|
||||
// uint chunk_count; /* UNUSED (other values are derived from this) */
|
||||
|
||||
/* pre-calculated */
|
||||
/* Pre-calculated. */
|
||||
size_t chunk_byte_size;
|
||||
/* min/max limits (inclusive) */
|
||||
/* Min/max limits (inclusive) */
|
||||
size_t chunk_byte_size_min;
|
||||
size_t chunk_byte_size_max;
|
||||
/**
|
||||
|
@ -245,19 +257,19 @@ typedef struct BArrayInfo {
|
|||
} BArrayInfo;
|
||||
|
||||
typedef struct BArrayMemory {
|
||||
BLI_mempool *chunk_list; /* BChunkList */
|
||||
BLI_mempool *chunk_ref; /* BChunkRef */
|
||||
BLI_mempool *chunk; /* BChunk */
|
||||
BLI_mempool *chunk_list; /* #BChunkList. */
|
||||
BLI_mempool *chunk_ref; /* #BChunkRef. */
|
||||
BLI_mempool *chunk; /* #BChunk. */
|
||||
} BArrayMemory;
|
||||
|
||||
/**
|
||||
* Main storage for all states
|
||||
* Main storage for all states.
|
||||
*/
|
||||
struct BArrayStore {
|
||||
/* static */
|
||||
/* Static. */
|
||||
BArrayInfo info;
|
||||
|
||||
/* memory storage */
|
||||
/** Memory storage. */
|
||||
BArrayMemory memory;
|
||||
|
||||
/**
|
||||
|
@ -277,14 +289,14 @@ struct BArrayStore {
|
|||
* it makes it easier to trace invalid usage, so leave as-is for now.
|
||||
*/
|
||||
struct BArrayState {
|
||||
/** linked list in #BArrayStore.states */
|
||||
/** linked list in #BArrayStore.states. */
|
||||
struct BArrayState *next, *prev;
|
||||
/** Shared chunk list, this reference must hold a #BChunkList::users. */
|
||||
struct BChunkList *chunk_list;
|
||||
};
|
||||
|
||||
typedef struct BChunkList {
|
||||
/** List of #BChunkRef's */
|
||||
/** List of #BChunkRef's. */
|
||||
ListBase chunk_refs;
|
||||
/** Result of `BLI_listbase_count(chunks)`, store for reuse. */
|
||||
uint chunk_refs_len;
|
||||
|
@ -367,13 +379,23 @@ static void bchunk_decref(BArrayMemory *bs_mem, BChunk *chunk)
|
|||
}
|
||||
}
|
||||
|
||||
BLI_INLINE bool bchunk_data_compare_unchecked(const BChunk *chunk,
|
||||
const uchar *data_base,
|
||||
const size_t data_base_len,
|
||||
const size_t offset)
|
||||
{
|
||||
BLI_assert(offset + (size_t)chunk->data_len <= data_base_len);
|
||||
UNUSED_VARS_NDEBUG(data_base_len);
|
||||
return (memcmp(&data_base[offset], chunk->data, chunk->data_len) == 0);
|
||||
}
|
||||
|
||||
static bool bchunk_data_compare(const BChunk *chunk,
|
||||
const uchar *data_base,
|
||||
const size_t data_base_len,
|
||||
const size_t offset)
|
||||
{
|
||||
if (offset + (size_t)chunk->data_len <= data_base_len) {
|
||||
return (memcmp(&data_base[offset], chunk->data, chunk->data_len) == 0);
|
||||
return bchunk_data_compare_unchecked(chunk, data_base, data_base_len, offset);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
@ -446,15 +468,15 @@ static void bchunk_list_ensure_min_size_last(const BArrayInfo *info,
|
|||
{
|
||||
BChunkRef *cref = chunk_list->chunk_refs.last;
|
||||
if (cref && cref->prev) {
|
||||
/* both are decref'd after use (end of this block) */
|
||||
/* Both are decref'd after use (end of this block) */
|
||||
BChunk *chunk_curr = cref->link;
|
||||
BChunk *chunk_prev = cref->prev->link;
|
||||
|
||||
if (MIN2(chunk_prev->data_len, chunk_curr->data_len) < info->chunk_byte_size_min) {
|
||||
const size_t data_merge_len = chunk_prev->data_len + chunk_curr->data_len;
|
||||
/* we could pass, but no need */
|
||||
/* We could pass, but no need. */
|
||||
if (data_merge_len <= info->chunk_byte_size_max) {
|
||||
/* we have enough space to merge */
|
||||
/* We have enough space to merge. */
|
||||
|
||||
/* Remove last from the linked-list. */
|
||||
BLI_assert(chunk_list->chunk_refs.last != chunk_list->chunk_refs.first);
|
||||
|
@ -478,10 +500,10 @@ static void bchunk_list_ensure_min_size_last(const BArrayInfo *info,
|
|||
*
|
||||
* if we do, the code below works (test by setting 'BCHUNK_SIZE_MAX_MUL = 1.2') */
|
||||
|
||||
/* keep chunk on the left hand side a regular size */
|
||||
/* Keep chunk on the left hand side a regular size. */
|
||||
const size_t split = info->chunk_byte_size;
|
||||
|
||||
/* merge and split */
|
||||
/* Merge and split. */
|
||||
const size_t data_prev_len = split;
|
||||
const size_t data_curr_len = data_merge_len - split;
|
||||
uchar *data_prev = MEM_mallocN(data_prev_len, __func__);
|
||||
|
@ -490,10 +512,10 @@ static void bchunk_list_ensure_min_size_last(const BArrayInfo *info,
|
|||
if (data_prev_len <= chunk_prev->data_len) {
|
||||
const size_t data_curr_shrink_len = chunk_prev->data_len - data_prev_len;
|
||||
|
||||
/* setup 'data_prev' */
|
||||
/* Setup 'data_prev'. */
|
||||
memcpy(data_prev, chunk_prev->data, data_prev_len);
|
||||
|
||||
/* setup 'data_curr' */
|
||||
/* Setup 'data_curr'. */
|
||||
memcpy(data_curr, &chunk_prev->data[data_prev_len], data_curr_shrink_len);
|
||||
memcpy(&data_curr[data_curr_shrink_len], chunk_curr->data, chunk_curr->data_len);
|
||||
}
|
||||
|
@ -503,11 +525,11 @@ static void bchunk_list_ensure_min_size_last(const BArrayInfo *info,
|
|||
|
||||
const size_t data_prev_grow_len = data_prev_len - chunk_prev->data_len;
|
||||
|
||||
/* setup 'data_prev' */
|
||||
/* Setup 'data_prev'. */
|
||||
memcpy(data_prev, chunk_prev->data, chunk_prev->data_len);
|
||||
memcpy(&data_prev[chunk_prev->data_len], chunk_curr->data, data_prev_grow_len);
|
||||
|
||||
/* setup 'data_curr' */
|
||||
/* Setup 'data_curr'. */
|
||||
memcpy(data_curr, &chunk_curr->data[data_prev_grow_len], data_curr_len);
|
||||
}
|
||||
|
||||
|
@ -518,7 +540,7 @@ static void bchunk_list_ensure_min_size_last(const BArrayInfo *info,
|
|||
cref->link->users += 1;
|
||||
}
|
||||
|
||||
/* free zero users */
|
||||
/* Free zero users. */
|
||||
bchunk_decref(bs_mem, chunk_curr);
|
||||
bchunk_decref(bs_mem, chunk_prev);
|
||||
}
|
||||
|
@ -543,8 +565,7 @@ static void bchunk_list_calc_trim_len(const BArrayInfo *info,
|
|||
size_t data_trim_len = data_len;
|
||||
|
||||
#ifdef USE_MERGE_CHUNKS
|
||||
/* avoid creating too-small chunks
|
||||
* more efficient than merging after */
|
||||
/* Avoid creating too-small chunks more efficient than merging after. */
|
||||
if (data_len > info->chunk_byte_size) {
|
||||
data_last_chunk_len = (data_trim_len % info->chunk_byte_size);
|
||||
data_trim_len = data_trim_len - data_last_chunk_len;
|
||||
|
@ -606,7 +627,7 @@ static void bchunk_list_append_data(const BArrayInfo *info,
|
|||
|
||||
if (MIN2(chunk_prev->data_len, data_len) < info->chunk_byte_size_min) {
|
||||
const size_t data_merge_len = chunk_prev->data_len + data_len;
|
||||
/* realloc for single user */
|
||||
/* Re-allocate for single user. */
|
||||
if (cref->link->users == 1) {
|
||||
uchar *data_merge = MEM_reallocN((void *)cref->link->data, data_merge_len);
|
||||
memcpy(&data_merge[chunk_prev->data_len], data, data_len);
|
||||
|
@ -631,7 +652,7 @@ static void bchunk_list_append_data(const BArrayInfo *info,
|
|||
BChunk *chunk = bchunk_new_copydata(bs_mem, data, data_len);
|
||||
bchunk_list_append_only(bs_mem, chunk_list, chunk);
|
||||
|
||||
/* don't run this, instead preemptively avoid creating a chunk only to merge it (above). */
|
||||
/* Don't run this, instead preemptively avoid creating a chunk only to merge it (above). */
|
||||
#if 0
|
||||
# ifdef USE_MERGE_CHUNKS
|
||||
bchunk_list_ensure_min_size_last(info, bs_mem, chunk_list);
|
||||
|
@ -678,8 +699,7 @@ static void bchunk_list_append_data_n(const BArrayInfo *info,
|
|||
}
|
||||
}
|
||||
else {
|
||||
/* if we didn't write any chunks previously,
|
||||
* we may need to merge with the last. */
|
||||
/* If we didn't write any chunks previously, we may need to merge with the last. */
|
||||
if (data_last_chunk_len) {
|
||||
bchunk_list_append_data(info, bs_mem, chunk_list, data, data_last_chunk_len);
|
||||
// i_prev = data_len; /* UNUSED */
|
||||
|
@ -740,7 +760,7 @@ static void bchunk_list_fill_from_array(const BArrayInfo *info,
|
|||
}
|
||||
#endif
|
||||
|
||||
/* works but better avoid redundant re-alloc */
|
||||
/* Works but better avoid redundant re-allocation. */
|
||||
#if 0
|
||||
# ifdef USE_MERGE_CHUNKS
|
||||
bchunk_list_ensure_min_size_last(info, bs_mem, chunk_list);
|
||||
|
@ -754,7 +774,7 @@ static void bchunk_list_fill_from_array(const BArrayInfo *info,
|
|||
/** \} */
|
||||
|
||||
/*
|
||||
* Internal Table Lookup Functions
|
||||
* Internal Table Lookup Functions.
|
||||
*/
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
@ -770,7 +790,7 @@ BLI_INLINE hash_key hash_data_single(const uchar p)
|
|||
return ((HASH_INIT << 5) + HASH_INIT) + (hash_key)(*((signed char *)&p));
|
||||
}
|
||||
|
||||
/* hash bytes, from BLI_ghashutil_strhash_n */
|
||||
/* Hash bytes, from #BLI_ghashutil_strhash_n. */
|
||||
static hash_key hash_data(const uchar *key, size_t n)
|
||||
{
|
||||
const signed char *p;
|
||||
|
@ -797,14 +817,14 @@ static void hash_array_from_data(const BArrayInfo *info,
|
|||
}
|
||||
}
|
||||
else {
|
||||
/* fast-path for bytes */
|
||||
/* Fast-path for bytes. */
|
||||
for (size_t i = 0; i < data_slice_len; i++) {
|
||||
hash_array[i] = hash_data_single(data_slice[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
* Similar to hash_array_from_data,
|
||||
* but able to step into the next chunk if we run-out of data.
|
||||
*/
|
||||
|
@ -829,7 +849,7 @@ static void hash_array_from_cref(const BArrayInfo *info,
|
|||
} while ((i < hash_array_len) && (cref != NULL));
|
||||
|
||||
/* If this isn't equal, the caller didn't properly check
|
||||
* that there was enough data left in all chunks */
|
||||
* that there was enough data left in all chunks. */
|
||||
BLI_assert(i == hash_array_len);
|
||||
}
|
||||
|
||||
|
@ -866,11 +886,11 @@ static void hash_accum_single(hash_key *hash_array, const size_t hash_array_len,
|
|||
{
|
||||
BLI_assert(iter_steps <= hash_array_len);
|
||||
if (UNLIKELY(!(iter_steps <= hash_array_len))) {
|
||||
/* while this shouldn't happen, avoid crashing */
|
||||
/* While this shouldn't happen, avoid crashing. */
|
||||
iter_steps = hash_array_len;
|
||||
}
|
||||
/* We can increase this value each step to avoid accumulating quite as much
|
||||
* while getting the same results as hash_accum */
|
||||
* while getting the same results as hash_accum. */
|
||||
size_t iter_steps_sub = iter_steps;
|
||||
|
||||
while (iter_steps != 0) {
|
||||
|
@ -886,11 +906,11 @@ static void hash_accum_single(hash_key *hash_array, const size_t hash_array_len,
|
|||
|
||||
static hash_key key_from_chunk_ref(const BArrayInfo *info,
|
||||
const BChunkRef *cref,
|
||||
/* avoid reallocating each time */
|
||||
/* Avoid reallocating each time. */
|
||||
hash_key *hash_store,
|
||||
const size_t hash_store_len)
|
||||
{
|
||||
/* in C, will fill in a reusable array */
|
||||
/* In C, will fill in a reusable array. */
|
||||
BChunk *chunk = cref->link;
|
||||
BLI_assert((info->accum_read_ahead_bytes * info->chunk_stride) != 0);
|
||||
|
||||
|
@ -901,14 +921,14 @@ static hash_key key_from_chunk_ref(const BArrayInfo *info,
|
|||
key = chunk->key;
|
||||
if (key != HASH_TABLE_KEY_UNSET) {
|
||||
/* Using key cache!
|
||||
* avoids calculating every time */
|
||||
* avoids calculating every time. */
|
||||
}
|
||||
else {
|
||||
hash_array_from_cref(info, cref, info->accum_read_ahead_bytes, hash_store);
|
||||
hash_accum_single(hash_store, hash_store_len, info->accum_steps);
|
||||
key = hash_store[0];
|
||||
|
||||
/* cache the key */
|
||||
/* Cache the key. */
|
||||
if (UNLIKELY(key == HASH_TABLE_KEY_UNSET)) {
|
||||
key = HASH_TABLE_KEY_FALLBACK;
|
||||
}
|
||||
|
@ -921,7 +941,7 @@ static hash_key key_from_chunk_ref(const BArrayInfo *info,
|
|||
# endif
|
||||
return key;
|
||||
}
|
||||
/* corner case - we're too small, calculate the key each time. */
|
||||
/* Corner case - we're too small, calculate the key each time. */
|
||||
|
||||
hash_array_from_cref(info, cref, info->accum_read_ahead_bytes, hash_store);
|
||||
hash_accum_single(hash_store, hash_store_len, info->accum_steps);
|
||||
|
@ -944,30 +964,33 @@ static const BChunkRef *table_lookup(const BArrayInfo *info,
|
|||
const size_t offset,
|
||||
const hash_key *table_hash_array)
|
||||
{
|
||||
size_t size_left = data_len - offset;
|
||||
hash_key key = table_hash_array[((offset - i_table_start) / info->chunk_stride)];
|
||||
size_t key_index = (size_t)(key % (hash_key)table_len);
|
||||
for (const BTableRef *tref = table[key_index]; tref; tref = tref->next) {
|
||||
const BChunkRef *cref = tref->cref;
|
||||
const hash_key key = table_hash_array[((offset - i_table_start) / info->chunk_stride)];
|
||||
const uint key_index = (uint)(key % (hash_key)table_len);
|
||||
const BTableRef *tref = table[key_index];
|
||||
if (tref != NULL) {
|
||||
const size_t size_left = data_len - offset;
|
||||
do {
|
||||
const BChunkRef *cref = tref->cref;
|
||||
# ifdef USE_HASH_TABLE_KEY_CACHE
|
||||
if (cref->link->key == key)
|
||||
if (cref->link->key == key)
|
||||
# endif
|
||||
{
|
||||
BChunk *chunk_test = cref->link;
|
||||
if (chunk_test->data_len <= size_left) {
|
||||
if (bchunk_data_compare(chunk_test, data, data_len, offset)) {
|
||||
/* we could remove the chunk from the table, to avoid multiple hits */
|
||||
return cref;
|
||||
{
|
||||
BChunk *chunk_test = cref->link;
|
||||
if (chunk_test->data_len <= size_left) {
|
||||
if (bchunk_data_compare_unchecked(chunk_test, data, data_len, offset)) {
|
||||
/* We could remove the chunk from the table, to avoid multiple hits. */
|
||||
return cref;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} while ((tref = tref->next));
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#else /* USE_HASH_TABLE_ACCUMULATE */
|
||||
|
||||
/* NON USE_HASH_TABLE_ACCUMULATE code (simply hash each chunk) */
|
||||
/* NON USE_HASH_TABLE_ACCUMULATE code (simply hash each chunk). */
|
||||
|
||||
static hash_key key_from_chunk_ref(const BArrayInfo *info, const BChunkRef *cref)
|
||||
{
|
||||
|
@ -979,10 +1002,10 @@ static hash_key key_from_chunk_ref(const BArrayInfo *info, const BChunkRef *cref
|
|||
key = chunk->key;
|
||||
if (key != HASH_TABLE_KEY_UNSET) {
|
||||
/* Using key cache!
|
||||
* avoids calculating every time */
|
||||
* avoids calculating every time. */
|
||||
}
|
||||
else {
|
||||
/* cache the key */
|
||||
/* Cache the key. */
|
||||
key = hash_data(chunk->data, data_hash_len);
|
||||
if (key == HASH_TABLE_KEY_UNSET) {
|
||||
key = HASH_TABLE_KEY_FALLBACK;
|
||||
|
@ -1007,9 +1030,9 @@ static const BChunkRef *table_lookup(const BArrayInfo *info,
|
|||
{
|
||||
const size_t data_hash_len = BCHUNK_HASH_LEN * info->chunk_stride; /* TODO: cache. */
|
||||
|
||||
size_t size_left = data_len - offset;
|
||||
hash_key key = hash_data(&data[offset], MIN2(data_hash_len, size_left));
|
||||
size_t key_index = (size_t)(key % (hash_key)table_len);
|
||||
const size_t size_left = data_len - offset;
|
||||
const hash_key key = hash_data(&data[offset], MIN2(data_hash_len, size_left));
|
||||
const uint key_index = (uint)(key % (hash_key)table_len);
|
||||
for (BTableRef *tref = table[key_index]; tref; tref = tref->next) {
|
||||
const BChunkRef *cref = tref->cref;
|
||||
# ifdef USE_HASH_TABLE_KEY_CACHE
|
||||
|
@ -1018,8 +1041,8 @@ static const BChunkRef *table_lookup(const BArrayInfo *info,
|
|||
{
|
||||
BChunk *chunk_test = cref->link;
|
||||
if (chunk_test->data_len <= size_left) {
|
||||
if (bchunk_data_compare(chunk_test, data, data_len, offset)) {
|
||||
/* we could remove the chunk from the table, to avoid multiple hits */
|
||||
if (bchunk_data_compare_unchecked(chunk_test, data, data_len, offset)) {
|
||||
/* We could remove the chunk from the table, to avoid multiple hits. */
|
||||
return cref;
|
||||
}
|
||||
}
|
||||
|
@ -1095,7 +1118,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
|
||||
#endif /* USE_FASTPATH_CHUNKS_FIRST */
|
||||
|
||||
/* Copy until we have a mismatch */
|
||||
/* Copy until we have a mismatch. */
|
||||
BChunkList *chunk_list = bchunk_list_new(bs_mem, data_len_original);
|
||||
if (cref_match_first != NULL) {
|
||||
size_t chunk_size_step = 0;
|
||||
|
@ -1111,7 +1134,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
}
|
||||
cref = cref->next;
|
||||
}
|
||||
/* happens when bytes are removed from the end of the array */
|
||||
/* Happens when bytes are removed from the end of the array. */
|
||||
if (chunk_size_step == data_len_original) {
|
||||
return chunk_list;
|
||||
}
|
||||
|
@ -1125,17 +1148,16 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
/* ------------------------------------------------------------------------
|
||||
* Fast-Path for end chunks
|
||||
*
|
||||
* Check for trailing chunks
|
||||
* Check for trailing chunks.
|
||||
*/
|
||||
|
||||
/* In this case use 'chunk_list_reference_last' to define the last index
|
||||
* index_match_last = -1 */
|
||||
* `index_match_last = -1`. */
|
||||
|
||||
/* warning, from now on don't use len(data)
|
||||
* since we want to ignore chunks already matched */
|
||||
/* Warning, from now on don't use len(data) since we want to ignore chunks already matched. */
|
||||
size_t data_len = data_len_original;
|
||||
#define data_len_original invalid_usage
|
||||
#ifdef data_len_original /* quiet warning */
|
||||
#ifdef data_len_original /* Quiet warning. */
|
||||
#endif
|
||||
|
||||
const BChunkRef *chunk_list_reference_last = NULL;
|
||||
|
@ -1175,7 +1197,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
|
||||
#ifdef USE_ALIGN_CHUNKS_TEST
|
||||
if (chunk_list->total_expanded_size == chunk_list_reference->total_expanded_size) {
|
||||
/* if we're already a quarter aligned */
|
||||
/* If we're already a quarter aligned. */
|
||||
if (data_len - i_prev <= chunk_list->total_expanded_size / 4) {
|
||||
use_aligned = true;
|
||||
}
|
||||
|
@ -1189,7 +1211,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
* ----------------------- */
|
||||
|
||||
if (use_aligned) {
|
||||
/* Copy matching chunks, creates using the same 'layout' as the reference */
|
||||
/* Copy matching chunks, creates using the same 'layout' as the reference. */
|
||||
const BChunkRef *cref = cref_match_first ? cref_match_first->next :
|
||||
chunk_list_reference->chunk_refs.first;
|
||||
while (i_prev != data_len) {
|
||||
|
@ -1218,12 +1240,12 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
(chunk_list_reference->chunk_refs.first != NULL)) {
|
||||
|
||||
/* --------------------------------------------------------------------
|
||||
* Non-Aligned Chunk De-Duplication */
|
||||
* Non-Aligned Chunk De-Duplication. */
|
||||
|
||||
/* only create a table if we have at least one chunk to search
|
||||
/* Only create a table if we have at least one chunk to search
|
||||
* otherwise just make a new one.
|
||||
*
|
||||
* Support re-arranged chunks */
|
||||
* Support re-arranged chunks. */
|
||||
|
||||
#ifdef USE_HASH_TABLE_ACCUMULATE
|
||||
size_t i_table_start = i_prev;
|
||||
|
@ -1234,7 +1256,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
|
||||
hash_accum(table_hash_array, table_hash_array_len, info->accum_steps);
|
||||
#else
|
||||
/* dummy vars */
|
||||
/* Dummy vars. */
|
||||
uint i_table_start = 0;
|
||||
hash_key *table_hash_array = NULL;
|
||||
#endif
|
||||
|
@ -1249,8 +1271,8 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
const size_t table_len = chunk_list_reference_remaining_len * BCHUNK_HASH_TABLE_MUL;
|
||||
BTableRef **table = MEM_callocN(table_len * sizeof(*table), __func__);
|
||||
|
||||
/* table_make - inline
|
||||
* include one matching chunk, to allow for repeating values */
|
||||
/* Table_make - inline
|
||||
* include one matching chunk, to allow for repeating values. */
|
||||
{
|
||||
#ifdef USE_HASH_TABLE_ACCUMULATE
|
||||
const size_t hash_store_len = info->accum_read_ahead_len;
|
||||
|
@ -1292,13 +1314,41 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
hash_store_len
|
||||
#endif
|
||||
);
|
||||
size_t key_index = (size_t)(key % (hash_key)table_len);
|
||||
const uint key_index = (uint)(key % (hash_key)table_len);
|
||||
BTableRef *tref_prev = table[key_index];
|
||||
BLI_assert(table_ref_stack_n < chunk_list_reference_remaining_len);
|
||||
BTableRef *tref = &table_ref_stack[table_ref_stack_n++];
|
||||
tref->cref = cref;
|
||||
tref->next = tref_prev;
|
||||
table[key_index] = tref;
|
||||
#ifdef USE_HASH_TABLE_DEDUPLICATE
|
||||
bool is_duplicate = false;
|
||||
if (tref_prev) {
|
||||
const BChunk *chunk_a = cref->link;
|
||||
const BTableRef *tref = tref_prev;
|
||||
do {
|
||||
const BChunk *chunk_b = tref->cref->link;
|
||||
# ifdef USE_HASH_TABLE_KEY_CACHE
|
||||
if (key == chunk_b->key)
|
||||
# endif
|
||||
{
|
||||
/* Not an error, it just isn't expected, in the case chunks are shared
|
||||
* matching chunks should also be skipped to avoid a redundant `memcmp` call. */
|
||||
BLI_assert(chunk_a != chunk_b);
|
||||
if (chunk_a->data_len == chunk_b->data_len) {
|
||||
if (memcmp(chunk_a->data, chunk_b->data, chunk_a->data_len) == 0) {
|
||||
is_duplicate = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} while ((tref = tref->next));
|
||||
}
|
||||
|
||||
if (!is_duplicate)
|
||||
#endif /* USE_HASH_TABLE_DEDUPLICATE */
|
||||
{
|
||||
BTableRef *tref = &table_ref_stack[table_ref_stack_n++];
|
||||
tref->cref = cref;
|
||||
tref->next = tref_prev;
|
||||
table[key_index] = tref;
|
||||
}
|
||||
|
||||
chunk_list_reference_bytes_remaining -= cref->link->data_len;
|
||||
cref = cref->next;
|
||||
|
@ -1310,7 +1360,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
MEM_freeN(hash_store);
|
||||
#endif
|
||||
}
|
||||
/* done making the table */
|
||||
/* Done making the table. */
|
||||
|
||||
BLI_assert(i_prev <= data_len);
|
||||
for (size_t i = i_prev; i < data_len;) {
|
||||
|
@ -1325,7 +1375,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
i_prev = i;
|
||||
}
|
||||
|
||||
/* now add the reference chunk */
|
||||
/* Now add the reference chunk. */
|
||||
{
|
||||
BChunk *chunk_found = cref_found->link;
|
||||
i += chunk_found->data_len;
|
||||
|
@ -1336,7 +1386,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
ASSERT_CHUNKLIST_SIZE(chunk_list, i_prev);
|
||||
ASSERT_CHUNKLIST_DATA(chunk_list, data);
|
||||
|
||||
/* its likely that the next chunk in the list will be a match, so check it! */
|
||||
/* Its likely that the next chunk in the list will be a match, so check it! */
|
||||
while (!ELEM(cref_found->next, NULL, chunk_list_reference_last)) {
|
||||
cref_found = cref_found->next;
|
||||
BChunk *chunk_found = cref_found->link;
|
||||
|
@ -1346,7 +1396,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
* repeating memory where it would be useful to re-use chunks. */
|
||||
i += chunk_found->data_len;
|
||||
bchunk_list_append(info, bs_mem, chunk_list, chunk_found);
|
||||
/* chunk_found may be freed! */
|
||||
/* Chunk_found may be freed! */
|
||||
i_prev = i;
|
||||
BLI_assert(i_prev <= data_len);
|
||||
ASSERT_CHUNKLIST_SIZE(chunk_list, i_prev);
|
||||
|
@ -1389,14 +1439,13 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
|
||||
#ifdef USE_FASTPATH_CHUNKS_LAST
|
||||
if (chunk_list_reference_last != NULL) {
|
||||
/* write chunk_list_reference_last since it hasn't been written yet */
|
||||
/* Write chunk_list_reference_last since it hasn't been written yet. */
|
||||
const BChunkRef *cref = chunk_list_reference_last;
|
||||
while (cref != NULL) {
|
||||
BChunk *chunk = cref->link;
|
||||
// BLI_assert(bchunk_data_compare(chunk, data, data_len, i_prev));
|
||||
i_prev += chunk->data_len;
|
||||
/* use simple since we assume the references chunks
|
||||
* have already been sized correctly. */
|
||||
/* Use simple since we assume the references chunks have already been sized correctly. */
|
||||
bchunk_list_append_only(bs_mem, chunk_list, chunk);
|
||||
ASSERT_CHUNKLIST_DATA(chunk_list, data);
|
||||
cref = cref->next;
|
||||
|
@ -1408,7 +1457,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
|
||||
BLI_assert(i_prev == data_len_original);
|
||||
|
||||
/* check we're the correct size and that we didn't accidentally modify the reference */
|
||||
/* Check we're the correct size and that we didn't accidentally modify the reference. */
|
||||
ASSERT_CHUNKLIST_SIZE(chunk_list, data_len_original);
|
||||
ASSERT_CHUNKLIST_SIZE(chunk_list_reference, chunk_list_reference->total_expanded_size);
|
||||
|
||||
|
@ -1416,7 +1465,7 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
|||
|
||||
return chunk_list;
|
||||
}
|
||||
/* end private API */
|
||||
/* End private API. */
|
||||
|
||||
/** \} */
|
||||
|
||||
|
@ -1470,7 +1519,7 @@ BArrayStore *BLI_array_store_create(uint stride, uint chunk_count)
|
|||
|
||||
bs->memory.chunk_list = BLI_mempool_create(sizeof(BChunkList), 0, 512, BLI_MEMPOOL_NOP);
|
||||
bs->memory.chunk_ref = BLI_mempool_create(sizeof(BChunkRef), 0, 512, BLI_MEMPOOL_NOP);
|
||||
/* allow iteration to simplify freeing, otherwise its not needed
|
||||
/* Allow iteration to simplify freeing, otherwise its not needed
|
||||
* (we could loop over all states as an alternative). */
|
||||
bs->memory.chunk = BLI_mempool_create(sizeof(BChunk), 0, 512, BLI_MEMPOOL_ALLOW_ITER);
|
||||
|
||||
|
@ -1481,7 +1530,7 @@ BArrayStore *BLI_array_store_create(uint stride, uint chunk_count)
|
|||
|
||||
static void array_store_free_data(BArrayStore *bs)
|
||||
{
|
||||
/* free chunk data */
|
||||
/* Free chunk data. */
|
||||
{
|
||||
BLI_mempool_iter iter;
|
||||
BChunk *chunk;
|
||||
|
@ -1492,7 +1541,7 @@ static void array_store_free_data(BArrayStore *bs)
|
|||
}
|
||||
}
|
||||
|
||||
/* free states */
|
||||
/* Free states. */
|
||||
for (BArrayState *state = bs->states.first, *state_next; state; state = state_next) {
|
||||
state_next = state->next;
|
||||
MEM_freeN(state);
|
||||
|
@ -1560,7 +1609,7 @@ BArrayState *BLI_array_store_state_add(BArrayStore *bs,
|
|||
const size_t data_len,
|
||||
const BArrayState *state_reference)
|
||||
{
|
||||
/* ensure we're aligned to the stride */
|
||||
/* Ensure we're aligned to the stride. */
|
||||
BLI_assert((data_len % bs->info.chunk_stride) == 0);
|
||||
|
||||
#ifdef USE_PARANOID_CHECKS
|
||||
|
@ -1575,7 +1624,7 @@ BArrayState *BLI_array_store_state_add(BArrayStore *bs,
|
|||
&bs->memory,
|
||||
(const uchar *)data,
|
||||
data_len,
|
||||
/* re-use reference chunks */
|
||||
/* Re-use reference chunks. */
|
||||
state_reference->chunk_list);
|
||||
}
|
||||
else {
|
||||
|
@ -1652,7 +1701,7 @@ void *BLI_array_store_state_data_get_alloc(BArrayState *state, size_t *r_data_le
|
|||
/** \name Debugging API (for testing).
|
||||
* \{ */
|
||||
|
||||
/* only for test validation */
|
||||
/* Only for test validation. */
|
||||
static size_t bchunk_list_size(const BChunkList *chunk_list)
|
||||
{
|
||||
size_t total_expanded_size = 0;
|
||||
|
@ -1680,7 +1729,7 @@ bool BLI_array_store_is_valid(BArrayStore *bs)
|
|||
}
|
||||
|
||||
#ifdef USE_MERGE_CHUNKS
|
||||
/* ensure we merge all chunks that could be merged */
|
||||
/* Ensure we merge all chunks that could be merged. */
|
||||
if (chunk_list->total_expanded_size > bs->info.chunk_byte_size_min) {
|
||||
LISTBASE_FOREACH (BChunkRef *, cref, &chunk_list->chunk_refs) {
|
||||
if (cref->link->data_len < bs->info.chunk_byte_size_min) {
|
||||
|
@ -1719,7 +1768,7 @@ bool BLI_array_store_is_valid(BArrayStore *bs)
|
|||
} \
|
||||
((void)0)
|
||||
|
||||
/* count chunk_list's */
|
||||
/* Count chunk_list's. */
|
||||
GHash *chunk_list_map = BLI_ghash_ptr_new(__func__);
|
||||
GHash *chunk_map = BLI_ghash_ptr_new(__func__);
|
||||
|
||||
|
@ -1740,7 +1789,7 @@ bool BLI_array_store_is_valid(BArrayStore *bs)
|
|||
goto user_finally;
|
||||
}
|
||||
|
||||
/* count chunk's */
|
||||
/* Count chunk's. */
|
||||
GHASH_ITER (gh_iter, chunk_list_map) {
|
||||
const struct BChunkList *chunk_list = BLI_ghashIterator_getKey(&gh_iter);
|
||||
LISTBASE_FOREACH (const BChunkRef *, cref, &chunk_list->chunk_refs) {
|
||||
|
|
|
@ -774,7 +774,7 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *bmain)
|
|||
part->clength = 1.0f;
|
||||
}
|
||||
|
||||
/* set old pointcaches to have disk cache flag */
|
||||
/* Set old point-caches to have disk cache flag. */
|
||||
for (ob = bmain->objects.first; ob; ob = ob->id.next) {
|
||||
|
||||
#if 0
|
||||
|
|
|
@ -3639,7 +3639,7 @@ void blo_do_versions_280(FileData *fd, Library *UNUSED(lib), Main *bmain)
|
|||
}
|
||||
|
||||
LISTBASE_FOREACH (bArmature *, arm, &bmain->armatures) {
|
||||
arm->flag &= ~(ARM_FLAG_UNUSED_1 | ARM_FLAG_UNUSED_5 | ARM_FLAG_UNUSED_6 |
|
||||
arm->flag &= ~(ARM_FLAG_UNUSED_1 | ARM_DRAW_RELATION_FROM_HEAD | ARM_FLAG_UNUSED_6 |
|
||||
ARM_FLAG_UNUSED_7 | ARM_FLAG_UNUSED_12);
|
||||
}
|
||||
|
||||
|
|
|
@ -222,10 +222,10 @@ static void basic_cache_populate(void *vedata, Object *ob)
|
|||
}
|
||||
}
|
||||
|
||||
if (G.debug_value == 889 && ob->sculpt && ob->sculpt->pbvh) {
|
||||
if (G.debug_value == 889 && ob->sculpt && BKE_object_sculpt_pbvh_get(ob)) {
|
||||
int debug_node_nr = 0;
|
||||
DRW_debug_modelmat(ob->object_to_world);
|
||||
BKE_pbvh_draw_debug_cb(ob->sculpt->pbvh, DRW_sculpt_debug_cb, &debug_node_nr);
|
||||
BKE_pbvh_draw_debug_cb(BKE_object_sculpt_pbvh_get(ob), DRW_sculpt_debug_cb, &debug_node_nr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -814,8 +814,8 @@ void EEVEE_materials_cache_populate(EEVEE_Data *vedata,
|
|||
bool use_sculpt_pbvh = BKE_sculptsession_use_pbvh_draw(ob, draw_ctx->rv3d) &&
|
||||
!DRW_state_is_image_render();
|
||||
|
||||
if (ob->sculpt && ob->sculpt->pbvh) {
|
||||
BKE_pbvh_is_drawing_set(ob->sculpt->pbvh, use_sculpt_pbvh);
|
||||
if (ob->sculpt && BKE_object_sculpt_pbvh_get(ob)) {
|
||||
BKE_pbvh_is_drawing_set(BKE_object_sculpt_pbvh_get(ob), use_sculpt_pbvh);
|
||||
}
|
||||
|
||||
/* First get materials for this mesh. */
|
||||
|
@ -887,10 +887,11 @@ void EEVEE_materials_cache_populate(EEVEE_Data *vedata,
|
|||
}
|
||||
}
|
||||
|
||||
if (G.debug_value == 889 && ob->sculpt && ob->sculpt->pbvh) {
|
||||
if (G.debug_value == 889 && ob->sculpt && BKE_object_sculpt_pbvh_get(ob)) {
|
||||
int debug_node_nr = 0;
|
||||
DRW_debug_modelmat(ob->object_to_world);
|
||||
BKE_pbvh_draw_debug_cb(ob->sculpt->pbvh, DRW_sculpt_debug_cb, &debug_node_nr);
|
||||
BKE_pbvh_draw_debug_cb(
|
||||
BKE_object_sculpt_pbvh_get(ob), DRW_sculpt_debug_cb, &debug_node_nr);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -31,7 +31,10 @@ GPU_SHADER_CREATE_INFO(eevee_legacy_material_empty_base_volume)
|
|||
|
||||
/**** MATERIAL VERTEX SHADER PERMUTATIONS ****/
|
||||
|
||||
/** -- Volumetric -- **/
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Volumetric
|
||||
* \{ */
|
||||
|
||||
GPU_SHADER_CREATE_INFO(eevee_legacy_material_volumetric_vert)
|
||||
.additional_info("eevee_legacy_material_empty_base_volume")
|
||||
.vertex_out(legacy_volume_vert_geom_iface)
|
||||
|
@ -45,7 +48,12 @@ GPU_SHADER_CREATE_INFO(eevee_legacy_material_volumetric_vert_no_geom)
|
|||
.additional_info("draw_resource_id_varying");
|
||||
#endif
|
||||
|
||||
/** -- World Shader -- **/
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name World Shader
|
||||
* \{ */
|
||||
|
||||
GPU_SHADER_CREATE_INFO(eevee_legacy_material_world_vert)
|
||||
.additional_info("eevee_legacy_material_empty_base")
|
||||
.additional_info("eevee_legacy_common_utiltex_lib")
|
||||
|
@ -54,7 +62,12 @@ GPU_SHADER_CREATE_INFO(eevee_legacy_material_world_vert)
|
|||
.additional_info("draw_resource_id_varying")
|
||||
.vertex_in(0, Type::VEC2, "pos");
|
||||
|
||||
/** -- Surface Shader -- **/
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Surface Shader
|
||||
* \{ */
|
||||
|
||||
GPU_SHADER_CREATE_INFO(eevee_legacy_material_surface_vert_common)
|
||||
.additional_info("eevee_legacy_material_empty_base")
|
||||
.additional_info("draw_resource_id_varying")
|
||||
|
@ -81,7 +94,13 @@ GPU_SHADER_CREATE_INFO(eevee_legacy_mateiral_surface_vert_pointcloud)
|
|||
.auto_resource_location(true);
|
||||
|
||||
/**** MATERIAL GEOMETRY SHADER PERMUTATIONS ****/
|
||||
/** -- Volumetric -- **/
|
||||
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Volumetric
|
||||
* \{ */
|
||||
|
||||
GPU_SHADER_CREATE_INFO(eevee_legacy_material_volumetric_geom)
|
||||
.additional_info("eevee_legacy_common_lib")
|
||||
.additional_info("draw_view")
|
||||
|
@ -89,9 +108,14 @@ GPU_SHADER_CREATE_INFO(eevee_legacy_material_volumetric_geom)
|
|||
.geometry_layout(PrimitiveIn::TRIANGLES, PrimitiveOut::TRIANGLE_STRIP, 3)
|
||||
.additional_info("draw_resource_id_varying");
|
||||
|
||||
/** \} */
|
||||
|
||||
/**** MATERIAL FRAGMENT SHADER PERMUTATIONS ****/
|
||||
|
||||
/** -- Volumetric Shader -- **/
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Volumetric Shader
|
||||
* \{ */
|
||||
|
||||
GPU_SHADER_CREATE_INFO(eevee_legacy_material_volumetric_frag)
|
||||
.additional_info("eevee_legacy_common_lib")
|
||||
.additional_info("draw_view")
|
||||
|
@ -102,7 +126,11 @@ GPU_SHADER_CREATE_INFO(eevee_legacy_material_volumetric_frag)
|
|||
.fragment_out(2, Type::VEC4, "volumeEmissive")
|
||||
.fragment_out(3, Type::VEC4, "volumePhase");
|
||||
|
||||
/** -- Prepass Shader -- **/
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Pre-pass Shader
|
||||
* \{ */
|
||||
|
||||
/* Common info for all `prepass_frag` variants. */
|
||||
GPU_SHADER_CREATE_INFO(eevee_legacy_material_prepass_frag_common)
|
||||
|
@ -148,7 +176,11 @@ GPU_SHADER_CREATE_INFO(eevee_legacy_material_prepass_frag_alpha_hash_pointcloud)
|
|||
.additional_info("eevee_legacy_material_prepass_frag_alpha_hash_common")
|
||||
.additional_info("draw_pointcloud");
|
||||
|
||||
/** -- Surface Shader -- **/
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Surface Shader
|
||||
* \{ */
|
||||
|
||||
GPU_SHADER_CREATE_INFO(eevee_legacy_material_surface_frag_common)
|
||||
.additional_info("eevee_legacy_common_lib")
|
||||
|
@ -173,6 +205,8 @@ GPU_SHADER_CREATE_INFO(eevee_legacy_material_surface_frag_alpha_blend)
|
|||
.fragment_out(0, Type::VEC4, "outRadiance", DualBlend::SRC_0)
|
||||
.fragment_out(0, Type::VEC4, "outTransmittance", DualBlend::SRC_1);
|
||||
|
||||
/** \} */
|
||||
|
||||
/* hair_refine_shader_transform_feedback_create */
|
||||
|
||||
GPU_SHADER_INTERFACE_INFO(legacy_hair_refine_shader_transform_feedback_iface, "")
|
||||
|
|
|
@ -3,6 +3,11 @@
|
|||
#pragma BLENDER_REQUIRE(common_math_lib.glsl)
|
||||
#pragma BLENDER_REQUIRE(common_uniforms_lib.glsl)
|
||||
|
||||
/* Fix for #104266 wherein AMD GPUs running Metal erroneously discard a successful hit. */
|
||||
#if defined(GPU_METAL) && defined(GPU_ATI)
|
||||
# define METAL_AMD_RAYTRACE_WORKAROUND 1
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Screen-Space Raytracing functions.
|
||||
*/
|
||||
|
@ -129,6 +134,9 @@ bool raytrace(Ray ray,
|
|||
/* Cross at least one pixel. */
|
||||
float t = 1.001, time = 1.001;
|
||||
bool hit = false;
|
||||
#ifdef METAL_AMD_RAYTRACE_WORKAROUND
|
||||
bool hit_failsafe = true;
|
||||
#endif
|
||||
const float max_steps = 255.0;
|
||||
for (float iter = 1.0; !hit && (time < ssray.max_time) && (iter < max_steps); iter++) {
|
||||
float stride = 1.0 + iter * params.trace_quality;
|
||||
|
@ -148,17 +156,36 @@ bool raytrace(Ray ray,
|
|||
hit = (delta < 0.0);
|
||||
/* ... and above it with the added thickness. */
|
||||
hit = hit && (delta > ss_p.z - ss_p.w || abs(delta) < abs(ssray.direction.z * stride * 2.0));
|
||||
|
||||
#ifdef METAL_AMD_RAYTRACE_WORKAROUND
|
||||
/* For workaround, perform discard backface and background check only within
|
||||
* the iteration where the first successful ray intersection is registered.
|
||||
* We flag failures to discard ray hits later. */
|
||||
bool hit_valid = !(discard_backface && prev_delta < 0.0) && (depth_sample != 1.0);
|
||||
if (hit && !hit_valid) {
|
||||
hit_failsafe = false;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifndef METAL_AMD_RAYTRACE_WORKAROUND
|
||||
/* Discard back-face hits. */
|
||||
hit = hit && !(discard_backface && prev_delta < 0.0);
|
||||
/* Reject hit if background. */
|
||||
hit = hit && (depth_sample != 1.0);
|
||||
#endif
|
||||
/* Refine hit using intersection between the sampled heightfield and the ray.
|
||||
* This simplifies nicely to this single line. */
|
||||
time = mix(prev_time, time, saturate(prev_delta / (prev_delta - delta)));
|
||||
|
||||
hit_position = ssray.origin.xyz + ssray.direction.xyz * time;
|
||||
|
||||
#ifdef METAL_AMD_RAYTRACE_WORKAROUND
|
||||
/* Check failed ray flag to discard bad hits. */
|
||||
if (!hit_failsafe) {
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
return hit;
|
||||
}
|
||||
|
||||
|
|
|
@ -110,7 +110,7 @@
|
|||
#define GBUF_COLOR_SLOT RBUFS_DIFF_COLOR_SLOT
|
||||
|
||||
/* Uniform Buffers. */
|
||||
/* Only during prepass. */
|
||||
/* Only during pre-pass. */
|
||||
#define VELOCITY_CAMERA_PREV_BUF 3
|
||||
#define VELOCITY_CAMERA_CURR_BUF 4
|
||||
#define VELOCITY_CAMERA_NEXT_BUF 5
|
||||
|
|
|
@ -161,8 +161,6 @@ class DeferredLayer {
|
|||
|
||||
class DeferredPipeline {
|
||||
private:
|
||||
Instance &inst_;
|
||||
|
||||
/* Gbuffer filling passes. We could have an arbitrary number of them but for now we just have
|
||||
* a hardcoded number of them. */
|
||||
DeferredLayer opaque_layer_;
|
||||
|
@ -171,7 +169,7 @@ class DeferredPipeline {
|
|||
|
||||
public:
|
||||
DeferredPipeline(Instance &inst)
|
||||
: inst_(inst), opaque_layer_(inst), refraction_layer_(inst), volumetric_layer_(inst){};
|
||||
: opaque_layer_(inst), refraction_layer_(inst), volumetric_layer_(inst){};
|
||||
|
||||
void begin_sync();
|
||||
void end_sync();
|
||||
|
|
|
@ -1,3 +1,5 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
||||
|
||||
#include "eevee_defines.hh"
|
||||
#include "gpu_shader_create_info.hh"
|
||||
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
/* -------------------------------------------------------------------- */
|
||||
/** \name Surface Velocity
|
||||
*
|
||||
* Combined with the depth prepass shader.
|
||||
* Combined with the depth pre-pass shader.
|
||||
* Outputs the view motion vectors for animated objects.
|
||||
* \{ */
|
||||
|
||||
|
|
|
@ -99,8 +99,8 @@ class ImageEngine {
|
|||
/* Setup the matrix to go from screen UV coordinates to UV texture space coordinates. */
|
||||
float image_resolution[2] = {image_buffer ? image_buffer->x : 1024.0f,
|
||||
image_buffer ? image_buffer->y : 1024.0f};
|
||||
float image_offset[2] = {(float)instance_data->image->offset_x,
|
||||
(float)instance_data->image->offset_y};
|
||||
float image_offset[2] = {float(instance_data->image->offset_x),
|
||||
float(instance_data->image->offset_y)};
|
||||
space->init_ss_to_texture_matrix(
|
||||
draw_ctx->region, image_offset, image_resolution, instance_data->ss_to_texture);
|
||||
|
||||
|
|
|
@ -2023,6 +2023,20 @@ static void pchan_draw_ik_lines(ArmatureDrawContext *ctx,
|
|||
}
|
||||
}
|
||||
|
||||
static void draw_bone_bone_relationship_line(ArmatureDrawContext *ctx,
|
||||
const float bone_head[3],
|
||||
const float parent_head[3],
|
||||
const float parent_tail[3],
|
||||
const eArmature_Flag armature_flags)
|
||||
{
|
||||
if (armature_flags & ARM_DRAW_RELATION_FROM_HEAD) {
|
||||
drw_shgroup_bone_relationship_lines(ctx, bone_head, parent_head);
|
||||
}
|
||||
else {
|
||||
drw_shgroup_bone_relationship_lines(ctx, bone_head, parent_tail);
|
||||
}
|
||||
}
|
||||
|
||||
static void draw_bone_relations(ArmatureDrawContext *ctx,
|
||||
EditBone *ebone,
|
||||
bPoseChannel *pchan,
|
||||
|
@ -2036,7 +2050,8 @@ static void draw_bone_relations(ArmatureDrawContext *ctx,
|
|||
* since riggers will want to know about the links between bones
|
||||
*/
|
||||
if ((boneflag & BONE_CONNECTED) == 0) {
|
||||
drw_shgroup_bone_relationship_lines(ctx, ebone->head, ebone->parent->tail);
|
||||
draw_bone_bone_relationship_line(
|
||||
ctx, ebone->head, ebone->parent->head, ebone->parent->tail, eArmature_Flag(arm->flag));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -2047,7 +2062,11 @@ static void draw_bone_relations(ArmatureDrawContext *ctx,
|
|||
if ((boneflag & BONE_SELECTED) ||
|
||||
(pchan->parent->bone && (pchan->parent->bone->flag & BONE_SELECTED))) {
|
||||
if ((boneflag & BONE_CONNECTED) == 0) {
|
||||
drw_shgroup_bone_relationship_lines(ctx, pchan->pose_head, pchan->parent->pose_tail);
|
||||
draw_bone_bone_relationship_line(ctx,
|
||||
pchan->pose_head,
|
||||
pchan->parent->pose_head,
|
||||
pchan->parent->pose_tail,
|
||||
eArmature_Flag(arm->flag));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1165,7 +1165,7 @@ OVERLAY_InstanceFormats *OVERLAY_shader_instance_formats_get(void)
|
|||
{
|
||||
{"boneStart", DRW_ATTR_FLOAT, 3},
|
||||
{"boneEnd", DRW_ATTR_FLOAT, 3},
|
||||
{"wireColor", DRW_ATTR_FLOAT, 4}, /* TODO: uchar color. */
|
||||
{"wireColor", DRW_ATTR_FLOAT, 4}, /* TODO: `uchar` color. */
|
||||
{"boneColor", DRW_ATTR_FLOAT, 4},
|
||||
{"headColor", DRW_ATTR_FLOAT, 4},
|
||||
{"tailColor", DRW_ATTR_FLOAT, 4},
|
||||
|
|
|
@ -277,8 +277,8 @@ static eV3DShadingColorType workbench_color_type_get(WORKBENCH_PrivateData *wpd,
|
|||
* of vertex color arrays from being sent to the GPU (e.g.
|
||||
* when switching from eevee to workbench).
|
||||
*/
|
||||
if (ob->sculpt && ob->sculpt->pbvh) {
|
||||
BKE_pbvh_is_drawing_set(ob->sculpt->pbvh, is_sculpt_pbvh);
|
||||
if (ob->sculpt && BKE_object_sculpt_pbvh_get(ob)) {
|
||||
BKE_pbvh_is_drawing_set(BKE_object_sculpt_pbvh_get(ob), is_sculpt_pbvh);
|
||||
}
|
||||
|
||||
bool has_color = false;
|
||||
|
@ -334,7 +334,7 @@ static eV3DShadingColorType workbench_color_type_get(WORKBENCH_PrivateData *wpd,
|
|||
}
|
||||
|
||||
if (is_sculpt_pbvh && color_type == V3D_SHADING_TEXTURE_COLOR &&
|
||||
BKE_pbvh_type(ob->sculpt->pbvh) != PBVH_FACES) {
|
||||
BKE_pbvh_type(BKE_object_sculpt_pbvh_get(ob)) != PBVH_FACES) {
|
||||
/* Force use of material color for sculpt. */
|
||||
color_type = V3D_SHADING_MATERIAL_COLOR;
|
||||
}
|
||||
|
|
|
@ -227,9 +227,9 @@ static void mesh_render_data_mat_tri_len_build_threaded(MeshRenderData *mr,
|
|||
}
|
||||
|
||||
/* Count how many triangles for each material. */
|
||||
static void mesh_render_data_mat_tri_len_build(MeshRenderData *mr,
|
||||
blender::MutableSpan<int> mat_tri_len)
|
||||
static blender::Array<int> mesh_render_data_mat_tri_len_build(MeshRenderData *mr)
|
||||
{
|
||||
blender::Array<int> mat_tri_len(mr->mat_len, 0);
|
||||
if (mr->extract_type == MR_EXTRACT_BMESH) {
|
||||
BMesh *bm = mr->bm;
|
||||
mesh_render_data_mat_tri_len_build_threaded(
|
||||
|
@ -239,15 +239,13 @@ static void mesh_render_data_mat_tri_len_build(MeshRenderData *mr,
|
|||
mesh_render_data_mat_tri_len_build_threaded(
|
||||
mr, mr->poly_len, mesh_render_data_mat_tri_len_mesh_range_fn, mat_tri_len);
|
||||
}
|
||||
return mat_tri_len;
|
||||
}
|
||||
|
||||
static void mesh_render_data_polys_sorted_build(MeshRenderData *mr, MeshBufferCache *cache)
|
||||
{
|
||||
using namespace blender;
|
||||
cache->poly_sorted.tri_first_index.reinitialize(mr->poly_len);
|
||||
cache->poly_sorted.mat_tri_len.reinitialize(mr->mat_len);
|
||||
|
||||
mesh_render_data_mat_tri_len_build(mr, cache->poly_sorted.mat_tri_len);
|
||||
cache->poly_sorted.mat_tri_len = mesh_render_data_mat_tri_len_build(mr);
|
||||
const Span<int> mat_tri_len = cache->poly_sorted.mat_tri_len;
|
||||
|
||||
/* Apply offset. */
|
||||
|
@ -261,6 +259,7 @@ static void mesh_render_data_polys_sorted_build(MeshRenderData *mr, MeshBufferCa
|
|||
}
|
||||
cache->poly_sorted.visible_tri_len = visible_tri_len;
|
||||
|
||||
cache->poly_sorted.tri_first_index.reinitialize(mr->poly_len);
|
||||
MutableSpan<int> tri_first_index = cache->poly_sorted.tri_first_index;
|
||||
|
||||
/* Sort per material. */
|
||||
|
|
|
@ -638,15 +638,15 @@ static void cage2d_draw_rect_edge_handles(const rctf *r,
|
|||
case ED_GIZMO_CAGE2D_PART_SCALE_MIN_X:
|
||||
case ED_GIZMO_CAGE2D_PART_SCALE_MAX_X: {
|
||||
const float rad[2] = {0.2f * margin[0], 0.4f * size[1]};
|
||||
imm_draw_point_aspect_2d(pos, r->xmin, 0.f, rad[0], rad[1], solid);
|
||||
imm_draw_point_aspect_2d(pos, r->xmax, 0.f, rad[0], rad[1], solid);
|
||||
imm_draw_point_aspect_2d(pos, r->xmin, 0.0f, rad[0], rad[1], solid);
|
||||
imm_draw_point_aspect_2d(pos, r->xmax, 0.0f, rad[0], rad[1], solid);
|
||||
break;
|
||||
}
|
||||
case ED_GIZMO_CAGE2D_PART_SCALE_MIN_Y:
|
||||
case ED_GIZMO_CAGE2D_PART_SCALE_MAX_Y: {
|
||||
const float rad[2] = {0.4f * size[0], 0.2f * margin[1]};
|
||||
imm_draw_point_aspect_2d(pos, 0.f, r->ymin, rad[0], rad[1], solid);
|
||||
imm_draw_point_aspect_2d(pos, 0.f, r->ymax, rad[0], rad[1], solid);
|
||||
imm_draw_point_aspect_2d(pos, 0.0f, r->ymin, rad[0], rad[1], solid);
|
||||
imm_draw_point_aspect_2d(pos, 0.0f, r->ymax, rad[0], rad[1], solid);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -213,7 +213,7 @@ void ED_gpencil_strokes_copybuf_free(void);
|
|||
/* drawgpencil.c */
|
||||
|
||||
/**
|
||||
* Draw grease-pencil sketches to specified 2d-view that uses ibuf corrections.
|
||||
* Draw grease-pencil sketches to specified 2d-view that uses `ibuf` corrections.
|
||||
*/
|
||||
void ED_annotation_draw_2dimage(const struct bContext *C);
|
||||
/**
|
||||
|
|
|
@ -148,6 +148,7 @@ typedef enum eKeyframeIterFlags {
|
|||
* iterator callbacks then. */
|
||||
KEYFRAME_ITER_HANDLES_DEFAULT_INVISIBLE = (1 << 3),
|
||||
} eKeyframeIterFlags;
|
||||
ENUM_OPERATORS(eKeyframeIterFlags, KEYFRAME_ITER_HANDLES_DEFAULT_INVISIBLE)
|
||||
|
||||
/** \} */
|
||||
|
||||
|
|
|
@ -12,34 +12,44 @@
|
|||
* - Custom context menus
|
||||
* - Notifier listening
|
||||
* - Drag controllers (dragging view items)
|
||||
* - Drop controllers (dropping onto/into view items)
|
||||
* - Drop targets (dropping onto/into view items)
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <memory>
|
||||
#include <optional>
|
||||
|
||||
#include "DNA_defs.h"
|
||||
#include "DNA_vec_types.h"
|
||||
|
||||
#include "BLI_span.hh"
|
||||
#include "BLI_string_ref.hh"
|
||||
|
||||
#include "UI_interface.hh"
|
||||
|
||||
struct bContext;
|
||||
struct uiBlock;
|
||||
struct uiLayout;
|
||||
struct uiViewItemHandle;
|
||||
struct ViewLink;
|
||||
struct wmDrag;
|
||||
struct wmNotifier;
|
||||
|
||||
namespace blender::ui {
|
||||
|
||||
class AbstractViewItem;
|
||||
class AbstractViewItemDropController;
|
||||
class AbstractViewItemDropTarget;
|
||||
class AbstractViewItemDragController;
|
||||
|
||||
/** The view drop target can share logic with the view item drop target for now, so just an alias.
|
||||
*/
|
||||
using AbstractViewDropTarget = AbstractViewItemDropTarget;
|
||||
|
||||
class AbstractView {
|
||||
friend class AbstractViewItem;
|
||||
friend struct ::ViewLink;
|
||||
|
||||
bool is_reconstructed_ = false;
|
||||
/**
|
||||
|
@ -51,9 +61,21 @@ class AbstractView {
|
|||
*/
|
||||
std::unique_ptr<std::array<char, MAX_NAME>> rename_buffer_;
|
||||
|
||||
/* See #get_bounds(). */
|
||||
std::optional<rcti> bounds_;
|
||||
|
||||
public:
|
||||
virtual ~AbstractView() = default;
|
||||
|
||||
/**
|
||||
* If a view wants to support dropping data into it, it has to return a drop target here.
|
||||
* That is an object implementing #AbstractViewDropTarget.
|
||||
*
|
||||
* \note This drop target may be requested for each event. The view doesn't keep the drop target
|
||||
* around currently. So it cannot contain persistent state.
|
||||
*/
|
||||
virtual std::unique_ptr<AbstractViewDropTarget> create_drop_target() const;
|
||||
|
||||
/** Listen to a notifier, returning true if a redraw is needed. */
|
||||
virtual bool listen(const wmNotifier &) const;
|
||||
|
||||
|
@ -70,6 +92,11 @@ class AbstractView {
|
|||
void end_renaming();
|
||||
Span<char> get_rename_buffer() const;
|
||||
MutableSpan<char> get_rename_buffer();
|
||||
/**
|
||||
* Get the rectangle containing all the view items that are in the layout, in button space.
|
||||
* Updated as part of #UI_block_end(), before that it's unset.
|
||||
*/
|
||||
std::optional<rcti> get_bounds() const;
|
||||
|
||||
protected:
|
||||
AbstractView() = default;
|
||||
|
@ -133,13 +160,13 @@ class AbstractViewItem {
|
|||
*/
|
||||
virtual std::unique_ptr<AbstractViewItemDragController> create_drag_controller() const;
|
||||
/**
|
||||
* If an item wants to support dropping data into it, it has to return a drop controller here.
|
||||
* That is an object implementing #AbstractViewItemDropController.
|
||||
* If an item wants to support dropping data into it, it has to return a drop target here.
|
||||
* That is an object implementing #AbstractViewItemDropTarget.
|
||||
*
|
||||
* \note This drop controller may be requested for each event. The view doesn't keep a drop
|
||||
* controller around currently. So it can not contain persistent state.
|
||||
* \note This drop target may be requested for each event. The view doesn't keep a drop target
|
||||
* around currently. So it can not contain persistent state.
|
||||
*/
|
||||
virtual std::unique_ptr<AbstractViewItemDropController> create_drop_controller() const;
|
||||
virtual std::unique_ptr<AbstractViewItemDropTarget> create_drop_target() const;
|
||||
|
||||
/** Get the view this item is registered for using #AbstractView::register_item(). */
|
||||
AbstractView &get_view() const;
|
||||
|
@ -200,7 +227,7 @@ template<typename ToType> ToType *AbstractViewItem::from_item_handle(uiViewItemH
|
|||
* \{ */
|
||||
|
||||
/**
|
||||
* Class to enable dragging a view item. An item can return a drop controller for itself by
|
||||
* Class to enable dragging a view item. An item can return a drag controller for itself by
|
||||
* implementing #AbstractViewItem::create_drag_controller().
|
||||
*/
|
||||
class AbstractViewItemDragController {
|
||||
|
@ -222,38 +249,15 @@ class AbstractViewItemDragController {
|
|||
|
||||
/**
|
||||
* Class to define the behavior when dropping something onto/into a view item, plus the behavior
|
||||
* when dragging over this item. An item can return a drop controller for itself via a custom
|
||||
* implementation of #AbstractViewItem::create_drop_controller().
|
||||
* when dragging over this item. An item can return a drop target for itself via a custom
|
||||
* implementation of #AbstractViewItem::create_drop_target().
|
||||
*/
|
||||
class AbstractViewItemDropController {
|
||||
class AbstractViewItemDropTarget : public DropTargetInterface {
|
||||
protected:
|
||||
AbstractView &view_;
|
||||
|
||||
public:
|
||||
AbstractViewItemDropController(AbstractView &view);
|
||||
virtual ~AbstractViewItemDropController() = default;
|
||||
|
||||
/**
|
||||
* Check if the data dragged with \a drag can be dropped on the item this controller is for.
|
||||
* \param r_disabled_hint: Return a static string to display to the user, explaining why dropping
|
||||
* isn't possible on this item. Shouldn't be done too aggressively, e.g.
|
||||
* don't set this if the drag-type can't be dropped here; only if it can
|
||||
* but there's another reason it can't be dropped.
|
||||
* Can assume this is a non-null pointer.
|
||||
*/
|
||||
virtual bool can_drop(const wmDrag &drag, const char **r_disabled_hint) const = 0;
|
||||
/**
|
||||
* Custom text to display when dragging over a view item. Should explain what happens when
|
||||
* dropping the data onto this item. Will only be used if #AbstractViewItem::can_drop()
|
||||
* returns true, so the implementing override doesn't have to check that again.
|
||||
* The returned value must be a translated string.
|
||||
*/
|
||||
virtual std::string drop_tooltip(const wmDrag &drag) const = 0;
|
||||
/**
|
||||
* Execute the logic to apply a drop of the data dragged with \a drag onto/into the item this
|
||||
* controller is for.
|
||||
*/
|
||||
virtual bool on_drop(struct bContext *C, const wmDrag &drag) = 0;
|
||||
AbstractViewItemDropTarget(AbstractView &view);
|
||||
|
||||
/** Request the view the item is registered for as type #ViewType. Throws a `std::bad_cast`
|
||||
* exception if the view is not of the requested type. */
|
||||
|
@ -267,7 +271,7 @@ template<class ViewType> ViewType &AbstractViewItemDragController::get_view() co
|
|||
return dynamic_cast<ViewType &>(view_);
|
||||
}
|
||||
|
||||
template<class ViewType> ViewType &AbstractViewItemDropController::get_view() const
|
||||
template<class ViewType> ViewType &AbstractViewItemDropTarget::get_view() const
|
||||
{
|
||||
static_assert(std::is_base_of<AbstractView, ViewType>::value,
|
||||
"Type must derive from and implement the ui::AbstractView interface");
|
||||
|
|
|
@ -155,8 +155,6 @@ class AbstractGridView : public AbstractView {
|
|||
* \{ */
|
||||
|
||||
class GridViewBuilder {
|
||||
uiBlock &block_;
|
||||
|
||||
public:
|
||||
GridViewBuilder(uiBlock &block);
|
||||
|
||||
|
|
|
@ -3274,18 +3274,12 @@ void UI_view_item_context_menu_build(struct bContext *C,
|
|||
* \return True if dragging started successfully, otherwise false.
|
||||
*/
|
||||
bool UI_view_item_drag_start(struct bContext *C, const uiViewItemHandle *item_);
|
||||
bool UI_view_item_can_drop(const uiViewItemHandle *item_,
|
||||
const struct wmDrag *drag,
|
||||
const char **r_disabled_hint);
|
||||
char *UI_view_item_drop_tooltip(const uiViewItemHandle *item, const struct wmDrag *drag);
|
||||
/**
|
||||
* Let a view item handle a drop event.
|
||||
* \return True if the drop was handled by the view item.
|
||||
*/
|
||||
bool UI_view_item_drop_handle(struct bContext *C,
|
||||
const uiViewItemHandle *item_,
|
||||
const struct ListBase *drags);
|
||||
|
||||
/**
|
||||
* \param xy: Coordinate to find a view item at, in window space.
|
||||
* \param pad: Extra padding added to the bounding box of the view.
|
||||
*/
|
||||
uiViewHandle *UI_region_view_find_at(const struct ARegion *region, const int xy[2], int pad);
|
||||
/**
|
||||
* \param xy: Coordinate to find a view item at, in window space.
|
||||
*/
|
||||
|
|
|
@ -18,11 +18,17 @@ namespace blender::nodes::geo_eval_log {
|
|||
struct GeometryAttributeInfo;
|
||||
}
|
||||
|
||||
struct ARegion;
|
||||
struct bContext;
|
||||
struct PointerRNA;
|
||||
struct StructRNA;
|
||||
struct uiBlock;
|
||||
struct uiLayout;
|
||||
struct uiList;
|
||||
struct uiSearchItems;
|
||||
struct uiViewHandle;
|
||||
struct uiViewItemHandle;
|
||||
struct wmDrag;
|
||||
|
||||
namespace blender::ui {
|
||||
|
||||
|
@ -54,6 +60,67 @@ void attribute_search_add_items(StringRefNull str,
|
|||
uiSearchItems *items,
|
||||
bool is_first);
|
||||
|
||||
/**
|
||||
* This provides a common interface for UI elements that want to support dragging & dropping
|
||||
* entities into/onto them. With it, the element can determine if the dragged entity can be dropped
|
||||
* onto itself, provide feedback while dragging and run custom code for the dropping.
|
||||
*
|
||||
* Note that this is just an interface. A #wmDropBox is needed to request instances of it from a UI
|
||||
* element and call its functions. For example the drop box using "UI_OT_view_drop" implements
|
||||
* dropping for views and view items via this interface. To support other kinds of UI elements,
|
||||
* similar drop boxes would be necessary.
|
||||
*/
|
||||
class DropTargetInterface {
|
||||
public:
|
||||
DropTargetInterface() = default;
|
||||
virtual ~DropTargetInterface() = default;
|
||||
|
||||
/**
|
||||
* Check if the data dragged with \a drag can be dropped on the element this drop target is for.
|
||||
* \param r_disabled_hint: Return a static string to display to the user, explaining why dropping
|
||||
* isn't possible on this UI element. Shouldn't be done too aggressively,
|
||||
* e.g. don't set this if the drag-type can't be dropped here; only if it
|
||||
* can but there's another reason it can't be dropped. Can assume this is
|
||||
* a non-null pointer.
|
||||
*/
|
||||
virtual bool can_drop(const wmDrag &drag, const char **r_disabled_hint) const = 0;
|
||||
/**
|
||||
* Custom text to display when dragging over the element using this drop target. Should
|
||||
* explain what happens when dropping the data onto this UI element. Will only be used if
|
||||
* #DropTargetInterface::can_drop() returns true, so the implementing override doesn't have
|
||||
* to check that again. The returned value must be a translated string.
|
||||
*/
|
||||
virtual std::string drop_tooltip(const wmDrag &drag) const = 0;
|
||||
/**
|
||||
* Execute the logic to apply a drop of the data dragged with \a drag onto/into the UI element
|
||||
* this drop target is for.
|
||||
*/
|
||||
virtual bool on_drop(bContext *C, const wmDrag &drag) const = 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Let a drop target handle a drop event.
|
||||
* \return True if the dropping was successful.
|
||||
*/
|
||||
bool drop_target_apply_drop(bContext &C,
|
||||
const DropTargetInterface &drop_target,
|
||||
const ListBase &drags);
|
||||
/**
|
||||
* Call #DropTargetInterface::drop_tooltip() and return the result as newly allocated C string
|
||||
* (unless the result is empty, returns null then). Needs freeing with MEM_freeN().
|
||||
*/
|
||||
char *drop_target_tooltip(const DropTargetInterface &drop_target, const wmDrag &drag);
|
||||
|
||||
std::unique_ptr<DropTargetInterface> view_drop_target(const uiViewHandle *view_handle);
|
||||
std::unique_ptr<DropTargetInterface> view_item_drop_target(const uiViewItemHandle *item_handle);
|
||||
/**
|
||||
* Try to find a view item with a drop target under the mouse cursor, or if not found, a view
|
||||
* with a drop target.
|
||||
* \param xy: Coordinate to find a drop target at, in window space.
|
||||
*/
|
||||
std::unique_ptr<DropTargetInterface> region_views_find_drop_target_at(const ARegion *region,
|
||||
const int xy[2]);
|
||||
|
||||
} // namespace blender::ui
|
||||
|
||||
enum eUIListFilterResult {
|
||||
|
|
|
@ -46,6 +46,7 @@ set(SRC
|
|||
interface_context_path.cc
|
||||
interface_drag.cc
|
||||
interface_draw.cc
|
||||
interface_drop.cc
|
||||
interface_dropboxes.cc
|
||||
interface_handlers.cc
|
||||
interface_icons.cc
|
||||
|
|
|
@ -2014,6 +2014,8 @@ void UI_block_end_ex(const bContext *C, uiBlock *block, const int xy[2], int r_x
|
|||
break;
|
||||
}
|
||||
|
||||
ui_block_views_bounds_calc(block);
|
||||
|
||||
if (block->rect.xmin == 0.0f && block->rect.xmax == 0.0f) {
|
||||
UI_block_bounds_set_normal(block, 0);
|
||||
}
|
||||
|
|
|
@ -0,0 +1,32 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
||||
|
||||
/** \file
|
||||
* \ingroup edinterface
|
||||
*/
|
||||
|
||||
#include "UI_interface.hh"
|
||||
|
||||
namespace blender::ui {
|
||||
|
||||
bool drop_target_apply_drop(bContext &C,
|
||||
const DropTargetInterface &drop_target,
|
||||
const ListBase &drags)
|
||||
{
|
||||
|
||||
const char *disabled_hint_dummy = nullptr;
|
||||
LISTBASE_FOREACH (const wmDrag *, drag, &drags) {
|
||||
if (drop_target.can_drop(*drag, &disabled_hint_dummy)) {
|
||||
return drop_target.on_drop(&C, *drag);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
char *drop_target_tooltip(const DropTargetInterface &drop_target, const wmDrag &drag)
|
||||
{
|
||||
const std::string tooltip = drop_target.drop_tooltip(drag);
|
||||
return tooltip.empty() ? nullptr : BLI_strdup(tooltip.c_str());
|
||||
}
|
||||
|
||||
} // namespace blender::ui
|
|
@ -20,6 +20,9 @@
|
|||
#include "WM_api.h"
|
||||
|
||||
#include "UI_interface.h"
|
||||
#include "UI_interface.hh"
|
||||
|
||||
using namespace blender::ui;
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name View Drag/Drop Callbacks
|
||||
|
@ -28,28 +31,27 @@
|
|||
static bool ui_view_drop_poll(bContext *C, wmDrag *drag, const wmEvent *event)
|
||||
{
|
||||
const ARegion *region = CTX_wm_region(C);
|
||||
const uiViewItemHandle *hovered_item = UI_region_views_find_item_at(region, event->xy);
|
||||
if (!hovered_item) {
|
||||
|
||||
std::unique_ptr<DropTargetInterface> drop_target = region_views_find_drop_target_at(region,
|
||||
event->xy);
|
||||
if (!drop_target) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (drag->drop_state.free_disabled_info) {
|
||||
MEM_SAFE_FREE(drag->drop_state.disabled_info);
|
||||
}
|
||||
|
||||
drag->drop_state.free_disabled_info = false;
|
||||
return UI_view_item_can_drop(hovered_item, drag, &drag->drop_state.disabled_info);
|
||||
|
||||
return drop_target->can_drop(*drag, &drag->drop_state.disabled_info);
|
||||
}
|
||||
|
||||
static char *ui_view_drop_tooltip(bContext *C, wmDrag *drag, const int xy[2], wmDropBox * /*drop*/)
|
||||
{
|
||||
const ARegion *region = CTX_wm_region(C);
|
||||
const uiViewItemHandle *hovered_item = UI_region_views_find_item_at(region, xy);
|
||||
if (!hovered_item) {
|
||||
return nullptr;
|
||||
}
|
||||
std::unique_ptr<DropTargetInterface> drop_target = region_views_find_drop_target_at(region, xy);
|
||||
|
||||
return UI_view_item_drop_tooltip(hovered_item, drag);
|
||||
return drop_target_tooltip(*drop_target, *drag);
|
||||
}
|
||||
|
||||
/** \} */
|
||||
|
|
|
@ -1452,6 +1452,7 @@ void ui_interface_tag_script_reload_queries();
|
|||
/* interface_view.cc */
|
||||
|
||||
void ui_block_free_views(uiBlock *block);
|
||||
void ui_block_views_bounds_calc(const uiBlock *block);
|
||||
void ui_block_views_listen(const uiBlock *block, const wmRegionListenerParams *listener_params);
|
||||
uiViewHandle *ui_block_view_find_matching_in_old_block(const uiBlock *new_block,
|
||||
const uiViewHandle *new_view);
|
||||
|
|
|
@ -47,6 +47,7 @@
|
|||
#include "RNA_types.h"
|
||||
|
||||
#include "UI_interface.h"
|
||||
#include "UI_interface.hh"
|
||||
|
||||
#include "interface_intern.hh"
|
||||
|
||||
|
@ -65,6 +66,8 @@
|
|||
#include "ED_screen.h"
|
||||
#include "ED_text.h"
|
||||
|
||||
using namespace blender::ui;
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Immediate redraw helper
|
||||
*
|
||||
|
@ -2351,7 +2354,7 @@ static void UI_OT_list_start_filter(wmOperatorType *ot)
|
|||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name UI Tree-View Drop Operator
|
||||
/** \name UI View Drop Operator
|
||||
* \{ */
|
||||
|
||||
static bool ui_view_drop_poll(bContext *C)
|
||||
|
@ -2361,9 +2364,7 @@ static bool ui_view_drop_poll(bContext *C)
|
|||
if (region == nullptr) {
|
||||
return false;
|
||||
}
|
||||
const uiViewItemHandle *hovered_item = UI_region_views_find_item_at(region, win->eventstate->xy);
|
||||
|
||||
return hovered_item != nullptr;
|
||||
return region_views_find_drop_target_at(region, win->eventstate->xy) != nullptr;
|
||||
}
|
||||
|
||||
static int ui_view_drop_invoke(bContext *C, wmOperator * /*op*/, const wmEvent *event)
|
||||
|
@ -2373,10 +2374,11 @@ static int ui_view_drop_invoke(bContext *C, wmOperator * /*op*/, const wmEvent *
|
|||
}
|
||||
|
||||
const ARegion *region = CTX_wm_region(C);
|
||||
uiViewItemHandle *hovered_item = UI_region_views_find_item_at(region, event->xy);
|
||||
std::unique_ptr<DropTargetInterface> drop_target = region_views_find_drop_target_at(region,
|
||||
event->xy);
|
||||
|
||||
if (!UI_view_item_drop_handle(
|
||||
C, hovered_item, static_cast<const ListBase *>(event->customdata))) {
|
||||
if (!drop_target_apply_drop(
|
||||
*C, *drop_target, *static_cast<const ListBase *>(event->customdata))) {
|
||||
return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
|
||||
}
|
||||
|
||||
|
@ -2385,9 +2387,9 @@ static int ui_view_drop_invoke(bContext *C, wmOperator * /*op*/, const wmEvent *
|
|||
|
||||
static void UI_OT_view_drop(wmOperatorType *ot)
|
||||
{
|
||||
ot->name = "View drop";
|
||||
ot->name = "View Drop";
|
||||
ot->idname = "UI_OT_view_drop";
|
||||
ot->description = "Drag and drop items onto a data-set item";
|
||||
ot->description = "Drag and drop onto a data-set or item within the data-set";
|
||||
|
||||
ot->invoke = ui_view_drop_invoke;
|
||||
ot->poll = ui_view_drop_poll;
|
||||
|
|
|
@ -62,6 +62,12 @@ void AbstractView::update_from_old(uiBlock &new_block)
|
|||
/** \name Default implementations of virtual functions
|
||||
* \{ */
|
||||
|
||||
std::unique_ptr<AbstractViewDropTarget> AbstractView::create_drop_target() const
|
||||
{
|
||||
/* There's no drop target (and hence no drop support) by default. */
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool AbstractView::listen(const wmNotifier & /*notifier*/) const
|
||||
{
|
||||
/* Nothing by default. */
|
||||
|
@ -104,6 +110,23 @@ MutableSpan<char> AbstractView::get_rename_buffer()
|
|||
return *rename_buffer_;
|
||||
}
|
||||
|
||||
std::optional<rcti> AbstractView::get_bounds() const
|
||||
{
|
||||
return bounds_;
|
||||
}
|
||||
|
||||
/** \} */
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
/** \name General API functions
|
||||
* \{ */
|
||||
|
||||
std::unique_ptr<DropTargetInterface> view_drop_target(const uiViewHandle *view_handle)
|
||||
{
|
||||
const AbstractView &view = reinterpret_cast<const AbstractView &>(*view_handle);
|
||||
return view.create_drop_target();
|
||||
}
|
||||
|
||||
/** \} */
|
||||
|
||||
} // namespace blender::ui
|
||||
|
|
|
@ -174,9 +174,9 @@ std::unique_ptr<AbstractViewItemDragController> AbstractViewItem::create_drag_co
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
std::unique_ptr<AbstractViewItemDropController> AbstractViewItem::create_drop_controller() const
|
||||
std::unique_ptr<AbstractViewItemDropTarget> AbstractViewItem::create_drop_target() const
|
||||
{
|
||||
/* There's no drop controller (and hence no drop support) by default. */
|
||||
/* There's no drop target (and hence no drop support) by default. */
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
@ -189,7 +189,7 @@ void AbstractViewItemDragController::on_drag_start()
|
|||
/* Do nothing by default. */
|
||||
}
|
||||
|
||||
AbstractViewItemDropController::AbstractViewItemDropController(AbstractView &view) : view_(view)
|
||||
AbstractViewItemDropTarget::AbstractViewItemDropTarget(AbstractView &view) : view_(view)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -217,6 +217,18 @@ bool AbstractViewItem::is_active() const
|
|||
|
||||
/** \} */
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
/** \name General API functions
|
||||
* \{ */
|
||||
|
||||
std::unique_ptr<DropTargetInterface> view_item_drop_target(const uiViewItemHandle *item_handle)
|
||||
{
|
||||
const AbstractViewItem &item = reinterpret_cast<const AbstractViewItem &>(*item_handle);
|
||||
return item.create_drop_target();
|
||||
}
|
||||
|
||||
/** \} */
|
||||
|
||||
} // namespace blender::ui
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
@ -264,45 +276,6 @@ class ViewItemAPIWrapper {
|
|||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool can_drop(const AbstractViewItem &item,
|
||||
const wmDrag &drag,
|
||||
const char **r_disabled_hint)
|
||||
{
|
||||
const std::unique_ptr<AbstractViewItemDropController> drop_controller =
|
||||
item.create_drop_controller();
|
||||
if (!drop_controller) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return drop_controller->can_drop(drag, r_disabled_hint);
|
||||
}
|
||||
|
||||
static std::string drop_tooltip(const AbstractViewItem &item, const wmDrag &drag)
|
||||
{
|
||||
const std::unique_ptr<AbstractViewItemDropController> drop_controller =
|
||||
item.create_drop_controller();
|
||||
if (!drop_controller) {
|
||||
return {};
|
||||
}
|
||||
|
||||
return drop_controller->drop_tooltip(drag);
|
||||
}
|
||||
|
||||
static bool drop_handle(bContext &C, const AbstractViewItem &item, const ListBase &drags)
|
||||
{
|
||||
std::unique_ptr<AbstractViewItemDropController> drop_controller =
|
||||
item.create_drop_controller();
|
||||
|
||||
const char *disabled_hint_dummy = nullptr;
|
||||
LISTBASE_FOREACH (const wmDrag *, drag, &drags) {
|
||||
if (drop_controller->can_drop(*drag, &disabled_hint_dummy)) {
|
||||
return drop_controller->on_drop(&C, *drag);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace blender::ui
|
||||
|
@ -348,26 +321,4 @@ bool UI_view_item_drag_start(bContext *C, const uiViewItemHandle *item_)
|
|||
return ViewItemAPIWrapper::drag_start(*C, item);
|
||||
}
|
||||
|
||||
bool UI_view_item_can_drop(const uiViewItemHandle *item_,
|
||||
const wmDrag *drag,
|
||||
const char **r_disabled_hint)
|
||||
{
|
||||
const AbstractViewItem &item = reinterpret_cast<const AbstractViewItem &>(*item_);
|
||||
return ViewItemAPIWrapper::can_drop(item, *drag, r_disabled_hint);
|
||||
}
|
||||
|
||||
char *UI_view_item_drop_tooltip(const uiViewItemHandle *item_, const wmDrag *drag)
|
||||
{
|
||||
const AbstractViewItem &item = reinterpret_cast<const AbstractViewItem &>(*item_);
|
||||
|
||||
const std::string tooltip = ViewItemAPIWrapper::drop_tooltip(item, *drag);
|
||||
return tooltip.empty() ? nullptr : BLI_strdup(tooltip.c_str());
|
||||
}
|
||||
|
||||
bool UI_view_item_drop_handle(bContext *C, const uiViewItemHandle *item_, const ListBase *drags)
|
||||
{
|
||||
const AbstractViewItem &item = reinterpret_cast<const AbstractViewItem &>(*item_);
|
||||
return ViewItemAPIWrapper::drop_handle(*C, item, *drags);
|
||||
}
|
||||
|
||||
/** \} */
|
||||
|
|
|
@ -389,7 +389,7 @@ uiLayout *GridViewLayoutBuilder::current_layout() const
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
GridViewBuilder::GridViewBuilder(uiBlock &block) : block_(block)
|
||||
GridViewBuilder::GridViewBuilder(uiBlock & /*block*/)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -24,6 +24,7 @@
|
|||
#include "BKE_screen.h"
|
||||
|
||||
#include "BLI_listbase.h"
|
||||
#include "BLI_map.hh"
|
||||
|
||||
#include "ED_screen.h"
|
||||
|
||||
|
@ -44,6 +45,8 @@ using namespace blender::ui;
|
|||
struct ViewLink : public Link {
|
||||
std::string idname;
|
||||
std::unique_ptr<AbstractView> view;
|
||||
|
||||
static void views_bounds_calc(const uiBlock &block);
|
||||
};
|
||||
|
||||
template<class T>
|
||||
|
@ -81,6 +84,51 @@ void ui_block_free_views(uiBlock *block)
|
|||
}
|
||||
}
|
||||
|
||||
void ViewLink::views_bounds_calc(const uiBlock &block)
|
||||
{
|
||||
Map<AbstractView *, rcti> views_bounds;
|
||||
|
||||
rcti minmax;
|
||||
BLI_rcti_init_minmax(&minmax);
|
||||
LISTBASE_FOREACH (ViewLink *, link, &block.views) {
|
||||
views_bounds.add(link->view.get(), minmax);
|
||||
}
|
||||
|
||||
LISTBASE_FOREACH (uiBut *, but, &block.buttons) {
|
||||
if (but->type != UI_BTYPE_VIEW_ITEM) {
|
||||
continue;
|
||||
}
|
||||
uiButViewItem *view_item_but = static_cast<uiButViewItem *>(but);
|
||||
if (!view_item_but->view_item) {
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Get the view from the button. */
|
||||
AbstractViewItem &view_item = reinterpret_cast<AbstractViewItem &>(*view_item_but->view_item);
|
||||
AbstractView &view = view_item.get_view();
|
||||
|
||||
rcti &bounds = views_bounds.lookup(&view);
|
||||
rcti but_rcti{};
|
||||
BLI_rcti_rctf_copy_round(&but_rcti, &view_item_but->rect);
|
||||
BLI_rcti_do_minmax_rcti(&bounds, &but_rcti);
|
||||
}
|
||||
|
||||
for (const auto item : views_bounds.items()) {
|
||||
const rcti &bounds = item.value;
|
||||
if (BLI_rcti_is_empty(&bounds)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
AbstractView &view = *item.key;
|
||||
view.bounds_ = bounds;
|
||||
}
|
||||
}
|
||||
|
||||
void ui_block_views_bounds_calc(const uiBlock *block)
|
||||
{
|
||||
ViewLink::views_bounds_calc(*block);
|
||||
}
|
||||
|
||||
void ui_block_views_listen(const uiBlock *block, const wmRegionListenerParams *listener_params)
|
||||
{
|
||||
ARegion *region = listener_params->region;
|
||||
|
@ -92,6 +140,35 @@ void ui_block_views_listen(const uiBlock *block, const wmRegionListenerParams *l
|
|||
}
|
||||
}
|
||||
|
||||
/* Similar to #ui_but_find_mouse_over_ex(). */
|
||||
uiViewHandle *UI_region_view_find_at(const ARegion *region, const int xy[2], const int pad)
|
||||
{
|
||||
if (!ui_region_contains_point_px(region, xy)) {
|
||||
return nullptr;
|
||||
}
|
||||
LISTBASE_FOREACH (uiBlock *, block, ®ion->uiblocks) {
|
||||
float mx = xy[0], my = xy[1];
|
||||
ui_window_to_block_fl(region, block, &mx, &my);
|
||||
|
||||
LISTBASE_FOREACH (ViewLink *, view_link, &block->views) {
|
||||
std::optional<rcti> bounds = view_link->view->get_bounds();
|
||||
if (!bounds) {
|
||||
continue;
|
||||
}
|
||||
|
||||
rcti padded_bounds = *bounds;
|
||||
if (pad) {
|
||||
BLI_rcti_pad(&padded_bounds, pad, pad);
|
||||
}
|
||||
if (BLI_rcti_isect_pt(&padded_bounds, mx, my)) {
|
||||
return reinterpret_cast<uiViewHandle *>(view_link->view.get());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
uiViewItemHandle *UI_region_views_find_item_at(const ARegion *region, const int xy[2])
|
||||
{
|
||||
uiButViewItem *item_but = (uiButViewItem *)ui_view_item_find_mouse_over(region, xy);
|
||||
|
@ -112,6 +189,34 @@ uiViewItemHandle *UI_region_views_find_active_item(const ARegion *region)
|
|||
return item_but->view_item;
|
||||
}
|
||||
|
||||
namespace blender::ui {
|
||||
|
||||
std::unique_ptr<DropTargetInterface> region_views_find_drop_target_at(const ARegion *region,
|
||||
const int xy[2])
|
||||
{
|
||||
const uiViewItemHandle *hovered_view_item = UI_region_views_find_item_at(region, xy);
|
||||
if (hovered_view_item) {
|
||||
std::unique_ptr<DropTargetInterface> drop_target = view_item_drop_target(hovered_view_item);
|
||||
if (drop_target) {
|
||||
return drop_target;
|
||||
}
|
||||
}
|
||||
|
||||
/* Get style for some sensible padding around the view items. */
|
||||
const uiStyle *style = UI_style_get_dpi();
|
||||
const uiViewHandle *hovered_view = UI_region_view_find_at(region, xy, style->buttonspacex);
|
||||
if (hovered_view) {
|
||||
std::unique_ptr<DropTargetInterface> drop_target = view_drop_target(hovered_view);
|
||||
if (drop_target) {
|
||||
return drop_target;
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
} // namespace blender::ui
|
||||
|
||||
static StringRef ui_block_view_find_idname(const uiBlock &block, const AbstractView &view)
|
||||
{
|
||||
/* First get the idname the of the view we're looking for. */
|
||||
|
|
|
@ -373,8 +373,6 @@ static bool wm_collada_export_check(bContext *UNUSED(C), wmOperator *op)
|
|||
|
||||
void WM_OT_collada_export(wmOperatorType *ot)
|
||||
{
|
||||
struct StructRNA *func = ot->srna;
|
||||
|
||||
static const EnumPropertyItem prop_bc_export_mesh_type[] = {
|
||||
{BC_MESH_TYPE_VIEW, "view", 0, "Viewport", "Apply modifier's viewport settings"},
|
||||
{BC_MESH_TYPE_RENDER, "render", 0, "Render", "Apply modifier's render settings"},
|
||||
|
@ -456,20 +454,20 @@ void WM_OT_collada_export(wmOperatorType *ot)
|
|||
FILE_DEFAULTDISPLAY,
|
||||
FILE_SORT_DEFAULT);
|
||||
|
||||
RNA_def_enum(func,
|
||||
RNA_def_enum(ot->srna,
|
||||
"prop_bc_export_ui_section",
|
||||
prop_bc_export_ui_section,
|
||||
0,
|
||||
"Export Section",
|
||||
"Only for User Interface organization");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"apply_modifiers",
|
||||
0,
|
||||
"Apply Modifiers",
|
||||
"Apply modifiers to exported mesh (non destructive))");
|
||||
|
||||
RNA_def_int(func,
|
||||
RNA_def_int(ot->srna,
|
||||
"export_mesh_type",
|
||||
0,
|
||||
INT_MIN,
|
||||
|
@ -479,83 +477,83 @@ void WM_OT_collada_export(wmOperatorType *ot)
|
|||
INT_MIN,
|
||||
INT_MAX);
|
||||
|
||||
RNA_def_enum(func,
|
||||
RNA_def_enum(ot->srna,
|
||||
"export_mesh_type_selection",
|
||||
prop_bc_export_mesh_type,
|
||||
0,
|
||||
"Resolution",
|
||||
"Modifier resolution for export");
|
||||
|
||||
RNA_def_enum(func,
|
||||
RNA_def_enum(ot->srna,
|
||||
"export_global_forward_selection",
|
||||
prop_bc_export_global_forward,
|
||||
BC_DEFAULT_FORWARD,
|
||||
"Global Forward Axis",
|
||||
"Global Forward axis for export");
|
||||
|
||||
RNA_def_enum(func,
|
||||
RNA_def_enum(ot->srna,
|
||||
"export_global_up_selection",
|
||||
prop_bc_export_global_up,
|
||||
BC_DEFAULT_UP,
|
||||
"Global Up Axis",
|
||||
"Global Up axis for export");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"apply_global_orientation",
|
||||
false,
|
||||
"Apply Global Orientation",
|
||||
"Rotate all root objects to match the global orientation settings "
|
||||
"otherwise set the global orientation per Collada asset");
|
||||
|
||||
RNA_def_boolean(func, "selected", false, "Selection Only", "Export only selected elements");
|
||||
RNA_def_boolean(ot->srna, "selected", false, "Selection Only", "Export only selected elements");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"include_children",
|
||||
false,
|
||||
"Include Children",
|
||||
"Export all children of selected objects (even if not selected)");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"include_armatures",
|
||||
false,
|
||||
"Include Armatures",
|
||||
"Export related armatures (even if not selected)");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"include_shapekeys",
|
||||
false,
|
||||
"Include Shape Keys",
|
||||
"Export all Shape Keys from Mesh Objects");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"deform_bones_only",
|
||||
false,
|
||||
"Deform Bones Only",
|
||||
"Only export deforming bones with armatures");
|
||||
|
||||
RNA_def_boolean(
|
||||
func,
|
||||
ot->srna,
|
||||
"include_animations",
|
||||
true,
|
||||
"Include Animations",
|
||||
"Export animations if available (exporting animations will enforce the decomposition of "
|
||||
"node transforms into <translation> <rotation> and <scale> components)");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"include_all_actions",
|
||||
true,
|
||||
"Include all Actions",
|
||||
"Export also unassigned actions (this allows you to export entire animation "
|
||||
"libraries for your character(s))");
|
||||
|
||||
RNA_def_enum(func,
|
||||
RNA_def_enum(ot->srna,
|
||||
"export_animation_type_selection",
|
||||
prop_bc_export_animation_type,
|
||||
0,
|
||||
"Key Type",
|
||||
"Type for exported animations (use sample keys or Curve keys)");
|
||||
|
||||
RNA_def_int(func,
|
||||
RNA_def_int(ot->srna,
|
||||
"sampling_rate",
|
||||
1,
|
||||
1,
|
||||
|
@ -565,7 +563,7 @@ void WM_OT_collada_export(wmOperatorType *ot)
|
|||
1,
|
||||
INT_MAX);
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"keep_smooth_curves",
|
||||
0,
|
||||
"Keep Smooth curves",
|
||||
|
@ -573,48 +571,51 @@ void WM_OT_collada_export(wmOperatorType *ot)
|
|||
"inverse parent matrix "
|
||||
"is the unity matrix, otherwise you may end up with odd results)");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"keep_keyframes",
|
||||
0,
|
||||
"Keep Keyframes",
|
||||
"Use existing keyframes as additional sample points (this helps when you want "
|
||||
"to keep manual tweaks)");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"keep_flat_curves",
|
||||
0,
|
||||
"All Keyed Curves",
|
||||
"Export also curves which have only one key or are totally flat");
|
||||
|
||||
RNA_def_boolean(
|
||||
func, "active_uv_only", 0, "Only Selected UV Map", "Export only the selected UV Map");
|
||||
ot->srna, "active_uv_only", 0, "Only Selected UV Map", "Export only the selected UV Map");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"use_texture_copies",
|
||||
1,
|
||||
"Copy",
|
||||
"Copy textures to same folder where the .dae file is exported");
|
||||
|
||||
RNA_def_boolean(
|
||||
func, "triangulate", 1, "Triangulate", "Export polygons (quads and n-gons) as triangles");
|
||||
RNA_def_boolean(ot->srna,
|
||||
"triangulate",
|
||||
1,
|
||||
"Triangulate",
|
||||
"Export polygons (quads and n-gons) as triangles");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"use_object_instantiation",
|
||||
1,
|
||||
"Use Object Instances",
|
||||
"Instantiate multiple Objects from same Data");
|
||||
|
||||
RNA_def_boolean(
|
||||
func,
|
||||
ot->srna,
|
||||
"use_blender_profile",
|
||||
1,
|
||||
"Use Blender Profile",
|
||||
"Export additional Blender specific information (for material, shaders, bones, etc.)");
|
||||
|
||||
RNA_def_boolean(
|
||||
func, "sort_by_name", 0, "Sort by Object name", "Sort exported data by Object name");
|
||||
ot->srna, "sort_by_name", 0, "Sort by Object name", "Sort exported data by Object name");
|
||||
|
||||
RNA_def_int(func,
|
||||
RNA_def_int(ot->srna,
|
||||
"export_object_transformation_type",
|
||||
0,
|
||||
INT_MIN,
|
||||
|
@ -624,14 +625,14 @@ void WM_OT_collada_export(wmOperatorType *ot)
|
|||
INT_MIN,
|
||||
INT_MAX);
|
||||
|
||||
RNA_def_enum(func,
|
||||
RNA_def_enum(ot->srna,
|
||||
"export_object_transformation_type_selection",
|
||||
prop_bc_export_transformation_type,
|
||||
0,
|
||||
"Transform",
|
||||
"Object Transformation type for translation, scale and rotation");
|
||||
|
||||
RNA_def_int(func,
|
||||
RNA_def_int(ot->srna,
|
||||
"export_animation_transformation_type",
|
||||
0,
|
||||
INT_MIN,
|
||||
|
@ -643,7 +644,7 @@ void WM_OT_collada_export(wmOperatorType *ot)
|
|||
INT_MIN,
|
||||
INT_MAX);
|
||||
|
||||
RNA_def_enum(func,
|
||||
RNA_def_enum(ot->srna,
|
||||
"export_animation_transformation_type_selection",
|
||||
prop_bc_export_transformation_type,
|
||||
0,
|
||||
|
@ -652,20 +653,20 @@ void WM_OT_collada_export(wmOperatorType *ot)
|
|||
"Note: The Animation transformation type in the Anim Tab "
|
||||
"is always equal to the Object transformation type in the Geom tab");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"open_sim",
|
||||
0,
|
||||
"Export to SL/OpenSim",
|
||||
"Compatibility mode for SL, OpenSim and other compatible online worlds");
|
||||
|
||||
RNA_def_boolean(func,
|
||||
RNA_def_boolean(ot->srna,
|
||||
"limit_precision",
|
||||
0,
|
||||
"Limit Precision",
|
||||
"Reduce the precision of the exported data to 6 digits");
|
||||
|
||||
RNA_def_boolean(
|
||||
func,
|
||||
ot->srna,
|
||||
"keep_bind_info",
|
||||
0,
|
||||
"Keep Bind Info",
|
||||
|
|
|
@ -845,7 +845,7 @@ static void define_primitive_add_properties(wmOperatorType *ot)
|
|||
static int primitive_circle_add_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
const float points[4][2] = {{0.0f, 0.5f}, {0.5f, 1.0f}, {1.0f, 0.5f}, {0.5f, 0.0f}};
|
||||
int num_points = sizeof(points) / sizeof(float[2]);
|
||||
int num_points = ARRAY_SIZE(points);
|
||||
|
||||
create_primitive_from_points(C, op, points, num_points, HD_AUTO);
|
||||
|
||||
|
@ -880,7 +880,7 @@ void MASK_OT_primitive_circle_add(wmOperatorType *ot)
|
|||
static int primitive_square_add_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
const float points[4][2] = {{0.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f}, {1.0f, 0.0f}};
|
||||
int num_points = sizeof(points) / sizeof(float[2]);
|
||||
int num_points = ARRAY_SIZE(points);
|
||||
|
||||
create_primitive_from_points(C, op, points, num_points, HD_VECT);
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue