fix fov, add named camera spaces

Signed-off-by: Alexey Smolenchuk <alexey.smolenchuk@gmail.com>

Author: AlexeySmolenchuk

src/testrender/cuda/optix_raytracer.cu

@@ -245,6 +245,10 @@ __raygen__setglobals()
         OSL::pvt::test_str_2            = render_params.test_str_2;
     }
 
+    OSL::pvt::num_named_xforms  = render_params.num_named_xforms;
+    OSL::pvt::xform_name_buffer = render_params.xform_name_buffer;
+    OSL::pvt::xform_buffer      = render_params.xform_buffer;
+
     if (render_params.bg_id < 0)
         return;
 

src/testrender/optixraytracer.cpp

@@ -114,6 +114,8 @@ OptixRaytracer::OptixRaytracer()
 
     CUDA_CHECK(cudaSetDevice(0));
     CUDA_CHECK(cudaStreamCreate(&m_cuda_stream));
+
+	cache = OIIO::ImageCache::create ();
 }
 
 
@@ -930,7 +932,7 @@ OptixRaytracer::get_texture_handle(ustring filename,
     auto itr = m_samplers.find(filename);
     if (itr == m_samplers.end()) {
         // Open image to check the number of mip levels
-        OIIO::ImageBuf image;
+        OIIO::ImageBuf image(filename, 0, 0, cache);
         if (!image.init_spec(filename, 0, 0)) {
             errhandler().errorfmt("Could not load: {} (hash {})", filename,
                                   filename);
@@ -1092,6 +1094,27 @@ OptixRaytracer::render(int xres OSL_MAYBE_UNUSED, int yres OSL_MAYBE_UNUSED)
     params.test_str_1            = test_str_1;
     params.test_str_2            = test_str_2;
 
+    // Named transforms
+    int nxforms = m_named_xforms.size();
+    params.num_named_xforms  = nxforms;
+    params.xform_name_buffer = DEVICE_ALLOC(sizeof(ustringhash)*nxforms);
+    params.xform_buffer      = DEVICE_ALLOC(sizeof(Transformation)*nxforms);
+    
+    std::vector<ustringhash> names;
+    std::vector<Transformation> xforms;
+    names.reserve(nxforms);
+    xforms.reserve(nxforms);
+
+    for (auto &pair : m_named_xforms)
+    {
+        names.push_back(pair.first);
+        xforms.push_back(*pair.second);
+    }
+
+    COPY_TO_DEVICE(params.xform_name_buffer, names.data(), sizeof(ustringhash)*nxforms);
+    COPY_TO_DEVICE(params.xform_buffer, xforms.data(), sizeof(Transformation)*nxforms);
+    CUDA_SYNC_CHECK();
+
     // Mesh data
     params.verts           = d_vertices;
     params.triangles       = d_vert_indices;

src/testrender/optixraytracer.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <OpenImageIO/ustring.h>
+#include <OpenImageIO/imagecache.h>
 
 #include <OSL/oslexec.h>
 
@@ -144,6 +145,8 @@ class OptixRaytracer final : public SimpleRaytracer {
     // CUdeviceptrs that need to be freed after we are done
     std::vector<CUdeviceptr> m_ptrs_to_free;
     std::vector<cudaArray_t> m_arrays_to_free;
+
+    std::shared_ptr<OIIO::ImageCache> cache;
 };
 
 

src/testrender/raytracer.h

@@ -135,8 +135,9 @@ struct Camera {
     {
         float k    = OIIO::fast_tan(fov * float(M_PI / 360));
         Vec3 right = dir.cross(up).normalize();
-        cx         = right * (xres * k / yres);
-        cy         = (cx.cross(dir)).normalize() * k;
+        // fov is horizontal
+        cx         = right * k;
+        cy         = (cx.cross(dir)).normalize() * k * yres / xres;
     }
 
     // Get a ray for the given screen coordinates.
@@ -147,7 +148,7 @@ struct Camera {
         // components with magnitudes slightly greater than 1.0, which can cause
         // downstream computations to blow up and produce NaNs. Normalizing the
         // vector again avoids this issue.
-        const Vec3 v = (cx * (x * invw - 0.5f) + cy * (0.5f - y * invh) + dir)
+        const Vec3 v = (cx * (x * invw - 0.5f) * 2.f + cy * (0.5f - y * invh) * 2.f + dir)
 #ifndef __CUDACC__
                            .normalize();
 #else

src/testrender/simpleraytracer.cpp

@@ -332,6 +332,7 @@ SimpleRaytracer::parse_scene_xml(const std::string& scenefile)
             if (fov_attr)
                 fov = OIIO::Strutil::from_string<float>(fov_attr.value());
 
+            m_fov = fov;
             camera.lookat(eye, dir, up, fov);
         } else if (strcmp(node.name(), "Sphere") == 0) {
             // load sphere
@@ -506,6 +507,60 @@ SimpleRaytracer::parse_scene_xml(const std::string& scenefile)
     if (scene.num_prims() == 0)
         errhandler().severefmt("No primitives in scene");
     camera.finalize();
+    prepare_camera_spaces();
+}
+
+
+
+void
+SimpleRaytracer::prepare_camera_spaces()
+{
+    Vec3 right = camera.cx.normalized();
+    Vec3 up    = camera.cy.normalized();
+
+    Matrix44 camera_to_world = {right.x,      right.y,      right.z,      0,
+                                up.x,         up.y,         up.z,         0,
+                                camera.dir.x, camera.dir.y, camera.dir.z, 0,
+                                camera.eye.x, camera.eye.y, camera.eye.z, 1};
+
+    name_transform("camera", camera_to_world );
+
+    // Seems never used once moved to named transforms
+    m_world_to_camera = camera_to_world.inverse();
+    Matrix44 M = m_world_to_camera;
+    float depthrange = (double)m_yon-(double)m_hither;
+    if (m_projection == RS::Hashes::perspective) {
+        float tanhalffov = tanf (0.5f * m_fov * M_PI/180.0);
+        Matrix44 camera_to_screen (1/tanhalffov, 0, 0, 0,
+                                    0, 1/tanhalffov, 0, 0,
+                                    0, 0, m_yon/depthrange, 1,
+                                    0, 0, -m_yon*m_hither/depthrange, 0);
+        M = M * camera_to_screen;
+    } else {
+        Matrix44 camera_to_screen (1, 0, 0, 0,
+                                    0, 1, 0, 0,
+                                    0, 0, 1/depthrange, 0,
+                                    0, 0, -m_hither/depthrange, 1);
+        M = M * camera_to_screen;
+    }
+    name_transform("screen", M.inverse() );
+
+    float aspect = (float)camera.yres / (float)camera.xres;
+    float screenleft = -1.0, screenwidth = 2.0;
+    float screenbottom = -1.0*aspect, screenheight = 2.0*aspect;
+    Matrix44 screen_to_ndc (1/screenwidth, 0, 0, 0,
+                            0, 1/screenheight, 0, 0,
+                            0, 0, 1, 0,
+                            -screenleft/screenwidth, -screenbottom/screenheight, 0, 1);
+    M = M * screen_to_ndc;
+    name_transform("NDC", M.inverse() );
+
+    Matrix44 ndc_to_raster (camera.xres, 0, 0, 0,
+                            0, camera.yres, 0, 0,
+                            0, 0, 1, 0,
+                            0, 0, 0, 1);
+    M = M * ndc_to_raster;
+    name_transform("raster", M.inverse() );
 }
 
 
@@ -577,48 +632,6 @@ bool
 SimpleRaytracer::get_inverse_matrix(ShaderGlobals* /*sg*/, Matrix44& result,
                                     ustringhash to, float /*time*/)
 {
-    if (to == OSL::Hashes::camera || to == OSL::Hashes::screen
-        || to == OSL::Hashes::NDC || to == RS::Hashes::raster) {
-        // clang-format off
-        Matrix44 M = m_world_to_camera;
-        if (to == OSL::Hashes::screen || to == OSL::Hashes::NDC || to == RS::Hashes::raster) {
-            float depthrange = (double)m_yon-(double)m_hither;
-            if (m_projection == RS::Hashes::perspective) {
-                float tanhalffov = tanf (0.5f * m_fov * M_PI/180.0);
-                Matrix44 camera_to_screen (1/tanhalffov, 0, 0, 0,
-                                           0, 1/tanhalffov, 0, 0,
-                                           0, 0, m_yon/depthrange, 1,
-                                           0, 0, -m_yon*m_hither/depthrange, 0);
-                M = M * camera_to_screen;
-            } else {
-                Matrix44 camera_to_screen (1, 0, 0, 0,
-                                           0, 1, 0, 0,
-                                           0, 0, 1/depthrange, 0,
-                                           0, 0, -m_hither/depthrange, 1);
-                M = M * camera_to_screen;
-            }
-            if (to == OSL::Hashes::NDC || to == RS::Hashes::raster) {
-                float screenleft = -1.0, screenwidth = 2.0;
-                float screenbottom = -1.0, screenheight = 2.0;
-                Matrix44 screen_to_ndc (1/screenwidth, 0, 0, 0,
-                                        0, 1/screenheight, 0, 0,
-                                        0, 0, 1, 0,
-                                        -screenleft/screenwidth, -screenbottom/screenheight, 0, 1);
-                M = M * screen_to_ndc;
-                if (to == RS::Hashes::raster) {
-                    Matrix44 ndc_to_raster (camera.xres, 0, 0, 0,
-                                            0, camera.yres, 0, 0,
-                                            0, 0, 1, 0,
-                                            0, 0, 0, 1);
-                    M = M * ndc_to_raster;
-                }
-            }
-        }
-        // clang-format on
-        result = M;
-        return true;
-    }
-
     TransformMap::const_iterator found = m_named_xforms.find(to);
     if (found != m_named_xforms.end()) {
         result = *(found->second);

src/testrender/simpleraytracer.h

@@ -85,6 +85,7 @@ class SimpleRaytracer : public RendererServices {
                                float yon, int xres, int yres);
 
     virtual void parse_scene_xml(const std::string& scenefile);
+    virtual void prepare_camera_spaces();
     virtual void prepare_render();
     void prepare_lights();
     void prepare_geometry();
@@ -113,14 +114,19 @@ class SimpleRaytracer : public RendererServices {
     int getBackgroundShaderID() const { return backgroundShaderID; }
     int getBackgroundResolution() const { return backgroundResolution; }
 
-private:
+protected:
     // Camera parameters
     Matrix44 m_world_to_camera;
     ustringhash m_projection;
     float m_fov, m_pixelaspect, m_hither, m_yon;
     float m_shutter[2];
     float m_screen_window[4];
 
+    // Named transforms
+    typedef std::map<ustringhash, std::shared_ptr<Transformation>> TransformMap;
+    TransformMap m_named_xforms;
+
+private:
     int backgroundShaderID   = -1;
     int backgroundResolution = 1024;
     int aa                   = 1;
@@ -140,10 +146,6 @@ class SimpleRaytracer : public RendererServices {
     std::unique_ptr<OIIO::ErrorHandler> m_errhandler;
     bool m_had_error = false;
 
-    // Named transforms
-    typedef std::map<ustringhash, std::shared_ptr<Transformation>> TransformMap;
-    TransformMap m_named_xforms;
-
     // Attribute and userdata retrieval -- for fast dispatch, use a hash
     // table to map attribute names to functions that retrieve them. We
     // imagine this to be fairly quick, but for a performance-critical