Master/RayTracer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
8104118a081e206f7a97a25f2a7761fbb6a05f1d
RayTracer/parsing_cylinder.c
T
H3XploR 8104118a08 updated
2025-02-17 18:22:13 +01:00

206 lines
8.0 KiB
C
Raw Blame History

/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parsing_cylinder.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: yantoine <yantoine@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/15 19:54:13 by yantoine #+# #+# */
/* Updated: 2025/02/17 18:21:13 by yantoine ### ########.fr */
/* */
/* ************************************************************************** */
#include "miniRT.h"
/*
float intersectCylinder(Ray ray, Cylinder cy, t_vec3 *hitNormal)
{
t_calc calc;
calc.d = ray.dir;
calc.oc = vec3_sub(ray.origin, cy.center);
calc.v = cy.axis;
calc.d_dot_v = vec3_dot(calc.d, calc.v);
calc.oc_dot_v = vec3_dot(calc.oc, calc.v);
calc.d_perp = vec3_sub(calc.calc.d, vec3_scale(calc.v, calc.d_dot_v));
oc_perp = vec3_sub(calc.oc, vec3_scale(calc.v, calc.oc_dot_v));
calc.a = vec3_dot(calc.d_perp, calc.d_perp);
calc.b = 2 * vec3_dot(calc.d_perp, oc_perp);
calc.c = vec3_dot(oc_perp, oc_perp) - cy.radius * cy.radius;
calc.disc = calc.b * calc.b - 4 * calc.a * calc.c;
if (calc.disc < 0)
return (-1);
calc.sqrtDisc = sqrtf(calc.disc);
calc.t0 = (-calc.b - calc.sqrtDisc) / (2 * calc.a);
calc.t1 = (-calc.b + calc.sqrtDisc) / (2 * calc.a);
calc.t_side = -1;
if (calc.t0 > 1e-3f)
{
calc.y = calc.oc_dot_v + calc.t0 * calc.d_dot_v;
if (fabs(calc.y) <= cy.height / 2.0f)
calc.t_side = calc.t0;
}
if (calc.t_side < 0 && calc.t1 > 1e-3f)
{
calc.y = calc.oc_dot_v + calc.t1 * calc.d_dot_v;
if (fabs(calc.y) <= cy.height / 2.0f)
calc.t_side = calc.t1;
}
calc.t_cap = -1;
if (fabs(calc.d_dot_v) > 1e-6f)
{
calc.t_bot = ((-cy.height / 2.0f) - calc.oc_dot_v) / calc.d_dot_v;
if (calc.t_bot > 1e-3f)
{
p = vec3_add(ray.origin, vec3_scale(calc.d, calc.t_bot));
cp = vec3_sub(p, cy.center);
calc.dist = vec3_length(vec3_sub(cp, vec3_scale(calc.v, vec3_dot(cp, calc.v))));
if (calc.dist <= cy.radius)
calc.t_cap = calc.t_bot;
}
t_top = ((cy.height / 2.0f) - calc.oc_dot_v) / calc.d_dot_v;
if (t_top > 1e-3f)
{
p = vec3_add(ray.origin, vec3_scale(calc.d, t_top));
cp = vec3_sub(p, cy.center);
calc.dist = vec3_length(vec3_sub(cp, vec3_scale(calc.v, vec3_dot(cp, calc.v))));
if (calc.dist <= cy.radius && (calc.t_cap < 0 || t_top < calc.t_cap))
calc.t_cap = t_top;
}
}
calc.t_final = -1;
if (calc.t_side > 1e-3f && calc.t_cap > 1e-3f)
calc.t_final = (calc.t_side < calc.t_cap) ? calc.t_side : calc.t_cap;
else if (calc.t_side > 1e-3f)
calc.t_final = calc.t_side;
else
calc.t_final = calc.t_cap;
if (calc.t_final < 1e-3f)
return (-1);
calc.hitPoint = vec3_add(ray.origin, vec3_scale(calc.d, calc.t_final));
cp = vec3_sub(calc.hitPoint, cy.center);
calc.proj = vec3_dot(cp, calc.v);
if (fabs(calc.proj) < cy.height / 2.0f - 1e-3f)
{
calc.n = vec3_sub(cp, vec3_scale(calc.v, calc.proj));
*hitNormal = vec3_normalize(calc.n);
}
else
{
*hitNormal = (calc.proj > 0) ? calc.v : vec3_scale(calc.v, -1);
}
return calc.t_final;
}*/
t_scene parsing_cylinder(const char *line, t_scene scene)
{
const char **tokens = get_tokens_secure(scene, scene.numCylinders, MAX_CYLINDERS, 6);
scene.token_if_exit = tokens;
scene.cylinders[scene.numCylinders].center = parse_vector(tokens[1], scene);
scene.cylinders[scene.numCylinders].axis = parse_vector_normalize(tokens[2], scene);
scene.cylinders[scene.numCylinders].radius = parse_float(tokens[3], scene);
scene.cylinders[scene.numCylinders].height = parse_float(tokens[4], scene);
scene.cylinders[scene.numCylinders].color = parse_color(tokens[5], scene);
ft_free_array(tokens);
scene.numCylinders++;
return (scene);
}
// Initialise les variables de calcul et les coefficients du polynôme d'intersection
static int init_intersection(Ray ray, Cylinder cy, t_calc *calc) {
calc->d = ray.dir;
calc->oc = vec3_sub(ray.origin, cy.center);
calc->v = cy.axis;
calc->d_dot_v = vec3_dot(calc->d, calc->v);
calc->oc_dot_v = vec3_dot(calc->oc, calc->v);
calc->d_perp = vec3_sub(calc->d, vec3_scale(calc->v, calc->d_dot_v));
calc->oc_perp = vec3_sub(calc->oc, vec3_scale(calc->v, calc->oc_dot_v));
calc->a = vec3_dot(calc->d_perp, calc->d_perp);
calc->b = 2 * vec3_dot(calc->d_perp, calc->oc_perp);
calc->c = vec3_dot(calc->oc_perp, calc->oc_perp) - cy.radius * cy.radius;
calc->disc = calc->b * calc->b - 4 * calc->a * calc->c;
if (calc->disc < 0)
return -1;
calc->sqrtDisc = sqrtf(calc->disc);
calc->t0 = (-calc->b - calc->sqrtDisc) / (2 * calc->a);
calc->t1 = (-calc->b + calc->sqrtDisc) / (2 * calc->a);
return 0;
}
// Calcule l'intersection sur la surface latérale du cylindre
static void compute_side_intersection(Ray ray, Cylinder cy, t_calc *calc) {
calc->t_side = -1;
if (calc->t0 > 1e-3f) {
calc->y = calc->oc_dot_v + calc->t0 * calc->d_dot_v;
if (fabs(calc->y) <= cy.height / 2.0f)
calc->t_side = calc->t0;
}
if (calc->t_side < 0 && calc->t1 > 1e-3f) {
calc->y = calc->oc_dot_v + calc->t1 * calc->d_dot_v;
if (fabs(calc->y) <= cy.height / 2.0f)
calc->t_side = calc->t1;
}
}
// Calcule l'intersection sur les capuchons supérieur et inférieur
static void compute_cap_intersection(Ray ray, Cylinder cy, t_calc *calc) {
calc->t_cap = -1;
if (fabs(calc->d_dot_v) > 1e-6f) {
calc->t_bot = ((-cy.height / 2.0f) - calc->oc_dot_v) / calc->d_dot_v;
if (calc->t_bot > 1e-3f) {
calc->p = vec3_add(ray.origin, vec3_scale(calc->d, calc->t_bot));
calc->cp = vec3_sub(calc->p, cy.center);
calc->dist = vec3_length(vec3_sub(calc->cp, vec3_scale(calc->v, vec3_dot(calc->cp, calc->v))));
if (calc->dist <= cy.radius)
calc->t_cap = calc->t_bot;
}
calc->t_top = ((cy.height / 2.0f) - calc->oc_dot_v) / calc->d_dot_v;
if (calc->t_top > 1e-3f) {
calc->p = vec3_add(ray.origin, vec3_scale(calc->d, calc->t_top));
calc->cp = vec3_sub(calc->p, cy.center);
calc->dist = vec3_length(vec3_sub(calc->cp, vec3_scale(calc->v, vec3_dot(calc->cp, calc->v))));
if (calc->dist <= cy.radius && (calc->t_cap < 0 || calc->t_top < calc->t_cap))
calc->t_cap = calc->t_top;
}
}
}
// Sélectionne l'intersection la plus proche entre la surface latérale et les capuchons
static float select_final_intersection(t_calc *calc) {
if (calc->t_side > 1e-3f && calc->t_cap > 1e-3f)
calc->t_final = (calc->t_side < calc->t_cap) ? calc->t_side : calc->t_cap;
else if (calc->t_side > 1e-3f)
calc->t_final = calc->t_side;
else
calc->t_final = calc->t_cap;
return (calc->t_final > 1e-3f) ? calc->t_final : -1;
}
// Calcule la normale au point d'intersection
static void compute_hit_normal(Ray ray, Cylinder cy, t_calc *calc, t_vec3 *hitNormal) {
calc->hitPoint = vec3_add(ray.origin, vec3_scale(calc->d, calc->t_final));
calc->cp = vec3_sub(calc->hitPoint, cy.center);
calc->proj = vec3_dot(calc->cp, calc->v);
if (fabs(calc->proj) < cy.height / 2.0f - 1e-3f) {
calc->n = vec3_sub(calc->cp, vec3_scale(calc->v, calc->proj));
*hitNormal = vec3_normalize(calc->n);
} else {
*hitNormal = (calc->proj > 0) ? calc->v : vec3_scale(calc->v, -1);
}
}
// Fonction principale d'intersection du cylindre
float intersectCylinder(Ray ray, Cylinder cy, t_vec3 *hitNormal) {
t_calc calc;
if (init_intersection(ray, cy, &calc) < 0)
return -1;
compute_side_intersection(ray, cy, &calc);
compute_cap_intersection(ray, cy, &calc);
if (select_final_intersection(&calc) < 0)
return -1;
compute_hit_normal(ray, cy, &calc, hitNormal);
return calc.t_final;
}
Reference in New Issue View Git Blame Copy Permalink