Fix trackball/camera and opengl rendering

Author: keckj

examples/cuda/dynamic_geometry.cu

@@ -101,14 +101,6 @@ extern "C" __global__ void __raygen__rg()
         static_cast< float >( idx.y ) / static_cast< float >( dim.y )
     ) - 1.0f;
 
-    if (idx.x == 0 && idx.y == 0 && idx.z == 0) {
-	    printf("ix=%u/%u, iy=%u/%u, width=%u, height=%u\n", idx.x, dim.x-1, idx.y, dim.y-1, params.width, params.height);
-	    printf("U: %f, %f, %f   V: %f, %f, %f,   W: %f, %f, %f,    eye: %f, %f, %f\n",
-		U.x, U.y, U.z, V.x, V.y, V.z, W.x, W.y, W.z, eye.x, eye.y, eye.z);
-	    printf("frame_buffer=%p, trav_handle=%p, subframe_index=%u\n", params.frame_buffer, params.trav_handle, params.subframe_index);
-    }
-
-
     const float3 direction = normalize( d.x * U + d.y * V + W );
     float3       payload_rgb = make_float3( 0.5f, 0.5f, 0.5f );
 

examples/dynamic_geometry.py

@@ -58,7 +58,7 @@ class DynamicGeometryState:
     __slots__ = ['params', 'time', 'ctx', 'module', 'pipeline', 'pipeline_opts',
             'raygen_grp', 'miss_grp', 'hit_grp', 'sbt',
             'generate_vertices_kernel', 'd_temp_vertices', 'last_exploding_sphere_rebuild_time',
-            'static_gas_handle', 'deforming_gas_handle', 'exploding_gas_handle', 'ias',
+            'static_gas', 'deforming_gas', 'exploding_gas', 'ias',
             'trackball', 'camera_changed', 'mouse_button', 'resize_dirty', 'minimized']
 
     def __init__(self):
@@ -78,7 +78,7 @@ def camera(self):
 
     @property
     def dimensions(self):
-        return (int(self.params.height), int(self.params.width))
+        return (int(self.params.width), int(self.params.height))
 
 class AnimationMode(enum.Enum):
     NONE = 0
@@ -101,17 +101,17 @@ class AnimationMode(enum.Enum):
 INST_COUNT = g_diffuse_colors.shape[0]
 
 g_instances = np.asarray([
-    [1, 0, 0, -4.5, 
-     0, 1, 0, 0, 
+    [1, 0, 0, -4.5,
+     0, 1, 0, 0,
      0, 0, 1, 0],
-    [1, 0, 0, -1.5, 
-     0, 1, 0, 0, 
+    [1, 0, 0, -1.5,
+     0, 1, 0, 0,
      0, 0, 1, 0],
-    [1, 0, 0, 1.5, 
-     0, 1, 0, 0, 
+    [1, 0, 0, 1.5,
+     0, 1, 0, 0,
      0, 0, 1, 0],
-    [1, 0, 0, 4.5, 
-     0, 1, 0, 0, 
+    [1, 0, 0, 4.5,
+     0, 1, 0, 0,
      0, 0, 1, 0],
 ], dtype=np.float32).reshape(INST_COUNT, 3, 4)
 
@@ -124,7 +124,7 @@ def mouse_button_callback(window, button, action, mods):
     (x, y) = glfw.get_cursor_pos(window)
     if action is glfw.PRESS:
         state.mouse_button = button
-        state.trackball.start_tracking(int(x), int(y))
+        state.trackball.start_tracking(x, y)
     else:
         state.mouse_button = -1
 
@@ -163,7 +163,7 @@ def key_callback(window, key, scancode, action, mods):
 
 def scroll_callback(window, xscroll, yscroll):
     state = glfw.get_window_user_pointer(window)
-    if state.trackball.wheel_event(int(yscroll)):
+    if state.trackball.wheel_event(yscroll):
         state.camera_changed = True
 
 #------------------------------------------------------------------------------
@@ -202,11 +202,6 @@ def update_state(output_buffer, state):
 
 def launch_subframe(output_buffer, state):
     state.params.frame_buffer = output_buffer.map()
-    
-    print('LAUNCH SUBFRAME')
-    print('state.dimensions', state.dimensions)
-    print(f'state.output_buffer: width={output_buffer.width}  height={output_buffer.height}')
-    print(f'state.params\n{state.params}')
 
     state.pipeline.launch(state.sbt, dimensions=state.dimensions,
             params=state.params.handle, stream=output_buffer.stream)
@@ -230,7 +225,7 @@ def init_camera_state(state):
     trackball = state.trackball
     trackball.move_speed = 10.0
     trackball.set_reference_frame([1,0,0], [0,0,1], [0,1,0])
-    trackball.gimbal_lock = True
+    trackball.reinitialize_orientation_from_camera()
 
 def create_context(state):
     logger = ox.Logger(log)
@@ -257,13 +252,13 @@ def update_mesh_accel(state):
 def build_vertex_generation_kernel(state):
     cuda_source = os.path.join(script_dir, 'cuda', 'dynamic_geometry_vertex_generation.cu')
     example_include_path = os.path.dirname(cuda_source)
-    
+
     build_flags = ox.module.get_default_nvrtc_compile_flags() + (f'-I{example_include_path}',)
 
     with open(cuda_source, 'r') as f:
         code = f.read()
 
-    state.generate_vertices_kernel = cp.RawKernel(code=code, backend='nvrtc', 
+    state.generate_vertices_kernel = cp.RawKernel(code=code, backend='nvrtc',
             options=build_flags, name='generate_vertices')
 
 def build_mesh_accel(state):
@@ -283,14 +278,14 @@ def build_mesh_accel(state):
     # Build an AS over the triangles.
     # We use un-indexed triangles so we can explode the sphere per triangle.
     build_input = ox.BuildInputTriangleArray(state.d_temp_vertices, flags=[ox.GeometryFlags.NONE])
-    state.static_gas_handle = ox.AccelerationStructure(state.ctx, build_input,
+    state.static_gas = ox.AccelerationStructure(state.ctx, build_input,
             compact=True, allow_update=True, random_vertex_access=True)
 
-    state.deforming_gas_handle = state.static_gas_handle
-    state.exploding_gas_handle = state.static_gas_handle
+    state.deforming_gas = state.static_gas
+    state.exploding_gas = state.static_gas
 
-    traversables = [state.static_gas_handle, state.static_gas_handle,
-                    state.deforming_gas_handle, state.exploding_gas_handle]
+    traversables = [state.static_gas, state.static_gas,
+                    state.deforming_gas, state.exploding_gas]
     instances = []
     for i in range(INST_COUNT):
         instance = ox.Instance(traversable=traversables[i], instance_id=0, flags=ox.InstanceFlags.NONE,

examples/dynamic_materials.py

@@ -62,7 +62,7 @@ def __init__(self, width, height):
 
     @property
     def dimensions(self):
-        return (int(self.params.image_height), int(self.params.image_width))
+        return (int(self.params.image_width), int(self.params.image_height))
 
 
 class MaterialIndex:
@@ -154,14 +154,15 @@ def create_context(state):
 
 def build_gas(state):
     aabb = np.asarray([[-1.5, -1.5, -1.5, 1.5, 1.5, 1.5]], dtype=np.float32)
-    build_input = ox.BuildInputCustomPrimitiveArray(aabb_buffers=aabb, num_sbt_records=1)
-    state.gas = ox.AccelerationStructure(state.ctx, build_input, compact=True)
+    build_input = ox.BuildInputCustomPrimitiveArray(aabb_buffers=aabb, flags=[ox.GeometryFlags.DISABLE_ANYHIT])
+    state.gas = ox.AccelerationStructure(state.ctx, build_input)
     state.params.radius = 1.5
 
 def build_ias(state):
+    return
     instances = []
     for i in range(transforms.shape[0]):
-        instance = ox.Instance(traversable=state.gas, instance_id=0, flags=ox.InstanceFlags.NONE,
+        instance = ox.Instance(traversable=state.gas, instance_id=0, flags=ox.InstanceFlags.DISABLE_ANYHIT,
                 sbt_offset=sbt_offsets[i], transform=transforms[i])
         instances.append(instance)
     state.instances = instances
@@ -173,7 +174,7 @@ def build_ias(state):
 def create_module(state):
     pipeline_opts = ox.PipelineCompileOptions(
             uses_motion_blur=False,
-            traversable_graph_flags=ox.TraversableGraphFlags.ALLOW_SINGLE_LEVEL_INSTANCING,
+            traversable_graph_flags=ox.TraversableGraphFlags.ALLOW_SINGLE_GAS,
             uses_primitive_type_flags=ox.PrimitiveTypeFlags.CUSTOM,
             num_payload_values=3,
             num_attribute_values=3,
@@ -220,7 +221,7 @@ def create_pipeline(state):
                            compile_options=state.pipeline_opts,
                            link_options=link_opts,
                            program_groups=program_grps,
-                           max_traversable_graph_depth=2)
+                           max_traversable_graph_depth=1)
 
     pipeline.compute_stack_sizes(1,  # max_trace_depth
                                  0,  # max_cc_depth

optix/sutils/camera.py

@@ -29,8 +29,10 @@ def _set_direction(self, value):
     direction = property(_get_direction, _set_direction)
 
     def uvw_frame(self):
+        # do not normalize W -- it implies focal length
         W = self.look_at - self.eye
         wlen = length(W)
+        assert wlen > 0, (self.eye, self.look_at)
 
         U = normalize(cross(W, self.up))
         V = normalize(cross(U, W))

optix/sutils/cuda_output_buffer.py

@@ -119,7 +119,7 @@ def _reallocate_buffers(self):
         buffer_type = self.buffer_type
 
         dtype = self.pixel_format
-        shape = (self.width, self.height)
+        shape = (self.height, self.width)
 
         if buffer_type is CudaOutputBufferType.CUDA_DEVICE:
             self._host_buffer = np.empty(shape=shape, dtype=dtype)

optix/sutils/gl_display.py

@@ -1,4 +1,4 @@
-
+import ctypes
 import numpy as np
 
 import OpenGL.GL as gl
@@ -11,13 +11,13 @@ class GLDisplay:
 """
 #version 330 core
 
-layout(location = 0) in vec3 vertexPosition_modelspace;
+layout(location = 0) in vec3 position;
 out vec2 UV;
 
 void main()
 {
-    gl_Position =  vec4(vertexPosition_modelspace,1);
-    UV = (vec2(vertexPosition_modelspace.x, vertexPosition_modelspace.y)+vec2(1,1))/2.0;
+    gl_Position =  vec4(position, 1);
+    UV = (vec2(position.x, position.y) + vec2(1,1)) / 2.0;
 }
 """
 
@@ -26,14 +26,13 @@ class GLDisplay:
 #version 330 core
 
 in vec2 UV;
-out vec3 color;
+layout(location=0) out vec4 color;
 
 uniform sampler2D render_tex;
-uniform bool correct_gamma;
 
 void main()
 {
-    color = texture(render_tex, UV).xyz;
+    color = texture(render_tex, UV).xyzw;
 }
 """
 
@@ -90,6 +89,7 @@ def display(self, screen_res_x, screen_res_y, framebuf_res_x, framebuf_res_y, pb
         gl.glViewport(0, 0, framebuf_res_x, framebuf_res_y)
         gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
         gl.glUseProgram(self._program)
+        gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_FILL)
 
         gl.glActiveTexture(gl.GL_TEXTURE0)
         gl.glBindTexture(gl.GL_TEXTURE_2D, self._render_tex)
@@ -109,7 +109,6 @@ def display(self, screen_res_x, screen_res_y, framebuf_res_x, framebuf_res_y, pb
 
         image_format = self._image_format
         if(image_format == BufferImageFormat.UCHAR4):
-            # input is assumed to be in srgb since it is only 1 byte per channel in size
             gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA8, screen_res_x, screen_res_y,
                             0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None)
             convert_to_srgb = False
@@ -120,22 +119,21 @@ def display(self, screen_res_x, screen_res_y, framebuf_res_x, framebuf_res_y, pb
             gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA32F, screen_res_x, screen_res_y,
                             0, gl.GL_RGBA, gl.GL_FLOAT, None)
         else:
-            raise NotImplementedError("Unknown buffer format.")
+            raise NotImplementedError(f"Unknown image format {image_format}.")
+
+        if convert_to_srgb:
+            gl.glEnable(gl.GL_FRAMEBUFFER_SRGB)
+        else:
+            gl.glDisable(gl.GL_FRAMEBUFFER_SRGB)
 
         gl.glBindBuffer(gl.GL_PIXEL_UNPACK_BUFFER, 0)
         gl.glUniform1i(self._render_tex_uniforloc, 0)
 
         # 1st attribute buffer : vertices
         gl.glEnableVertexAttribArray(0)
         gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._quad_vertex_buffer)
-        gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
-
-        if convert_to_srgb:
-            gl.glEnable(gl.GL_FRAMEBUFFER_SRGB)
-        else:
-            gl.glDisable(gl.GL_FRAMEBUFFER_SRGB)
-
+        gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, ctypes.c_void_p(0))
         gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)
-
         gl.glDisableVertexAttribArray(0)
+
         gl.glDisable(gl.GL_FRAMEBUFFER_SRGB)

optix/sutils/gui.py

@@ -37,6 +37,8 @@ def init_ui(window_title, width, height):
     if not window:
         raise RuntimeError("Could not initialize Window")
 
+    glfw.swap_interval(0)
+
     init_gl()
     impl = init_imgui(window)
 
@@ -62,20 +64,20 @@ def display_stats(state_update_time, render_time, display_time):
 
     cur_time = glfw.get_time()
 
+    display_stats.last_update_frames += 1
     last_update_time = display_stats.last_update_time or cur_time - 1e-7
     last_update_frames = display_stats.last_update_frames
     total_subframe_count = display_stats.total_subframe_count
 
     dt = cur_time - last_update_time
-    display_stats.last_update_frames += 1
 
     do_update = (dt > display_update_min_interval_time) or (total_subframe_count == 0)
 
     if do_update:
         fps = last_update_frames / dt
-        state_ms = 1000.0 * state_update_time
-        render_ms = 1000.0 * render_time
-        display_ms = 1000.0 * display_time
+        state_ms = 1000.0 * state_update_time / last_update_frames
+        render_ms = 1000.0 * render_time / last_update_frames
+        display_ms = 1000.0 * display_time / last_update_frames
 
         display_stats.last_update_time = cur_time
         display_stats.last_update_frames = 0

optix/sutils/trackball.py

@@ -2,7 +2,7 @@
 
 import numpy as np
 
-from optix.sutils.properties import get_member, set_bool, set_int, set_float, set_float3
+from optix.sutils.properties import get_member, set_bool, set_float, set_float3
 from optix.sutils.vecmath import dot, length, normalize
 from optix.sutils.camera import Camera
 
@@ -28,9 +28,8 @@ def __init__(self):
     roll_speed = property(get_member('_roll_speed'), set_float('_roll_speed', 0.5))
     latitude = property(get_member('_latitude'), set_float('_latitude', 0.0))
     longitude = property(get_member('_longitude'), set_float('_longitude', 0.0))
-
-    previous_position_x = property(get_member('_previous_position_x'), set_int('_previous_position_x', 0))
-    previous_position_y = property(get_member('_previous_position_y'), set_int('_previous_position_y', 0))
+    previous_position_x = property(get_member('_previous_position_x'), set_float('_previous_position_x', 0))
+    previous_position_y = property(get_member('_previous_position_y'), set_float('_previous_position_y', 0))
 
     gimbal_lock = property(get_member('_gimbal_lock'), set_bool('_gimbal_lock', False))
     perform_tracking = property(get_member('_perform_tracking'), set_bool('_perform_tracking', False))
@@ -64,7 +63,6 @@ def _set_camera(self, camera):
     camera = property(_get_camera, _set_camera)
 
     def start_tracking(self, x, y):
-        x, y = int(x), int(y)
         self.previous_position_x = x
         self.previous_position_y = y
         self.perform_tracking = True
@@ -73,10 +71,12 @@ def update_tracking(self, x, y, canvas_width, canvas_height):
         if not self._perform_tracking:
             return self.start_tracking(x, y)
 
-        x, y = int(x), int(y)
         delta_x = x - self.previous_position_x
         delta_y = y - self.previous_position_y
 
+        if delta_x == 0 and delta_y == 0:
+            return
+
         self.previous_position_x = x
         self.previous_position_y = y
 
@@ -85,7 +85,7 @@ def update_tracking(self, x, y, canvas_width, canvas_height):
 
         self._update_camera()
 
-        if self.gimbal_lock:
+        if not self.gimbal_lock:
             self.reinitialize_orientation_from_camera()
             self.camera.up = self.w
 
@@ -133,6 +133,7 @@ def set_reference_frame(self, u, v, w):
         self.v = v
         self.w = w
 
+        assert length(self.camera.look_at - self.camera.eye) != 0
         dir_ws = -normalize(self.camera.look_at - self.camera.eye)
 
         dirx = dot(dir_ws, u)

optix/sutils/vecmath.py

@@ -11,8 +11,9 @@ def length(x):
     return np.sqrt(dot(x, x))
 
 def normalize(x):
-    return x/length(x)
-
+    l = length(x)
+    assert l>0, x
+    return x/l
 
 def ctype_to_dtype(ctype):
     _ctype_to_dtype = {