Add Chromium-only Blender WebEngine parity work

blender-5.2.0/source/blender/gpu/vulkan/tests/vk_data_conversion_test.cc

@@ -0,0 +1,147 @@
+/* SPDX-FileCopyrightText: 2023 Blender Authors
+ *
+ * SPDX-License-Identifier: Apache-2.0 */
+
+#include "testing/testing.h"
+
+#include "vk_data_conversion.hh"
+#include "vk_device.hh"
+
+#include "gpu_vertex_format_private.hh"
+
+namespace blender::gpu::tests {
+
+TEST(VulkanDataConversion, clamp_negative_to_zero)
+{
+  const uint32_t f32_2 = 0b11000000000000000000000000000000;
+  const uint32_t f32_inf_min = 0b11111111100000000000000000000000;
+  const uint32_t f32_inf_max = 0b01111111100000000000000000000000;
+  const uint32_t f32_nan = 0b11111111111111111111111111111111;
+
+  /* F32(-2) doesn't fit in F11 as F11 only supports unsigned values. Clamp to zero. */
+  const uint32_t f11_0_expected = 0b00000000000;
+  const uint32_t f11_2_expected = 0b10000000000;
+  const uint32_t f11_inf_expected = 0b11111000000;
+  const uint32_t f11_nan_expected = 0b11111111111;
+  {
+    const uint32_t f11_0 = convert_float_formats<FormatF11, FormatF32, true>(f32_2);
+    EXPECT_EQ(f11_0, f11_0_expected);
+    const uint32_t f11_0b = convert_float_formats<FormatF11, FormatF32, true>(f32_inf_min);
+    EXPECT_EQ(f11_0b, f11_0_expected);
+    const uint32_t f11_inf = convert_float_formats<FormatF11, FormatF32, true>(f32_inf_max);
+    EXPECT_EQ(f11_inf, f11_inf_expected);
+    const uint32_t f11_nan = convert_float_formats<FormatF11, FormatF32, true>(f32_nan);
+    EXPECT_EQ(f11_nan, f11_nan_expected);
+  }
+
+  /* F32(-2) doesn't fit in F11 as F11 only supports unsigned values. Make absolute. */
+  {
+    const uint32_t f11_2 = convert_float_formats<FormatF11, FormatF32, false>(f32_2);
+    EXPECT_EQ(f11_2, f11_2_expected);
+    const uint32_t f11_inf = convert_float_formats<FormatF11, FormatF32, false>(f32_inf_min);
+    EXPECT_EQ(f11_inf, f11_inf_expected);
+    const uint32_t f11_infb = convert_float_formats<FormatF11, FormatF32, false>(f32_inf_max);
+    EXPECT_EQ(f11_infb, f11_inf_expected);
+    const uint32_t f11_nan = convert_float_formats<FormatF11, FormatF32, false>(f32_nan);
+    EXPECT_EQ(f11_nan, f11_nan_expected);
+  }
+}
+
+TEST(VulkanDataConversion, infinity_upper)
+{
+  const uint32_t f32_inf = 0b01111111100000000000000000000000;
+
+  const uint32_t f11_inf_expected = 0b11111000000;
+  const uint32_t f11_inf = convert_float_formats<FormatF11, FormatF32, true>(f32_inf);
+  EXPECT_EQ(f11_inf, f11_inf_expected);
+
+  const uint32_t f10_inf_expected = 0b1111100000;
+  const uint32_t f10_inf = convert_float_formats<FormatF10, FormatF32, true>(f32_inf);
+  EXPECT_EQ(f10_inf, f10_inf_expected);
+}
+
+TEST(VulkanDataConversion, texture_rgb16f_as_floats_to_rgba16f)
+{
+  const size_t num_pixels = 4;
+  const float input[] = {
+      1.0,
+      0.5,
+      0.2,
+
+      0.2,
+      1.0,
+      0.3,
+
+      0.4,
+      0.2,
+      1.0,
+
+      1.0,
+      1.0,
+      1.0,
+  };
+
+  uint64_t device[num_pixels];
+  convert_host_to_device(device,
+                         input,
+                         num_pixels,
+                         GPU_DATA_FLOAT,
+                         TextureFormat::SFLOAT_16_16_16,
+                         TextureFormat::SFLOAT_16_16_16_16);
+
+  float read_back[num_pixels * 3];
+  convert_device_to_host(read_back,
+                         device,
+                         num_pixels,
+                         GPU_DATA_FLOAT,
+                         TextureFormat::SFLOAT_16_16_16,
+                         TextureFormat::SFLOAT_16_16_16_16);
+
+  for (int i : IndexRange(num_pixels * 3)) {
+    EXPECT_NEAR(input[i], read_back[i], 0.01);
+  }
+}
+
+TEST(VulkanDataConversion, texture_rgb32f_as_floats_to_rgba32f)
+{
+  const size_t num_pixels = 4;
+  const float input[] = {
+      1.0,
+      0.5,
+      0.2,
+
+      0.2,
+      1.0,
+      0.3,
+
+      0.4,
+      0.2,
+      1.0,
+
+      1.0,
+      1.0,
+      1.0,
+  };
+
+  float device[num_pixels * 4];
+  convert_host_to_device(device,
+                         input,
+                         num_pixels,
+                         GPU_DATA_FLOAT,
+                         TextureFormat::SFLOAT_32_32_32,
+                         TextureFormat::SFLOAT_32_32_32_32);
+
+  float read_back[num_pixels * 3];
+  convert_device_to_host(read_back,
+                         device,
+                         num_pixels,
+                         GPU_DATA_FLOAT,
+                         TextureFormat::SFLOAT_32_32_32,
+                         TextureFormat::SFLOAT_32_32_32_32);
+
+  for (int i : IndexRange(num_pixels * 3)) {
+    EXPECT_NEAR(input[i], read_back[i], 0.01);
+  }
+}
+
+}  // namespace blender::gpu::tests

blender-5.2.0/source/blender/gpu/vulkan/tests/vk_memory_layout_test.cc

@@ -0,0 +1,149 @@
+/* SPDX-FileCopyrightText: 2023 Blender Authors
+ *
+ * SPDX-License-Identifier: Apache-2.0 */
+
+#include "testing/testing.h"
+
+#include "vk_memory_layout.hh"
+
+namespace blender::gpu {
+
+template<typename Layout>
+static void def_attr(const shader::Type type,
+                     const int array_size,
+                     const uint32_t expected_alignment,
+                     const uint32_t expected_reserve,
+                     uint32_t *r_offset)
+{
+  align<Layout>(type, array_size, r_offset);
+  EXPECT_EQ(*r_offset, expected_alignment);
+  reserve<Layout>(type, array_size, r_offset);
+  EXPECT_EQ(*r_offset, expected_reserve);
+}
+
+TEST(std140, fl)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std140>(shader::Type::float_t, 0, 0, 4, &offset);
+
+  align_end_of_struct<Std140>(&offset);
+  EXPECT_EQ(offset, 16);
+}
+
+TEST(std140, _2fl)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std140>(shader::Type::float_t, 0, 0, 4, &offset);
+  def_attr<Std140>(shader::Type::float_t, 0, 4, 8, &offset);
+
+  align_end_of_struct<Std140>(&offset);
+  EXPECT_EQ(offset, 16);
+}
+
+TEST(std140, _3fl)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std140>(shader::Type::float_t, 0, 0, 4, &offset);
+  def_attr<Std140>(shader::Type::float_t, 0, 4, 8, &offset);
+  def_attr<Std140>(shader::Type::float_t, 0, 8, 12, &offset);
+
+  align_end_of_struct<Std140>(&offset);
+  EXPECT_EQ(offset, 16);
+}
+
+TEST(std140, _4fl)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std140>(shader::Type::float_t, 0, 0, 4, &offset);
+  def_attr<Std140>(shader::Type::float_t, 0, 4, 8, &offset);
+  def_attr<Std140>(shader::Type::float_t, 0, 8, 12, &offset);
+  def_attr<Std140>(shader::Type::float_t, 0, 12, 16, &offset);
+
+  align_end_of_struct<Std140>(&offset);
+  EXPECT_EQ(offset, 16);
+}
+
+TEST(std140, fl2)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std140>(shader::Type::float_t, 2, 0, 32, &offset);
+
+  align_end_of_struct<Std140>(&offset);
+  EXPECT_EQ(offset, 32);
+}
+
+TEST(std140, fl_fl2)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std140>(shader::Type::float_t, 0, 0, 4, &offset);
+  def_attr<Std140>(shader::Type::float_t, 2, 16, 48, &offset);
+
+  align_end_of_struct<Std140>(&offset);
+  EXPECT_EQ(offset, 48);
+}
+
+TEST(std140, fl_vec2)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std140>(shader::Type::float_t, 0, 0, 4, &offset);
+  def_attr<Std140>(shader::Type::float2_t, 0, 8, 16, &offset);
+
+  align_end_of_struct<Std140>(&offset);
+  EXPECT_EQ(offset, 16);
+}
+
+TEST(std140, gpu_shader_2D_widget_base)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std140>(shader::Type::float4_t, 12, 0, 192, &offset);
+  def_attr<Std140>(shader::Type::float4x4_t, 0, 192, 256, &offset);
+  def_attr<Std140>(shader::Type::float3_t, 0, 256, 268, &offset);
+  def_attr<Std140>(shader::Type::bool_t, 0, 268, 272, &offset);
+
+  align_end_of_struct<Std140>(&offset);
+  EXPECT_EQ(offset, 272);
+}
+
+TEST(std430, overlay_grid)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std430>(shader::Type::float3_t, 0, 0, 12, &offset);
+  def_attr<Std430>(shader::Type::int_t, 0, 12, 16, &offset);
+
+  align_end_of_struct<Std430>(&offset);
+  EXPECT_EQ(offset, 16);
+}
+
+TEST(std430, simple_lighting)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std430>(shader::Type::float4x4_t, 0, 0, 64, &offset);
+  def_attr<Std430>(shader::Type::float3x3_t, 0, 64, 112, &offset);
+
+  align_end_of_struct<Std430>(&offset);
+  EXPECT_EQ(offset, 112);
+}
+
+TEST(std430, compositor_cryptomatte_matte_compute)
+{
+  uint32_t offset = 0;
+
+  def_attr<Std430>(shader::Type::float2_t, 0, 0, 8, &offset);
+  def_attr<Std430>(shader::Type::float_t, 0, 8, 12, &offset);
+  def_attr<Std430>(shader::Type::float_t, 32, 12, 140, &offset);
+
+  align_end_of_struct<Std430>(&offset);
+  EXPECT_EQ(offset, 144);
+}
+
+}  // namespace blender::gpu