Misaki
4c62b3ecde
Added support for HDR sky lighting, including sampling environment maps with a hierarchical CDF. Added new utility functions for handling HDR sky data, including memory management and sampling functions. Added functions to improve texture handling, including pixel data retrieval and texture coordinate management. Changed the path tracing algorithm to enhance light evaluation from HDR skies and adjust light contribution calculations. Changed BSDF sampling functions to utilize constants from Common.h for better readability. Changed the main application logic to load HDR textures and configure the scene with improved lighting settings. Refactored ray intersection logic to enhance accuracy and performance in triangle intersections. Adjusted the sample count in the rendering configuration to optimize performance. Updated the README.md to document new features and example renders.
156 lines
3.9 KiB
C
156 lines
3.9 KiB
C
#ifndef LIGHT_H
|
|
#define LIGHT_H
|
|
|
|
#include "Algorithm/BVH.h"
|
|
#include "Algorithm/Sobol.h"
|
|
#include "Geometry/Triangle.h"
|
|
#include "Rendering/Texture.h"
|
|
#include "cglm/struct/vec3.h"
|
|
|
|
typedef struct
|
|
{
|
|
vec3s hit_point;
|
|
vec3s normal;
|
|
vec3s tangent;
|
|
vec2s uv;
|
|
vec3s wo;
|
|
|
|
uint16_t bounce_depth;
|
|
|
|
const bvh_tree_t* bvh_tree;
|
|
const texture_collection_t* textures;
|
|
} light_shading_context_t;
|
|
|
|
typedef path_output (*evaluate_bsdf_sky_f) (const void* data, const light_shading_context_t* context, vec3s throughput, uint32_t sample_index);
|
|
typedef void (*sky_free_f) (void* data);
|
|
|
|
typedef struct
|
|
{
|
|
uint16_t data_size;
|
|
void* data;
|
|
|
|
evaluate_bsdf_sky_f evaluate_bsdf_sky;
|
|
sky_free_f free_sky_data;
|
|
} sky_light_t;
|
|
|
|
typedef enum
|
|
{
|
|
LIGHT_TYPE_POINT,
|
|
LIGHT_TYPE_SPOT,
|
|
LIGHT_TYPE_AREA,
|
|
} punctual_light_type_e;
|
|
|
|
typedef struct
|
|
{
|
|
vec3s position;
|
|
vec3s color;
|
|
float intensity;
|
|
punctual_light_type_e type;
|
|
} punctual_light_t;
|
|
|
|
typedef struct
|
|
{
|
|
vec3s direction;
|
|
vec3s color;
|
|
float intensity;
|
|
float angular_diameter;
|
|
} directional_light_t;
|
|
|
|
typedef struct
|
|
{
|
|
uint32_t punctual_light_count;
|
|
uint32_t directional_light_count;
|
|
uint32_t max_punctual_lights;
|
|
uint32_t max_directional_lights;
|
|
|
|
sky_light_t sky_light;
|
|
punctual_light_t* punctual_lights;
|
|
directional_light_t* directional_lights;
|
|
} light_collection_t;
|
|
|
|
typedef struct
|
|
{
|
|
uint32_t id;
|
|
bool is_punctual;
|
|
} light_entity_t;
|
|
|
|
inline bool light_collection_create(uint32_t max_punctual_lights, uint32_t max_directional_lights, light_collection_t* collection)
|
|
{
|
|
if (max_punctual_lights == 0 || max_directional_lights == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
collection->max_punctual_lights = max_punctual_lights;
|
|
collection->max_directional_lights = max_directional_lights;
|
|
collection->punctual_light_count = 0;
|
|
collection->directional_light_count = 0;
|
|
|
|
collection->punctual_lights = (punctual_light_t*)malloc(max_punctual_lights * sizeof(punctual_light_t));
|
|
if (collection->punctual_lights == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
collection->directional_lights = (directional_light_t*)malloc(max_directional_lights * sizeof(directional_light_t));
|
|
if (collection->directional_lights == NULL)
|
|
{
|
|
free(collection->punctual_lights);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
inline light_entity_t light_create_punctual_light(light_collection_t* collection)
|
|
{
|
|
if (collection->punctual_light_count >= collection->max_punctual_lights)
|
|
{
|
|
return (light_entity_t){0};
|
|
}
|
|
|
|
punctual_light_t light = {0};
|
|
collection->punctual_lights[collection->punctual_light_count] = light;
|
|
light_entity_t entity = {.id = collection->punctual_light_count, .is_punctual = true};
|
|
collection->punctual_light_count++;
|
|
|
|
return entity;
|
|
}
|
|
|
|
inline light_entity_t light_create_directional_light(light_collection_t* collection)
|
|
{
|
|
if (collection->directional_light_count >= collection->max_directional_lights)
|
|
{
|
|
return (light_entity_t){0};
|
|
}
|
|
|
|
directional_light_t light = {0};
|
|
collection->directional_lights[collection->directional_light_count] = light;
|
|
light_entity_t entity = {.id = collection->directional_light_count, .is_punctual = false};
|
|
collection->directional_light_count++;
|
|
|
|
return entity;
|
|
}
|
|
|
|
inline void light_collection_free(light_collection_t* collection)
|
|
{
|
|
free(collection->punctual_lights);
|
|
free(collection->directional_lights);
|
|
|
|
if (collection->sky_light.free_sky_data != NULL)
|
|
{
|
|
collection->sky_light.free_sky_data(collection->sky_light.data);
|
|
}
|
|
free(collection->sky_light.data);
|
|
|
|
collection->max_punctual_lights = 0;
|
|
collection->max_directional_lights = 0;
|
|
collection->punctual_light_count = 0;
|
|
collection->directional_light_count = 0;
|
|
collection->punctual_lights = NULL;
|
|
collection->directional_lights = NULL;
|
|
collection->sky_light.data = NULL;
|
|
}
|
|
|
|
#endif // LIGHT_H
|