Overlay-Next: Initial implementation #107045
|
|
@ -40,7 +40,8 @@ ExternalProject_Add(external_igc_llvm
|
|||
${PATCH_CMD} -p 1 -d ${IGC_LLVM_SOURCE_DIR} < ${IGC_OPENCL_CLANG_PATCH_DIR}/clang/0004-OpenCL-support-cl_ext_float_atomics.patch &&
|
||||
${PATCH_CMD} -p 1 -d ${IGC_LLVM_SOURCE_DIR} < ${IGC_OPENCL_CLANG_PATCH_DIR}/clang/0005-OpenCL-Add-cl_khr_integer_dot_product.patch &&
|
||||
${PATCH_CMD} -p 1 -d ${IGC_LLVM_SOURCE_DIR} < ${IGC_OPENCL_CLANG_PATCH_DIR}/llvm/0001-Memory-leak-fix-for-Managed-Static-Mutex.patch &&
|
||||
${PATCH_CMD} -p 1 -d ${IGC_LLVM_SOURCE_DIR} < ${IGC_OPENCL_CLANG_PATCH_DIR}/llvm/0002-Remove-repo-name-in-LLVM-IR.patch
|
||||
${PATCH_CMD} -p 1 -d ${IGC_LLVM_SOURCE_DIR} < ${IGC_OPENCL_CLANG_PATCH_DIR}/llvm/0002-Remove-repo-name-in-LLVM-IR.patch &&
|
||||
${PATCH_CMD} -p 1 -d ${IGC_LLVM_SOURCE_DIR} < ${IGC_OPENCL_CLANG_PATCH_DIR}/llvm/0003-Add-missing-include-limit-in-benchmark.patch
|
||||
)
|
||||
add_dependencies(
|
||||
external_igc_llvm
|
||||
|
|
@ -55,9 +56,6 @@ ExternalProject_Add(external_igc_spirv_translator
|
|||
CONFIGURE_COMMAND echo .
|
||||
BUILD_COMMAND echo .
|
||||
INSTALL_COMMAND echo .
|
||||
PATCH_COMMAND ${PATCH_CMD} -p 1 -d ${IGC_SPIRV_TRANSLATOR_SOURCE_DIR} < ${IGC_OPENCL_CLANG_PATCH_DIR}/spirv/0001-update-SPIR-V-headers-for-SPV_INTEL_split_barrier.patch &&
|
||||
${PATCH_CMD} -p 1 -d ${IGC_SPIRV_TRANSLATOR_SOURCE_DIR} < ${IGC_OPENCL_CLANG_PATCH_DIR}/spirv/0002-Add-support-for-split-barriers-extension-SPV_INTEL_s.patch &&
|
||||
${PATCH_CMD} -p 1 -d ${IGC_SPIRV_TRANSLATOR_SOURCE_DIR} < ${IGC_OPENCL_CLANG_PATCH_DIR}/spirv/0003-Support-cl_bf16_conversions.patch
|
||||
)
|
||||
add_dependencies(
|
||||
external_igc_spirv_translator
|
||||
|
|
|
|||
|
|
@ -88,6 +88,19 @@ else()
|
|||
export LDFLAGS=${PYTHON_LDFLAGS} &&
|
||||
export PKG_CONFIG_PATH=${LIBDIR}/ffi/lib/pkgconfig)
|
||||
|
||||
# NOTE: untested on APPLE so far.
|
||||
if(NOT APPLE)
|
||||
set(PYTHON_CONFIGURE_EXTRA_ARGS
|
||||
${PYTHON_CONFIGURE_EXTRA_ARGS}
|
||||
# Used on most release Linux builds (Fedora for e.g.),
|
||||
# increases build times noticeably with the benefit of a modest speedup at runtime.
|
||||
--enable-optimizations
|
||||
# While LTO is OK when building on the same system, it's incompatible across GCC versions,
|
||||
# making it impractical for developers to build against, so keep it disabled.
|
||||
# `--with-lto`
|
||||
)
|
||||
endif()
|
||||
|
||||
ExternalProject_Add(external_python
|
||||
URL file://${PACKAGE_DIR}/${PYTHON_FILE}
|
||||
DOWNLOAD_DIR ${DOWNLOAD_DIR}
|
||||
|
|
|
|||
|
|
@ -668,9 +668,9 @@ set(SPIRV_HEADERS_FILE SPIR-V-Headers-${SPIRV_HEADERS_VERSION}.tar.gz)
|
|||
# compiler, the versions used are taken from the following location
|
||||
# https://github.com/intel/intel-graphics-compiler/releases
|
||||
|
||||
set(IGC_VERSION 1.0.12149.1)
|
||||
set(IGC_VERSION 1.0.13064.7)
|
||||
set(IGC_URI https://github.com/intel/intel-graphics-compiler/archive/refs/tags/igc-${IGC_VERSION}.tar.gz)
|
||||
set(IGC_HASH 44f67f24e3bc5130f9f062533abf8154782a9d0a992bc19b498639a8521ae836)
|
||||
set(IGC_HASH a929abd4cca2b293961ec0437ee4b3b2147bd3b2c8a3c423af78c0c359b2e5ae)
|
||||
set(IGC_HASH_TYPE SHA256)
|
||||
set(IGC_FILE igc-${IGC_VERSION}.tar.gz)
|
||||
|
||||
|
|
@ -690,15 +690,15 @@ set(IGC_LLVM_FILE ${IGC_LLVM_VERSION}.tar.gz)
|
|||
#
|
||||
# WARNING WARNING WARNING
|
||||
|
||||
set(IGC_OPENCL_CLANG_VERSION 363a5262d8c7cff3fb28f3bdb5d85c8d7e91c1bb)
|
||||
set(IGC_OPENCL_CLANG_VERSION ee31812ea8b89d08c2918f045d11a19bd33525c5)
|
||||
set(IGC_OPENCL_CLANG_URI https://github.com/intel/opencl-clang/archive/${IGC_OPENCL_CLANG_VERSION}.tar.gz)
|
||||
set(IGC_OPENCL_CLANG_HASH aa8cf72bb239722ce8ce44f79413c6887ecc8ca18477dd520aa5c4809756da9a)
|
||||
set(IGC_OPENCL_CLANG_HASH 1db6735bbcfaa31e8a9ba39f121d6bafa806ea8919e9f56782d6aaa67771ddda)
|
||||
set(IGC_OPENCL_CLANG_HASH_TYPE SHA256)
|
||||
set(IGC_OPENCL_CLANG_FILE opencl-clang-${IGC_OPENCL_CLANG_VERSION}.tar.gz)
|
||||
|
||||
set(IGC_VCINTRINSICS_VERSION v0.5.0)
|
||||
set(IGC_VCINTRINSICS_VERSION v0.11.0)
|
||||
set(IGC_VCINTRINSICS_URI https://github.com/intel/vc-intrinsics/archive/refs/tags/${IGC_VCINTRINSICS_VERSION}.tar.gz)
|
||||
set(IGC_VCINTRINSICS_HASH 70bb47c5e32173cf61514941e83ae7c7eb4485e6d2fca60cfa1f50d4f42c41f2)
|
||||
set(IGC_VCINTRINSICS_HASH e5acd5626ce7fa6d41ce154c50ac805eda734ee66af94ef28e680ac2ad81bb9f)
|
||||
set(IGC_VCINTRINSICS_HASH_TYPE SHA256)
|
||||
set(IGC_VCINTRINSICS_FILE vc-intrinsics-${IGC_VCINTRINSICS_VERSION}.tar.gz)
|
||||
|
||||
|
|
@ -714,9 +714,9 @@ set(IGC_SPIRV_TOOLS_HASH 6e19900e948944243024aedd0a201baf3854b377b9cc7a386553bc1
|
|||
set(IGC_SPIRV_TOOLS_HASH_TYPE SHA256)
|
||||
set(IGC_SPIRV_TOOLS_FILE SPIR-V-Tools-${IGC_SPIRV_TOOLS_VERSION}.tar.gz)
|
||||
|
||||
set(IGC_SPIRV_TRANSLATOR_VERSION a31ffaeef77e23d500b3ea3d35e0c42ff5648ad9)
|
||||
set(IGC_SPIRV_TRANSLATOR_VERSION d739c01d65ec00dee64dedd40deed805216a7193)
|
||||
set(IGC_SPIRV_TRANSLATOR_URI https://github.com/KhronosGroup/SPIRV-LLVM-Translator/archive/${IGC_SPIRV_TRANSLATOR_VERSION}.tar.gz)
|
||||
set(IGC_SPIRV_TRANSLATOR_HASH 9e26c96a45341b8f8af521bacea20e752623346340addd02af95d669f6e89252)
|
||||
set(IGC_SPIRV_TRANSLATOR_HASH ddc0cc9ccbe59dadeaf291012d59de142b2e9f2b124dbb634644d39daddaa13e)
|
||||
set(IGC_SPIRV_TRANSLATOR_HASH_TYPE SHA256)
|
||||
set(IGC_SPIRV_TRANSLATOR_FILE SPIR-V-Translator-${IGC_SPIRV_TRANSLATOR_VERSION}.tar.gz)
|
||||
|
||||
|
|
@ -724,15 +724,15 @@ set(IGC_SPIRV_TRANSLATOR_FILE SPIR-V-Translator-${IGC_SPIRV_TRANSLATOR_VERSION}.
|
|||
### Intel Graphics Compiler DEPS END ###
|
||||
########################################
|
||||
|
||||
set(GMMLIB_VERSION intel-gmmlib-22.1.8)
|
||||
set(GMMLIB_VERSION intel-gmmlib-22.3.0)
|
||||
set(GMMLIB_URI https://github.com/intel/gmmlib/archive/refs/tags/${GMMLIB_VERSION}.tar.gz)
|
||||
set(GMMLIB_HASH bf23e9a3742b4fb98c7666c9e9b29f3219e4b2fb4d831aaf4eed71f5e2d17368)
|
||||
set(GMMLIB_HASH c1f33e1519edfc527127baeb0436b783430dfd256c643130169a3a71dc86aff9)
|
||||
set(GMMLIB_HASH_TYPE SHA256)
|
||||
set(GMMLIB_FILE ${GMMLIB_VERSION}.tar.gz)
|
||||
|
||||
set(OCLOC_VERSION 22.38.24278)
|
||||
set(OCLOC_VERSION 22.49.25018.21)
|
||||
set(OCLOC_URI https://github.com/intel/compute-runtime/archive/refs/tags/${OCLOC_VERSION}.tar.gz)
|
||||
set(OCLOC_HASH db0c542fccd651e6404b15a74d46027f1ce0eda8dc9e25a40cbb6c0faef257ee)
|
||||
set(OCLOC_HASH 92362dae08b503a34e5d3820ed284198c452bcd5e7504d90eb69887b20492c06)
|
||||
set(OCLOC_HASH_TYPE SHA256)
|
||||
set(OCLOC_FILE ocloc-${OCLOC_VERSION}.tar.gz)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
diff -Naur external_igc_opencl_clang.orig/CMakeLists.txt external_igc_opencl_clang/CMakeLists.txt
|
||||
--- external_igc_opencl_clang.orig/CMakeLists.txt 2022-03-16 05:51:10 -0600
|
||||
+++ external_igc_opencl_clang/CMakeLists.txt 2022-05-23 10:40:09 -0600
|
||||
@@ -126,22 +126,24 @@
|
||||
@@ -147,22 +147,24 @@
|
||||
)
|
||||
endif()
|
||||
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ from bpy.props import (
|
|||
PointerProperty,
|
||||
StringProperty,
|
||||
)
|
||||
from bpy.app.translations import pgettext_iface as iface_
|
||||
|
||||
from math import pi
|
||||
|
||||
|
|
@ -1664,30 +1665,48 @@ class CyclesPreferences(bpy.types.AddonPreferences):
|
|||
col.label(text="No compatible GPUs found for Cycles", icon='INFO')
|
||||
|
||||
if device_type == 'CUDA':
|
||||
col.label(text="Requires NVIDIA GPU with compute capability 3.0", icon='BLANK1')
|
||||
compute_capability = "3.0"
|
||||
col.label(text=iface_("Requires NVIDIA GPU with compute capability %s") % compute_capability,
|
||||
icon='BLANK1', translate=False)
|
||||
elif device_type == 'OPTIX':
|
||||
col.label(text="Requires NVIDIA GPU with compute capability 5.0", icon='BLANK1')
|
||||
col.label(text="and NVIDIA driver version 470 or newer", icon='BLANK1')
|
||||
compute_capability = "5.0"
|
||||
driver_version = "470"
|
||||
col.label(text=iface_("Requires NVIDIA GPU with compute capability %s") % compute_capability,
|
||||
icon='BLANK1', translate=False)
|
||||
col.label(text="and NVIDIA driver version %s or newer" % driver_version,
|
||||
icon='BLANK1', translate=False)
|
||||
elif device_type == 'HIP':
|
||||
import sys
|
||||
if sys.platform[:3] == "win":
|
||||
driver_version = "21.Q4"
|
||||
col.label(text="Requires AMD GPU with RDNA architecture", icon='BLANK1')
|
||||
col.label(text="and AMD Radeon Pro 21.Q4 driver or newer", icon='BLANK1')
|
||||
col.label(text=iface_("and AMD Radeon Pro %s driver or newer") % driver_version,
|
||||
icon='BLANK1', translate=False)
|
||||
elif sys.platform.startswith("linux"):
|
||||
driver_version = "22.10"
|
||||
col.label(text="Requires AMD GPU with RDNA architecture", icon='BLANK1')
|
||||
col.label(text="and AMD driver version 22.10 or newer", icon='BLANK1')
|
||||
col.label(text=iface_("and AMD driver version %s or newer") % driver_version, icon='BLANK1',
|
||||
translate=False)
|
||||
elif device_type == 'ONEAPI':
|
||||
import sys
|
||||
if sys.platform.startswith("win"):
|
||||
driver_version = "101.4032"
|
||||
col.label(text="Requires Intel GPU with Xe-HPG architecture", icon='BLANK1')
|
||||
col.label(text="and Windows driver version 101.4032 or newer", icon='BLANK1')
|
||||
col.label(text=iface_("and Windows driver version %s or newer") % driver_version,
|
||||
icon='BLANK1', translate=False)
|
||||
elif sys.platform.startswith("linux"):
|
||||
driver_version = "1.3.24931"
|
||||
col.label(text="Requires Intel GPU with Xe-HPG architecture and", icon='BLANK1')
|
||||
col.label(text=" - intel-level-zero-gpu version 1.3.24931 or newer", icon='BLANK1')
|
||||
col.label(text=iface_(" - intel-level-zero-gpu version %s or newer") % driver_version,
|
||||
icon='BLANK1', translate=False)
|
||||
col.label(text=" - oneAPI Level-Zero Loader", icon='BLANK1')
|
||||
elif device_type == 'METAL':
|
||||
col.label(text="Requires Apple Silicon with macOS 12.2 or newer", icon='BLANK1')
|
||||
col.label(text="or AMD with macOS 12.3 or newer", icon='BLANK1')
|
||||
silicon_mac_version = "12.2"
|
||||
amd_mac_version = "12.3"
|
||||
col.label(text=iface_("Requires Apple Silicon with macOS %s or newer") % silicon_mac_version,
|
||||
icon='BLANK1', translate=False)
|
||||
col.label(text=iface_("or AMD with macOS %s or newer") % amd_mac_version, icon='BLANK1',
|
||||
translate=False)
|
||||
return
|
||||
|
||||
for device in devices:
|
||||
|
|
|
|||
|
|
@ -602,7 +602,7 @@ void GHOST_SystemSDL::processEvent(SDL_Event *sdl_event)
|
|||
/* NOTE: the `sdl_sub_evt.keysym.sym` is truncated,
|
||||
* for unicode support ghost has to be modified. */
|
||||
|
||||
/* TODO(@campbellbarton): support full unicode, SDL supports this but it needs to be
|
||||
/* TODO(@ideasman42): support full unicode, SDL supports this but it needs to be
|
||||
* explicitly enabled via #SDL_StartTextInput which GHOST would have to wrap. */
|
||||
char utf8_buf[sizeof(GHOST_TEventKeyData::utf8_buf)] = {'\0'};
|
||||
if (type == GHOST_kEventKeyDown) {
|
||||
|
|
|
|||
|
|
@ -241,7 +241,7 @@ enum {
|
|||
BTN_STYLUS = 0x14b,
|
||||
/** Use as right-mouse. */
|
||||
BTN_STYLUS2 = 0x14c,
|
||||
/** NOTE(@campbellbarton): Map to an additional button (not sure which hardware uses this). */
|
||||
/** NOTE(@ideasman42): Map to an additional button (not sure which hardware uses this). */
|
||||
BTN_STYLUS3 = 0x149,
|
||||
};
|
||||
|
||||
|
|
@ -916,7 +916,7 @@ struct GWL_Display {
|
|||
* The main purpose of having an active seat is an alternative from always using the first
|
||||
* seat which prevents events from any other seat.
|
||||
*
|
||||
* NOTE(@campbellbarton): This could be extended and developed further extended to support
|
||||
* NOTE(@ideasman42): This could be extended and developed further extended to support
|
||||
* an active seat per window (for e.g.), basic support is sufficient for now as currently isn't
|
||||
* a widely used feature.
|
||||
*/
|
||||
|
|
@ -957,7 +957,7 @@ struct GWL_Display {
|
|||
* Needed because #GHOST_System::dispatchEvents fires timers
|
||||
* outside of WAYLAND (without locking the `timer_mutex`).
|
||||
*/
|
||||
GHOST_TimerManager *ghost_timer_manager;
|
||||
GHOST_TimerManager *ghost_timer_manager = nullptr;
|
||||
|
||||
#endif /* USE_EVENT_BACKGROUND_THREAD */
|
||||
};
|
||||
|
|
@ -1014,8 +1014,10 @@ static void gwl_display_destroy(GWL_Display *display)
|
|||
}
|
||||
|
||||
/* Important to remove after the seats which may have key repeat timers active. */
|
||||
delete display->ghost_timer_manager;
|
||||
display->ghost_timer_manager = nullptr;
|
||||
if (display->ghost_timer_manager) {
|
||||
delete display->ghost_timer_manager;
|
||||
display->ghost_timer_manager = nullptr;
|
||||
}
|
||||
|
||||
#endif /* USE_EVENT_BACKGROUND_THREAD */
|
||||
|
||||
|
|
@ -1237,7 +1239,7 @@ static void gwl_registry_entry_remove_all(GWL_Display *display)
|
|||
{
|
||||
const bool on_exit = true;
|
||||
|
||||
/* NOTE(@campbellbarton): Free by slot instead of simply looping over
|
||||
/* NOTE(@ideasman42): Free by slot instead of simply looping over
|
||||
* `display->registry_entry` so the order of freeing is always predictable.
|
||||
* Otherwise global objects would be feed in the order they are registered.
|
||||
* While this works in my tests, it could cause difficult to reproduce bugs
|
||||
|
|
@ -1267,7 +1269,7 @@ static void gwl_registry_entry_remove_all(GWL_Display *display)
|
|||
* so there is no reason to update all other outputs that an output was removed (for e.g.).
|
||||
* Pass as -1 to update all slots.
|
||||
*
|
||||
* NOTE(@campbellbarton): Updating all other items on a single change is typically worth avoiding.
|
||||
* NOTE(@ideasman42): Updating all other items on a single change is typically worth avoiding.
|
||||
* In practice this isn't a problem as so there are so few elements in `display->registry_entry`,
|
||||
* so few use update functions and adding/removal at runtime is rarely called (plugging/unplugging)
|
||||
* hardware for e.g. So while it's possible to store dependency links to avoid unnecessary
|
||||
|
|
@ -1316,7 +1318,7 @@ static void ghost_wl_display_report_error(struct wl_display *display)
|
|||
fprintf(stderr, "The Wayland connection experienced a fatal error: %s\n", strerror(ecode));
|
||||
}
|
||||
|
||||
/* NOTE(@campbellbarton): The application is running,
|
||||
/* NOTE(@ideasman42): The application is running,
|
||||
* however an error closes all windows and most importantly:
|
||||
* shuts down the GPU context (loosing all GPU state - shaders, bind codes etc),
|
||||
* so recovering from this effectively involves restarting.
|
||||
|
|
@ -2968,7 +2970,7 @@ static void gesture_pinch_handle_begin(void *data,
|
|||
if (wl_surface *wl_surface_focus = seat->pointer.wl_surface_window) {
|
||||
win = ghost_wl_surface_user_data(wl_surface_focus);
|
||||
}
|
||||
/* NOTE(@campbellbarton): Blender's use of track-pad coordinates is inconsistent and needs work.
|
||||
/* NOTE(@ideasman42): Blender's use of track-pad coordinates is inconsistent and needs work.
|
||||
* This isn't specific to WAYLAND, in practice they tend to work well enough in most cases.
|
||||
* Some operators scale by the UI scale, some don't.
|
||||
* Even this window scale is not correct because it doesn't account for:
|
||||
|
|
@ -2982,7 +2984,7 @@ static void gesture_pinch_handle_begin(void *data,
|
|||
*/
|
||||
const wl_fixed_t win_scale = win ? win->scale() : 1;
|
||||
|
||||
/* NOTE(@campbellbarton): Scale factors match Blender's operators & default preferences.
|
||||
/* NOTE(@ideasman42): Scale factors match Blender's operators & default preferences.
|
||||
* For these values to work correctly, operator logic will need to be changed not to scale input
|
||||
* by the region size (as with 3D view zoom) or preference for 3D view orbit sensitivity.
|
||||
*
|
||||
|
|
@ -3145,7 +3147,7 @@ static const struct zwp_pointer_gesture_swipe_v1_listener gesture_swipe_listener
|
|||
/* -------------------------------------------------------------------- */
|
||||
/** \name Listener (Touch Seat), #wl_touch_listener
|
||||
*
|
||||
* NOTE(@campbellbarton): It's not clear if this interface is used by popular compositors.
|
||||
* NOTE(@ideasman42): It's not clear if this interface is used by popular compositors.
|
||||
* It looks like GNOME/KDE only support `zwp_pointer_gestures_v1_interface`.
|
||||
* If this isn't used anywhere, it could be removed.
|
||||
* \{ */
|
||||
|
|
@ -3806,7 +3808,7 @@ static xkb_keysym_t xkb_state_key_get_one_sym_without_modifiers(
|
|||
/* Use an empty keyboard state to access key symbol without modifiers. */
|
||||
xkb_keysym_t sym = xkb_state_key_get_one_sym(xkb_state_empty, key);
|
||||
|
||||
/* NOTE(@campbellbarton): Only perform the number-locked lookup as a fallback
|
||||
/* NOTE(@ideasman42): Only perform the number-locked lookup as a fallback
|
||||
* when a number-pad key has been pressed. This is important as some key-maps use number lock
|
||||
* for switching other layers (in particular `de(neo_qwertz)` turns on layer-4), see: T96170.
|
||||
* Alternative solutions could be to inspect the layout however this could get involved
|
||||
|
|
@ -3936,7 +3938,7 @@ static void keyboard_handle_key(void *data,
|
|||
else {
|
||||
/* Key-up from keys that were not repeating cause the repeat timer to pause.
|
||||
*
|
||||
* NOTE(@campbellbarton): This behavior isn't universal, some text input systems will
|
||||
* NOTE(@ideasman42): This behavior isn't universal, some text input systems will
|
||||
* stop the repeat entirely. Choose to pause repeat instead as this is what GTK/WIN32 do,
|
||||
* and it fits better for keyboard input that isn't related to text entry. */
|
||||
timer_action = RESET;
|
||||
|
|
@ -7035,7 +7037,7 @@ bool GHOST_SystemWayland::window_cursor_grab_set(const GHOST_TGrabCursorMode mod
|
|||
UNPACK2(xy_next));
|
||||
wl_surface_commit(wl_surface);
|
||||
|
||||
/* NOTE(@campbellbarton): The new cursor position is a hint,
|
||||
/* NOTE(@ideasman42): The new cursor position is a hint,
|
||||
* it's possible the hint is ignored. It doesn't seem like there is a good way to
|
||||
* know if the hint will be used or not, at least not immediately. */
|
||||
xy_motion[0] = xy_next[0];
|
||||
|
|
@ -7078,7 +7080,7 @@ bool GHOST_SystemWayland::window_cursor_grab_set(const GHOST_TGrabCursorMode mod
|
|||
if (mode != GHOST_kGrabDisable) {
|
||||
if (grab_state_next.use_lock) {
|
||||
if (!grab_state_prev.use_lock) {
|
||||
/* TODO(@campbellbarton): As WAYLAND does not support warping the pointer it may not be
|
||||
/* TODO(@ideasman42): As WAYLAND does not support warping the pointer it may not be
|
||||
* possible to support #GHOST_kGrabWrap by pragmatically settings it's coordinates.
|
||||
* An alternative could be to draw the cursor in software (and hide the real cursor),
|
||||
* or just accept a locked cursor on WAYLAND. */
|
||||
|
|
|
|||
|
|
@ -1080,7 +1080,7 @@ GHOST_EventCursor *GHOST_SystemWin32::processCursorEvent(GHOST_WindowWin32 *wind
|
|||
if (window->getCursorGrabMode() == GHOST_kGrabHide) {
|
||||
window->getClientBounds(bounds);
|
||||
|
||||
/* WARNING(@campbellbarton): The current warping logic fails to warp on every event,
|
||||
/* WARNING(@ideasman42): The current warping logic fails to warp on every event,
|
||||
* so the box needs to small enough not to let the cursor escape the window but large
|
||||
* enough that the cursor isn't being warped every time.
|
||||
* If this was not the case it would be less trouble to simply warp the cursor to the
|
||||
|
|
@ -1179,7 +1179,7 @@ GHOST_EventKey *GHOST_SystemWin32::processKeyEvent(GHOST_WindowWin32 *window, RA
|
|||
GHOST_TKey key = system->hardKey(raw, &key_down);
|
||||
GHOST_EventKey *event;
|
||||
|
||||
/* NOTE(@campbellbarton): key repeat in WIN32 also applies to modifier-keys.
|
||||
/* NOTE(@ideasman42): key repeat in WIN32 also applies to modifier-keys.
|
||||
* Check for this case and filter out modifier-repeat.
|
||||
* Typically keyboard events are *not* filtered as part of GHOST's event handling.
|
||||
* As other GHOST back-ends don't have the behavior, it's simplest not to send them through.
|
||||
|
|
|
|||
|
|
@ -278,7 +278,7 @@ uint8_t GHOST_SystemX11::getNumDisplays() const
|
|||
void GHOST_SystemX11::getMainDisplayDimensions(uint32_t &width, uint32_t &height) const
|
||||
{
|
||||
if (m_display) {
|
||||
/* NOTE(@campbellbarton): for this to work as documented,
|
||||
/* NOTE(@ideasman42): for this to work as documented,
|
||||
* we would need to use Xinerama check r54370 for code that did this,
|
||||
* we've since removed since its not worth the extra dependency. */
|
||||
getAllDisplayDimensions(width, height);
|
||||
|
|
@ -927,7 +927,7 @@ void GHOST_SystemX11::processEvent(XEvent *xe)
|
|||
if (window->getCursorGrabMode() == GHOST_kGrabHide) {
|
||||
window->getClientBounds(bounds);
|
||||
|
||||
/* TODO(@campbellbarton): warp the cursor to `window->getCursorGrabInitPos`,
|
||||
/* TODO(@ideasman42): warp the cursor to `window->getCursorGrabInitPos`,
|
||||
* on every motion event, see: D16557 (alternative fix for T102346). */
|
||||
const int32_t subregion_div = 4; /* One quarter of the region. */
|
||||
const int32_t size[2] = {bounds.getWidth(), bounds.getHeight()};
|
||||
|
|
|
|||
|
|
@ -669,7 +669,7 @@ static void xdg_surface_handle_configure(void *data,
|
|||
GHOST_SystemWayland *system = win->ghost_system;
|
||||
const bool is_main_thread = system->main_thread_id == std::this_thread::get_id();
|
||||
if (!is_main_thread) {
|
||||
/* NOTE(@campbellbarton): this only gets one redraw,
|
||||
/* NOTE(@ideasman42): this only gets one redraw,
|
||||
* I could not find a case where this causes problems. */
|
||||
gwl_window_pending_actions_tag(win, PENDING_FRAME_CONFIGURE);
|
||||
}
|
||||
|
|
@ -774,7 +774,7 @@ GHOST_WindowWayland::GHOST_WindowWayland(GHOST_SystemWayland *system,
|
|||
window_->ghost_window = this;
|
||||
window_->ghost_system = system;
|
||||
|
||||
/* NOTE(@campbellbarton): The scale set here to avoid flickering on startup.
|
||||
/* NOTE(@ideasman42): The scale set here to avoid flickering on startup.
|
||||
* When all monitors use the same scale (which is quite common) there aren't any problems.
|
||||
*
|
||||
* When monitors have different scales there may still be a visible window resize on startup.
|
||||
|
|
@ -1078,7 +1078,7 @@ GHOST_WindowWayland::~GHOST_WindowWayland()
|
|||
|
||||
wl_surface_destroy(window_->wl_surface);
|
||||
|
||||
/* NOTE(@campbellbarton): Flushing will often run the appropriate handlers event
|
||||
/* NOTE(@ideasman42): Flushing will often run the appropriate handlers event
|
||||
* (#wl_surface_listener.leave in particular) to avoid attempted access to the freed surfaces.
|
||||
* This is not fool-proof though, hence the call to #window_surface_unref, see: T99078. */
|
||||
wl_display_flush(system_->wl_display());
|
||||
|
|
|
|||
|
|
@ -1002,11 +1002,11 @@ def unregister_tool(tool_cls):
|
|||
|
||||
# we start with the built-in default mapping
|
||||
def _blender_default_map():
|
||||
import rna_manual_reference as ref_mod
|
||||
ret = (ref_mod.url_manual_prefix, ref_mod.url_manual_mapping)
|
||||
# avoid storing in memory
|
||||
del _sys.modules["rna_manual_reference"]
|
||||
return ret
|
||||
# NOTE(@ideasman42): Avoid importing this as there is no need to keep the lookup table in memory.
|
||||
# As this runs when the user accesses the "Online Manual", the overhead loading the file is acceptable.
|
||||
# In my tests it's under 1/100th of a second loading from a `pyc`.
|
||||
ref_mod = execfile(_os.path.join(_script_base_dir, "modules", "rna_manual_reference.py"))
|
||||
return (ref_mod.url_manual_prefix, ref_mod.url_manual_mapping)
|
||||
|
||||
|
||||
# hooks for doc lookups
|
||||
|
|
|
|||
|
|
@ -338,6 +338,7 @@ class NODE_MT_geometry_node_GEO_MESH_READ(Menu):
|
|||
node_add_menu.add_node_type(layout, "GeometryNodeInputMeshEdgeAngle")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeInputMeshEdgeNeighbors")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeInputMeshEdgeVertices")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeEdgesToFaceGroups")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeInputMeshFaceArea")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeInputMeshFaceNeighbors")
|
||||
node_add_menu.add_node_type(layout, "GeometryNodeMeshFaceSetBoundaries")
|
||||
|
|
|
|||
|
|
@ -1996,7 +1996,7 @@ class SEQUENCER_PT_adjust_sound(SequencerButtonsPanel, Panel):
|
|||
|
||||
split = col.split(factor=0.4)
|
||||
split.alignment = 'RIGHT'
|
||||
split.label(text="Pan", heading_ctxt=i18n_contexts.id_sound)
|
||||
split.label(text="Pan", text_ctxt=i18n_contexts.id_sound)
|
||||
split.prop(strip, "pan", text="")
|
||||
split.enabled = pan_enabled
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -40,7 +40,7 @@ typedef int32_t ft_pix;
|
|||
/* Macros copied from `include/freetype/internal/ftobjs.h`. */
|
||||
|
||||
/**
|
||||
* FIXME(@campbellbarton): Follow rounding from Blender 3.1x and older.
|
||||
* FIXME(@ideasman42): Follow rounding from Blender 3.1x and older.
|
||||
* This is what users will expect and changing this creates wider spaced text.
|
||||
* Use this macro to communicate that rounding should be used, using floor is to avoid
|
||||
* user visible changes, which can be reviewed and handled separately.
|
||||
|
|
|
|||
|
|
@ -2,17 +2,12 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include "BKE_curves.h"
|
||||
|
||||
/** \file
|
||||
* \ingroup bke
|
||||
* \brief Low-level operations for curves.
|
||||
*/
|
||||
|
||||
#include <mutex>
|
||||
|
||||
#include "BLI_bounds_types.hh"
|
||||
#include "BLI_cache_mutex.hh"
|
||||
#include "BLI_generic_virtual_array.hh"
|
||||
#include "BLI_index_mask.hh"
|
||||
#include "BLI_math_matrix_types.hh"
|
||||
|
|
@ -20,12 +15,12 @@
|
|||
#include "BLI_offset_indices.hh"
|
||||
#include "BLI_shared_cache.hh"
|
||||
#include "BLI_span.hh"
|
||||
#include "BLI_task.hh"
|
||||
#include "BLI_vector.hh"
|
||||
#include "BLI_virtual_array.hh"
|
||||
|
||||
#include "BKE_attribute.hh"
|
||||
#include "BKE_attribute_math.hh"
|
||||
#include "BKE_curves.h"
|
||||
|
||||
namespace blender::bke {
|
||||
|
||||
|
|
|
|||
|
|
@ -425,7 +425,7 @@ int set_listbasepointers(struct Main *main, struct ListBase *lb[]);
|
|||
/**
|
||||
* The size of thumbnails (optionally) stored in the `.blend` files header.
|
||||
*
|
||||
* NOTE(@campbellbarton): This is kept small as it's stored uncompressed in the `.blend` file,
|
||||
* NOTE(@ideasman42): This is kept small as it's stored uncompressed in the `.blend` file,
|
||||
* where a larger size would increase the size of every `.blend` file unreasonably.
|
||||
* If we wanted to increase the size, we'd want to use compression (JPEG or similar).
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -229,10 +229,6 @@ void BKE_mesh_material_remap(struct Mesh *me, const unsigned int *remap, unsigne
|
|||
void BKE_mesh_smooth_flag_set(struct Mesh *me, bool use_smooth);
|
||||
void BKE_mesh_auto_smooth_flag_set(struct Mesh *me, bool use_auto_smooth, float auto_smooth_angle);
|
||||
|
||||
/**
|
||||
* Needed after converting a mesh with subsurf optimal display to mesh.
|
||||
*/
|
||||
void BKE_mesh_edges_set_draw_render(struct Mesh *me);
|
||||
|
||||
/**
|
||||
* Used for unit testing; compares two meshes, checking only
|
||||
|
|
|
|||
|
|
@ -145,10 +145,7 @@ void BKE_mesh_convert_mfaces_to_mpolys(struct Mesh *mesh);
|
|||
*/
|
||||
void BKE_mesh_do_versions_convert_mfaces_to_mpolys(struct Mesh *mesh);
|
||||
|
||||
/**
|
||||
* Convert legacy #MFace.edcode to edge #ME_EDGEDRAW.
|
||||
*/
|
||||
void BKE_mesh_calc_edges_legacy(struct Mesh *me, bool use_old);
|
||||
void BKE_mesh_calc_edges_legacy(struct Mesh *me);
|
||||
|
||||
void BKE_mesh_do_versions_cd_flag_init(struct Mesh *mesh);
|
||||
|
||||
|
|
|
|||
|
|
@ -353,6 +353,7 @@ Array<Vector<int>> build_vert_to_edge_map(Span<MEdge> edges, int verts_num);
|
|||
Array<Vector<int>> build_vert_to_poly_map(Span<MPoly> polys, Span<MLoop> loops, int verts_num);
|
||||
Array<Vector<int>> build_vert_to_loop_map(Span<MLoop> loops, int verts_num);
|
||||
Array<Vector<int>> build_edge_to_loop_map(Span<MLoop> loops, int edges_num);
|
||||
Array<Vector<int, 2>> build_edge_to_poly_map(Span<MPoly> polys, Span<MLoop> loops, int edges_num);
|
||||
Vector<Vector<int>> build_edge_to_loop_map_resizable(Span<MLoop> loops, int edges_num);
|
||||
|
||||
inline int poly_loop_prev(const MPoly &poly, int loop_i)
|
||||
|
|
|
|||
|
|
@ -174,6 +174,13 @@ struct MeshRuntime {
|
|||
*/
|
||||
BitVector<> subsurf_face_dot_tags;
|
||||
|
||||
/**
|
||||
* A bit vector the size of the number of edges, set to true for edges that should be drawn in
|
||||
* the viewport. Created by the "Optimimal Display" feature of the subdivision surface modifier.
|
||||
* Otherwise it will be empty.
|
||||
*/
|
||||
BitVector<> subsurf_optimal_display_edges;
|
||||
|
||||
MeshRuntime() = default;
|
||||
~MeshRuntime();
|
||||
|
||||
|
|
|
|||
|
|
@ -1534,6 +1534,7 @@ void BKE_nodetree_remove_layer_n(struct bNodeTree *ntree, struct Scene *scene, i
|
|||
#define GEO_NODE_BLUR_ATTRIBUTE 1190
|
||||
#define GEO_NODE_IMAGE 1191
|
||||
#define GEO_NODE_INTERPOLATE_CURVES 1192
|
||||
#define GEO_NODE_EDGES_TO_FACE_GROUPS 1193
|
||||
|
||||
/** \} */
|
||||
|
||||
|
|
|
|||
|
|
@ -1467,7 +1467,7 @@ static void editbmesh_calc_modifiers(struct Depsgraph *depsgraph,
|
|||
|
||||
/* Add orco coordinates to final and deformed mesh if requested. */
|
||||
if (final_datamask.vmask & CD_MASK_ORCO) {
|
||||
/* FIXME(@campbellbarton): avoid the need to convert to mesh data just to add an orco layer. */
|
||||
/* FIXME(@ideasman42): avoid the need to convert to mesh data just to add an orco layer. */
|
||||
BKE_mesh_wrapper_ensure_mdata(mesh_final);
|
||||
|
||||
add_orco_mesh(ob, em_input, mesh_final, mesh_orco, CD_ORCO);
|
||||
|
|
|
|||
|
|
@ -884,7 +884,7 @@ static void where_am_i(char *fullname, const size_t maxlen, const char *name)
|
|||
void BKE_appdir_program_path_init(const char *argv0)
|
||||
{
|
||||
#ifdef WITH_PYTHON_MODULE
|
||||
/* NOTE(@campbellbarton): Always use `argv[0]` as is, when building as a Python module.
|
||||
/* NOTE(@ideasman42): Always use `argv[0]` as is, when building as a Python module.
|
||||
* Otherwise other methods of detecting the binary that override this argument
|
||||
* which must point to the Python module for data-files to be detected. */
|
||||
STRNCPY(g_app.program_filepath, argv0);
|
||||
|
|
|
|||
|
|
@ -144,7 +144,7 @@ static float color_sample_remove_cost(const struct ColorResampleElem *c)
|
|||
return area;
|
||||
}
|
||||
|
||||
/* TODO(@campbellbarton): create `BLI_math_filter` ? */
|
||||
/* TODO(@ideasman42): create `BLI_math_filter` ? */
|
||||
static float filter_gauss(float x)
|
||||
{
|
||||
const float gaussfac = 1.6f;
|
||||
|
|
|
|||
|
|
@ -1558,7 +1558,7 @@ static void followpath_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *
|
|||
|
||||
/* un-apply scaling caused by path */
|
||||
if ((data->followflag & FOLLOWPATH_RADIUS) == 0) {
|
||||
/* XXX(@campbellbarton): Assume that scale correction means that radius
|
||||
/* XXX(@ideasman42): Assume that scale correction means that radius
|
||||
* will have some scale error in it. */
|
||||
float obsize[3];
|
||||
|
||||
|
|
@ -3835,7 +3835,7 @@ static void clampto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *tar
|
|||
|
||||
unit_m4(targetMatrix);
|
||||
INIT_MINMAX(curveMin, curveMax);
|
||||
/* XXX(@campbellbarton): don't think this is good calling this here because
|
||||
/* XXX(@ideasman42): don't think this is good calling this here because
|
||||
* the other object's data is lazily initializing bounding-box information.
|
||||
* This could cause issues when evaluating from a thread.
|
||||
* If the depsgraph ensures the bound-box is always available, a code-path could
|
||||
|
|
|
|||
|
|
@ -2251,7 +2251,7 @@ static void make_bevel_list_3D_minimum_twist(BevList *bl)
|
|||
int nr;
|
||||
float q[4];
|
||||
const bool is_cyclic = bl->poly != -1;
|
||||
/* NOTE(@campbellbarton): For non-cyclic curves only initialize the first direction
|
||||
/* NOTE(@ideasman42): For non-cyclic curves only initialize the first direction
|
||||
* (via `vec_to_quat`), necessary for symmetry, see T71137.
|
||||
* Otherwise initialize the first and second points before propagating rotation forward.
|
||||
* This is historical as changing this can cause significantly different output.
|
||||
|
|
@ -2480,7 +2480,7 @@ static void make_bevel_list_segment_2D(BevList *bl)
|
|||
|
||||
static void make_bevel_list_2D(BevList *bl)
|
||||
{
|
||||
/* NOTE(@campbellbarton): `bevp->dir` and `bevp->quat` are not needed for beveling but are
|
||||
/* NOTE(@ideasman42): `bevp->dir` and `bevp->quat` are not needed for beveling but are
|
||||
* used when making a path from a 2D curve, therefore they need to be set. */
|
||||
|
||||
BevPoint *bevp0, *bevp1, *bevp2;
|
||||
|
|
|
|||
|
|
@ -6,6 +6,8 @@
|
|||
|
||||
#include <algorithm>
|
||||
|
||||
#include "BLI_task.hh"
|
||||
|
||||
#include "BKE_attribute_math.hh"
|
||||
#include "BKE_curves.hh"
|
||||
|
||||
|
|
|
|||
|
|
@ -4,6 +4,8 @@
|
|||
* \ingroup bke
|
||||
*/
|
||||
|
||||
#include "BLI_task.hh"
|
||||
|
||||
#include "BKE_attribute_math.hh"
|
||||
#include "BKE_curves.hh"
|
||||
|
||||
|
|
|
|||
|
|
@ -62,7 +62,6 @@ static void fill_mesh_topology(const int vert_offset,
|
|||
MEdge &edge = edges[profile_edge_offset + i_ring];
|
||||
edge.v1 = ring_vert_offset + i_profile;
|
||||
edge.v2 = next_ring_vert_offset + i_profile;
|
||||
edge.flag = ME_EDGEDRAW;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -78,7 +77,6 @@ static void fill_mesh_topology(const int vert_offset,
|
|||
MEdge &edge = edges[ring_edge_offset + i_profile];
|
||||
edge.v1 = ring_vert_offset + i_profile;
|
||||
edge.v2 = ring_vert_offset + i_next_profile;
|
||||
edge.flag = ME_EDGEDRAW;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1122,7 +1122,7 @@ void BKE_effectors_apply(ListBase *effectors,
|
|||
float *wind_force,
|
||||
float *impulse)
|
||||
{
|
||||
/* WARNING(@campbellbarton): historic comment?
|
||||
/* WARNING(@ideasman42): historic comment?
|
||||
* Many of these parameters don't exist!
|
||||
*
|
||||
* scene = scene where it runs in, for time and stuff.
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ ImBuf *BKE_icon_geom_rasterize(const struct Icon_Geom *geom, const uint size_x,
|
|||
const uchar(*pos)[2] = geom->coords;
|
||||
const uint *col = (void *)geom->colors;
|
||||
|
||||
/* TODO(@campbellbarton): Currently rasterizes to fixed size, then scales.
|
||||
/* TODO(@ideasman42): Currently rasterizes to fixed size, then scales.
|
||||
* Should rasterize to double size for eg instead. */
|
||||
const int rect_size[2] = {max_ii(256, (int)size_x * 2), max_ii(256, (int)size_y * 2)};
|
||||
|
||||
|
|
|
|||
|
|
@ -797,7 +797,7 @@ IDProperty *IDP_GetProperties(ID *id, const bool create_if_needed)
|
|||
if (create_if_needed) {
|
||||
id->properties = MEM_callocN(sizeof(IDProperty), "IDProperty");
|
||||
id->properties->type = IDP_GROUP;
|
||||
/* NOTE(@campbellbarton): Don't overwrite the data's name and type
|
||||
/* NOTE(@ideasman42): Don't overwrite the data's name and type
|
||||
* some functions might need this if they
|
||||
* don't have a real ID, should be named elsewhere. */
|
||||
// strcpy(id->name, "top_level_group");
|
||||
|
|
|
|||
|
|
@ -121,7 +121,7 @@ void BKE_library_filepath_set(Main *bmain, Library *lib, const char *filepath)
|
|||
/* Not essential but set `filepath_abs` is an absolute copy of value which
|
||||
* is more useful if its kept in sync. */
|
||||
if (BLI_path_is_rel(lib->filepath_abs)) {
|
||||
/* NOTE(@campbellbarton): the file may be unsaved, in this case, setting the
|
||||
/* NOTE(@ideasman42): the file may be unsaved, in this case, setting the
|
||||
* `filepath_abs` on an indirectly linked path is not allowed from the
|
||||
* outliner, and its not really supported but allow from here for now
|
||||
* since making local could cause this to be directly linked.
|
||||
|
|
|
|||
|
|
@ -850,7 +850,7 @@ void BKE_object_material_resize(Main *bmain, Object *ob, const short totcol, boo
|
|||
ob->mat = newmatar;
|
||||
ob->matbits = newmatbits;
|
||||
}
|
||||
/* XXX(@campbellbarton): why not realloc on shrink? */
|
||||
/* XXX(@ideasman42): why not realloc on shrink? */
|
||||
|
||||
ob->totcol = totcol;
|
||||
if (ob->totcol && ob->actcol == 0) {
|
||||
|
|
|
|||
|
|
@ -277,7 +277,7 @@ bool BKE_mball_is_basis(const Object *ob)
|
|||
/* Meta-Ball Basis Notes from Blender-2.5x
|
||||
* =======================================
|
||||
*
|
||||
* NOTE(@campbellbarton): This is a can of worms.
|
||||
* NOTE(@ideasman42): This is a can of worms.
|
||||
*
|
||||
* This really needs a rewrite/refactor its totally broken in anything other than basic cases
|
||||
* Multiple Scenes + Set Scenes & mixing meta-ball basis _should_ work but fails to update the
|
||||
|
|
@ -485,7 +485,7 @@ bool BKE_mball_minmax_ex(
|
|||
copy_v3_v3(centroid, &ml->x);
|
||||
}
|
||||
|
||||
/* TODO(@campbellbarton): non circle shapes cubes etc, probably nobody notices. */
|
||||
/* TODO(@ideasman42): non circle shapes cubes etc, probably nobody notices. */
|
||||
for (int i = -1; i != 3; i += 2) {
|
||||
copy_v3_v3(vec, centroid);
|
||||
add_v3_fl(vec, scale_mb * i);
|
||||
|
|
|
|||
|
|
@ -107,10 +107,12 @@ static void mesh_copy_data(Main *bmain, ID *id_dst, const ID *id_src, const int
|
|||
mesh_dst->runtime->wrapper_type_finalize = mesh_src->runtime->wrapper_type_finalize;
|
||||
mesh_dst->runtime->subsurf_runtime_data = mesh_src->runtime->subsurf_runtime_data;
|
||||
mesh_dst->runtime->cd_mask_extra = mesh_src->runtime->cd_mask_extra;
|
||||
/* Copy face dot tags, since meshes may be duplicated after a subsurf modifier or node, but we
|
||||
* still need to be able to draw face center vertices. The tags may be cleared explicitly when
|
||||
* the topology is changed. */
|
||||
/* Copy face dot tags and edge tags, since meshes may be duplicated after a subsurf modifier or
|
||||
* node, but we still need to be able to draw face center vertices and "optimal edges"
|
||||
* differently. The tags may be cleared explicitly when the topology is changed. */
|
||||
mesh_dst->runtime->subsurf_face_dot_tags = mesh_src->runtime->subsurf_face_dot_tags;
|
||||
mesh_dst->runtime->subsurf_optimal_display_edges =
|
||||
mesh_src->runtime->subsurf_optimal_display_edges;
|
||||
if ((mesh_src->id.tag & LIB_TAG_NO_MAIN) == 0) {
|
||||
/* This is a direct copy of a main mesh, so for now it has the same topology. */
|
||||
mesh_dst->runtime->deformed_only = true;
|
||||
|
|
|
|||
|
|
@ -146,7 +146,6 @@ static void serialize_and_initialize_deduplicated_edges(MutableSpan<EdgeMap> edg
|
|||
/* Initialize new edge. */
|
||||
new_edge.v1 = item.key.v_low;
|
||||
new_edge.v2 = item.key.v_high;
|
||||
new_edge.flag = ME_EDGEDRAW;
|
||||
}
|
||||
item.value.index = new_edge_index;
|
||||
new_edge_index++;
|
||||
|
|
|
|||
|
|
@ -121,7 +121,7 @@ static void make_edges_mdata_extend(Mesh &mesh)
|
|||
BLI_edgehashIterator_getKey(ehi, &medge->v1, &medge->v2);
|
||||
BLI_edgehashIterator_setValue(ehi, POINTER_FROM_UINT(e_index));
|
||||
|
||||
medge->flag = ME_EDGEDRAW;
|
||||
medge->flag = 0;
|
||||
}
|
||||
BLI_edgehashIterator_free(ehi);
|
||||
|
||||
|
|
@ -223,7 +223,6 @@ static Mesh *mesh_nurbs_displist_to_mesh(const Curve *cu, const ListBase *dispba
|
|||
for (b = 1; b < dl->nr; b++) {
|
||||
edges[dst_edge].v1 = startvert + ofs + b - 1;
|
||||
edges[dst_edge].v2 = startvert + ofs + b;
|
||||
edges[dst_edge].flag = ME_EDGEDRAW;
|
||||
|
||||
dst_edge++;
|
||||
}
|
||||
|
|
@ -250,7 +249,6 @@ static Mesh *mesh_nurbs_displist_to_mesh(const Curve *cu, const ListBase *dispba
|
|||
else {
|
||||
edges[dst_edge].v2 = startvert + ofs + b + 1;
|
||||
}
|
||||
edges[dst_edge].flag = ME_EDGEDRAW;
|
||||
dst_edge++;
|
||||
}
|
||||
}
|
||||
|
|
@ -662,14 +660,6 @@ void BKE_mesh_from_pointcloud(const PointCloud *pointcloud, Mesh *me)
|
|||
&pointcloud->pdata, &me->vdata, CD_MASK_PROP_ALL, CD_DUPLICATE, pointcloud->totpoint);
|
||||
}
|
||||
|
||||
void BKE_mesh_edges_set_draw_render(Mesh *mesh)
|
||||
{
|
||||
MutableSpan<MEdge> edges = mesh->edges_for_write();
|
||||
for (int i = 0; i < mesh->totedge; i++) {
|
||||
edges[i].flag |= ME_EDGEDRAW;
|
||||
}
|
||||
}
|
||||
|
||||
void BKE_pointcloud_to_mesh(Main *bmain, Depsgraph *depsgraph, Scene * /*scene*/, Object *ob)
|
||||
{
|
||||
BLI_assert(ob->type == OB_POINTCLOUD);
|
||||
|
|
|
|||
|
|
@ -89,7 +89,6 @@ static void mesh_calc_edges_mdata(const MVert * /*allvert*/,
|
|||
int totface,
|
||||
int /*totloop*/,
|
||||
int totpoly,
|
||||
const bool use_old,
|
||||
MEdge **r_medge,
|
||||
int *r_totedge)
|
||||
{
|
||||
|
|
@ -156,9 +155,6 @@ static void mesh_calc_edges_mdata(const MVert * /*allvert*/,
|
|||
if (ed->v1 != (ed + 1)->v1 || ed->v2 != (ed + 1)->v2) {
|
||||
med->v1 = ed->v1;
|
||||
med->v2 = ed->v2;
|
||||
if (use_old == false || ed->is_draw) {
|
||||
med->flag = ME_EDGEDRAW;
|
||||
}
|
||||
|
||||
/* order is swapped so extruding this edge as a surface won't flip face normals
|
||||
* with cyclic curves */
|
||||
|
|
@ -175,7 +171,6 @@ static void mesh_calc_edges_mdata(const MVert * /*allvert*/,
|
|||
/* last edge */
|
||||
med->v1 = ed->v1;
|
||||
med->v2 = ed->v2;
|
||||
med->flag = ME_EDGEDRAW;
|
||||
|
||||
MEM_freeN(edsort);
|
||||
|
||||
|
|
@ -206,7 +201,7 @@ static void mesh_calc_edges_mdata(const MVert * /*allvert*/,
|
|||
*r_totedge = totedge_final;
|
||||
}
|
||||
|
||||
void BKE_mesh_calc_edges_legacy(Mesh *me, const bool use_old)
|
||||
void BKE_mesh_calc_edges_legacy(Mesh *me)
|
||||
{
|
||||
using namespace blender;
|
||||
MEdge *medge;
|
||||
|
|
@ -224,7 +219,6 @@ void BKE_mesh_calc_edges_legacy(Mesh *me, const bool use_old)
|
|||
me->totface,
|
||||
loops.size(),
|
||||
polys.size(),
|
||||
use_old,
|
||||
&medge,
|
||||
&totedge);
|
||||
|
||||
|
|
|
|||
|
|
@ -610,6 +610,20 @@ Array<Vector<int>> build_edge_to_loop_map(const Span<MLoop> loops, const int edg
|
|||
return map;
|
||||
}
|
||||
|
||||
Array<Vector<int, 2>> build_edge_to_poly_map(const Span<MPoly> polys,
|
||||
const Span<MLoop> loops,
|
||||
const int edges_num)
|
||||
{
|
||||
Array<Vector<int, 2>> map(edges_num);
|
||||
for (const int64_t i : polys.index_range()) {
|
||||
const MPoly &poly = polys[i];
|
||||
for (const MLoop &loop : loops.slice(poly.loopstart, poly.totloop)) {
|
||||
map[loop.e].append(int(i));
|
||||
}
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
Vector<Vector<int>> build_edge_to_loop_map_resizable(const Span<MLoop> loops, const int edges_num)
|
||||
{
|
||||
Vector<Vector<int>> map(edges_num);
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ static int compare_v2_classify(const float uv_a[2], const float uv_b[2])
|
|||
if (uv_a[0] == uv_b[0] && uv_a[1] == uv_b[1]) {
|
||||
return CMP_EQUAL;
|
||||
}
|
||||
/* NOTE(@campbellbarton): that the ULP value is the primary value used to compare relative
|
||||
/* NOTE(@ideasman42): that the ULP value is the primary value used to compare relative
|
||||
* values as the absolute value doesn't account for float precision at difference scales.
|
||||
* - For subdivision-surface ULP of 3 is sufficient,
|
||||
* although this value is extremely small.
|
||||
|
|
|
|||
|
|
@ -230,6 +230,7 @@ void BKE_mesh_runtime_clear_geometry(Mesh *mesh)
|
|||
mesh->runtime->loose_edges_cache.tag_dirty();
|
||||
mesh->runtime->looptris_cache.tag_dirty();
|
||||
mesh->runtime->subsurf_face_dot_tags.clear_and_shrink();
|
||||
mesh->runtime->subsurf_optimal_display_edges.clear_and_shrink();
|
||||
if (mesh->runtime->shrinkwrap_data) {
|
||||
BKE_shrinkwrap_boundary_data_free(mesh->runtime->shrinkwrap_data);
|
||||
}
|
||||
|
|
@ -245,6 +246,7 @@ void BKE_mesh_tag_edges_split(struct Mesh *mesh)
|
|||
free_subdiv_ccg(*mesh->runtime);
|
||||
mesh->runtime->loose_edges_cache.tag_dirty();
|
||||
mesh->runtime->subsurf_face_dot_tags.clear_and_shrink();
|
||||
mesh->runtime->subsurf_optimal_display_edges.clear_and_shrink();
|
||||
if (mesh->runtime->shrinkwrap_data) {
|
||||
BKE_shrinkwrap_boundary_data_free(mesh->runtime->shrinkwrap_data);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -573,7 +573,7 @@ void BKE_mesh_calc_loop_tangents(Mesh *me_eval,
|
|||
const char (*tangent_names)[MAX_CUSTOMDATA_LAYER_NAME],
|
||||
int tangent_names_len)
|
||||
{
|
||||
/* TODO(@campbellbarton): store in Mesh.runtime to avoid recalculation. */
|
||||
/* TODO(@ideasman42): store in Mesh.runtime to avoid recalculation. */
|
||||
short tangent_mask = 0;
|
||||
BKE_mesh_calc_loop_tangent_ex(
|
||||
BKE_mesh_vert_positions(me_eval),
|
||||
|
|
|
|||
|
|
@ -1356,8 +1356,6 @@ void BKE_mesh_calc_edges_tessface(Mesh *mesh)
|
|||
for (int i = 0; BLI_edgesetIterator_isDone(ehi) == false;
|
||||
BLI_edgesetIterator_step(ehi), i++, med++, index++) {
|
||||
BLI_edgesetIterator_getKey(ehi, &med->v1, &med->v2);
|
||||
|
||||
med->flag = ME_EDGEDRAW;
|
||||
*index = ORIGINDEX_NONE;
|
||||
}
|
||||
BLI_edgesetIterator_free(ehi);
|
||||
|
|
|
|||
|
|
@ -2342,8 +2342,10 @@ bNode *node_copy_with_mapping(bNodeTree *dst_tree,
|
|||
node_dst->typeinfo->copyfunc_api(&ptr, &node_src);
|
||||
}
|
||||
|
||||
/* Reset the declaration of the new node. */
|
||||
nodeDeclarationEnsure(dst_tree, node_dst);
|
||||
/* Reset the declaration of the new node in real tree. */
|
||||
if (dst_tree != nullptr) {
|
||||
nodeDeclarationEnsure(dst_tree, node_dst);
|
||||
}
|
||||
|
||||
return node_dst;
|
||||
}
|
||||
|
|
@ -3617,6 +3619,8 @@ bool nodeDeclarationEnsureOnOutdatedNode(bNodeTree *ntree, bNode *node)
|
|||
return false;
|
||||
}
|
||||
if (node->typeinfo->declare_dynamic) {
|
||||
BLI_assert(ntree != nullptr);
|
||||
BLI_assert(node != nullptr);
|
||||
node->runtime->declaration = new blender::nodes::NodeDeclaration();
|
||||
blender::nodes::build_node_declaration_dynamic(*ntree, *node, *node->runtime->declaration);
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -2432,7 +2432,7 @@ ParticleSystem *BKE_object_copy_particlesystem(ParticleSystem *psys, const int f
|
|||
psysn->pointcache = BKE_ptcache_copy_list(&psysn->ptcaches, &psys->ptcaches, flag);
|
||||
}
|
||||
|
||||
/* XXX(@campbellbarton): from reading existing code this seems correct but intended usage of
|
||||
/* XXX(@ideasman42): from reading existing code this seems correct but intended usage of
|
||||
* point-cache should with cloth should be added in 'ParticleSystem'. */
|
||||
if (psysn->clmd) {
|
||||
psysn->clmd->point_cache = psysn->pointcache;
|
||||
|
|
|
|||
|
|
@ -1382,7 +1382,7 @@ void BKE_ocean_bake(struct Ocean *o,
|
|||
void (*update_cb)(void *, float progress, int *cancel),
|
||||
void *update_cb_data)
|
||||
{
|
||||
/* NOTE(@campbellbarton): some of these values remain uninitialized unless certain options
|
||||
/* NOTE(@ideasman42): some of these values remain uninitialized unless certain options
|
||||
* are enabled, take care that #BKE_ocean_eval_ij() initializes a member before use. */
|
||||
OceanResult ocr;
|
||||
|
||||
|
|
@ -1437,7 +1437,7 @@ void BKE_ocean_bake(struct Ocean *o,
|
|||
rgb_to_rgba_unit_alpha(&ibuf_disp->rect_float[4 * (res_x * y + x)], ocr.disp);
|
||||
|
||||
if (o->_do_jacobian) {
|
||||
/* TODO(@campbellbarton): cleanup unused code. */
|
||||
/* TODO(@ideasman42): cleanup unused code. */
|
||||
|
||||
float /* r, */ /* UNUSED */ pr = 0.0f, foam_result;
|
||||
float neg_disp, neg_eplus;
|
||||
|
|
|
|||
|
|
@ -5470,7 +5470,7 @@ void BKE_particle_system_blend_read_lib(BlendLibReader *reader,
|
|||
BLO_read_id_address(reader, id->lib, &psys->target_ob);
|
||||
|
||||
if (psys->clmd) {
|
||||
/* XXX(@campbellbarton): from reading existing code this seems correct but intended usage
|
||||
/* XXX(@ideasman42): from reading existing code this seems correct but intended usage
|
||||
* of point-cache with cloth should be added in #ParticleSystem. */
|
||||
psys->clmd->point_cache = psys->pointcache;
|
||||
psys->clmd->ptcaches.first = psys->clmd->ptcaches.last = nullptr;
|
||||
|
|
|
|||
|
|
@ -967,7 +967,7 @@ void psys_get_birth_coords(
|
|||
float tmat[3][3];
|
||||
|
||||
/* NOTE: utan_local is not taken from 'utan', we calculate from rot_vec/vtan. */
|
||||
/* NOTE(@campbellbarton): it looks like rotation phase may be applied twice
|
||||
/* NOTE(@ideasman42): it looks like rotation phase may be applied twice
|
||||
* (once with vtan, again below) however this isn't the case. */
|
||||
float *rot_vec_local = tmat[0];
|
||||
float *vtan_local = tmat[1];
|
||||
|
|
|
|||
|
|
@ -2588,7 +2588,7 @@ static bool check_rendered_viewport_visible(Main *bmain)
|
|||
return false;
|
||||
}
|
||||
|
||||
/* TODO(@campbellbarton): shouldn't we be able to use 'DEG_get_view_layer' here?
|
||||
/* TODO(@ideasman42): shouldn't we be able to use 'DEG_get_view_layer' here?
|
||||
* Currently this is nullptr on load, so don't. */
|
||||
static void prepare_mesh_for_viewport_render(Main *bmain,
|
||||
const Scene *scene,
|
||||
|
|
|
|||
|
|
@ -536,6 +536,10 @@ static bool subdiv_mesh_topology_info(const SubdivForeachContext *foreach_contex
|
|||
subdiv_mesh_prepare_accumulator(subdiv_context, num_vertices);
|
||||
subdiv_context->subdiv_mesh->runtime->subsurf_face_dot_tags.clear();
|
||||
subdiv_context->subdiv_mesh->runtime->subsurf_face_dot_tags.resize(num_vertices);
|
||||
if (subdiv_context->settings->use_optimal_display) {
|
||||
subdiv_context->subdiv_mesh->runtime->subsurf_optimal_display_edges.clear();
|
||||
subdiv_context->subdiv_mesh->runtime->subsurf_optimal_display_edges.resize(num_edges);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -784,15 +788,10 @@ static void subdiv_mesh_vertex_inner(const SubdivForeachContext *foreach_context
|
|||
* \{ */
|
||||
|
||||
static void subdiv_copy_edge_data(SubdivMeshContext *ctx,
|
||||
MEdge *subdiv_edge,
|
||||
const int subdiv_edge_index,
|
||||
const int coarse_edge_index)
|
||||
{
|
||||
const int subdiv_edge_index = subdiv_edge - ctx->subdiv_edges;
|
||||
if (coarse_edge_index == ORIGINDEX_NONE) {
|
||||
subdiv_edge->flag = 0;
|
||||
if (!ctx->settings->use_optimal_display) {
|
||||
subdiv_edge->flag |= ME_EDGEDRAW;
|
||||
}
|
||||
if (ctx->edge_origindex != nullptr) {
|
||||
ctx->edge_origindex[subdiv_edge_index] = ORIGINDEX_NONE;
|
||||
}
|
||||
|
|
@ -800,7 +799,9 @@ static void subdiv_copy_edge_data(SubdivMeshContext *ctx,
|
|||
}
|
||||
CustomData_copy_data(
|
||||
&ctx->coarse_mesh->edata, &ctx->subdiv_mesh->edata, coarse_edge_index, subdiv_edge_index, 1);
|
||||
subdiv_edge->flag |= ME_EDGEDRAW;
|
||||
if (ctx->settings->use_optimal_display) {
|
||||
ctx->subdiv_mesh->runtime->subsurf_optimal_display_edges[subdiv_edge_index].set();
|
||||
}
|
||||
}
|
||||
|
||||
static void subdiv_mesh_edge(const SubdivForeachContext *foreach_context,
|
||||
|
|
@ -814,7 +815,7 @@ static void subdiv_mesh_edge(const SubdivForeachContext *foreach_context,
|
|||
SubdivMeshContext *ctx = static_cast<SubdivMeshContext *>(foreach_context->user_data);
|
||||
MEdge *subdiv_medge = ctx->subdiv_edges;
|
||||
MEdge *subdiv_edge = &subdiv_medge[subdiv_edge_index];
|
||||
subdiv_copy_edge_data(ctx, subdiv_edge, coarse_edge_index);
|
||||
subdiv_copy_edge_data(ctx, subdiv_edge_index, coarse_edge_index);
|
||||
subdiv_edge->v1 = subdiv_v1;
|
||||
subdiv_edge->v2 = subdiv_v2;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -893,7 +893,7 @@ static void ccgDM_copyFinalVertArray(DerivedMesh *dm, float (*r_positions)[3])
|
|||
int x;
|
||||
|
||||
for (x = 1; x < edgeSize - 1; x++) {
|
||||
/* NOTE(@campbellbarton): This gives errors with `--debug-fpe` the normals don't seem to be
|
||||
/* NOTE(@ideasman42): This gives errors with `--debug-fpe` the normals don't seem to be
|
||||
* unit length. This is most likely caused by edges with no faces which are now zeroed out,
|
||||
* see comment in: `ccgSubSurf__calcVertNormals()`. */
|
||||
vd = static_cast<CCGElem *>(ccgSubSurf_getEdgeData(ss, e, x));
|
||||
|
|
@ -928,7 +928,6 @@ static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *medge)
|
|||
int edgeSize = ccgSubSurf_getEdgeSize(ss);
|
||||
uint i = 0;
|
||||
short *edgeFlags = ccgdm->edgeFlags;
|
||||
const short ed_interior_flag = ccgdm->drawInteriorEdges ? ME_EDGEDRAW : 0;
|
||||
|
||||
totface = ccgSubSurf_getNumFaces(ss);
|
||||
for (index = 0; index < totface; index++) {
|
||||
|
|
@ -940,7 +939,7 @@ static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *medge)
|
|||
ccgDM_to_MEdge(&medge[i++],
|
||||
getFaceIndex(ss, f, S, x, 0, edgeSize, gridSize),
|
||||
getFaceIndex(ss, f, S, x + 1, 0, edgeSize, gridSize),
|
||||
ed_interior_flag);
|
||||
0);
|
||||
}
|
||||
|
||||
for (x = 1; x < gridSize - 1; x++) {
|
||||
|
|
@ -948,11 +947,11 @@ static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *medge)
|
|||
ccgDM_to_MEdge(&medge[i++],
|
||||
getFaceIndex(ss, f, S, x, y, edgeSize, gridSize),
|
||||
getFaceIndex(ss, f, S, x, y + 1, edgeSize, gridSize),
|
||||
ed_interior_flag);
|
||||
0);
|
||||
ccgDM_to_MEdge(&medge[i++],
|
||||
getFaceIndex(ss, f, S, y, x, edgeSize, gridSize),
|
||||
getFaceIndex(ss, f, S, y + 1, x, edgeSize, gridSize),
|
||||
ed_interior_flag);
|
||||
0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -967,12 +966,9 @@ static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *medge)
|
|||
|
||||
if (edgeFlags) {
|
||||
if (edgeIdx != -1) {
|
||||
ed_flag |= ((edgeFlags[index] & ME_SEAM) | ME_EDGEDRAW);
|
||||
ed_flag |= (edgeFlags[index] & ME_SEAM);
|
||||
}
|
||||
}
|
||||
else {
|
||||
ed_flag |= ME_EDGEDRAW;
|
||||
}
|
||||
|
||||
for (x = 0; x < edgeSize - 1; x++) {
|
||||
ccgDM_to_MEdge(&medge[i++],
|
||||
|
|
|
|||
|
|
@ -757,7 +757,7 @@ template<typename T> detail::Quaternion<T> normalized_to_quat_fast(const MatBase
|
|||
}
|
||||
}
|
||||
else {
|
||||
/* NOTE(@campbellbarton): A zero matrix will fall through to this block,
|
||||
/* NOTE(@ideasman42): A zero matrix will fall through to this block,
|
||||
* needed so a zero scaled matrices to return a quaternion without rotation, see: T101848.
|
||||
*/
|
||||
const T trace = 1.0f + mat[0][0] + mat[1][1] + mat[2][2];
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ struct ScanFillEdge *BLI_scanfill_edge_add(ScanFillContext *sf_ctx,
|
|||
struct ScanFillVert *v2);
|
||||
|
||||
enum {
|
||||
/* NOTE(@campbellbarton): using #BLI_SCANFILL_CALC_REMOVE_DOUBLES
|
||||
/* NOTE(@ideasman42): using #BLI_SCANFILL_CALC_REMOVE_DOUBLES
|
||||
* Assumes ordered edges, otherwise we risk an eternal loop
|
||||
* removing double verts. */
|
||||
BLI_SCANFILL_CALC_REMOVE_DOUBLES = (1 << 1),
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
*/
|
||||
|
||||
#ifdef __GNUC__
|
||||
/* NOTE(@campbellbarton): CLANG behaves slightly differently to GCC,
|
||||
/* NOTE(@ideasman42): CLANG behaves slightly differently to GCC,
|
||||
* these can be enabled but do so carefully as they can introduce build-errors. */
|
||||
# if !defined(__clang__)
|
||||
# pragma GCC diagnostic error "-Wsign-compare"
|
||||
|
|
|
|||
|
|
@ -1667,7 +1667,7 @@ bool isect_ray_tri_v3(const float ray_origin[3],
|
|||
float *r_lambda,
|
||||
float r_uv[2])
|
||||
{
|
||||
/* NOTE(@campbellbarton): these values were 0.000001 in 2.4x but for projection snapping on
|
||||
/* NOTE(@ideasman42): these values were 0.000001 in 2.4x but for projection snapping on
|
||||
* a human head `(1BU == 1m)`, subdivision-surface level 2, this gave many errors. */
|
||||
const float epsilon = 0.00000001f;
|
||||
float p[3], s[3], e1[3], e2[3], q[3];
|
||||
|
|
@ -3773,7 +3773,7 @@ void barycentric_weights_v2_quad(const float v1[2],
|
|||
const float co[2],
|
||||
float w[4])
|
||||
{
|
||||
/* NOTE(@campbellbarton): fabsf() here is not needed for convex quads
|
||||
/* NOTE(@ideasman42): fabsf() here is not needed for convex quads
|
||||
* (and not used in #interp_weights_poly_v2).
|
||||
* But in the case of concave/bow-tie quads for the mask rasterizer it
|
||||
* gives unreliable results without adding `absf()`. If this becomes an issue for more general
|
||||
|
|
|
|||
|
|
@ -334,7 +334,7 @@ void mat3_normalized_to_quat_fast(float q[4], const float mat[3][3])
|
|||
}
|
||||
}
|
||||
else {
|
||||
/* NOTE(@campbellbarton): A zero matrix will fall through to this block,
|
||||
/* NOTE(@ideasman42): A zero matrix will fall through to this block,
|
||||
* needed so a zero scaled matrices to return a quaternion without rotation, see: T101848. */
|
||||
const float trace = 1.0f + mat[0][0] + mat[1][1] + mat[2][2];
|
||||
float s = 2.0f * sqrtf(trace);
|
||||
|
|
|
|||
|
|
@ -329,7 +329,7 @@ void **BLI_smallhash_iternew_p(const SmallHash *sh, SmallHashIter *iter, uintptr
|
|||
/** \name Debugging & Introspection
|
||||
* \{ */
|
||||
|
||||
/* NOTE(@campbellbarton): useful for debugging but may not be intended for general use. */
|
||||
/* NOTE(@ideasman42): useful for debugging but may not be intended for general use. */
|
||||
#if 0
|
||||
void BLI_smallhash_print(SmallHash *sh)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -402,7 +402,7 @@ bool BLI_str_quoted_substr_range(const char *__restrict str,
|
|||
return true;
|
||||
}
|
||||
|
||||
/* NOTE(@campbellbarton): in principal it should be possible to access a quoted string
|
||||
/* NOTE(@ideasman42): in principal it should be possible to access a quoted string
|
||||
* with an arbitrary size, currently all callers for this functionality
|
||||
* happened to use a fixed size buffer, so only #BLI_str_quoted_substr is needed. */
|
||||
#if 0
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ static const size_t utf8_skip_data[256] = {
|
|||
|
||||
ptrdiff_t BLI_str_utf8_invalid_byte(const char *str, size_t length)
|
||||
{
|
||||
/* NOTE(@campbellbarton): from libswish3, originally called u8_isvalid(),
|
||||
/* NOTE(@ideasman42): from libswish3, originally called u8_isvalid(),
|
||||
* modified to return the index of the bad character (byte index not UTF).
|
||||
* http://svn.swish-e.org/libswish3/trunk/src/libswish3/utf8.c r3044.
|
||||
*
|
||||
|
|
@ -403,7 +403,7 @@ int BLI_str_utf8_char_width_safe(const char *p)
|
|||
|
||||
/* copied from glib's gutf8.c, added 'Err' arg */
|
||||
|
||||
/* NOTE(@campbellbarton): glib uses uint for unicode, best we do the same,
|
||||
/* NOTE(@ideasman42): glib uses uint for unicode, best we do the same,
|
||||
* though we don't typedef it. */
|
||||
|
||||
#define UTF8_COMPUTE(Char, Mask, Len, Err) \
|
||||
|
|
|
|||
|
|
@ -288,7 +288,7 @@ void BLO_expand_id(BlendExpander *expander, struct ID *id);
|
|||
* This function ensures that reports are printed,
|
||||
* in the case of library linking errors this is important!
|
||||
*
|
||||
* NOTE(@campbellbarton) a kludge but better than doubling up on prints,
|
||||
* NOTE(@ideasman42) a kludge but better than doubling up on prints,
|
||||
* we could alternatively have a versions of a report function which forces printing.
|
||||
*/
|
||||
void BLO_reportf_wrap(struct BlendFileReadReport *reports,
|
||||
|
|
|
|||
|
|
@ -3779,15 +3779,6 @@ void blo_do_versions_300(FileData *fd, Library * /*lib*/, Main *bmain)
|
|||
}
|
||||
}
|
||||
|
||||
if (!MAIN_VERSION_ATLEAST(bmain, 305, 1)) {
|
||||
/* Reset edge visibility flag, since the base is meant to be "true" for original meshes. */
|
||||
LISTBASE_FOREACH (Mesh *, mesh, &bmain->meshes) {
|
||||
for (MEdge &edge : mesh->edges_for_write()) {
|
||||
edge.flag |= ME_EDGEDRAW;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!MAIN_VERSION_ATLEAST(bmain, 305, 2)) {
|
||||
LISTBASE_FOREACH (MovieClip *, clip, &bmain->movieclips) {
|
||||
MovieTracking *tracking = &clip->tracking;
|
||||
|
|
|
|||
|
|
@ -1467,7 +1467,7 @@ void blo_do_versions_pre250(FileData *fd, Library *lib, Main *bmain)
|
|||
|
||||
for (me = bmain->meshes.first; me; me = me->id.next) {
|
||||
if (!me->medge) {
|
||||
BKE_mesh_calc_edges_legacy(me, true); /* true = use #MFace.edcode. */
|
||||
BKE_mesh_calc_edges_legacy(me);
|
||||
}
|
||||
else {
|
||||
BKE_mesh_strip_loose_faces(me);
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ using blender::StringRef;
|
|||
|
||||
static char bm_edge_flag_from_mflag(const short mflag)
|
||||
{
|
||||
return ((mflag & ME_SEAM) ? BM_ELEM_SEAM : 0) | ((mflag & ME_EDGEDRAW) ? BM_ELEM_DRAW : 0);
|
||||
return ((mflag & ME_SEAM) ? BM_ELEM_SEAM : 0) | BM_ELEM_DRAW;
|
||||
}
|
||||
static char bm_face_flag_from_mflag(const char mflag)
|
||||
{
|
||||
|
|
@ -124,7 +124,7 @@ static short bm_edge_flag_to_mflag(const BMEdge *e)
|
|||
{
|
||||
const char hflag = e->head.hflag;
|
||||
|
||||
return ((hflag & BM_ELEM_SEAM) ? ME_SEAM : 0) | ((hflag & BM_ELEM_DRAW) ? ME_EDGEDRAW : 0);
|
||||
return (hflag & BM_ELEM_SEAM) ? ME_SEAM : 0;
|
||||
}
|
||||
static char bm_face_flag_to_mflag(const BMFace *f)
|
||||
{
|
||||
|
|
@ -859,7 +859,7 @@ static void bm_to_mesh_shape(BMesh *bm,
|
|||
((keyi = BM_ELEM_CD_GET_INT(eve, cd_shape_keyindex_offset)) != ORIGINDEX_NONE) &&
|
||||
(keyi < currkey->totelem)) {
|
||||
/* Reconstruct keys via vertices original key indices.
|
||||
* WARNING(@campbellbarton): `currkey->data` is known to be unreliable as the edit-mesh
|
||||
* WARNING(@ideasman42): `currkey->data` is known to be unreliable as the edit-mesh
|
||||
* coordinates may be flushed back to the shape-key when exporting or rendering.
|
||||
* This is a last resort! If this branch is running as part of regular usage
|
||||
* it can be considered a bug. */
|
||||
|
|
@ -1420,15 +1420,6 @@ static void bm_to_mesh_edges(const BMesh &bm,
|
|||
dst_edge.v1 = BM_elem_index_get(src_edge.v1);
|
||||
dst_edge.v2 = BM_elem_index_get(src_edge.v2);
|
||||
dst_edge.flag = bm_edge_flag_to_mflag(&src_edge);
|
||||
|
||||
/* Handle this differently to editmode switching; only enable draw for single user
|
||||
* edges rather than calculating angle. */
|
||||
if ((dst_edge.flag & ME_EDGEDRAW) == 0) {
|
||||
if (src_edge.l && src_edge.l == src_edge.l->radial_next) {
|
||||
dst_edge.flag |= ME_EDGEDRAW;
|
||||
}
|
||||
}
|
||||
|
||||
CustomData_from_bmesh_block(&bm.edata, &mesh.edata, src_edge.head.data, edge_i);
|
||||
}
|
||||
if (!select_edge.is_empty()) {
|
||||
|
|
|
|||
|
|
@ -82,7 +82,6 @@ void BM_mesh_bm_to_me(struct Main *bmain,
|
|||
* - Ignore shape-keys.
|
||||
* - Ignore vertex-parents.
|
||||
* - Ignore selection history.
|
||||
* - Uses simpler method to calculate #ME_EDGEDRAW
|
||||
* - Uses #CD_MASK_DERIVEDMESH instead of #CD_MASK_MESH.
|
||||
*
|
||||
* \note Was `cddm_from_bmesh_ex` in 2.7x, removed `MFace` support.
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
#include "intern/bmesh_operators_private.h" /* own include */
|
||||
|
||||
/**
|
||||
* TODO(@campbellbarton): Many connected edge loops can cause an error attempting
|
||||
* TODO(@ideasman42): Many connected edge loops can cause an error attempting
|
||||
* to create faces with duplicate vertices. While this needs to be investigated,
|
||||
* it's simple enough to check for this case, see: T102232.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@
|
|||
|
||||
void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
|
||||
{
|
||||
/* NOTE(@campbellbarton): doing the best thing here isn't always easy create vs dissolve,
|
||||
/* NOTE(@ideasman42): doing the best thing here isn't always easy create vs dissolve,
|
||||
* its nice to support but it _really_ gives issues we might have to not call dissolve. */
|
||||
|
||||
BMOIter oiter;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
namespace blender::compositor {
|
||||
|
||||
#define USE_FORCE_BILINEAR
|
||||
/* XXX(@campbellbarton): ignore input and use default from old compositor,
|
||||
/* XXX(@ideasman42): ignore input and use default from old compositor,
|
||||
* could become an option like the transform node.
|
||||
*
|
||||
* NOTE: use bilinear because bicubic makes fuzzy even when not scaling at all (1:1)
|
||||
|
|
|
|||
|
|
@ -507,7 +507,7 @@ void EEVEE_motion_blur_cache_finish(EEVEE_Data *vedata)
|
|||
if (!GPU_batch_vertbuf_has(batch, vbo)) {
|
||||
/* Currently, the code assumes that all objects that share the same mesh in the
|
||||
* current frame also share the same mesh on other frames. */
|
||||
GPU_batch_vertbuf_add_ex(batch, vbo, false);
|
||||
GPU_batch_vertbuf_add(batch, vbo, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,8 +21,8 @@
|
|||
|
||||
namespace blender::eevee {
|
||||
|
||||
struct ShadowDirectional;
|
||||
struct ShadowPunctual;
|
||||
class ShadowDirectional;
|
||||
class ShadowPunctual;
|
||||
|
||||
using namespace draw;
|
||||
|
||||
|
|
@ -631,7 +631,7 @@ struct LightData {
|
|||
float2 spot_size_inv;
|
||||
/** Spot angle tangent. */
|
||||
float spot_tan;
|
||||
/** Reuse for directionnal lod bias. */
|
||||
/** Reuse for directional LOD bias. */
|
||||
#define _clipmap_lod_bias spot_tan
|
||||
/** Power depending on shader type. */
|
||||
float diffuse_power;
|
||||
|
|
@ -643,12 +643,12 @@ struct LightData {
|
|||
/** Directional : Near clip distance. Float stored as int for atomic operations. */
|
||||
int clip_near;
|
||||
int clip_far;
|
||||
/** Directional : Clip-map lod range to avoid sampling outside of valid range. */
|
||||
/** Directional : Clip-map LOD range to avoid sampling outside of valid range. */
|
||||
int clipmap_lod_min;
|
||||
int clipmap_lod_max;
|
||||
/** Index of the first tile-map. */
|
||||
int tilemap_index;
|
||||
/** Directional : Offset of the lod min in lod min tile units. */
|
||||
/** Directional : Offset of the LOD min in LOD min tile units. */
|
||||
int2 clipmap_base_offset;
|
||||
/** Punctual & Directional : Normal matrix packed for automatic bias. */
|
||||
float2 normal_mat_packed;
|
||||
|
|
@ -758,7 +758,7 @@ struct ShadowTileData {
|
|||
uint2 page;
|
||||
/** Page index inside pages_cached_buf. Only valid if `is_cached` is true. */
|
||||
uint cache_index;
|
||||
/** Lod pointed to LOD 0 tile page. (cubemap only) */
|
||||
/** LOD pointed to LOD 0 tile page. (cube-map only). */
|
||||
uint lod;
|
||||
/** If the tile is needed for rendering. */
|
||||
bool is_used;
|
||||
|
|
@ -811,11 +811,11 @@ static inline ShadowTileDataPacked shadow_tile_pack(ShadowTileData tile)
|
|||
data |= (tile.page.y & 63u) << 6u;
|
||||
data |= (tile.lod & 7u) << 12u;
|
||||
data |= (tile.cache_index & 4095u) << 15u;
|
||||
data |= (tile.is_used ? SHADOW_IS_USED : 0);
|
||||
data |= (tile.is_allocated ? SHADOW_IS_ALLOCATED : 0);
|
||||
data |= (tile.is_cached ? SHADOW_IS_CACHED : 0);
|
||||
data |= (tile.is_rendered ? SHADOW_IS_RENDERED : 0);
|
||||
data |= (tile.do_update ? SHADOW_DO_UPDATE : 0);
|
||||
data |= (tile.is_used ? uint(SHADOW_IS_USED) : 0);
|
||||
data |= (tile.is_allocated ? uint(SHADOW_IS_ALLOCATED) : 0);
|
||||
data |= (tile.is_cached ? uint(SHADOW_IS_CACHED) : 0);
|
||||
data |= (tile.is_rendered ? uint(SHADOW_IS_RENDERED) : 0);
|
||||
data |= (tile.do_update ? uint(SHADOW_DO_UPDATE) : 0);
|
||||
return data;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -137,7 +137,7 @@ void ShadowTileMap::debug_draw() const
|
|||
ShadowTileMapPool::ShadowTileMapPool()
|
||||
{
|
||||
free_indices.reserve(SHADOW_MAX_TILEMAP);
|
||||
/* Reverse order to help debugging (first allocated tilemap will get 0). */
|
||||
/* Reverse order to help debugging (first allocated tile-map will get 0). */
|
||||
for (int i = SHADOW_MAX_TILEMAP - 1; i >= 0; i--) {
|
||||
free_indices.append(i * SHADOW_TILEDATA_PER_TILEMAP);
|
||||
}
|
||||
|
|
@ -154,7 +154,7 @@ ShadowTileMapPool::ShadowTileMapPool()
|
|||
ShadowTileMap *ShadowTileMapPool::acquire()
|
||||
{
|
||||
if (free_indices.is_empty()) {
|
||||
/* Grow the tilemap buffer. See `end_sync`. */
|
||||
/* Grow the tile-map buffer. See `end_sync`. */
|
||||
for (auto i : IndexRange(free_indices.size(), SHADOW_MAX_TILEMAP)) {
|
||||
free_indices.append(i * SHADOW_TILEDATA_PER_TILEMAP);
|
||||
}
|
||||
|
|
@ -180,7 +180,7 @@ void ShadowTileMapPool::end_sync(ShadowModule &module)
|
|||
tiles_data.resize(needed_tilemap_capacity * SHADOW_TILEDATA_PER_TILEMAP);
|
||||
tilemaps_clip.resize(needed_tilemap_capacity);
|
||||
/* We reallocated the tile-map buffer, discarding all the data it contained.
|
||||
* We need to re-init the page heaps. */
|
||||
* We need to re-initialize the page heaps. */
|
||||
module.do_full_update = true;
|
||||
}
|
||||
|
||||
|
|
@ -191,8 +191,8 @@ void ShadowTileMapPool::end_sync(ShadowModule &module)
|
|||
Span<uint> newly_unused_indices = free_indices.as_span().slice(last_free_len,
|
||||
newly_unused_count);
|
||||
for (uint index : newly_unused_indices) {
|
||||
/* Push a dummy tilemap to a unused tilemap buffer. It is then processed through the some of
|
||||
* the setup steps to release the pages. */
|
||||
/* Push a dummy tile-map to a unused tile-map buffer. It is then processed through the some
|
||||
* of the setup steps to release the pages. */
|
||||
ShadowTileMapData tilemap_data = {};
|
||||
tilemap_data.tiles_index = index;
|
||||
tilemap_data.clip_data_index = 0;
|
||||
|
|
@ -261,7 +261,7 @@ void ShadowPunctual::end_sync(Light &light, float lod_bias)
|
|||
obmat_tmp[0][3] = obmat_tmp[1][3] = obmat_tmp[2][3] = 0.0f;
|
||||
obmat_tmp[3][3] = 1.0f;
|
||||
|
||||
/* Acquire missing tilemaps. */
|
||||
/* Acquire missing tile-maps. */
|
||||
while (tilemaps_.size() < tilemaps_needed_) {
|
||||
tilemaps_.append(tilemap_pool.acquire());
|
||||
}
|
||||
|
|
@ -311,23 +311,23 @@ void ShadowPunctual::end_sync(Light &light, float lod_bias)
|
|||
/* -------------------------------------------------------------------- */
|
||||
/** \name Directional Shadow Maps
|
||||
*
|
||||
* In order to inprove shadow map density, we switch between two tilemap distribution mode.
|
||||
* One is beter suited for large FOV (clipmap), the other for really small FOV or Orthographic
|
||||
* In order to improve shadow map density, we switch between two tile-map distribution mode.
|
||||
* One is beater suited for large FOV (clip-map), the other for really small FOV or Orthographic
|
||||
* projections (cascade).
|
||||
*
|
||||
* Clipmap distribution centers a number of log2 sized tilemaps around the view position.
|
||||
* Clip-map distribution centers a number of log2 sized tile-maps around the view position.
|
||||
* https://developer.nvidia.com/gpugems/gpugems2/part-i-geometric-complexity/chapter-2-terrain-rendering-using-gpu-based-geometry
|
||||
*
|
||||
* Cascade distribution puts tilemaps along the frustum projection to the light space.
|
||||
* Cascade distribution puts tile-maps along the frustum projection to the light space.
|
||||
* https://developer.nvidia.com/gpugems/gpugems3/part-ii-light-and-shadows/chapter-10-parallel-split-shadow-maps-programmable-gpus
|
||||
*
|
||||
* We choose to distribute cascades linearly to acheive uniform density and simplify lookup.
|
||||
* Using clipmap instead of cascades for perspective view also allows for better caching.
|
||||
* We choose to distribute cascades linearly to achieve uniform density and simplify lookup.
|
||||
* Using clip-map instead of cascades for perspective view also allows for better caching.
|
||||
* \{ */
|
||||
|
||||
eShadowProjectionType ShadowDirectional::directional_distribution_type_get(const Camera &camera)
|
||||
{
|
||||
/* TODO(fclem): Enable the cascade projection if the fov is tiny in perspective mode. */
|
||||
/* TODO(fclem): Enable the cascade projection if the FOV is tiny in perspective mode. */
|
||||
return camera.is_perspective() ? SHADOW_PROJECTION_CLIPMAP : SHADOW_PROJECTION_CASCADE;
|
||||
}
|
||||
|
||||
|
|
@ -347,24 +347,24 @@ void ShadowDirectional::cascade_tilemaps_distribution_near_far_points(const Came
|
|||
float3x3(object_mat_.view<3, 3>());
|
||||
}
|
||||
|
||||
/* \note All tilemaps are meant to have the same LOD but we still return a range starting at the
|
||||
/* \note All tile-maps are meant to have the same LOD but we still return a range starting at the
|
||||
* unique LOD. */
|
||||
IndexRange ShadowDirectional::cascade_level_range(const Camera &camera, float lod_bias)
|
||||
{
|
||||
using namespace blender::math;
|
||||
|
||||
/* 16 is arbitrary. To avoid too much tilemap per directional lights. */
|
||||
/* 16 is arbitrary. To avoid too much tile-map per directional lights. */
|
||||
const int max_tilemap_per_shadows = 16;
|
||||
const CameraData &cam_data = camera.data_get();
|
||||
|
||||
float3 near_point, far_point;
|
||||
cascade_tilemaps_distribution_near_far_points(camera, near_point, far_point);
|
||||
|
||||
/* This gives the maximum resolution in depth we can have with a fixed set of tilemaps. Gives
|
||||
/* This gives the maximum resolution in depth we can have with a fixed set of tile-maps. Gives
|
||||
* the best results when view direction is orthogonal to the light direction. */
|
||||
float depth_range_in_shadow_space = distance(far_point.xy(), near_point.xy());
|
||||
float min_depth_tilemap_size = 2 * (depth_range_in_shadow_space / max_tilemap_per_shadows);
|
||||
/* This allow coverage of the whole view with a single tilemap if camera forward is colinear
|
||||
/* This allow coverage of the whole view with a single tile-map if camera forward is colinear
|
||||
* with the light direction. */
|
||||
float min_diagonal_tilemap_size = cam_data.screen_diagonal_length;
|
||||
|
||||
|
|
@ -373,28 +373,28 @@ IndexRange ShadowDirectional::cascade_level_range(const Camera &camera, float lo
|
|||
min_diagonal_tilemap_size *= cam_data.clip_far / cam_data.clip_near;
|
||||
}
|
||||
|
||||
/* Allow better tilemap usage without missing pages near end of view. */
|
||||
/* Allow better tile-map usage without missing pages near end of view. */
|
||||
lod_bias += 0.5f;
|
||||
/* Level of detail (or size) of every tilemaps of this light. */
|
||||
/* Level of detail (or size) of every tile-maps of this light. */
|
||||
int lod_level = ceil(log2(max_ff(min_depth_tilemap_size, min_diagonal_tilemap_size)) + lod_bias);
|
||||
|
||||
/* Tilemaps "rotate" around the first one so their effective range is only half their size. */
|
||||
/* Tile-maps "rotate" around the first one so their effective range is only half their size. */
|
||||
float per_tilemap_coverage = ShadowDirectional::coverage_get(lod_level) * 0.5f;
|
||||
/* Number of tilemaps needed to cover the whole view. */
|
||||
/* Number of tile-maps needed to cover the whole view. */
|
||||
/* Note: floor + 0.5 to avoid 0 when parallel. */
|
||||
int tilemap_len = ceil(0.5f + depth_range_in_shadow_space / per_tilemap_coverage);
|
||||
return IndexRange(lod_level, tilemap_len);
|
||||
}
|
||||
|
||||
/**
|
||||
* Distribute tilemaps in a linear pattern along camera forward vector instead of a clipmap
|
||||
* Distribute tile-maps in a linear pattern along camera forward vector instead of a clipmap
|
||||
* centered on camera position.
|
||||
*/
|
||||
void ShadowDirectional::cascade_tilemaps_distribution(Light &light, const Camera &camera)
|
||||
{
|
||||
using namespace blender::math;
|
||||
|
||||
/* All tilemaps use the first level size. */
|
||||
/* All tile-maps use the first level size. */
|
||||
float half_size = ShadowDirectional::coverage_get(levels_range.first()) / 2.0f;
|
||||
float tile_size = ShadowDirectional::tile_size_get(levels_range.first());
|
||||
|
||||
|
|
@ -407,14 +407,14 @@ void ShadowDirectional::cascade_tilemaps_distribution(Light &light, const Camera
|
|||
/* Offset for smooth level transitions. */
|
||||
light.object_mat.location() = near_point;
|
||||
|
||||
/* Offset in tiles from the origin to the center of the first tilemaps. */
|
||||
/* Offset in tiles from the origin to the center of the first tile-maps. */
|
||||
int2 origin_offset = int2(round(float2(near_point) / tile_size));
|
||||
/* Offset in tiles between the first andlod the last tilemaps. */
|
||||
/* Offset in tiles between the first andlod the last tile-maps. */
|
||||
int2 offset_vector = int2(round(farthest_tilemap_center / tile_size));
|
||||
|
||||
light.clipmap_base_offset = (offset_vector * (1 << 16)) / max_ii(levels_range.size() - 1, 1);
|
||||
|
||||
/* \note: cascade_level_range starts the range at the unique LOD to apply to all tilemaps. */
|
||||
/* \note: cascade_level_range starts the range at the unique LOD to apply to all tile-maps. */
|
||||
int level = levels_range.first();
|
||||
for (int i : IndexRange(levels_range.size())) {
|
||||
ShadowTileMap *tilemap = tilemaps_[i];
|
||||
|
|
@ -433,8 +433,8 @@ void ShadowDirectional::cascade_tilemaps_distribution(Light &light, const Camera
|
|||
|
||||
light.type = LIGHT_SUN_ORTHO;
|
||||
|
||||
/* Not really clipmaps, but this is in order to make light_tilemap_max_get() work and determine
|
||||
* the scalling. */
|
||||
/* Not really clip-maps, but this is in order to make #light_tilemap_max_get() work and determine
|
||||
* the scaling. */
|
||||
light.clipmap_lod_min = levels_range.first();
|
||||
light.clipmap_lod_max = levels_range.last();
|
||||
|
||||
|
|
@ -505,7 +505,7 @@ void ShadowDirectional::clipmap_tilemaps_distribution(Light &light,
|
|||
for (int lod : IndexRange(levels_range.size() - 1)) {
|
||||
/* Since offset can only differ by one tile from the higher level, we can compress that as a
|
||||
* single integer where one bit contains offset between 2 levels. Then a single bit shift in
|
||||
* the shader gives the number of tile to offset in the given tilemap space. However we need
|
||||
* the shader gives the number of tile to offset in the given tile-map space. However we need
|
||||
* also the sign of the offset for each level offset. To this end, we split the negative
|
||||
* offsets to a separate int.
|
||||
* Recovering the offset with: (pos_offset >> lod) - (neg_offset >> lod). */
|
||||
|
|
@ -583,7 +583,7 @@ void ShadowDirectional::end_sync(Light &light, const Camera &camera, float lod_b
|
|||
clipmap_level_range(camera);
|
||||
|
||||
if (levels_range != levels_new) {
|
||||
/* Acquire missing tilemaps. */
|
||||
/* Acquire missing tile-maps. */
|
||||
IndexRange isect_range = levels_new.intersect(levels_range);
|
||||
int64_t before_range = isect_range.start() - levels_new.start();
|
||||
int64_t after_range = levels_new.one_after_last() - isect_range.one_after_last();
|
||||
|
|
@ -666,7 +666,7 @@ void ShadowModule::init()
|
|||
inst_.info = "Error: Could not allocate shadow atlas. Most likely out of GPU memory.";
|
||||
}
|
||||
|
||||
/* Read end of the swapchain to avoid stall. */
|
||||
/* Read end of the swap-chain to avoid stall. */
|
||||
{
|
||||
if (inst_.sampling.finished_viewport()) {
|
||||
/* Swap enough to read the last one. */
|
||||
|
|
@ -769,7 +769,7 @@ void ShadowModule::sync_object(const ObjectHandle &handle,
|
|||
|
||||
void ShadowModule::end_sync()
|
||||
{
|
||||
/* Delete unused shadows first to release tilemaps that could be reused for new lights. */
|
||||
/* Delete unused shadows first to release tile-maps that could be reused for new lights. */
|
||||
for (Light &light : inst_.lights.light_map_.values()) {
|
||||
if (!light.used || !enabled_) {
|
||||
light.shadow_discard_safe(*this);
|
||||
|
|
@ -782,7 +782,7 @@ void ShadowModule::end_sync()
|
|||
}
|
||||
}
|
||||
|
||||
/* Allocate new tilemaps and fill shadow data of the lights. */
|
||||
/* Allocate new tile-maps and fill shadow data of the lights. */
|
||||
tilemap_pool.tilemaps_data.clear();
|
||||
for (Light &light : inst_.lights.light_map_.values()) {
|
||||
if (light.directional != nullptr) {
|
||||
|
|
@ -831,7 +831,7 @@ void ShadowModule::end_sync()
|
|||
/* Clear tiles to not reference any page. */
|
||||
tilemap_pool.tiles_data.clear_to_zero();
|
||||
|
||||
/* Clear tilemap clip buffer. */
|
||||
/* Clear tile-map clip buffer. */
|
||||
union {
|
||||
ShadowTileMapClip clip;
|
||||
int4 i;
|
||||
|
|
@ -877,7 +877,7 @@ void ShadowModule::end_sync()
|
|||
sub.barrier(GPU_BARRIER_SHADER_STORAGE);
|
||||
}
|
||||
{
|
||||
/** Clear usage bits. Tag update from the tilemap for sun shadow clip-maps shifting. */
|
||||
/** Clear usage bits. Tag update from the tile-map for sun shadow clip-maps shifting. */
|
||||
PassSimple::Sub &sub = pass.sub("Init");
|
||||
sub.shader_set(inst_.shaders.static_shader_get(SHADOW_TILEMAP_INIT));
|
||||
sub.bind_ssbo("tilemaps_buf", tilemap_pool.tilemaps_data);
|
||||
|
|
@ -1120,15 +1120,15 @@ void ShadowModule::set_view(View &view)
|
|||
tile_update_remains = false;
|
||||
}
|
||||
else {
|
||||
/* This provoke a GPU/CPU sync. Avoid it if we are sure that all tilemaps will be rendered in
|
||||
* a single iteration. */
|
||||
/* This provoke a GPU/CPU sync. Avoid it if we are sure that all tile-maps will be rendered
|
||||
* in a single iteration. */
|
||||
bool enough_tilemap_for_single_iteration = tilemap_pool.tilemaps_data.size() <=
|
||||
SHADOW_VIEW_MAX;
|
||||
if (enough_tilemap_for_single_iteration) {
|
||||
tile_update_remains = false;
|
||||
}
|
||||
else {
|
||||
/* Readback and check if there is still tilemap to update. */
|
||||
/* Read back and check if there is still tile-map to update. */
|
||||
tile_update_remains = false;
|
||||
statistics_buf_.current().read();
|
||||
ShadowStatistics stats = statistics_buf_.current();
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ struct ShadowTileMapPool {
|
|||
Vector<uint> free_indices;
|
||||
/** Pool containing shadow tile structure on CPU. */
|
||||
Pool<ShadowTileMap> tilemap_pool;
|
||||
/** Sorted descriptions for each tilemap in the pool. Updated each frame. */
|
||||
/** Sorted descriptions for each tile-map in the pool. Updated each frame. */
|
||||
ShadowTileMapDataBuf tilemaps_data = {"tilemaps_data"};
|
||||
/** Previously used tile-maps that needs to release their tiles/pages. Updated each frame. */
|
||||
ShadowTileMapDataBuf tilemaps_unused = {"tilemaps_unused"};
|
||||
|
|
@ -190,7 +190,7 @@ class ShadowModule {
|
|||
Map<ObjectKey, ShadowObject> objects_;
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Tilemap Management
|
||||
/** \name Tile-map Management
|
||||
* \{ */
|
||||
|
||||
PassSimple tilemap_setup_ps_ = {"TilemapSetup"};
|
||||
|
|
@ -214,7 +214,7 @@ class ShadowModule {
|
|||
StorageArrayBuffer<uint, SHADOW_MAX_PAGE> clear_page_buf_ = {"clear_page_buf"};
|
||||
|
||||
int3 dispatch_depth_scan_size_;
|
||||
/* Ratio between tilemap pixel world "radius" and film pixel world "radius". */
|
||||
/* Ratio between tile-map pixel world "radius" and film pixel world "radius". */
|
||||
float tilemap_projection_ratio_;
|
||||
|
||||
/* Statistics that are read back to CPU after a few frame (to avoid stall). */
|
||||
|
|
@ -230,7 +230,7 @@ class ShadowModule {
|
|||
/** Atlas containing all physical pages. */
|
||||
Texture atlas_tx_ = {"shadow_atlas_tx_"};
|
||||
|
||||
/** Pool of unallocated pages waiting to be assigned to specific tiles in the tilemap atlas. */
|
||||
/** Pool of unallocated pages waiting to be assigned to specific tiles in the tile-map atlas. */
|
||||
ShadowPageHeapBuf pages_free_data_ = {"PagesFreeBuf"};
|
||||
/** Pool of cached tiles waiting to be reused. */
|
||||
ShadowPageCacheBuf pages_cached_data_ = {"PagesCachedBuf"};
|
||||
|
|
@ -259,7 +259,7 @@ class ShadowModule {
|
|||
64,
|
||||
nullptr,
|
||||
SHADOW_TILEMAP_LOD + 1};
|
||||
/** An empty frame-buffer (no attachment) the size of a whole tilemap. */
|
||||
/** An empty frame-buffer (no attachment) the size of a whole tile-map. */
|
||||
Framebuffer render_fb_;
|
||||
|
||||
/** \} */
|
||||
|
|
@ -416,7 +416,7 @@ class ShadowDirectional : public NonCopyable, NonMovable {
|
|||
*/
|
||||
void end_sync(Light &light, const Camera &camera, float lod_bias);
|
||||
|
||||
/* Return coverage of the whole tilemap in world unit. */
|
||||
/* Return coverage of the whole tile-map in world unit. */
|
||||
static float coverage_get(int lvl)
|
||||
{
|
||||
/* This function should be kept in sync with shadow_directional_level(). */
|
||||
|
|
@ -424,7 +424,7 @@ class ShadowDirectional : public NonCopyable, NonMovable {
|
|||
return exp2(lvl);
|
||||
}
|
||||
|
||||
/* Return coverage of a single tile for a tilemap of this LOD in world unit. */
|
||||
/* Return coverage of a single tile for a tile-map of this LOD in world unit. */
|
||||
static float tile_size_get(int lvl)
|
||||
{
|
||||
return coverage_get(lvl) / SHADOW_TILEMAP_RES;
|
||||
|
|
@ -441,8 +441,8 @@ class ShadowDirectional : public NonCopyable, NonMovable {
|
|||
float3 &near_point,
|
||||
float3 &far_point);
|
||||
|
||||
/* Choose between clipmap and cascade distribution of shadowmap precision depending on the camera
|
||||
* projection type and bounds. */
|
||||
/* Choose between clip-map and cascade distribution of shadow-map precision depending on the
|
||||
* camera projection type and bounds. */
|
||||
static eShadowProjectionType directional_distribution_type_get(const Camera &camera);
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -2229,7 +2229,7 @@ static void draw_armature_edit(ArmatureDrawContext *ctx)
|
|||
const bool show_text = DRW_state_show_text();
|
||||
|
||||
const Object *ob_orig = DEG_get_original_object(ob);
|
||||
/* FIXME(@campbellbarton): We should be able to use the CoW object,
|
||||
/* FIXME(@ideasman42): We should be able to use the CoW object,
|
||||
* however the active bone isn't updated. Long term solution is an 'EditArmature' struct.
|
||||
* for now we can draw from the original armature. See: T66773. */
|
||||
// bArmature *arm = ob->data;
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ void main()
|
|||
|
||||
if (lineStyle == OVERLAY_UV_LINE_STYLE_OUTLINE) {
|
||||
#ifdef USE_EDGE_SELECT
|
||||
/* TODO(@campbellbarton): The current wire-edit color contrast enough against the selection.
|
||||
/* TODO(@ideasman42): The current wire-edit color contrast enough against the selection.
|
||||
* Look into changing the default theme color instead of reducing contrast with edge-select. */
|
||||
inner_color = (geom_out.selectionFac != 0.0) ? colorEdgeSelect : (colorWireEdit * 0.5);
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -904,10 +904,10 @@ static void gpencil_edit_batches_ensure(Object *ob, GpencilBatchCache *cache, in
|
|||
|
||||
/* Create the batches */
|
||||
cache->edit_points_batch = GPU_batch_create(GPU_PRIM_POINTS, cache->vbo, nullptr);
|
||||
GPU_batch_vertbuf_add(cache->edit_points_batch, cache->edit_vbo);
|
||||
GPU_batch_vertbuf_add(cache->edit_points_batch, cache->edit_vbo, false);
|
||||
|
||||
cache->edit_lines_batch = GPU_batch_create(GPU_PRIM_LINE_STRIP, cache->vbo, nullptr);
|
||||
GPU_batch_vertbuf_add(cache->edit_lines_batch, cache->edit_vbo);
|
||||
GPU_batch_vertbuf_add(cache->edit_lines_batch, cache->edit_vbo, false);
|
||||
}
|
||||
|
||||
/* Curve Handles and Points for Editing. */
|
||||
|
|
@ -941,11 +941,11 @@ static void gpencil_edit_batches_ensure(Object *ob, GpencilBatchCache *cache, in
|
|||
|
||||
cache->edit_curve_handles_batch = GPU_batch_create(
|
||||
GPU_PRIM_LINES, cache->edit_curve_vbo, nullptr);
|
||||
GPU_batch_vertbuf_add(cache->edit_curve_handles_batch, cache->edit_curve_vbo);
|
||||
GPU_batch_vertbuf_add(cache->edit_curve_handles_batch, cache->edit_curve_vbo, false);
|
||||
|
||||
cache->edit_curve_points_batch = GPU_batch_create(
|
||||
GPU_PRIM_POINTS, cache->edit_curve_vbo, nullptr);
|
||||
GPU_batch_vertbuf_add(cache->edit_curve_points_batch, cache->edit_curve_vbo);
|
||||
GPU_batch_vertbuf_add(cache->edit_curve_points_batch, cache->edit_curve_vbo, false);
|
||||
}
|
||||
|
||||
gpd->flag &= ~GP_DATA_CACHE_IS_DIRTY;
|
||||
|
|
|
|||
|
|
@ -197,7 +197,7 @@ static void drw_volume_wireframe_cb(
|
|||
GPU_PRIM_LINES, cache->face_wire.pos_nor_in_order, ibo, GPU_BATCH_OWNS_INDEX);
|
||||
}
|
||||
|
||||
GPU_batch_vertbuf_add_ex(cache->face_wire.batch, vbo_wiredata, true);
|
||||
GPU_batch_vertbuf_add(cache->face_wire.batch, vbo_wiredata, true);
|
||||
}
|
||||
|
||||
GPUBatch *DRW_volume_batch_cache_get_wireframes_face(Volume *volume)
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ BLI_INLINE void DRW_vbo_request(GPUBatch *batch, GPUVertBuf **vbo)
|
|||
}
|
||||
if (batch != NULL) {
|
||||
/* HACK we set VBO's that may not yet be valid. */
|
||||
GPU_batch_vertbuf_add(batch, *vbo);
|
||||
GPU_batch_vertbuf_add(batch, *vbo, false);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -226,11 +226,11 @@ void DRW_instance_buffer_finish(DRWInstanceDataList *idatalist)
|
|||
GPU_batch_copy(batch, geom);
|
||||
if (inst_batch != NULL) {
|
||||
for (int i = 0; i < GPU_BATCH_INST_VBO_MAX_LEN && inst_batch->verts[i]; i++) {
|
||||
GPU_batch_instbuf_add_ex(batch, inst_batch->verts[i], false);
|
||||
GPU_batch_instbuf_add(batch, inst_batch->verts[i], false);
|
||||
}
|
||||
}
|
||||
else {
|
||||
GPU_batch_instbuf_add_ex(batch, inst_buf, false);
|
||||
GPU_batch_instbuf_add(batch, inst_buf, false);
|
||||
}
|
||||
/* Add reference to avoid comparing pointers (in DRW_temp_batch_request) that could
|
||||
* potentially be the same. This will delay the freeing of the GPUVertBuf itself. */
|
||||
|
|
|
|||
|
|
@ -1303,10 +1303,10 @@ struct PBVHBatches {
|
|||
int vbo_i = get_vbo_index(vbo);
|
||||
|
||||
batch.vbos.append(vbo_i);
|
||||
GPU_batch_vertbuf_add_ex(batch.tris, vbo->vert_buf, false);
|
||||
GPU_batch_vertbuf_add(batch.tris, vbo->vert_buf, false);
|
||||
|
||||
if (batch.lines) {
|
||||
GPU_batch_vertbuf_add_ex(batch.lines, vbo->vert_buf, false);
|
||||
GPU_batch_vertbuf_add(batch.lines, vbo->vert_buf, false);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -60,15 +60,8 @@ static void extract_edge_fac_init(const MeshRenderData *mr,
|
|||
|
||||
if (mr->extract_type == MR_EXTRACT_MESH) {
|
||||
data->edge_loop_count = MEM_cnew_array<uint8_t>(mr->edge_len, __func__);
|
||||
|
||||
/* HACK(@fclem): Detecting the need for edge render.
|
||||
* We could have a flag in the mesh instead or check the modifier stack. */
|
||||
const MEdge *med = mr->medge;
|
||||
for (int e_index = 0; e_index < mr->edge_len; e_index++, med++) {
|
||||
if ((med->flag & ME_EDGEDRAW) == 0) {
|
||||
data->use_edge_render = true;
|
||||
break;
|
||||
}
|
||||
if (!mr->me->runtime->subsurf_optimal_display_edges.is_empty()) {
|
||||
data->use_edge_render = true;
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
|
@ -109,6 +102,7 @@ static void extract_edge_fac_iter_poly_mesh(const MeshRenderData *mr,
|
|||
void *_data)
|
||||
{
|
||||
MeshExtract_EdgeFac_Data *data = static_cast<MeshExtract_EdgeFac_Data *>(_data);
|
||||
const BitVector<> &optimal_display_edges = mr->me->runtime->subsurf_optimal_display_edges;
|
||||
|
||||
const MLoop *mloop = mr->mloop;
|
||||
const int ml_index_end = mp->loopstart + mp->totloop;
|
||||
|
|
@ -116,8 +110,7 @@ static void extract_edge_fac_iter_poly_mesh(const MeshRenderData *mr,
|
|||
const MLoop *ml = &mloop[ml_index];
|
||||
|
||||
if (data->use_edge_render) {
|
||||
const MEdge *med = &mr->medge[ml->e];
|
||||
data->vbo_data[ml_index] = (med->flag & ME_EDGEDRAW) ? 255 : 0;
|
||||
data->vbo_data[ml_index] = optimal_display_edges[ml->e] ? 255 : 0;
|
||||
}
|
||||
else {
|
||||
|
||||
|
|
|
|||
|
|
@ -4373,6 +4373,53 @@ static bool achannel_is_being_renamed(const bAnimContext *ac,
|
|||
return false;
|
||||
}
|
||||
|
||||
float ANIM_UI_get_keyframe_scale_factor(void)
|
||||
{
|
||||
bTheme *btheme = UI_GetTheme();
|
||||
const float yscale_fac = btheme->space_action.keyframe_scale_fac;
|
||||
|
||||
/* clamp to avoid problems with uninitialized values... */
|
||||
if (yscale_fac < 0.1f) {
|
||||
return 1.0f;
|
||||
}
|
||||
return yscale_fac;
|
||||
}
|
||||
|
||||
float ANIM_UI_get_channel_height(void)
|
||||
{
|
||||
return 0.8f * ANIM_UI_get_keyframe_scale_factor() * U.widget_unit;
|
||||
}
|
||||
|
||||
float ANIM_UI_get_channel_skip(void)
|
||||
{
|
||||
return 0.1f * U.widget_unit;
|
||||
}
|
||||
|
||||
float ANIM_UI_get_first_channel_top(View2D *v2d)
|
||||
{
|
||||
return UI_view2d_scale_get_y(v2d) * -UI_TIME_SCRUB_MARGIN_Y - ANIM_UI_get_channel_skip();
|
||||
}
|
||||
|
||||
float ANIM_UI_get_channel_step(void)
|
||||
{
|
||||
return ANIM_UI_get_channel_height() + ANIM_UI_get_channel_skip();
|
||||
}
|
||||
|
||||
float ANIM_UI_get_channels_total_height(View2D *v2d, const int item_count)
|
||||
{
|
||||
return -ANIM_UI_get_first_channel_top(v2d) + ANIM_UI_get_channel_step() * (item_count + 1);
|
||||
}
|
||||
|
||||
float ANIM_UI_get_channel_name_width(void)
|
||||
{
|
||||
return 10 * U.widget_unit;
|
||||
}
|
||||
|
||||
float ANIM_UI_get_channel_button_width(void)
|
||||
{
|
||||
return 0.8f * U.widget_unit;
|
||||
}
|
||||
|
||||
void ANIM_channel_draw(
|
||||
bAnimContext *ac, bAnimListElem *ale, float yminc, float ymaxc, size_t channel_index)
|
||||
{
|
||||
|
|
@ -4566,7 +4613,8 @@ void ANIM_channel_draw(
|
|||
}
|
||||
|
||||
/* check if there's enough space for the toggles if the sliders are drawn too */
|
||||
if (!(draw_sliders) || (BLI_rcti_size_x(&v2d->mask) > ACHANNEL_BUTTON_WIDTH / 2)) {
|
||||
if (!(draw_sliders) ||
|
||||
(BLI_rcti_size_x(&v2d->mask) > ANIM_UI_get_channel_button_width() / 2)) {
|
||||
/* protect... */
|
||||
if (acf->has_setting(ac, ale, ACHANNEL_SETTING_PROTECT)) {
|
||||
offset += ICON_WIDTH;
|
||||
|
|
@ -5279,7 +5327,8 @@ void ANIM_channel_draw_widgets(const bContext *C,
|
|||
}
|
||||
|
||||
/* check if there's enough space for the toggles if the sliders are drawn too */
|
||||
if (!(draw_sliders) || (BLI_rcti_size_x(&v2d->mask) > ACHANNEL_BUTTON_WIDTH / 2)) {
|
||||
if (!(draw_sliders) ||
|
||||
(BLI_rcti_size_x(&v2d->mask) > ANIM_UI_get_channel_button_width() / 2)) {
|
||||
/* protect... */
|
||||
if (acf->has_setting(ac, ale, ACHANNEL_SETTING_PROTECT)) {
|
||||
offset -= ICON_WIDTH;
|
||||
|
|
|
|||
|
|
@ -2718,7 +2718,7 @@ static void box_select_anim_channels(bAnimContext *ac, rcti *rect, short selectm
|
|||
ymax = NLACHANNEL_FIRST_TOP(ac);
|
||||
}
|
||||
else {
|
||||
ymax = ACHANNEL_FIRST_TOP(ac);
|
||||
ymax = ANIM_UI_get_first_channel_top(v2d);
|
||||
}
|
||||
|
||||
/* loop over data, doing box select */
|
||||
|
|
@ -2726,7 +2726,7 @@ static void box_select_anim_channels(bAnimContext *ac, rcti *rect, short selectm
|
|||
float ymin;
|
||||
|
||||
if (ale->type == ANIMTYPE_GPDATABLOCK) {
|
||||
ymax -= ACHANNEL_STEP(ac);
|
||||
ymax -= ANIM_UI_get_channel_step();
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -2734,7 +2734,7 @@ static void box_select_anim_channels(bAnimContext *ac, rcti *rect, short selectm
|
|||
ymin = ymax - NLACHANNEL_STEP(snla);
|
||||
}
|
||||
else {
|
||||
ymin = ymax - ACHANNEL_STEP(ac);
|
||||
ymin = ymax - ANIM_UI_get_channel_step();
|
||||
}
|
||||
|
||||
/* if channel is within border-select region, alter it */
|
||||
|
|
@ -2948,10 +2948,10 @@ static int animchannels_channel_get(bAnimContext *ac, const int mval[2])
|
|||
&channel_index);
|
||||
}
|
||||
else {
|
||||
UI_view2d_listview_view_to_cell(ACHANNEL_NAMEWIDTH,
|
||||
ACHANNEL_STEP(ac),
|
||||
UI_view2d_listview_view_to_cell(ANIM_UI_get_channel_name_width(),
|
||||
ANIM_UI_get_channel_step(),
|
||||
0,
|
||||
ACHANNEL_FIRST_TOP(ac),
|
||||
ANIM_UI_get_first_channel_top(v2d),
|
||||
x,
|
||||
y,
|
||||
NULL,
|
||||
|
|
@ -3484,10 +3484,10 @@ static int animchannels_mouseclick_invoke(bContext *C, wmOperator *op, const wmE
|
|||
|
||||
/* figure out which channel user clicked in */
|
||||
UI_view2d_region_to_view(v2d, event->mval[0], event->mval[1], &x, &y);
|
||||
UI_view2d_listview_view_to_cell(ACHANNEL_NAMEWIDTH,
|
||||
ACHANNEL_STEP(&ac),
|
||||
UI_view2d_listview_view_to_cell(ANIM_UI_get_channel_name_width(),
|
||||
ANIM_UI_get_channel_step(),
|
||||
0,
|
||||
ACHANNEL_FIRST_TOP(&ac),
|
||||
ANIM_UI_get_first_channel_top(v2d),
|
||||
x,
|
||||
y,
|
||||
NULL,
|
||||
|
|
|
|||
|
|
@ -92,26 +92,6 @@
|
|||
/* ************************************************************ */
|
||||
/* Blender Context <-> Animation Context mapping */
|
||||
|
||||
/* ----------- Private Stuff - General -------------------- */
|
||||
|
||||
/* Get vertical scaling factor (i.e. typically used for keyframe size) */
|
||||
static void animedit_get_yscale_factor(bAnimContext *ac)
|
||||
{
|
||||
bTheme *btheme = UI_GetTheme();
|
||||
|
||||
/* grab scale factor directly from action editor setting
|
||||
* NOTE: This theme setting doesn't have an ID, as it cannot be accessed normally
|
||||
* since it is a float, and the theme settings methods can only handle chars.
|
||||
*/
|
||||
ac->yscale_fac = btheme->space_action.keyframe_scale_fac;
|
||||
|
||||
/* clamp to avoid problems with uninitialized values... */
|
||||
if (ac->yscale_fac < 0.1f) {
|
||||
ac->yscale_fac = 1.0f;
|
||||
}
|
||||
// printf("yscale_fac = %f\n", ac->yscale_fac);
|
||||
}
|
||||
|
||||
/* ----------- Private Stuff - Action Editor ------------- */
|
||||
|
||||
/* Get shapekey data being edited (for Action Editor -> ShapeKey mode) */
|
||||
|
|
@ -408,9 +388,6 @@ bool ANIM_animdata_get_context(const bContext *C, bAnimContext *ac)
|
|||
ac->spacetype = (area) ? area->spacetype : 0;
|
||||
ac->regiontype = (region) ? region->regiontype : 0;
|
||||
|
||||
/* Initialize default y-scale factor. */
|
||||
animedit_get_yscale_factor(ac);
|
||||
|
||||
/* get data context info */
|
||||
/* XXX: if the below fails, try to grab this info from context instead...
|
||||
* (to allow for scripting). */
|
||||
|
|
@ -1095,7 +1072,7 @@ static bool skip_fcurve_selected_data(bDopeSheet *ads, FCurve *fcu, ID *owner_id
|
|||
/* Can only add this F-Curve if it is selected. */
|
||||
if (ads->filterflag & ADS_FILTER_ONLYSEL) {
|
||||
|
||||
/* NOTE(@campbellbarton): The `seq == NULL` check doesn't look right
|
||||
/* NOTE(@ideasman42): The `seq == NULL` check doesn't look right
|
||||
* (compared to other checks in this function which skip data that can't be found).
|
||||
*
|
||||
* This is done since the search for sequence strips doesn't use a global lookup:
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ Base *ED_armature_base_and_ebone_from_select_buffer(Base **bases,
|
|||
const uint hit_object = select_id & 0xFFFF;
|
||||
Base *base = NULL;
|
||||
EditBone *ebone = NULL;
|
||||
/* TODO(@campbellbarton): optimize, eg: sort & binary search. */
|
||||
/* TODO(@ideasman42): optimize, eg: sort & binary search. */
|
||||
for (uint base_index = 0; base_index < bases_len; base_index++) {
|
||||
if (bases[base_index]->object->runtime.select_id == hit_object) {
|
||||
base = bases[base_index];
|
||||
|
|
@ -83,7 +83,7 @@ Object *ED_armature_object_and_ebone_from_select_buffer(Object **objects,
|
|||
const uint hit_object = select_id & 0xFFFF;
|
||||
Object *ob = NULL;
|
||||
EditBone *ebone = NULL;
|
||||
/* TODO(@campbellbarton): optimize, eg: sort & binary search. */
|
||||
/* TODO(@ideasman42): optimize, eg: sort & binary search. */
|
||||
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
|
||||
if (objects[ob_index]->runtime.select_id == hit_object) {
|
||||
ob = objects[ob_index];
|
||||
|
|
@ -107,7 +107,7 @@ Base *ED_armature_base_and_pchan_from_select_buffer(Base **bases,
|
|||
const uint hit_object = select_id & 0xFFFF;
|
||||
Base *base = NULL;
|
||||
bPoseChannel *pchan = NULL;
|
||||
/* TODO(@campbellbarton): optimize, eg: sort & binary search. */
|
||||
/* TODO(@ideasman42): optimize, eg: sort & binary search. */
|
||||
for (uint base_index = 0; base_index < bases_len; base_index++) {
|
||||
if (bases[base_index]->object->runtime.select_id == hit_object) {
|
||||
base = bases[base_index];
|
||||
|
|
@ -1451,7 +1451,7 @@ static void armature_select_more_less(Object *ob, bool more)
|
|||
bArmature *arm = (bArmature *)ob->data;
|
||||
EditBone *ebone;
|
||||
|
||||
/* XXX(@campbellbarton): eventually we shouldn't need this. */
|
||||
/* XXX(@ideasman42): eventually we shouldn't need this. */
|
||||
ED_armature_edit_sync_selection(arm->edbo);
|
||||
|
||||
/* count bones & store selection state */
|
||||
|
|
|
|||
|
|
@ -168,7 +168,7 @@ bool ED_armature_pose_select_pick_bone(const Scene *scene,
|
|||
|
||||
/* Since we do unified select, we don't shift+select a bone if the
|
||||
* armature object was not active yet.
|
||||
* NOTE(@campbellbarton): special exception for armature mode so we can do multi-select
|
||||
* NOTE(@ideasman42): special exception for armature mode so we can do multi-select
|
||||
* we could check for multi-select explicitly but think its fine to
|
||||
* always give predictable behavior in weight paint mode. */
|
||||
if ((ob_act == NULL) || ((ob_act != ob) && (ob_act->mode & OB_MODE_ALL_WEIGHT_PAINT) == 0)) {
|
||||
|
|
|
|||
|
|
@ -1278,7 +1278,7 @@ void ED_curve_editnurb_make(Object *obedit)
|
|||
|
||||
if (actkey) {
|
||||
// XXX strcpy(G.editModeTitleExtra, "(Key) ");
|
||||
/* TODO(@campbellbarton): undo_system: investigate why this was needed. */
|
||||
/* TODO(@ideasman42): undo_system: investigate why this was needed. */
|
||||
#if 0
|
||||
undo_editmode_clear();
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
#include "BLI_array_utils.hh"
|
||||
#include "BLI_index_mask_ops.hh"
|
||||
#include "BLI_rand.hh"
|
||||
#include "BLI_rect.h"
|
||||
|
||||
#include "BKE_attribute.hh"
|
||||
#include "BKE_crazyspace.hh"
|
||||
|
|
@ -285,6 +286,46 @@ void select_random(bke::CurvesGeometry &curves,
|
|||
selection.finish();
|
||||
}
|
||||
|
||||
static void apply_selection_operation_at_index(GMutableSpan selection,
|
||||
const int index,
|
||||
const eSelectOp sel_op)
|
||||
{
|
||||
if (selection.type().is<bool>()) {
|
||||
MutableSpan<bool> selection_typed = selection.typed<bool>();
|
||||
switch (sel_op) {
|
||||
case SEL_OP_ADD:
|
||||
case SEL_OP_SET:
|
||||
selection_typed[index] = true;
|
||||
break;
|
||||
case SEL_OP_SUB:
|
||||
selection_typed[index] = false;
|
||||
break;
|
||||
case SEL_OP_XOR:
|
||||
selection_typed[index] ^= selection_typed[index];
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (selection.type().is<float>()) {
|
||||
MutableSpan<float> selection_typed = selection.typed<float>();
|
||||
switch (sel_op) {
|
||||
case SEL_OP_ADD:
|
||||
case SEL_OP_SET:
|
||||
selection_typed[index] = 1.0f;
|
||||
break;
|
||||
case SEL_OP_SUB:
|
||||
selection_typed[index] = 0.0f;
|
||||
break;
|
||||
case SEL_OP_XOR:
|
||||
selection_typed[index] = 1.0f - selection_typed[index];
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper struct for `find_closest_point_to_screen_co`.
|
||||
*/
|
||||
|
|
@ -392,33 +433,69 @@ bool select_pick(const ViewContext &vc,
|
|||
elem_index = std::distance(curves.offsets().begin(), it) - 1;
|
||||
}
|
||||
|
||||
selection.span.type().to_static_type_tag<bool, float>([&](auto type_tag) {
|
||||
using T = typename decltype(type_tag)::type;
|
||||
if constexpr (std::is_void_v<T>) {
|
||||
BLI_assert_unreachable();
|
||||
}
|
||||
else {
|
||||
MutableSpan<T> selection_typed = selection.span.typed<T>();
|
||||
switch (params.sel_op) {
|
||||
case SEL_OP_ADD:
|
||||
case SEL_OP_SET:
|
||||
selection_typed[elem_index] = T(1);
|
||||
break;
|
||||
case SEL_OP_SUB:
|
||||
selection_typed[elem_index] = T(0);
|
||||
break;
|
||||
case SEL_OP_XOR:
|
||||
selection_typed[elem_index] = T(1 - selection_typed[elem_index]);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
apply_selection_operation_at_index(selection.span, elem_index, params.sel_op);
|
||||
selection.finish();
|
||||
}
|
||||
|
||||
return changed || found;
|
||||
}
|
||||
|
||||
bool select_box(const ViewContext &vc,
|
||||
bke::CurvesGeometry &curves,
|
||||
const eAttrDomain selection_domain,
|
||||
const rcti &rect,
|
||||
const eSelectOp sel_op)
|
||||
{
|
||||
rctf rectf;
|
||||
BLI_rctf_rcti_copy(&rectf, &rect);
|
||||
|
||||
bke::GSpanAttributeWriter selection = ensure_selection_attribute(
|
||||
curves, selection_domain, CD_PROP_BOOL);
|
||||
|
||||
bool changed = false;
|
||||
if (sel_op == SEL_OP_SET) {
|
||||
fill_selection_false(selection.span);
|
||||
changed = true;
|
||||
}
|
||||
|
||||
float4x4 projection;
|
||||
ED_view3d_ob_project_mat_get(vc.rv3d, vc.obact, projection.ptr());
|
||||
|
||||
const bke::crazyspace::GeometryDeformation deformation =
|
||||
bke::crazyspace::get_evaluated_curves_deformation(*vc.depsgraph, *vc.obact);
|
||||
const OffsetIndices points_by_curve = curves.points_by_curve();
|
||||
if (selection_domain == ATTR_DOMAIN_POINT) {
|
||||
threading::parallel_for(curves.points_range(), 1024, [&](const IndexRange point_range) {
|
||||
for (const int point_i : point_range) {
|
||||
float2 pos_proj;
|
||||
ED_view3d_project_float_v2_m4(
|
||||
vc.region, deformation.positions[point_i], pos_proj, projection.ptr());
|
||||
if (BLI_rctf_isect_pt_v(&rectf, pos_proj)) {
|
||||
apply_selection_operation_at_index(selection.span, point_i, sel_op);
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
else if (selection_domain == ATTR_DOMAIN_CURVE) {
|
||||
threading::parallel_for(curves.curves_range(), 512, [&](const IndexRange curves_range) {
|
||||
for (const int curve_i : curves_range) {
|
||||
for (const int point_i : points_by_curve[curve_i]) {
|
||||
float2 pos_proj;
|
||||
ED_view3d_project_float_v2_m4(
|
||||
vc.region, deformation.positions[point_i], pos_proj, projection.ptr());
|
||||
if (BLI_rctf_isect_pt_v(&rectf, pos_proj)) {
|
||||
apply_selection_operation_at_index(selection.span, curve_i, sel_op);
|
||||
changed = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
selection.finish();
|
||||
|
||||
return changed;
|
||||
}
|
||||
|
||||
} // namespace blender::ed::curves
|
||||
|
|
|
|||
|
|
@ -4,6 +4,8 @@
|
|||
* \ingroup edcurves
|
||||
*/
|
||||
|
||||
#include "BLI_task.hh"
|
||||
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_curves.hh"
|
||||
#include "BKE_main.h"
|
||||
|
|
|
|||
|
|
@ -94,8 +94,6 @@ typedef struct bAnimContext {
|
|||
/** pointer to current reports list */
|
||||
struct ReportList *reports;
|
||||
|
||||
/** Scale factor for height of channels (i.e. based on the size of keyframes). */
|
||||
float yscale_fac;
|
||||
} bAnimContext;
|
||||
|
||||
/* Main Data container types */
|
||||
|
|
@ -430,28 +428,6 @@ ENUM_OPERATORS(eAnimFilter_Flags, ANIMFILTER_TMP_IGNORE_ONLYSEL);
|
|||
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Channel Defines
|
||||
* \{ */
|
||||
|
||||
/** Channel heights. */
|
||||
#define ACHANNEL_FIRST_TOP(ac) \
|
||||
(UI_view2d_scale_get_y(&(ac)->region->v2d) * -UI_TIME_SCRUB_MARGIN_Y - ACHANNEL_SKIP)
|
||||
#define ACHANNEL_HEIGHT(ac) (0.8f * (ac)->yscale_fac * U.widget_unit)
|
||||
#define ACHANNEL_SKIP (0.1f * U.widget_unit)
|
||||
#define ACHANNEL_STEP(ac) (ACHANNEL_HEIGHT(ac) + ACHANNEL_SKIP)
|
||||
/** Additional offset to give some room at the end. */
|
||||
#define ACHANNEL_TOT_HEIGHT(ac, item_amount) \
|
||||
(-ACHANNEL_FIRST_TOP(ac) + ACHANNEL_STEP(ac) * (item_amount + 1))
|
||||
|
||||
/** Channel widths. */
|
||||
#define ACHANNEL_NAMEWIDTH (10 * U.widget_unit)
|
||||
|
||||
/** Channel toggle-buttons. */
|
||||
#define ACHANNEL_BUTTON_WIDTH (0.8f * U.widget_unit)
|
||||
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name NLA Channel Defines
|
||||
* \{ */
|
||||
|
|
@ -612,6 +588,20 @@ typedef struct bAnimChannelType {
|
|||
void *(*setting_ptr)(bAnimListElem *ale, eAnimChannel_Settings setting, short *type);
|
||||
} bAnimChannelType;
|
||||
|
||||
/** \} */
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Channel dimensions API
|
||||
* \{ */
|
||||
|
||||
float ANIM_UI_get_keyframe_scale_factor(void);
|
||||
float ANIM_UI_get_channel_height(void);
|
||||
float ANIM_UI_get_channel_skip(void);
|
||||
float ANIM_UI_get_first_channel_top(View2D *v2d);
|
||||
float ANIM_UI_get_channel_step(void);
|
||||
float ANIM_UI_get_channels_total_height(View2D *v2d, int item_count);
|
||||
float ANIM_UI_get_channel_name_width(void);
|
||||
float ANIM_UI_get_channel_button_width(void);
|
||||
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ struct Curves;
|
|||
struct UndoType;
|
||||
struct SelectPick_Params;
|
||||
struct ViewContext;
|
||||
struct rcti;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
|
|
@ -46,6 +47,8 @@ float (*ED_curves_point_normals_array_create(const struct Curves *curves_id))[3]
|
|||
|
||||
# include "BKE_curves.hh"
|
||||
|
||||
# include "ED_select_utils.h"
|
||||
|
||||
namespace blender::ed::curves {
|
||||
|
||||
bool object_has_editable_curves(const Main &bmain, const Object &object);
|
||||
|
|
@ -146,6 +149,14 @@ bool select_pick(const ViewContext &vc,
|
|||
const SelectPick_Params ¶ms,
|
||||
const int2 mval);
|
||||
|
||||
/**
|
||||
* Select points or curves in a (screenspace) rectangle.
|
||||
*/
|
||||
bool select_box(const ViewContext &vc,
|
||||
bke::CurvesGeometry &curves,
|
||||
const eAttrDomain selection_domain,
|
||||
const rcti& rect,
|
||||
const eSelectOp sel_op);
|
||||
/** \} */
|
||||
|
||||
} // namespace blender::ed::curves
|
||||
|
|
|
|||
|
|
@ -241,6 +241,9 @@ void ED_object_parent(struct Object *ob, struct Object *parent, int type, const
|
|||
char *ED_object_ot_drop_named_material_tooltip(struct bContext *C,
|
||||
const char *name,
|
||||
const int mval[2]);
|
||||
char *ED_object_ot_drop_geometry_nodes_tooltip(struct bContext *C,
|
||||
struct PointerRNA *properties,
|
||||
const int mval[2]);
|
||||
|
||||
/* bitflags for enter/exit editmode */
|
||||
enum {
|
||||
|
|
@ -475,7 +478,7 @@ void ED_object_constraint_copy_for_pose(struct Main *bmain,
|
|||
struct bPoseChannel *pchan,
|
||||
struct bConstraint *con);
|
||||
|
||||
/* object_modes.c */
|
||||
/* object_modes.cc */
|
||||
|
||||
/**
|
||||
* Checks the mode to be set is compatible with the object
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ struct wmKeyConfig;
|
|||
struct wmOperator;
|
||||
typedef struct PaintTileMap PaintTileMap;
|
||||
|
||||
/* paint_ops.c */
|
||||
/* paint_ops.cc */
|
||||
|
||||
void ED_operatortypes_paint(void);
|
||||
void ED_operatormacros_paint(void);
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ struct IDRemapper;
|
|||
struct Main;
|
||||
struct bContext;
|
||||
|
||||
/* ed_util.c */
|
||||
/* ed_util.cc */
|
||||
|
||||
void ED_editors_init_for_undo(struct Main *bmain);
|
||||
void ED_editors_init(struct bContext *C);
|
||||
|
|
|
|||
|
|
@ -1310,7 +1310,7 @@ static bool ui_but_event_operator_string_from_panel(const bContext *C,
|
|||
IDP_AddToGroup(prop_panel, IDP_New(IDP_INT, ®ion_type_val, "region_type"));
|
||||
|
||||
for (int i = 0; i < 2; i++) {
|
||||
/* FIXME(@campbellbarton): We can't reasonably search all configurations - long term. */
|
||||
/* FIXME(@ideasman42): We can't reasonably search all configurations - long term. */
|
||||
IDPropertyTemplate val = {0};
|
||||
val.i = i;
|
||||
|
||||
|
|
|
|||
|
|
@ -322,7 +322,7 @@ void ui_but_anim_decorate_cb(bContext *C, void *arg_but, void * /*arg_dummy*/)
|
|||
return;
|
||||
}
|
||||
|
||||
/* FIXME(@campbellbarton): swapping active pointer is weak. */
|
||||
/* FIXME(@ideasman42): swapping active pointer is weak. */
|
||||
std::swap(but_anim->active, but_decorate->active);
|
||||
wm->op_undo_depth++;
|
||||
|
||||
|
|
|
|||
|
|
@ -8793,7 +8793,7 @@ void UI_context_active_but_prop_handle(bContext *C, const bool handle_undo)
|
|||
{
|
||||
uiBut *activebut = ui_context_rna_button_active(C);
|
||||
if (activebut) {
|
||||
/* TODO(@campbellbarton): look into a better way to handle the button change
|
||||
/* TODO(@ideasman42): look into a better way to handle the button change
|
||||
* currently this is mainly so reset defaults works for the
|
||||
* operator redo panel. */
|
||||
uiBlock *block = activebut->block;
|
||||
|
|
|
|||
|
|
@ -1630,7 +1630,7 @@ static void icon_draw_cache_texture_flush_ex(GPUTexture *texture,
|
|||
|
||||
GPUBatch *quad = GPU_batch_preset_quad();
|
||||
GPU_batch_set_shader(quad, shader);
|
||||
GPU_batch_draw_instanced(quad, texture_draw_calls->calls);
|
||||
GPU_batch_draw_instance_range(quad, 0, texture_draw_calls->calls);
|
||||
|
||||
GPU_texture_unbind(texture);
|
||||
GPU_uniformbuf_unbind(ubo);
|
||||
|
|
@ -1890,7 +1890,7 @@ static void icon_draw_size(float x,
|
|||
}
|
||||
else if (di->type == ICON_TYPE_GEOM) {
|
||||
#ifdef USE_UI_TOOLBAR_HACK
|
||||
/* TODO(@campbellbarton): scale icons up for toolbar,
|
||||
/* TODO(@ideasman42): scale icons up for toolbar,
|
||||
* we need a way to detect larger buttons and do this automatic. */
|
||||
{
|
||||
float scale = float(ICON_DEFAULT_HEIGHT_TOOLBAR) / float(ICON_DEFAULT_HEIGHT);
|
||||
|
|
@ -1905,7 +1905,7 @@ static void icon_draw_size(float x,
|
|||
const bool geom_inverted = di->data.geom.inverted;
|
||||
|
||||
/* This could re-generate often if rendered at different sizes in the one interface.
|
||||
* TODO(@campbellbarton): support caching multiple sizes. */
|
||||
* TODO(@ideasman42): support caching multiple sizes. */
|
||||
ImBuf *ibuf = di->data.geom.image_cache;
|
||||
if ((ibuf == nullptr) || (ibuf->x != w) || (ibuf->y != h) || (invert != geom_inverted)) {
|
||||
if (ibuf) {
|
||||
|
|
|
|||
|
|
@ -397,7 +397,7 @@ void UI_popover_end(bContext *C, uiPopover *pup, wmKeyMap *keymap)
|
|||
|
||||
pup->window = window;
|
||||
|
||||
/* TODO(@campbellbarton): we may want to make this configurable.
|
||||
/* TODO(@ideasman42): we may want to make this configurable.
|
||||
* The begin/end stype of calling popups doesn't allow 'can_refresh' to be set.
|
||||
* For now close this style of popovers when accessed. */
|
||||
UI_block_flag_disable(pup->block, UI_BLOCK_KEEP_OPEN);
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* ToolTip Region and Construction
|
||||
*/
|
||||
|
||||
/* TODO(@campbellbarton):
|
||||
/* TODO(@ideasman42):
|
||||
* We may want to have a higher level API that initializes a timer,
|
||||
* checks for mouse motion and clears the tool-tip afterwards.
|
||||
* We never want multiple tool-tips at once
|
||||
|
|
@ -996,7 +996,7 @@ static uiTooltipData *ui_tooltip_data_from_gizmo(bContext *C, wmGizmo *gz)
|
|||
{
|
||||
uiTooltipData *data = MEM_cnew<uiTooltipData>(__func__);
|
||||
|
||||
/* TODO(@campbellbarton): a way for gizmos to have their own descriptions (low priority). */
|
||||
/* TODO(@ideasman42): a way for gizmos to have their own descriptions (low priority). */
|
||||
|
||||
/* Operator Actions */
|
||||
{
|
||||
|
|
@ -1058,7 +1058,7 @@ static uiTooltipData *ui_tooltip_data_from_gizmo(bContext *C, wmGizmo *gz)
|
|||
if (gz->type->target_property_defs_len) {
|
||||
wmGizmoProperty *gz_prop_array = WM_gizmo_target_property_array(gz);
|
||||
for (int i = 0; i < gz->type->target_property_defs_len; i++) {
|
||||
/* TODO(@campbellbarton): function callback descriptions. */
|
||||
/* TODO(@ideasman42): function callback descriptions. */
|
||||
wmGizmoProperty *gz_prop = &gz_prop_array[i];
|
||||
if (gz_prop->prop != nullptr) {
|
||||
const char *info = RNA_property_ui_description(gz_prop->prop);
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue