Helios/_opti_x8_launch_params_8h_source.html

#ifndef OPTIX8_LAUNCH_PARAMS_H

#define OPTIX8_LAUNCH_PARAMS_H


// This header is included by both host (.cpp) and device (.cu) code.

// Only use types compatible with both CUDA and C++.

#include <stdint.h>


// CUDA vector types (float3, float2, int2, float4, ...) - available in both host and device contexts

#include <vector_types.h>


// OptiX traversable handle type (host and device)

#include <optix.h>


#ifndef M_PI

#define M_PI 3.14159265358979323846f

#endif


typedef unsigned int uint;


// Maximum number of radiation bands that may be launched together. Used to size the

// per-band translucent-cover transmittance accumulator in the payload (the payload lives in a

// per-thread pool, not registers, so this array adds no register pressure). The host validates

// that the launch band count does not exceed this cap (fail-fast) before launching.

#ifndef HELIOS_MAX_RADIATION_BANDS

#define HELIOS_MAX_RADIATION_BANDS 32

#endif


// ---------------------------------------------------------------------------

// Per-ray payload.  Passed by pointer-in-two-registers.

// Allocated in a per-thread pool on the device.

// ---------------------------------------------------------------------------


struct PerRayData {

    double strength;

    uint   origin_UUID;

    bool   face;

    uint   seed;

    unsigned char source_ID;

    bool   hit_periodic_boundary;

    float3 periodic_hit;

    float  cover_transmittance[HELIOS_MAX_RADIATION_BANDS];

};


// ---------------------------------------------------------------------------

// SBT hit-group record data (per primitive type).

// ---------------------------------------------------------------------------


struct HitGroupData {

    float3*   vertices;

    uint32_t* UUIDs;

    uint32_t  prim_type;

};


// ---------------------------------------------------------------------------

// Main launch parameters structure.

// Passed from host to device via optixLaunch(d_params, ...).

// Accessible on device as: extern "C" __constant__ OptiX8LaunchParams params;

// ---------------------------------------------------------------------------


struct OptiX8LaunchParams {

    // Traversal handle

    OptixTraversableHandle traversable;


    // ---- Per-ray-data pool (size = launch_dim_x * launch_dim_y) ----

    PerRayData* prd_pool;


    // ---- Geometry buffers (device pointers) ----

    float*    transform_matrix;

    uint32_t* primitive_type;

    uint32_t* primitive_positions;

    uint32_t* primitiveID;

    uint32_t* objectID;

    int32_t*  object_subdivisions;

    int8_t*   twosided_flag;

    float*    primitive_solid_fraction;


    // ---- Global UUID lookup (indexed by global primitive position) ----

    uint32_t* primitive_uuid;


    // ---- Per-type geometry (also in SBT HitGroupData, mirrored here for easy access) ----

    float3*   patch_vertices;

    uint32_t* patch_UUIDs;

    float3*   triangle_vertices;

    uint32_t* triangle_UUIDs;

    float3*   disk_centers;

    float*    disk_radii;

    float3*   disk_normals;

    uint32_t* disk_UUIDs;

    float3*   tile_vertices;

    uint32_t* tile_UUIDs;

    float3*   voxel_vertices;

    uint32_t* voxel_UUIDs;

    float3*   bbox_vertices;

    uint32_t* bbox_UUIDs;


    // ---- Material buffers ----

    float*    rho;

    float*    tau;

    float*    rho_cam;

    float*    tau_cam;

    float*    specular_exponent;

    float*    specular_scale;


    // ---- Translucent cover (glass/plastic) material buffers (same layout as rho/tau) ----

    float*    glass_n;

    float*    glass_KL;

    int8_t*   is_glass;


    // ---- Radiation energy buffers ----

    float*    radiation_in;

    float*    radiation_out_top;

    float*    radiation_out_bottom;

    float*    scatter_buff_top;

    float*    scatter_buff_bottom;

    float*    radiation_in_camera;

    float*    scatter_buff_top_cam;

    float*    scatter_buff_bottom_cam;

    float*    radiation_specular;

    float*    Rsky;


    // ---- Camera output buffers ----

    uint32_t* camera_pixel_label;

    float*    camera_pixel_depth;


    // ---- Source buffers ----

    float3*   source_positions;

    float3*   source_rotations;

    float2*   source_widths;

    uint32_t* source_types;

    float*    source_fluxes;

    float*    source_fluxes_cam;


    // ---- Diffuse/sky buffers ----

    float*    diffuse_flux;

    float*    diffuse_extinction;

    float3*   diffuse_peak_dir;

    float*    diffuse_dist_norm;

    float4*   sky_radiance_params;

    float*    camera_sky_radiance;

    float*    solar_disk_radiance;

    float*    camera_diffuse_flux;

    uint32_t* band_emission_flag;


    // ---- Band launch flags ----

    bool*     band_launch_flag;


    // ---- Texture/mask buffers ----

    uint8_t*  mask_data;

    uint32_t* mask_offsets;

    int32_t*  mask_sizes;

    int32_t*  mask_IDs;

    float2*   uv_data;

    int32_t*  uv_IDs;


    // ---- Scalar parameters ----

    uint32_t  Nprimitives;

    uint32_t  Nsources;

    uint32_t  Ncameras;

    uint32_t  Nbands_global;

    uint32_t  Nbands_launch;

    uint32_t  launch_offset;

    uint32_t  launch_count;

    uint32_t  rays_per_primitive;

    uint32_t  random_seed;

    uint32_t  launch_face;

    uint32_t  scattering_iteration;

    uint32_t  specular_reflection_enabled;

    uint32_t  camera_ID;

    uint32_t  bbox_UUID_base;


    float2    periodic_flag;

    float3    sun_direction;

    float     solar_disk_cos_angle;

    float2    camera_direction;

    float3    camera_position;

    float     camera_lens_diameter;

    float     camera_focal_length;

    float     FOV_aspect_ratio;

    float     camera_HFOV;

    int2      camera_resolution;

    float     camera_viewplane_length;

    float     camera_pixel_solid_angle;

    int2      camera_pixel_offset;

    int2      camera_resolution_full;


    // ---- Launch grid ----

    uint32_t  launch_dim_x;

    uint32_t  launch_dim_y;

};


// ---------------------------------------------------------------------------

// Helper: pack/unpack 64-bit pointer into two 32-bit OptiX payload registers

// Device-only (requires OptiX device header)

// ---------------------------------------------------------------------------

#ifdef __CUDACC__

static __forceinline__ __device__ void packPointer(void *ptr, uint32_t &u0, uint32_t &u1) {

    const uint64_t uptr = reinterpret_cast<uint64_t>(ptr);

    u0 = static_cast<uint32_t>(uptr >> 32);

    u1 = static_cast<uint32_t>(uptr & 0xFFFFFFFFULL);

}


static __forceinline__ __device__ void *unpackPointer(uint32_t u0, uint32_t u1) {

    const uint64_t uptr = (static_cast<uint64_t>(u0) << 32) | static_cast<uint64_t>(u1);

    return reinterpret_cast<void *>(uptr);

}


static __forceinline__ __device__ PerRayData *getPayloadPRD() {

    const uint32_t u0 = optixGetPayload_0();

    const uint32_t u1 = optixGetPayload_1();

    return reinterpret_cast<PerRayData *>(unpackPointer(u0, u1));

}

#endif // __CUDACC__


#endif // OPTIX8_LAUNCH_PARAMS_H