RayTracingTypes.h

Go to the documentation of this file.

 
#ifndef RAYTRACING_TYPES_H
#define RAYTRACING_TYPES_H
 
#include "Context.h"
#include "IndexTypes.h"
#include <vector>
 
namespace helios {
 
    struct PrimitiveTypeGeometry {
        std::vector<helios::vec3> vertices; 
        std::vector<uint> UUIDs; 
        size_t count = 0; 
    };
 
    struct RayTracingGeometry {
 
        // Per-primitive data (indexed by primitive index 0..primitive_count-1)
        std::vector<float> transform_matrices; 
        std::vector<uint> primitive_types; 
        std::vector<uint> primitive_UUIDs; 
        std::vector<uint> primitive_IDs; 
        std::vector<uint> object_IDs; 
        std::vector<helios::int2> object_subdivisions; 
        std::vector<char> twosided_flags; 
        std::vector<float> solid_fractions; 
 
        // UUID-to-position lookup table (indexed by UUID value)
        std::vector<uint> primitive_positions;
 
        // Per-type geometry data
        PrimitiveTypeGeometry patches; 
        PrimitiveTypeGeometry triangles; 
        PrimitiveTypeGeometry tiles; 
        PrimitiveTypeGeometry voxels; 
        PrimitiveTypeGeometry bboxes; 
 
        // Disk-specific data (disks don't use vertex arrays)
        std::vector<helios::vec3> disk_centers; 
        std::vector<float> disk_radii; 
        std::vector<helios::vec3> disk_normals; 
        std::vector<uint> disk_UUIDs; 
        size_t disk_count = 0; 
 
        // Texture/masking data
        std::vector<bool> mask_data; 
        std::vector<helios::int2> mask_sizes; 
        std::vector<int> mask_IDs; 
        std::vector<helios::vec2> uv_data; 
        std::vector<int> uv_IDs; 
 
        // Periodic boundary condition
        helios::vec2 periodic_flag; 
 
        // Counts
        size_t primitive_count = 0; 
        size_t patch_count = 0; 
        size_t triangle_count = 0; 
        size_t tile_count = 0; 
        size_t voxel_count = 0; 
        size_t bbox_count = 0; 
        uint bbox_UUID_base = 0; 
 
        // UUID ↔ Position mapping utility (CPU-side type-safe conversion)
        UUIDPositionMapper mapper;
 
        // ========== Helper Methods for Backend Implementation ==========
 
        size_t getPerPrimitiveBufferSize() const {
            return primitive_count;
        }
 
        size_t getUUIDLookupBufferSize() const {
            if (primitive_UUIDs.empty())
                return 0;
            return *std::max_element(primitive_UUIDs.begin(), primitive_UUIDs.end()) + 1;
        }
 
        void validate() const;
    };
 
    struct RayTracingMaterial {
        std::vector<float> reflectivity; 
        std::vector<float> transmissivity; 
        std::vector<float> reflectivity_cam; 
        std::vector<float> transmissivity_cam; 
        std::vector<float> specular_exponent; 
        std::vector<float> specular_scale; 
 
        // Translucent cover (glass/plastic) material. When is_glass != 0 for a [source][primitive][band]
        // entry, the angular transmittance/reflectance is computed on-device from glass_n and glass_KL
        // via the Fresnel+Bouguer model, overriding reflectivity/transmissivity for that entry.
        std::vector<float> glass_n; 
        std::vector<float> glass_KL; 
        std::vector<char> is_glass; 
 
        size_t num_bands = 0; 
        size_t num_sources = 0; 
        size_t num_primitives = 0; 
        size_t num_cameras = 0; 
    };
 
    struct RayTracingSource {
        helios::vec3 position; 
        helios::vec3 rotation; 
        helios::vec2 width; 
        uint type; 
        std::vector<float> fluxes; 
        std::vector<float> fluxes_cam; 
    };
 
    struct RayTracingLaunchParams {
        // Launch dimensions
        uint launch_offset = 0; 
        uint launch_count = 0; 
        uint rays_per_primitive = 0; 
        uint random_seed = 0; 
 
        // Band configuration
        uint current_band = 0; 
        uint num_bands_global = 0; 
        uint num_bands_launch = 0; 
        std::vector<bool> band_launch_flag; 
 
        // Scattering
        uint scattering_iteration = 0; 
        uint max_scatters = 0; 
 
        // Face selection (for diffuse rays)
        uint launch_face = 0; 
 
        // Camera-specific parameters
        uint camera_id = 0; 
        helios::vec3 camera_position; 
        helios::vec2 camera_direction; 
        float camera_focal_length = 0.0f; 
        float camera_lens_diameter = 0.0f; 
        float camera_fov_aspect = 0.0f; 
        helios::int2 camera_resolution; 
        float camera_HFOV = 0.0f; 
        uint antialiasing_samples = 1; 
        helios::int2 camera_pixel_offset; 
        float camera_viewplane_length = 0.0f; 
        float camera_pixel_solid_angle = 0.0f; 
        helios::int2 camera_resolution_full; 
 
        // Diffuse radiation parameters (for diffuse ray launches)
        std::vector<float> diffuse_flux; 
        std::vector<float> diffuse_extinction; 
        std::vector<helios::vec3> diffuse_peak_dir; 
        std::vector<float> diffuse_dist_norm; 
        std::vector<helios::vec4> sky_radiance_params; 
 
        // Emission/outgoing radiation (for diffuse ray launches)
        std::vector<float> radiation_out_top; 
        std::vector<float> radiation_out_bottom; 
 
        // Flags
        uint specular_reflection_enabled = 0; 
    };
 
    struct RayTracingResults {
        std::vector<float> radiation_in; 
        std::vector<float> radiation_out_top; 
        std::vector<float> radiation_out_bottom; 
        std::vector<float> scatter_buff_top; 
        std::vector<float> scatter_buff_bottom; 
        std::vector<float> scatter_buff_top_cam; 
        std::vector<float> scatter_buff_bottom_cam; 
        std::vector<float> radiation_specular; 
        std::vector<float> sky_energy; 
 
        size_t num_primitives = 0; 
        size_t num_bands = 0; 
        size_t num_sources = 0; 
        size_t num_cameras = 0; 
    };
 
} // namespace helios
 
#endif // RAYTRACING_TYPES_H