From 2019ca1f700c305369ddebc397c68f2bfcf50774 Mon Sep 17 00:00:00 2001
From: Jakob Progsch <jakob@progsch.net>
Date: Wed, 25 Jan 2023 17:25:08 +0100
Subject: [PATCH] Expand attributes scene to test different samplers and their
 parameters

---
 libs/anari_test_scenes/scenes/attributes.cpp | 285 ++++++++++++++++++-
 1 file changed, 276 insertions(+), 9 deletions(-)

diff --git a/libs/anari_test_scenes/scenes/attributes.cpp b/libs/anari_test_scenes/scenes/attributes.cpp
index bc3d02f5..295446e0 100644
--- a/libs/anari_test_scenes/scenes/attributes.cpp
+++ b/libs/anari_test_scenes/scenes/attributes.cpp
@@ -6,6 +6,7 @@
 #include "glm/ext/matrix_transform.hpp"
 #include <limits>
 #include <type_traits>
+#include <cmath>
 
 namespace anari {
 namespace scenes {
@@ -15,6 +16,7 @@ static float vertices[] = {
     1.f, -1.f, 0.f,
     -1.f, -1.f, 0.f,
     -1.f, 1.f, 0.f,
+    0.f, 0.f, 0.f,
 };
 
 static float uv[] = {
@@ -22,11 +24,14 @@ static float uv[] = {
     1.f, 0.f,
     0.f, 0.f,
     0.f, 1.f,
+    0.5f, 0.5f,
 };
 
 static uint32_t indices[] = {
-    0, 1, 2,
-    0, 2, 3,
+    0, 1, 4,
+    1, 2, 4,
+    2, 3, 4,
+    3, 0, 4,
 };
 
 static float colors4f[] = {
@@ -34,6 +39,8 @@ static float colors4f[] = {
     0.f, 1.f, 0.f, 1.f,
     0.f, 0.f, 1.f, 1.f,
     1.f, 1.f, 1.f, 1.f,
+    0.5f, 0.5f, 0.5f, 1.f,
+
 };
 
 static float colors3f[] = {
@@ -41,6 +48,7 @@ static float colors3f[] = {
     0.f, 1.f, 0.f,
     0.f, 0.f, 1.f,
     1.f, 1.f, 1.f,
+    0.5f, 0.5f, 0.5f,
 };
 
 
@@ -49,6 +57,7 @@ static float colors2f[] = {
     0.f, 1.f,
     0.f, 0.f,
     1.f, 1.f,
+    0.5f, 0.5f,
 };
 
 static float colors1f[] = {
@@ -56,6 +65,7 @@ static float colors1f[] = {
     0.f,
     0.f,
     1.f,
+    0.5f,
 };
 
 static uint32_t colors4u[] = {
@@ -63,6 +73,7 @@ static uint32_t colors4u[] = {
     UINT32_C(0), UINT32_MAX, UINT32_C(0), UINT32_MAX,
     UINT32_C(0), UINT32_C(0), UINT32_MAX, UINT32_MAX,
     UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX,
+    UINT32_MAX/2u, UINT32_MAX/2u, UINT32_MAX/2u, UINT32_MAX,
 };
 
 static uint32_t colors3u[] = {
@@ -70,6 +81,7 @@ static uint32_t colors3u[] = {
     UINT32_C(0), UINT32_MAX, UINT32_C(0),
     UINT32_C(0), UINT32_C(0), UINT32_MAX,
     UINT32_MAX, UINT32_MAX, UINT32_MAX,
+    UINT32_MAX/2u, UINT32_MAX/2u, UINT32_MAX/2u,
 };
 
 
@@ -78,6 +90,7 @@ static uint32_t colors2u[] = {
     UINT32_C(0), UINT32_MAX,
     UINT32_C(0), UINT32_C(0),
     UINT32_MAX, UINT32_MAX,
+    UINT32_MAX/2u, UINT32_MAX/2u,
 };
 
 static uint32_t colors1u[] = {
@@ -85,6 +98,7 @@ static uint32_t colors1u[] = {
     UINT32_C(0),
     UINT32_C(0),
     UINT32_MAX,
+    UINT32_MAX/2u,
 };
 
 static uint16_t colors4us[] = {
@@ -92,6 +106,7 @@ static uint16_t colors4us[] = {
     UINT16_C(0), UINT16_MAX, UINT16_C(0), UINT16_MAX,
     UINT16_C(0), UINT16_C(0), UINT16_MAX, UINT16_MAX,
     UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX,
+    UINT16_MAX/2u, UINT16_MAX/2u, UINT16_MAX/2u, UINT16_MAX,
 };
 
 static uint16_t colors3us[] = {
@@ -99,6 +114,7 @@ static uint16_t colors3us[] = {
     UINT16_C(0), UINT16_MAX, UINT16_C(0),
     UINT16_C(0), UINT16_C(0), UINT16_MAX,
     UINT16_MAX, UINT16_MAX, UINT16_MAX,
+    UINT16_MAX/2u, UINT16_MAX/2u, UINT16_MAX/2u,
 };
 
 
@@ -107,6 +123,7 @@ static uint16_t colors2us[] = {
     UINT16_C(0), UINT16_MAX,
     UINT16_C(0), UINT16_C(0),
     UINT16_MAX, UINT16_MAX,
+    UINT16_MAX/2u, UINT16_MAX/2u,
 };
 
 static uint16_t colors1us[] = {
@@ -114,6 +131,7 @@ static uint16_t colors1us[] = {
     UINT16_C(0),
     UINT16_C(0),
     UINT16_MAX,
+    UINT16_MAX/2u,
 };
 
 static uint8_t colors4ub[] = {
@@ -121,6 +139,7 @@ static uint8_t colors4ub[] = {
     UINT8_C(0), UINT8_MAX, UINT8_C(0), UINT8_MAX,
     UINT8_C(0), UINT8_C(0), UINT8_MAX, UINT8_MAX,
     UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX,
+    UINT8_MAX/2u, UINT8_MAX/2u, UINT8_MAX/2u, UINT8_MAX,
 };
 
 static uint8_t colors3ub[] = {
@@ -128,6 +147,7 @@ static uint8_t colors3ub[] = {
     UINT8_C(0), UINT8_MAX, UINT8_C(0),
     UINT8_C(0), UINT8_C(0), UINT8_MAX,
     UINT8_MAX, UINT8_MAX, UINT8_MAX,
+    UINT8_MAX/2u, UINT8_MAX/2u, UINT8_MAX/2u,
 };
 
 
@@ -136,6 +156,7 @@ static uint8_t colors2ub[] = {
     UINT8_C(0), UINT8_MAX,
     UINT8_C(0), UINT8_C(0),
     UINT8_MAX, UINT8_MAX,
+    UINT8_MAX/2u, UINT8_MAX/2u,
 };
 
 static uint8_t colors1ub[] = {
@@ -143,6 +164,7 @@ static uint8_t colors1ub[] = {
     UINT8_C(0),
     UINT8_C(0),
     UINT8_MAX,
+    UINT8_MAX/2u,
 };
 
 void *arrays[] = {
@@ -241,12 +263,146 @@ ANARIMaterial setupTexturedMaterial(ANARIDevice d,
   return material;
 }
 
+ANARIMaterial setupSamplerMaterial2D(ANARIDevice d, ANARIArray2D array2d,
+  float *inTransform, float *outTransform,
+  const char *filter, const char *wrapMode1, const char *wrapMode2)
+{
+  ANARISampler sampler = anariNewSampler(d, "image2D");
+  anari::setParameter(d, sampler, "image", array2d);
+  anari::setParameter(d, sampler, "inAttribute", "attribute0");
+
+  if(inTransform) {
+    anari::setParameter(d, sampler, "inTransform", ANARI_FLOAT32_MAT4, inTransform);
+  }
+  if(outTransform) {
+    anari::setParameter(d, sampler, "outTransform", ANARI_FLOAT32_MAT4, outTransform);
+  }
+  if(filter) {
+    anari::setParameter(d, sampler, "filter", filter);
+  }
+  if(wrapMode1) {
+    anari::setParameter(d, sampler, "wrapMode1", wrapMode1);
+  }
+  if(wrapMode2) {
+    anari::setParameter(d, sampler, "wrapMode2", wrapMode2);
+  }
+
+  anari::commitParameters(d, sampler);
+
+  auto material = anari::newObject<anari::Material>(d, "matte");
+  anari::setAndReleaseParameter(d, material, "color", sampler);
+  anari::commitParameters(d, material);
+
+  return material;
+}
+
+ANARIMaterial setupSamplerMaterial1D(ANARIDevice d, ANARIArray1D array1d,
+  float *inTransform, float *outTransform,
+  const char *filter, const char *wrapMode1)
+{
+  ANARISampler sampler = anariNewSampler(d, "image1D");
+  anari::setParameter(d, sampler, "image", array1d);
+  anari::setParameter(d, sampler, "inAttribute", "attribute0");
+
+  if(inTransform) {
+    anari::setParameter(d, sampler, "inTransform", ANARI_FLOAT32_MAT4, inTransform);
+  }
+  if(outTransform) {
+    anari::setParameter(d, sampler, "outTransform", ANARI_FLOAT32_MAT4, outTransform);
+  }
+  if(filter) {
+    anari::setParameter(d, sampler, "filter", filter);
+  }
+  if(wrapMode1) {
+    anari::setParameter(d, sampler, "wrapMode1", wrapMode1);
+  }
+
+  anari::commitParameters(d, sampler);
+
+  auto material = anari::newObject<anari::Material>(d, "matte");
+  anari::setAndReleaseParameter(d, material, "color", sampler);
+  anari::commitParameters(d, material);
+
+  return material;
+}
+
+ANARIMaterial setupSamplerMaterial3D(ANARIDevice d, ANARIArray3D array3d,
+  float *inTransform, float *outTransform,
+  const char *filter, const char *wrapMode1, const char *wrapMode2, const char *wrapMode3)
+{
+  ANARISampler sampler = anariNewSampler(d, "image3D");
+  anari::setParameter(d, sampler, "image", array3d);
+  anari::setParameter(d, sampler, "inAttribute", "attribute0");
+
+  if(inTransform) {
+    anari::setParameter(d, sampler, "inTransform", ANARI_FLOAT32_MAT4, inTransform);
+  }
+  if(outTransform) {
+    anari::setParameter(d, sampler, "outTransform", ANARI_FLOAT32_MAT4, outTransform);
+  }
+  if(filter) {
+    anari::setParameter(d, sampler, "filter", filter);
+  }
+  if(wrapMode1) {
+    anari::setParameter(d, sampler, "wrapMode1", wrapMode1);
+  }
+  if(wrapMode2) {
+    anari::setParameter(d, sampler, "wrapMode2", wrapMode1);
+  }
+  if(wrapMode3) {
+    anari::setParameter(d, sampler, "wrapMode3", wrapMode1);
+  }
+
+  anari::commitParameters(d, sampler);
+
+  auto material = anari::newObject<anari::Material>(d, "matte");
+  anari::setAndReleaseParameter(d, material, "color", sampler);
+  anari::commitParameters(d, material);
+
+  return material;
+}
+
+ANARIMaterial setupSamplerTransform(ANARIDevice d,
+  float *transform)
+{
+  ANARISampler sampler = anariNewSampler(d, "transform");
+  anari::setParameter(d, sampler, "inAttribute", "attribute0");
+
+  if(transform) {
+    anari::setParameter(d, sampler, "transform", ANARI_FLOAT32_MAT4, transform);
+  }
+
+  anari::commitParameters(d, sampler);
+
+  auto material = anari::newObject<anari::Material>(d, "matte");
+  anari::setAndReleaseParameter(d, material, "color", sampler);
+  anari::commitParameters(d, material);
+
+  return material;
+}
+
+ANARIMaterial setupSamplerPrimitive(ANARIDevice d, ANARIArray1D array1d, uint64_t offset)
+{
+  ANARISampler sampler = anariNewSampler(d, "primitive");
+  anari::setParameter(d, sampler, "array", array1d);
+  anari::setParameter(d, sampler, "offset", offset);
+
+  anari::commitParameters(d, sampler);
+
+  auto material = anari::newObject<anari::Material>(d, "matte");
+  anari::setAndReleaseParameter(d, material, "color", sampler);
+  anari::commitParameters(d, material);
+
+  return material;
+}
+
+
 void Attributes::commit()
 {
   auto d = m_device;
 
-  auto vertexArray = anariNewArray1D(d, vertices, 0, 0, ANARI_FLOAT32_VEC3, 4);
-  auto indexArray = anariNewArray1D(d, indices, 0, 0, ANARI_UINT32_VEC3, 2);
+  auto vertexArray = anariNewArray1D(d, vertices, 0, 0, ANARI_FLOAT32_VEC3, 5);
+  auto indexArray = anariNewArray1D(d, indices, 0, 0, ANARI_UINT32_VEC3, 4);
 
   ANARIGeometry geometries[64] = { };
   for(int i = 0;i<16;++i) {
@@ -256,7 +412,7 @@ void Attributes::commit()
     anari::setAndReleaseParameter(d,
         geometries[i],
         "primitive.color",
-        anariNewArray1D(d, arrays[i], 0, 0, types[i], 2));
+        anariNewArray1D(d, arrays[i], 0, 0, types[i], 4));
     anari::commitParameters(d, geometries[i]);
   }
 
@@ -267,7 +423,7 @@ void Attributes::commit()
     anari::setAndReleaseParameter(d,
         geometries[i+16],
         "vertex.color",
-        anariNewArray1D(d, arrays[i], 0, 0, types[i], 4));
+        anariNewArray1D(d, arrays[i], 0, 0, types[i], 5));
     anari::commitParameters(d, geometries[i+16]);
   }
 
@@ -282,10 +438,10 @@ void Attributes::commit()
   anari::setAndReleaseParameter(d,
       textured,
       "vertex.attribute0",
-      anariNewArray1D(d, uv, 0, 0, ANARI_FLOAT32_VEC2, 4));
+      anariNewArray1D(d, uv, 0, 0, ANARI_FLOAT32_VEC2, 5));
   anari::commitParameters(d, textured);
 
-  ANARIMaterial materials[16];
+  ANARIMaterial materials[32] = { };
   materials[0] = setupTexturedMaterial<float>(d, 32, 32, 4, ANARI_FLOAT32_VEC4, "attribute0");
   materials[1] = setupTexturedMaterial<float>(d, 32, 32, 3, ANARI_FLOAT32_VEC3, "attribute0");
   materials[2] = setupTexturedMaterial<float>(d, 32, 32, 2, ANARI_FLOAT32_VEC2, "attribute0");
@@ -307,6 +463,113 @@ void Attributes::commit()
   materials[15] = setupTexturedMaterial<uint8_t>(d, 32, 32, 1, ANARI_UFIXED8, "attribute0");
 
 
+  int N = 32;
+  Picture<uint8_t> p(N, N, 4);
+  fill_texture(p);
+  ANARIArray2D array2d = anariNewArray2D(d, p.data.data(), 0, 0, ANARI_UFIXED8_VEC4, N, N);
+
+  std::vector<uint8_t> data3d(4*N*N*N);
+  for(uint64_t z = 0;z<N;++z) {
+    for(uint64_t y = 0;y<N;++y) {
+      for(uint64_t x = 0;x<N;++x) {
+        float r = float(x)/float(N-1);
+        float g = float(y)/float(N-1);
+        float b = float(z)/float(N-1);
+        float m = (x/4 + y/4 + z/4)%2 ? 1.0f : 0.5f;
+        uint64_t idx = x + N*y + N*N*z;
+        data3d[4*idx+0] = m*r*255u;
+        data3d[4*idx+1] = m*g*255u;
+        data3d[4*idx+2] = m*b*255u;
+        data3d[4*idx+3] = 255u;
+      }
+    }
+  }
+  ANARIArray3D array3d = anariNewArray3D(d, data3d.data(), 0, 0, ANARI_UFIXED8_VEC4, N, N, N);
+
+  std::vector<uint8_t> data1d(4*N);
+  for(uint64_t i = 0;i<N;++i) {
+    float s = float(i)/float(N-1);
+    float r = std::fmaxf(1.0f-2.0f*s, 0.0f);
+    float g = 1.0f-std::fabs(2.0f*s-1.0f);
+    float b = std::fmaxf(2.0f*s-1.0f, 0.0f);
+    data1d[4*i+0] = r*255u;
+    data1d[4*i+1] = g*255u;
+    data1d[4*i+2] = b*255u;
+    data1d[4*i+3] = 255u;
+  }
+  ANARIArray1D array1d = anariNewArray1D(d, data1d.data(), 0, 0, ANARI_UFIXED8_VEC4, N);
+  
+
+  float scale2[16] = {
+    2.0f, 0.0f, 0.0f, 0.0f,
+    0.0f, 2.0f, 0.0f, 0.0f,
+    0.0f, 0.0f, 1.0f, 0.0f,
+   -0.5f,-0.5f, 0.0f, 1.0f,
+  };
+
+  float scalehalf[16] = {
+    0.5f, 0.0f, 0.0f, 0.0f,
+    0.0f, 0.5f, 0.0f, 0.0f,
+    0.0f, 0.0f, 1.0f, 0.0f,
+    0.0f, 0.0f, 0.0f, 1.0f,
+  };
+
+
+  float sqr = 2.0f*std::sqrt(0.5f);
+  float rotate[16] = {
+     sqr, -sqr, 0.0f, 0.0f,
+     sqr,  sqr, 0.0f, 0.0f,
+    0.0f, 0.0f, 1.0f, 0.0f,
+    0.0f, 0.0f, 0.0f, 1.0f,
+  };
+
+
+  float third = 1.0f/3.0f;
+  float grayscale[16] = {
+    third, third, third, 0.0f,
+    third, third, third, 0.0f,
+    third, third, third, 0.0f,
+    0.0f, 0.0f, 0.0f, 1.0f,
+  };
+
+  float complementary[16] = {
+    0.0f, 1.0f, 1.0f, 0.0f,
+    1.0f, 0.0f, 1.0f, 0.0f,
+    1.0f, 1.0f, 0.0f, 0.0f,
+    0.0f, 0.0f, 0.0f, 1.0f,
+  };
+
+  float tex3d[16] = {
+    1.0f, 0.0f,-0.5f, 0.0f,
+    0.0f, 1.0f,-0.5f, 0.0f,
+    0.0f, 0.0f, 0.0f, 0.0f,
+    0.0f, 0.0f, 1.0f, 1.0f,
+  };
+
+  materials[16] = setupSamplerMaterial2D(d, array2d, scale2, nullptr, nullptr, "clampToEdge", "clampToEdge");
+  materials[17] = setupSamplerMaterial2D(d, array2d, scale2, nullptr, nullptr, "repeat", nullptr);
+  materials[18] = setupSamplerMaterial2D(d, array2d, scale2, nullptr, nullptr, "repeat", "repeat");
+  materials[19] = setupSamplerMaterial2D(d, array2d, scale2, nullptr, nullptr, "mirrorRepeat", "mirrorRepeat");
+
+  materials[20] = setupSamplerMaterial2D(d, array2d, rotate, nullptr, nullptr, "repeat", "repeat");
+  materials[21] = setupSamplerMaterial2D(d, array2d, scalehalf, nullptr, "linear", "repeat", "repeat");
+  materials[22] = setupSamplerMaterial2D(d, array2d, nullptr, grayscale, nullptr, nullptr, nullptr);
+  materials[23] = setupSamplerMaterial2D(d, array2d, nullptr, complementary, nullptr, nullptr, nullptr);
+
+  materials[24] = setupSamplerMaterial1D(d, array1d, nullptr, nullptr, "linear", nullptr);
+  materials[25] = setupSamplerMaterial1D(d, array1d, rotate, nullptr, "linear", "repeat");
+  materials[26] = setupSamplerMaterial3D(d, array3d, nullptr, nullptr, "linear", nullptr, nullptr, nullptr);
+  materials[27] = setupSamplerMaterial3D(d, array3d, tex3d, nullptr, "linear", nullptr, nullptr, nullptr);
+
+  materials[28] = setupSamplerTransform(d, nullptr);
+  materials[29] = setupSamplerTransform(d, complementary);
+  materials[30] = setupSamplerPrimitive(d, array1d, 0);
+  materials[31] = setupSamplerPrimitive(d, array1d, 16);
+
+  anari::release(d, array1d);
+  anari::release(d, array2d);
+  anari::release(d, array3d);
+
   std::vector<ANARIInstance> instances;
 
   for(int i = 0;i<32;++i) {
@@ -342,7 +605,10 @@ void Attributes::commit()
   }
 
 
-  for(int i = 0;i<16;++i) {
+  for(int i = 0;i<32;++i) {
+    if(!materials[i]) {
+      continue;
+    }
 
     int x = i%4;
     int y = i/4;
@@ -375,6 +641,7 @@ void Attributes::commit()
   }
 
 
+
   for(auto g : geometries) {
     anari::release(d, g);
   }