void VectorMutable::commit_sub_vector( RTOpPack::MutableSubVector* sub_vec_inout )
{
RTOpPack::SparseSubVector spc_sub_vec(
sub_vec_inout->globalOffset(), sub_vec_inout->subDim()
,sub_vec_inout->values(), sub_vec_inout->stride()
);
VectorMutable::set_sub_vector( spc_sub_vec ); // Commit the changes!
RTOpPack::SubVector sub_vec(*sub_vec_inout);
Vector::free_sub_vector( &sub_vec ); // Free the memory!
sub_vec_inout->set_uninitialized(); // Make null as promised!
}
double inter_plan(t_object *obj, t_ray *ray)
{
t_plan *plan;
t_vec tmp;
double d;
plan = &obj->prim.plan;
sub_vec(&tmp, &ray->ori, &plan->pos);
d = -(dot_product(&plan->normal, &tmp)
/ dot_product(&plan->normal, &ray->dir));
return (d);
}
void check_triangle(t_item *item, t_pd *s, t_inter *inter, t_thr *f)
{
t_vec n;
t_vec a;
FLOAT_SIZE t;
n = (prod_vector(item->tr->u, item->tr->v));
a.x = -dot_prod(n, sub_vec(s->pos, item->tr->p1));
a.y = dot_prod(n, s->dir);
if (fabs(a.y) > 0 && (t = a.x / a.y) >= 0)
{
n = sub_vec(set_dist_pos(t, s->dir, s->pos), item->tr->p1);
a.x = dot_prod(n, item->tr->u);
a.y = dot_prod(n, item->tr->v);
a.z = (a.y * item->tr->uv - item->tr->vv * a.x) / item->tr->d;
a.y = (item->tr->uv * a.x - item->tr->uu * a.y) / item->tr->d;
if (a.z < 0.0 || a.z > 1.0 || a.y < 0.0 || (a.y + a.z) > 1.0)
return ;
if (check_t(inter, t, s, item) == 1 && f->impactmod)
inter->norm = item->tr->n;
}
return ;
}
void shade(t_raytracer *ray, t_vec dir)
{
if (ray->shade > 0)
{
ray->l = sub_vec(ray->tmp->pos, ray->pi);
ray->l = norm(ray->l);
if (ray->ret->diffuse > 0)
{
ray->dot = DOT(ray->n, ray->l);
if (ray->dot > 0)
ray->color = dot_positif(ray);
}
specular(ray, dir);
}
}
void set_nray(t_raytracer *ray, t_obj *l, t_vec dir, t_vec o)
{
ray->shade = 1.0f;
if (ray->tmp->type == SPHERE)
tmp_type_sphere(ray, l);
if (ray->ret->type == SPHERE)
{
ray->n = sub_vec(ray->pi, ray->ret->pos);
ray->n = mul_vec(ray->n, 1.0f / ray->ret->radius);
}
else if (ray->ret->type == PLAN)
ray->n = ray->ret->pos;
else
ray->n = set_nvec(ray->ret, dir, o, ray->ret2);
}
double inter_cylinder(t_object *obj, t_ray *ray)
{
t_cylinder *cyl;
t_vec tmp;
double d;
double a;
double b;
double c;
cyl = &obj->prim.cylinder;
sub_vec(&tmp, &ray->ori, &cyl->pos);
a = pow(ray->dir.x, 2) + pow(ray->dir.y, 2);
b = 2 * (ray->dir.x * tmp.x + ray->dir.y * tmp.y);
c = pow(ray->ori.x, 2) + pow(ray->ori.y, 2) - pow(cyl->radius, 2);
d = determinant(a, b, c);
return (d);
}
void specular(t_raytracer *ray, t_vec dir)
{
t_specular spc;
if (ray->ret->specular > 0)
{
spc.r_spect = 2.0f * DOT(ray->l, ray->n);
spc.r_spec = mul_vec(ray->n, spc.r_spect);
spc.r_spec = sub_vec(ray->l, spc.r_spec);
spc.dot_spec = DOT(dir, spc.r_spec);
if (spc.dot_spec > 0)
{
spc.spect_diff = powf(spc.dot_spec, 20)
* ray->ret->specular * ray->shade;
spc.ret_spec = mul_vec(ray->tmp->col, spc.spect_diff);
ray->color = add_vec(ray->color, spc.ret_spec);
}
}
}
t_color diffuse_plan(t_light *li, t_object *obj, t_vec *vi, double sh)
{
t_color col;
t_vec u;
double dot;
double diff;
col.r = 0;
col.g = 0;
col.b = 0;
sub_vec(&u, &li->pos, vi);
normalize(&u);
dot = dot_product(&u, &obj->prim.plan.normal);
if (dot > 0)
{
diff = dot * 0.9 * sh;
diff_col(&col, &obj->color, &li->color, diff);
}
return (col);
}
double inter_sphere(t_object *obj, t_ray *ray)
{
t_sphere *sphere;
t_vec tmp;
double d;
double a;
double b;
double c;
sphere = &obj->prim.sphere;
a = square_length(&ray->dir);
sub_vec(&tmp, &ray->ori, &sphere->center);
b = 2 * dot_product(&ray->dir, &tmp);
c = square_length(&sphere->center) + square_length(&ray->ori)
+ -2 * dot_product(&sphere->center, &ray->ori)
- pow(sphere->radius, 2);
d = determinant(a, b, c);
if (d >= 0)
return (d);
return (-1);
}
void check_cyl(t_item *item, t_pd *s, t_inter *inter, int impactmod)
{
FLOAT_SIZE a;
FLOAT_SIZE b;
FLOAT_SIZE c;
FLOAT_SIZE t;
t_vec l;
l = sub_vec(s->pos, item->cyl->pos);
a = dot_prod(s->dir, s->dir) - (dot_prod(s->dir,
item->cyl->dir) * dot_prod(s->dir, item->cyl->dir));
b = 2 * (dot_prod(s->dir, l) - (dot_prod(s->dir,
item->cyl->dir) * dot_prod(l, item->cyl->dir)));
c = dot_prod(l, l) - (dot_prod(l, item->cyl->dir)
* dot_prod(l, item->cyl->dir)) - item->cyl->ray * item->cyl->ray;
if ((t = (b * b - 4.0 * a * c)) <= 0)
return ;
t = ft_minspe(((-b + sqrt(t)) / (2 * a)), ((-b - sqrt(t)) / (2 * a)));
if (check_t(inter, t, s, item) == 1 && impactmod)
set_normal_cyl(item->cyl, inter);
return ;
}
int point_triangle(t_vec pos, t_triangle *p)
{
FLOAT_SIZE accumilator;
t_vec dot;
t_vec line1;
t_vec line2;
accumilator = 0;
line1 = normalizator_ret(sub_vec(p->p1, pos));
line2 = normalizator_ret(sub_vec(p->p2, pos));
dot.x = dot_prod(line1, line2);
line1 = normalizator_ret(sub_vec(p->p2, pos));
line2 = normalizator_ret(sub_vec(p->p3, pos));
dot.y = dot_prod(line1, line2);
line1 = normalizator_ret(sub_vec(p->p3, pos));
line2 = normalizator_ret(sub_vec(p->p1, pos));
dot.z = dot_prod(line1, line2);
accumilator = acos(dot.x) + acos(dot.y) + acos(dot.z);
if (accumilator < (359.9 * M_PI))
return (0);
else
return (1);
}
void set_normal_cyl(t_cyl *cyl, t_inter *inter)
{
inter->norm = normalizator_ret(sub_vec(vector_proj_vector(
normalizator_ret(sub_vec(cyl->pos, inter->pos)), cyl->dir),
normalizator_ret(sub_vec(cyl->pos, inter->pos))));
}
void myKeyHandler(unsigned char ch, int x, int y)
{
int i;
static int subdiv=0;
struct point_t *slice;
struct point_t *linecur;
struct point_t *cur;
struct point_t *new_points;
struct slice_t *cur_slice,*cur2_slice;
struct point_t *cur2;
struct point_t points[5];
double a,b,c;
GLfloat v1[3],v2[3],v3[3];
double deginc;
// struct slice_t *cur_slice;
switch(ch)
{
case 'q':
endSubdiv(0);
break;
case 'z':
mode=(~mode)&1;
printf("%s\n",mode?"3D mode":"2D mode");
switch(mode)
{
case 0:
resetCamera();
break;
case 1:
reset3DCamera();
break;
}
break;
case 'k':
/* test phong stuff */
cur_slice = slices;
cur2_slice = slices->n;
//while(cur_slice!=NULL)
{
cur = cur_slice->line;
cur2 = cur2_slice->line;
//while(cur->n!=NULL)
{
/* right vertex */
add_vec(&(cur->nx),&(cur->n->nx),&(points[0].nx));
normalize(&(points[0].nx));
sub_vec(&(cur->n->x),&(cur->x),v1);
v1[0] /= 2; v1[1] /= 2; v1[2] /= 2;
add_vec(&(cur->x),v1,&(points[0].x));
/* top vertex */
add_vec(&(cur->nx),&(cur2->nx),&(points[1].nx));
normalize(&(points[1].nx));
sub_vec(&(cur2->x),&(cur->x),v1);
v1[0] /= 2; v1[1] /= 2; v1[2] /= 2;
add_vec(&(cur->x),v1,&(points[1].x));
/* left vertex */
add_vec(&(cur2->nx),&(cur2->n->nx),&(points[2].nx));
normalize(&(points[2].nx));
sub_vec(&(cur2->n->x),&(cur2->x),v1);
v1[0] /= 2; v1[1] /= 2; v1[2] /= 2;
add_vec(&(cur2->x),v1,&(points[2].x));
/* bottom vertex */
add_vec(&(cur2->n->nx),&(cur->n->nx),&(points[3].nx));
normalize(&(points[3].nx));
sub_vec(&(cur->n->x),&(cur2->n->x),v1);
v1[0] /= 2; v1[1] /= 2; v1[2] /= 2;
add_vec(&(cur2->n->x),v1,&(points[3].x));
/* center vertex */
add_vec(&(points[0].nx),&(points[1].nx),v1);
add_vec(&(points[2].nx),&(points[3].nx),v2);
add_vec(v1,v2,&(points[4].nx));
normalize(&(points[4].nx));
sub_vec(&(points[3].x),&(cur2->n->x),v1);
sub_vec(&(points[2].x),&(cur2->n->x),v2);
add_vec(v1,v2,v3);
normalize(v3);
a=sqrt(v1[0]*v1[0]+v1[1]*v1[1]+v1[2]*v1[2]);
b=sqrt(v2[0]*v2[0]+v2[1]*v2[1]+v2[2]*v2[2]);
c=sqrt(a*a+b*b);
v3[0] *= c; v3[1] *= c; v3[2] *= c;
add_vec(&(cur2->n->x),v3,&(points[4].x));
printf("v2[0]=%f,v2[1]=%f,v2[2]=%f\nv3[0]=%f,v3[1]=%f,v3[2]=%f\n",v2[0],v2[1],v2[2],v3[0],v3[1],v3[2]);
for(i=0; i<5; i++)
printf("points[%d]->x=%f,points[%d]->y=%f,points[%d]->z=%f\n",
i,points[i].x,i,points[i].y,i,points[i].z);
printf("cur->x=%f,cur->y=%f,cur->z=%f\ncur->n->x=%f,cur->n->y=%f,cur->n->z=%f\n",
cur->x,cur->y,cur->z,cur->n->x,cur->n->y,cur->n->z);
printf("cur2->x=%f,cur2->y=%f,cur2->z=%f\ncur2->n->x=%f,cur2->n->y=%f,cur2->n->z=%f\n",
cur2->x,cur2->y,cur2->z,cur2->n->x,cur2->n->y,cur2->n->z);
cur = cur->n;
cur2 = cur2->n;
}
cur_slice = cur_slice->n;
cur2_slice = cur2_slice->n != NULL ? cur2_slice->n : slices; /* circle around */
}
break;
case 'n':
normals=(~normals)&1;
printf("Normal mode %s\n",normals?"on":"off");
break;
case 'e':
solid=(~solid)&1;
printf("%s\n",solid?"Solid mode":"Wireframe mode");
switch(solid)
{
case 0:
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
break;
case 1:
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
break;
}
break;
case 'r':
faces=(~faces)&1;
printf("%s\n",faces?"Faces mode":"Control points mode");
break;
case 'w': /* calculate initial 3d object */
if(num<5)
printf("There must be at least 5 control points.\n");
else if(!mode)
{
mode=(~mode)&1;
printf("%s\n",mode?"3D mode":"2D mode");
switch(mode)
{
case 0:
resetCamera();
break;
case 1:
reset3DCamera();
break;
}
freeModel();
subdiv_v = 0;
subdiv_h = NUMSLICES;
/* the radius of the circle for each of the points is x */
for(i=0;i<subdiv_h;i++)
{
ALLOC_POINT(slice);
cur=slice;
linecur=line;
while(linecur!=NULL)
{
cur->z = linecur->x*sin(DEGINC*i);
cur->x = linecur->x*cos(DEGINC*i);
cur->y = linecur->y;
linecur = linecur->n;
if(linecur!=NULL)
{
ALLOC_POINT(cur->n);
cur = cur->n;
}
}
addSlice(slice);
}
}
recompute_normals();
break;
case 's': /* horizontal subdivision */
if(!mode || slices==NULL) break;
/* backup the original slice */
new_points = duplicate_slice(slices->line);
freeModel();
subdiv_h<<=1;
subdiv++;
printf("Horizontal subdivision level %d\n",subdiv);
deginc = 2*M_PI/subdiv_h;
for(i=0;i<subdiv_h;i++)
{
ALLOC_POINT(slice);
cur=slice;
linecur=new_points;
while(linecur!=NULL)
{
cur->z = linecur->x*sin(deginc*i);
cur->x = linecur->x*cos(deginc*i);
cur->y = linecur->y;
linecur = linecur->n;
if(linecur!=NULL)
{
ALLOC_POINT(cur->n);
cur = cur->n;
}
}
addSlice(slice);
}
recompute_normals();
break;
case 'a': /* vertical subdivision */
if(!mode || slices==NULL) break;
cur_slice=slices;
subdiv_v++;
printf("Vertical subdivision level %d\n",subdiv_v);
linecur = cur_slice->line;
/* calc the first point */
cur = new_points = calc_point(linecur,linecur,linecur->n,linecur->n->n);
/* calc middle and last points */
while(linecur->n->n!=NULL)
{
if(linecur->n->n->n!=NULL) /* middle points */
cur->n = calc_point(linecur,linecur->n,linecur->n->n,linecur->n->n->n);
else
cur->n = calc_point(linecur,linecur->n,linecur->n->n,linecur->n->n);
cur = cur->n;
linecur = linecur->n;
}
interleave(cur_slice->line,new_points);
new_points = duplicate_slice(cur_slice->line);
deginc = 2*M_PI/subdiv_h;
freeModel();
for(i=0;i<subdiv_h;i++)
{
ALLOC_POINT(slice);
cur=slice;
linecur=new_points;
while(linecur!=NULL)
{
cur->z = linecur->x*sin(deginc*i);
cur->x = linecur->x*cos(deginc*i);
cur->y = linecur->y;
linecur = linecur->n;
if(linecur!=NULL)
{
ALLOC_POINT(cur->n);
cur = cur->n;
}
}
addSlice(slice);
}
recompute_normals();
break;
case 'd':
shading=(~shading)&1;
printf("%s shading\n",shading?"Phong":"Gouraud");
break;
case '<':
if(mode)
{
glMatrixMode(GL_MODELVIEW);
glRotatef(1,0.0,1.0,0.0);
}
break;
case '>':
if(mode)
{
glMatrixMode(GL_MODELVIEW);
glRotatef(-1,0.0,1.0,0.0);
}
break;
default:
/* Unrecognized keypress */
return;
}
glutPostRedisplay();
return;
}
