Misaki
6800810369
Added new files for BVH, AABB, and Debug functionalities. Added new utility functions in Common.h. Added gamma correction function in PostProcessing.h. Changed the return type of path_trace to vec4s for alpha blending. Changed BSDF function signatures to include sample index and bounce. Changed the BSDF.h to replace inline functions with declarations. Changed the Light and SkyLight evaluation functions to include throughput and sample index. Changed the sphere creation function in GeometryUtilities.h for better quality. Changed the scene structure to include a BVH tree for improved ray intersection. Changed the scene initialization parameters for better performance. Created new Debug functions for ray intersection counting. Created new functions for triangle collection management in Triangle.c. Improved pixel updating logic in Window.c. Improved ray intersection performance with new BVH implementation. Removed unused includes from Common.h. Removed old library linking methods in CMakeLists.txt.
143 lines
3.5 KiB
C
143 lines
3.5 KiB
C
#ifndef LIGHT_H
|
|
#define LIGHT_H
|
|
|
|
#include "Algorithm/BVH.h"
|
|
#include "Algorithm/Sobol.h"
|
|
#include "Geometry/Triangle.h"
|
|
#include "Material/Material.h"
|
|
#include "cglm/struct/vec3.h"
|
|
|
|
typedef struct
|
|
{
|
|
vec3s normal;
|
|
vec3s hit_point;
|
|
vec3s wo;
|
|
|
|
uint16_t bounce_depth;
|
|
|
|
const bvh_tree_t* bvh_tree;
|
|
const material_t* material;
|
|
} light_shading_context_t;
|
|
|
|
typedef vec3s (*evaluate_bsdf_sky_f) (const void* data, const light_shading_context_t* context, vec3s throughput, uint32_t index);
|
|
|
|
typedef struct
|
|
{
|
|
evaluate_bsdf_sky_f evaluate_bsdf_sky;
|
|
const void* 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);
|
|
|
|
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;
|
|
}
|
|
|
|
#endif // LIGHT_H
|