Geometry Nodes: Implement Gabor noise node #125718

Merged
Omar Emara merged 4 commits from OmarEmaraDev/blender:geometry-nodes-gabor into main 2024-08-14 08:48:35 +02:00
Member

This patch ports the Gabor noise shader texture node into Geometry
Nodes.

This patch ports the Gabor noise shader texture node into Geometry Nodes.
Omar Emara added the
Interest
Geometry Nodes
Module
Nodes & Physics
labels 2024-07-31 16:50:58 +02:00
Omar Emara added 1 commit 2024-07-31 16:51:08 +02:00
This patch ports the Gabor noise shader texture node into Geometry
Nodes.
Omar Emara requested review from Jacques Lucke 2024-07-31 16:51:54 +02:00
Omar Emara requested review from Hans Goudey 2024-07-31 16:51:54 +02:00
Iliya Katushenock reviewed 2024-07-31 16:59:48 +02:00
@ -2040,0 +2077,4 @@
* are sampled using a Bernoulli distribution, as shown in Figure (3). By stratified sampling, they
* mean a constant number of impulses per cell, so the stratification is the grid itself in that
* sense, as described in the supplementary material of the paper. */
static constexpr int IMPULSES_COUNT = 8;

static constexpr int impulses_count = 8;

`static constexpr int impulses_count = 8;`
OmarEmaraDev marked this conversation as resolved
@ -2040,0 +2104,4 @@
* real part of the phasor, we use the sine part instead, that is, the imaginary part of the
* phasor, as suggested by Tavernier's paper in "Section 3.3. Instance stationarity and
* normalization", to ensure a zero mean, which should help with normalization. */
static float2 compute_2d_gabor_kernel(const float2 position,

No reason for compute in the name, this can be const float2 kernel = 2d_gabor_kernel(...);, same below.

No reason for `compute` in the name, this can be `const float2 kernel = 2d_gabor_kernel(...);`, same below.
OmarEmaraDev marked this conversation as resolved
@ -2040,0 +2158,4 @@
* noise while it is random for isotropic noise. The original Gabor noise paper mentions that the
* weights should be uniformly distributed in the [-1, 1] range, however, Tavernier's paper showed
* that using a Bernoulli distribution yields better results, so that is what we do. */
float2 compute_2d_gabor_noise_cell(const float2 cell,

static float2 2d_gabor_noise_cell

`static float2 2d_gabor_noise_cell`
Member

Especially note the static. I'm fine with the name, because it's the same in all other implementations.
Same for compute_3d_orientation

Especially note the **static**. I'm fine with the name, because it's the same in all other implementations. Same for `compute_3d_orientation`
OmarEmaraDev marked this conversation as resolved
@ -2040,0 +2257,4 @@
/* Computes the orientation of the Gabor kernel such that it is constant for anisotropic
* noise while it is random for isotropic noise. We randomize in spherical coordinates for a
* uniform distribution. */
float3 compute_3d_orientation(float3 orientation, float isotropy, float4 seed)

static float3 3d_orientation, const orientation, ...

`static float3 3d_orientation`, `const orientation`, ...
OmarEmaraDev marked this conversation as resolved
@ -99,0 +142,4 @@
void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const override
{
int param = 0;
const VArray<float3> &vector = params.readonly_single_input<float3>(param++, "Vector");

(0, "Vector"), same below, no reason for counter (+ lines will be shorter - better formatting).

`(0, "Vector")`, same below, no reason for counter (+ lines will be shorter - better formatting).
OmarEmaraDev marked this conversation as resolved
@ -99,0 +154,4 @@
MutableSpan<float> r_intensity = params.uninitialized_single_output_if_required<float>(
param++, "Intensity");
if (type_ == SHD_GABOR_TYPE_2D) {

Use switch statment.

Use switch statment.
OmarEmaraDev marked this conversation as resolved
Iliya Katushenock added this to the Nodes & Physics project 2024-07-31 17:00:24 +02:00
Iliya Katushenock removed the
Module
Nodes & Physics
label 2024-07-31 17:00:27 +02:00
Author
Member

@mod_moder I don't really see a good reason to rename functions, mainly because this code is copied from shader code, so it is better to keep code as identical as possible. I am already not happy about existing deviations.

@mod_moder I don't really see a good reason to rename functions, mainly because this code is copied from shader code, so it is better to keep code as identical as possible. I am already not happy about existing deviations.

This is bad what we have to do not change the backend code (without user-visible affect) due to such reason.

This is bad what we have to do not change the backend code (without user-visible affect) due to such reason.
Omar Emara added 1 commit 2024-07-31 17:29:36 +02:00
Address review
All checks were successful
buildbot/vexp-code-patch-lint Build done.
buildbot/vexp-code-patch-linux-x86_64 Build done.
buildbot/vexp-code-patch-darwin-arm64 Build done.
buildbot/vexp-code-patch-darwin-x86_64 Build done.
buildbot/vexp-code-patch-windows-amd64 Build done.
buildbot/vexp-code-patch-coordinator Build done.
0fc661d01c
Iliya Katushenock reviewed 2024-07-31 17:32:35 +02:00
@ -99,0 +195,4 @@
{
const NodeTexGabor &storage = node_storage(builder.node());
builder.construct_and_set_matching_fn<GaborNoiseFunction>(
static_cast<NodeGaborType>(storage.type));

Use function style cast for trivial/numeric type/

Use function style cast for trivial/numeric type/
OmarEmaraDev marked this conversation as resolved
Member

@OmarEmaraDev Based on the previous patch (#125443) I have some further optimisations taken from my original implementation #110802.

  1. Add early exit for skipping cells that do not contribute to the noise. Taken from Lee Bruemmer's OSL implementation. https://devtalk.blender.org/t/gabor-procedural-texture-node/25934/17.
  2. Move weight calculation to the kernel function so it can be skipped if there is an early exit in the kernel function.

These optimisations are especially significant on the 3D variant as this significantly reduces the number of expensive noise::hash calls.
I'll leave it to you to either implement in this patch or I can create a new patch once this patch is accepted.
image

diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc b/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc
index da957a7bc07..ceb40c2a05d 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc
@@ -153,7 +153,8 @@ static constexpr int IMPULSES_COUNT = 8;
  * normalization", to ensure a zero mean, which should help with normalization. */
 static float2 compute_2d_gabor_kernel(const float2 position,
                                       const float frequency,
-                                      const float orientation)
+                                      const float orientation,
+                                      const float3 seed_for_weight)
 {
   /* The kernel is windowed beyond the unit distance, so early exist with a zero for points that
    * are further than a unit radius. */
@@ -162,6 +163,10 @@ static float2 compute_2d_gabor_kernel(const float2 position,
     return float2(0.0f);
   }
 
+  /* We either add or subtract the Gabor kernel based on a Bernoulli distribution of equal
+   * probability. */
+  const float weight = noise::hash_float_to_float(seed_for_weight) < 0.5f ? -1.0f : 1.0f;
+
   const float hann_window = 0.5f + 0.5f * math::cos(math::numbers::pi * distance_squared);
   const float gaussian_envelop = math::exp(-math::numbers::pi * distance_squared);
   const float windowed_gaussian_envelope = gaussian_envelop * hann_window;
@@ -170,7 +175,7 @@ static float2 compute_2d_gabor_kernel(const float2 position,
   const float angle = 2.0f * math::numbers::pi * math::dot(position, frequency_vector);
   const float2 phasor = float2(math::cos(angle), math::sin(angle));
 
-  return windowed_gaussian_envelope * phasor;
+  return weight * windowed_gaussian_envelope * phasor;
 }
 
 /* Computes the approximate standard deviation of the zero mean normal distribution representing
@@ -230,11 +235,8 @@ float2 compute_2d_gabor_noise_cell(const float2 cell,
     const float2 kernel_center = noise::hash_float_to_float2(seed_for_kernel_center);
     const float2 position_in_kernel_space = position - kernel_center;
 
-    /* We either add or subtract the Gabor kernel based on a Bernoulli distribution of equal
-     * probability. */
-    const float weight = noise::hash_float_to_float(seed_for_weight) < 0.5f ? -1.0f : 1.0f;
-
-    noise += weight * compute_2d_gabor_kernel(position_in_kernel_space, frequency, orientation);
+    noise += compute_2d_gabor_kernel(
+        position_in_kernel_space, frequency, orientation, seed_for_weight);
   }
   return noise;
 }
@@ -253,6 +255,13 @@ static float2 compute_2d_gabor_noise(const float2 coordinates,
   for (int j = -1; j <= 1; j++) {
     for (int i = -1; i <= 1; i++) {
       const float2 cell_offset = float2(i, j);
+
+      /* Optimisation: Skip cells that are too far away to contribute - Bruemmer.osl */
+      const float2 skip_distance = (float2(i > 0, j > 0) - local_position) * cell_offset;
+      if (math::dot(skip_distance, skip_distance) >= 1.0f) {
+        continue;
+      }
+
       const float2 current_cell_position = cell_position + cell_offset;
       const float2 position_in_cell_space = local_position - cell_offset;
       sum += compute_2d_gabor_noise_cell(
@@ -269,7 +278,8 @@ static float2 compute_2d_gabor_noise(const float2 coordinates,
  * vector, so we just need to scale it by the frequency value. */
 static float2 compute_3d_gabor_kernel(const float3 position,
                                       const float frequency,
-                                      const float3 orientation)
+                                      const float3 orientation,
+                                      const float4 seed_for_weight)
 {
   /* The kernel is windowed beyond the unit distance, so early exist with a zero for points that
    * are further than a unit radius. */
@@ -278,6 +288,10 @@ static float2 compute_3d_gabor_kernel(const float3 position,
     return float2(0.0f);
   }
 
+  /* We either add or subtract the Gabor kernel based on a Bernoulli distribution of equal
+   * probability. */
+  const float weight = noise::hash_float_to_float(seed_for_weight) < 0.5f ? -1.0f : 1.0f;
+
   const float hann_window = 0.5f + 0.5f * math::cos(math::numbers::pi * distance_squared);
   const float gaussian_envelop = math::exp(-math::numbers::pi * distance_squared);
   const float windowed_gaussian_envelope = gaussian_envelop * hann_window;
@@ -286,7 +300,7 @@ static float2 compute_3d_gabor_kernel(const float3 position,
   const float angle = 2.0f * math::numbers::pi * math::dot(position, frequency_vector);
   const float2 phasor = float2(math::cos(angle), math::sin(angle));
 
-  return windowed_gaussian_envelope * phasor;
+  return weight * windowed_gaussian_envelope * phasor;
 }
 
 /* Identical to compute_2d_gabor_standard_deviation except we do triple integration in 3D. The only
@@ -350,11 +364,8 @@ static float2 compute_3d_gabor_noise_cell(const float3 cell,
     const float3 kernel_center = noise::hash_float_to_float3(seed_for_kernel_center);
     const float3 position_in_kernel_space = position - kernel_center;
 
-    /* We either add or subtract the Gabor kernel based on a Bernoulli distribution of equal
-     * probability. */
-    const float weight = noise::hash_float_to_float(seed_for_weight) < 0.5f ? -1.0f : 1.0f;
-
-    noise += weight * compute_3d_gabor_kernel(position_in_kernel_space, frequency, orientation);
+    noise += compute_3d_gabor_kernel(
+        position_in_kernel_space, frequency, orientation, seed_for_weight);
   }
   return noise;
 }
@@ -373,6 +384,13 @@ static float2 compute_3d_gabor_noise(const float3 coordinates,
     for (int j = -1; j <= 1; j++) {
       for (int i = -1; i <= 1; i++) {
         const float3 cell_offset = float3(i, j, k);
+
+        /* Optimisation: Skip cells that are too far away to contribute - Bruemmer.osl */
+        const float3 skip_distance = (float3(i > 0, j > 0, k > 0) - local_position) * cell_offset;
+        if (math::dot(skip_distance, skip_distance) >= 1.0f) {
+          continue;
+        }
+
         const float3 current_cell_position = cell_position + cell_offset;
         const float3 position_in_cell_space = local_position - cell_offset;
         sum += compute_3d_gabor_noise_cell(

@OmarEmaraDev Based on the previous patch (#125443) I have some further optimisations taken from my original implementation #110802. 1. Add early exit for skipping cells that do not contribute to the noise. Taken from Lee Bruemmer's OSL implementation. https://devtalk.blender.org/t/gabor-procedural-texture-node/25934/17. 2. Move weight calculation to the kernel function so it can be skipped if there is an early exit in the kernel function. These optimisations are especially significant on the 3D variant as this significantly reduces the number of expensive noise::hash calls. I'll leave it to you to either implement in this patch or I can create a new patch once this patch is accepted. <img width="971" alt="image" src="attachments/0c0eaf45-b8ac-4b15-b5f2-6790c2d0a7e7"> ```Diff diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc b/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc index da957a7bc07..ceb40c2a05d 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_gabor.cc @@ -153,7 +153,8 @@ static constexpr int IMPULSES_COUNT = 8; * normalization", to ensure a zero mean, which should help with normalization. */ static float2 compute_2d_gabor_kernel(const float2 position, const float frequency, - const float orientation) + const float orientation, + const float3 seed_for_weight) { /* The kernel is windowed beyond the unit distance, so early exist with a zero for points that * are further than a unit radius. */ @@ -162,6 +163,10 @@ static float2 compute_2d_gabor_kernel(const float2 position, return float2(0.0f); } + /* We either add or subtract the Gabor kernel based on a Bernoulli distribution of equal + * probability. */ + const float weight = noise::hash_float_to_float(seed_for_weight) < 0.5f ? -1.0f : 1.0f; + const float hann_window = 0.5f + 0.5f * math::cos(math::numbers::pi * distance_squared); const float gaussian_envelop = math::exp(-math::numbers::pi * distance_squared); const float windowed_gaussian_envelope = gaussian_envelop * hann_window; @@ -170,7 +175,7 @@ static float2 compute_2d_gabor_kernel(const float2 position, const float angle = 2.0f * math::numbers::pi * math::dot(position, frequency_vector); const float2 phasor = float2(math::cos(angle), math::sin(angle)); - return windowed_gaussian_envelope * phasor; + return weight * windowed_gaussian_envelope * phasor; } /* Computes the approximate standard deviation of the zero mean normal distribution representing @@ -230,11 +235,8 @@ float2 compute_2d_gabor_noise_cell(const float2 cell, const float2 kernel_center = noise::hash_float_to_float2(seed_for_kernel_center); const float2 position_in_kernel_space = position - kernel_center; - /* We either add or subtract the Gabor kernel based on a Bernoulli distribution of equal - * probability. */ - const float weight = noise::hash_float_to_float(seed_for_weight) < 0.5f ? -1.0f : 1.0f; - - noise += weight * compute_2d_gabor_kernel(position_in_kernel_space, frequency, orientation); + noise += compute_2d_gabor_kernel( + position_in_kernel_space, frequency, orientation, seed_for_weight); } return noise; } @@ -253,6 +255,13 @@ static float2 compute_2d_gabor_noise(const float2 coordinates, for (int j = -1; j <= 1; j++) { for (int i = -1; i <= 1; i++) { const float2 cell_offset = float2(i, j); + + /* Optimisation: Skip cells that are too far away to contribute - Bruemmer.osl */ + const float2 skip_distance = (float2(i > 0, j > 0) - local_position) * cell_offset; + if (math::dot(skip_distance, skip_distance) >= 1.0f) { + continue; + } + const float2 current_cell_position = cell_position + cell_offset; const float2 position_in_cell_space = local_position - cell_offset; sum += compute_2d_gabor_noise_cell( @@ -269,7 +278,8 @@ static float2 compute_2d_gabor_noise(const float2 coordinates, * vector, so we just need to scale it by the frequency value. */ static float2 compute_3d_gabor_kernel(const float3 position, const float frequency, - const float3 orientation) + const float3 orientation, + const float4 seed_for_weight) { /* The kernel is windowed beyond the unit distance, so early exist with a zero for points that * are further than a unit radius. */ @@ -278,6 +288,10 @@ static float2 compute_3d_gabor_kernel(const float3 position, return float2(0.0f); } + /* We either add or subtract the Gabor kernel based on a Bernoulli distribution of equal + * probability. */ + const float weight = noise::hash_float_to_float(seed_for_weight) < 0.5f ? -1.0f : 1.0f; + const float hann_window = 0.5f + 0.5f * math::cos(math::numbers::pi * distance_squared); const float gaussian_envelop = math::exp(-math::numbers::pi * distance_squared); const float windowed_gaussian_envelope = gaussian_envelop * hann_window; @@ -286,7 +300,7 @@ static float2 compute_3d_gabor_kernel(const float3 position, const float angle = 2.0f * math::numbers::pi * math::dot(position, frequency_vector); const float2 phasor = float2(math::cos(angle), math::sin(angle)); - return windowed_gaussian_envelope * phasor; + return weight * windowed_gaussian_envelope * phasor; } /* Identical to compute_2d_gabor_standard_deviation except we do triple integration in 3D. The only @@ -350,11 +364,8 @@ static float2 compute_3d_gabor_noise_cell(const float3 cell, const float3 kernel_center = noise::hash_float_to_float3(seed_for_kernel_center); const float3 position_in_kernel_space = position - kernel_center; - /* We either add or subtract the Gabor kernel based on a Bernoulli distribution of equal - * probability. */ - const float weight = noise::hash_float_to_float(seed_for_weight) < 0.5f ? -1.0f : 1.0f; - - noise += weight * compute_3d_gabor_kernel(position_in_kernel_space, frequency, orientation); + noise += compute_3d_gabor_kernel( + position_in_kernel_space, frequency, orientation, seed_for_weight); } return noise; } @@ -373,6 +384,13 @@ static float2 compute_3d_gabor_noise(const float3 coordinates, for (int j = -1; j <= 1; j++) { for (int i = -1; i <= 1; i++) { const float3 cell_offset = float3(i, j, k); + + /* Optimisation: Skip cells that are too far away to contribute - Bruemmer.osl */ + const float3 skip_distance = (float3(i > 0, j > 0, k > 0) - local_position) * cell_offset; + if (math::dot(skip_distance, skip_distance) >= 1.0f) { + continue; + } + const float3 current_cell_position = cell_position + cell_offset; const float3 position_in_cell_space = local_position - cell_offset; sum += compute_3d_gabor_noise_cell( ```
506 KiB
Author
Member

@CharlieJolly Can you explain how the condition works?

Add early exit for skipping cells that do not contribute to the noise.

The code looks wrong or incomplete.

@CharlieJolly Can you explain how the condition works? > Add early exit for skipping cells that do not contribute to the noise. The code looks wrong or incomplete.
Member

@CharlieJolly Can you explain how the condition works?

Add early exit for skipping cells that do not contribute to the noise.

The code looks wrong or incomplete.

@OmarEmaraDev It works because it is potentially skipping edge cells that are over a unit radius away from the current cell position. This is similar to the distance check in the compute_Xd_gabor_kernel function but performed earlier.

There is also another possible optimisation. The windowed gaussian envelope can be closely approximated using a power curve. In the attached file this is showing about a 10% performance increase. This is possible because the distance value is always in the 0-1 unit range. For artistic uses, this is totally acceptable in my opinion.

  // const float hann_window = 0.5f + 0.5f * math::cos(math::numbers::pi * distance_squared);
  // const float gaussian_envelop = math::exp(-math::numbers::pi * distance_squared);
  // const float windowed_gaussian_envelope = gaussian_envelop * hann_window;

  /* The windowed_gaussian_envelope curve can be simplified and optimised
   * using this curve pow(1.0-distance_squared,PI) as opposed to
   * (0.5+0.5*cos(PI*distance_squared))*exp(-PI*distance_squared).
   *
   * Graphtoy comparison https://tinyurl.com/364tytwn */
  const float windowed_gaussian_envelope = math::pow(1.0f - distance_squared,
                                                     float(math::numbers::pi));
> @CharlieJolly Can you explain how the condition works? > > > Add early exit for skipping cells that do not contribute to the noise. > > The code looks wrong or incomplete. @OmarEmaraDev It works because it is potentially skipping edge cells that are over a unit radius away from the current cell position. This is similar to the distance check in the `compute_Xd_gabor_kernel` function but performed earlier. There is also another possible optimisation. The windowed gaussian envelope can be closely approximated using a power curve. In the attached file this is showing about a 10% performance increase. This is possible because the distance value is always in the 0-1 unit range. For artistic uses, this is totally acceptable in my opinion. ```Cpp // const float hann_window = 0.5f + 0.5f * math::cos(math::numbers::pi * distance_squared); // const float gaussian_envelop = math::exp(-math::numbers::pi * distance_squared); // const float windowed_gaussian_envelope = gaussian_envelop * hann_window; /* The windowed_gaussian_envelope curve can be simplified and optimised * using this curve pow(1.0-distance_squared,PI) as opposed to * (0.5+0.5*cos(PI*distance_squared))*exp(-PI*distance_squared). * * Graphtoy comparison https://tinyurl.com/364tytwn */ const float windowed_gaussian_envelope = math::pow(1.0f - distance_squared, float(math::numbers::pi)); ```
Author
Member

@CharlieJolly Sure, but what does (float3(i > 0, j > 0, k > 0) - local_position) * cell_offset compute?

@CharlieJolly Sure, but what does `(float3(i > 0, j > 0, k > 0) - local_position) * cell_offset` compute?
Member

@CharlieJolly Sure, but what does (float3(i > 0, j > 0, k > 0) - local_position) * cell_offset compute?

It's computing the relative position nearest the edge of the cell grid based on the cell offset. If that relative position is too far away it is safe to skip the calculations.

> @CharlieJolly Sure, but what does `(float3(i > 0, j > 0, k > 0) - local_position) * cell_offset` compute? It's computing the relative position nearest the edge of the cell grid based on the cell offset. If that relative position is too far away it is safe to skip the calculations.
Member

It would be great if you could create a test file that demonstrates that the results are the same in geometry nodes and shader nodes.

It would be great if you could create a test file that demonstrates that the results are the same in geometry nodes and shader nodes.
Member

It would be great if you could create a test file that demonstrates that the results are the same in geometry nodes and shader nodes.

I've added a file that can be used for validation.

> It would be great if you could create a test file that demonstrates that the results are the same in geometry nodes and shader nodes. I've added a file that can be used for validation.
Jacques Lucke approved these changes 2024-08-13 20:25:34 +02:00
Jacques Lucke left a comment
Member

There are warnings because of missing static right now, see inline comment. Generally looks good though.

There are warnings because of missing `static` right now, see inline comment. Generally looks good though.
Member

@blender-bot build

@blender-bot build
Omar Emara added 2 commits 2024-08-14 08:46:21 +02:00
Omar Emara merged commit 94d3b764e7 into main 2024-08-14 08:48:35 +02:00
Omar Emara deleted branch geometry-nodes-gabor 2024-08-14 08:48:39 +02:00
Sign in to join this conversation.
No reviewers
No Label
Interest
Alembic
Interest
Animation & Rigging
Interest
Asset System
Interest
Audio
Interest
Automated Testing
Interest
Blender Asset Bundle
Interest
BlendFile
Interest
Collada
Interest
Compatibility
Interest
Compositing
Interest
Core
Interest
Cycles
Interest
Dependency Graph
Interest
Development Management
Interest
EEVEE
Interest
Freestyle
Interest
Geometry Nodes
Interest
Grease Pencil
Interest
ID Management
Interest
Images & Movies
Interest
Import Export
Interest
Line Art
Interest
Masking
Interest
Metal
Interest
Modeling
Interest
Modifiers
Interest
Motion Tracking
Interest
Nodes & Physics
Interest
OpenGL
Interest
Overlay
Interest
Overrides
Interest
Performance
Interest
Physics
Interest
Pipeline, Assets & IO
Interest
Platforms, Builds & Tests
Interest
Python API
Interest
Render & Cycles
Interest
Render Pipeline
Interest
Sculpt, Paint & Texture
Interest
Text Editor
Interest
Translations
Interest
Triaging
Interest
Undo
Interest
USD
Interest
User Interface
Interest
UV Editing
Interest
VFX & Video
Interest
Video Sequencer
Interest
Viewport & EEVEE
Interest
Virtual Reality
Interest
Vulkan
Interest
Wayland
Interest
Workbench
Interest: X11
Legacy
Asset Browser Project
Legacy
Blender 2.8 Project
Legacy
Milestone 1: Basic, Local Asset Browser
Legacy
OpenGL Error
Meta
Good First Issue
Meta
Papercut
Meta
Retrospective
Meta
Security
Module
Animation & Rigging
Module
Core
Module
Development Management
Module
Grease Pencil
Module
Modeling
Module
Nodes & Physics
Module
Pipeline, Assets & IO
Module
Platforms, Builds & Tests
Module
Python API
Module
Render & Cycles
Module
Sculpt, Paint & Texture
Module
Triaging
Module
User Interface
Module
VFX & Video
Module
Viewport & EEVEE
Platform
FreeBSD
Platform
Linux
Platform
macOS
Platform
Windows
Severity
High
Severity
Low
Severity
Normal
Severity
Unbreak Now!
Status
Archived
Status
Confirmed
Status
Duplicate
Status
Needs Info from Developers
Status
Needs Information from User
Status
Needs Triage
Status
Resolved
Type
Bug
Type
Design
Type
Known Issue
Type
Patch
Type
Report
Type
To Do
No Milestone
No Assignees
4 Participants
Notifications
Due Date
The due date is invalid or out of range. Please use the format 'yyyy-mm-dd'.

No due date set.

Dependencies

No dependencies set.

Reference: blender/blender#125718
No description provided.