mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-21 20:12:30 +00:00
635 lines
17 KiB
C
635 lines
17 KiB
C
/*****************/
|
|
/* Shading stuff */
|
|
/*****************/
|
|
|
|
#include "lighting_shade.h"
|
|
|
|
GckVector3 *triangle_normals[2] = { NULL, NULL };
|
|
GckVector3 *vertex_normals[3] = { NULL, NULL, NULL };
|
|
gdouble *heights[3] = { NULL, NULL, NULL };
|
|
gdouble xstep,ystep;
|
|
guchar *bumprow=NULL;
|
|
|
|
gint pre_w=-1;
|
|
gint pre_h=-1;
|
|
|
|
/*****************/
|
|
/* Phong shading */
|
|
/*****************/
|
|
|
|
GckRGB phong_shade(GckVector3 *position,GckVector3 *viewpoint,
|
|
GckVector3 *normal,GckVector3 *lightposition,
|
|
GckRGB *diff_col,GckRGB *spec_col,
|
|
LightType light_type)
|
|
{
|
|
GckRGB ambient_color,diffuse_color,specular_color;
|
|
gdouble nl,rv,dist;
|
|
GckVector3 l,nn,v,n;
|
|
|
|
/* Compute ambient intensity */
|
|
/* ========================= */
|
|
|
|
n=*normal;
|
|
ambient_color=*diff_col;
|
|
gck_rgb_mul(&ambient_color,mapvals.material.ambient_int);
|
|
|
|
/* Compute (N*L) term of Phong's equation */
|
|
/* ====================================== */
|
|
|
|
if (light_type==POINT_LIGHT)
|
|
gck_vector3_sub(&l,lightposition,position);
|
|
else
|
|
l=*lightposition;
|
|
|
|
dist=gck_vector3_length(&l);
|
|
|
|
if (dist!=0.0)
|
|
gck_vector3_mul(&l,1.0/dist);
|
|
|
|
nl=2.0*gck_vector3_inner_product(&n,&l);
|
|
|
|
if (nl>=0.0)
|
|
{
|
|
/* Compute (R*V)^alpha term of Phong's equation */
|
|
/* ============================================ */
|
|
|
|
gck_vector3_sub(&v,viewpoint,position);
|
|
gck_vector3_normalize(&v);
|
|
|
|
gck_vector3_mul(&n,nl);
|
|
gck_vector3_sub(&nn,&n,&l);
|
|
rv=gck_vector3_inner_product(&nn,&v);
|
|
rv=pow(rv,mapvals.material.highlight);
|
|
|
|
/* Compute diffuse and specular intensity contribution */
|
|
/* =================================================== */
|
|
|
|
diffuse_color=*diff_col;
|
|
gck_rgb_mul(&diffuse_color,mapvals.material.diffuse_ref);
|
|
gck_rgb_mul(&diffuse_color,nl);
|
|
|
|
specular_color=*spec_col;
|
|
gck_rgb_mul(&specular_color,mapvals.material.specular_ref);
|
|
gck_rgb_mul(&specular_color,rv);
|
|
|
|
gck_rgb_add(&diffuse_color,&specular_color);
|
|
gck_rgb_mul(&diffuse_color,mapvals.material.diffuse_int);
|
|
gck_rgb_clamp(&diffuse_color);
|
|
|
|
gck_rgb_add(&ambient_color,&diffuse_color);
|
|
}
|
|
|
|
gck_rgb_clamp(&ambient_color);
|
|
return(ambient_color);
|
|
}
|
|
|
|
void get_normal(gdouble xf,gdouble yf,GckVector3 *normal)
|
|
{
|
|
GckVector3 v1,v2,n;
|
|
gint numvecs=0,x,y,f;
|
|
gdouble val,val1=-1.0,val2=-1.0,val3=-1.0,val4=-1.0, xstep,ystep;
|
|
|
|
x=(gint)(xf+0.5);
|
|
y=(gint)(yf+0.5);
|
|
|
|
xstep=1.0/(gdouble)width;
|
|
ystep=1.0/(gdouble)height;
|
|
|
|
val=mapvals.bumpmax*get_map_value(&bump_region, xf,yf, &f)/255.0;
|
|
if (check_bounds(x-1,y)) val1=mapvals.bumpmax*get_map_value(&bump_region, xf-1.0,yf, &f)/255.0 - val;
|
|
if (check_bounds(x,y-1)) val2=mapvals.bumpmax*get_map_value(&bump_region, xf,yf-1.0, &f)/255.0 - val;
|
|
if (check_bounds(x+1,y)) val3=mapvals.bumpmax*get_map_value(&bump_region, xf+1.0,yf, &f)/255.0 - val;
|
|
if (check_bounds(x,y+1)) val4=mapvals.bumpmax*get_map_value(&bump_region, xf,yf+1.0, &f)/255.0 - val;
|
|
|
|
gck_vector3_set(normal, 0.0,0.0,0.0);
|
|
|
|
if (val1!=-1.0 && val4!=-1.0)
|
|
{
|
|
v1.x=-xstep; v1.y=0.0; v1.z=val1;
|
|
v2.x=0.0; v2.y=ystep; v2.z=val4;
|
|
n=gck_vector3_cross_product(&v1,&v2);
|
|
gck_vector3_normalize(&n);
|
|
|
|
if (n.z<0.0)
|
|
n.z=-n.z;
|
|
|
|
gck_vector3_add(normal,normal,&n);
|
|
numvecs++;
|
|
}
|
|
|
|
if (val1!=-1.0 && val2!=-1.0)
|
|
{
|
|
v1.x=-xstep; v1.y=0.0; v1.z=val1;
|
|
v2.x=0.0; v2.y=-ystep; v2.z=val2;
|
|
n=gck_vector3_cross_product(&v1,&v2);
|
|
gck_vector3_normalize(&n);
|
|
|
|
if (n.z<0.0)
|
|
n.z=-n.z;
|
|
|
|
gck_vector3_add(normal,normal,&n);
|
|
numvecs++;
|
|
}
|
|
|
|
if (val2!=-1.0 && val3!=-1.0)
|
|
{
|
|
v1.x=0.0; v1.y=-ystep; v1.z=val2;
|
|
v2.x=xstep; v2.y=0.0; v2.z=val3;
|
|
n=gck_vector3_cross_product(&v1,&v2);
|
|
gck_vector3_normalize(&n);
|
|
|
|
if (n.z<0.0)
|
|
n.z=-n.z;
|
|
|
|
gck_vector3_add(normal,normal,&n);
|
|
numvecs++;
|
|
}
|
|
|
|
if (val3!=-1.0 && val4!=-1.0)
|
|
{
|
|
v1.x=xstep; v1.y=0.0; v1.z=val3;
|
|
v2.x=0.0; v2.y=ystep; v2.z=val4;
|
|
n=gck_vector3_cross_product(&v1,&v2);
|
|
gck_vector3_normalize(&n);
|
|
|
|
if (n.z<0.0)
|
|
n.z=-n.z;
|
|
|
|
gck_vector3_add(normal,normal,&n);
|
|
numvecs++;
|
|
}
|
|
|
|
gck_vector3_mul(normal,1.0/(gdouble)numvecs);
|
|
gck_vector3_normalize(normal);
|
|
}
|
|
|
|
void precompute_init(gint w,gint h)
|
|
{
|
|
gint n;
|
|
|
|
xstep=1.0/(gdouble)width;
|
|
ystep=1.0/(gdouble)height;
|
|
|
|
pre_w=w;
|
|
pre_h=h;
|
|
|
|
for (n=0;n<3;n++)
|
|
{
|
|
if (vertex_normals[n]!=NULL)
|
|
free(vertex_normals[n]);
|
|
if (heights[n]!=NULL)
|
|
free(heights[n]);
|
|
|
|
heights[n]=(gdouble *)malloc(sizeof(gdouble)*(size_t)w);
|
|
vertex_normals[n]=(GckVector3 *)malloc(sizeof(GckVector3)*(size_t)w);
|
|
}
|
|
|
|
for (n=0;n<2;n++)
|
|
if (triangle_normals[n]!=NULL)
|
|
free(triangle_normals[n]);
|
|
|
|
if (bumprow!=NULL)
|
|
{
|
|
free(bumprow);
|
|
bumprow=NULL;
|
|
}
|
|
|
|
bumprow=(guchar *)malloc(sizeof(guchar)*(size_t)w);
|
|
|
|
triangle_normals[0]=(GckVector3 *)malloc(sizeof(GckVector3)*(size_t)((w<<1)+2));
|
|
triangle_normals[1]=(GckVector3 *)malloc(sizeof(GckVector3)*(size_t)((w<<1)+2));
|
|
|
|
for (n=0;n<(w<<1)+1;n++)
|
|
{
|
|
gck_vector3_set(&triangle_normals[0][n],0.0,0.0,1.0);
|
|
gck_vector3_set(&triangle_normals[1][n],0.0,0.0,1.0);
|
|
}
|
|
|
|
for (n=0;n<w;n++)
|
|
{
|
|
gck_vector3_set(&vertex_normals[0][n],0.0,0.0,1.0);
|
|
gck_vector3_set(&vertex_normals[1][n],0.0,0.0,1.0);
|
|
gck_vector3_set(&vertex_normals[2][n],0.0,0.0,1.0);
|
|
heights[0][n]=0.0;
|
|
heights[1][n]=0.0;
|
|
heights[2][n]=0.0;
|
|
}
|
|
}
|
|
|
|
/********************************************/
|
|
/* Compute triangle and then vertex normals */
|
|
/********************************************/
|
|
|
|
void precompute_normals(gint x1,gint x2,gint y)
|
|
{
|
|
GckVector3 *tmpv,p1,p2,p3,normal;
|
|
gdouble *tmpd;
|
|
gint n,i,nv;
|
|
guchar *map=NULL;
|
|
|
|
/* First, compute the heights */
|
|
/* ========================== */
|
|
|
|
tmpv=triangle_normals[0];
|
|
triangle_normals[0]=triangle_normals[1];
|
|
triangle_normals[1]=tmpv;
|
|
|
|
tmpv=vertex_normals[0];
|
|
vertex_normals[0]=vertex_normals[1];
|
|
vertex_normals[1]=vertex_normals[2];
|
|
vertex_normals[2]=tmpv;
|
|
|
|
tmpd=heights[0];
|
|
heights[0]=heights[1];
|
|
heights[1]=heights[2];
|
|
heights[2]=tmpd;
|
|
|
|
/* printf("Get row (%d,%d,%d) to %p\n",x1,y,x2-x1,bumprow); */
|
|
|
|
gimp_pixel_rgn_get_row(&bump_region,bumprow,x1,y,x2-x1);
|
|
|
|
if (mapvals.bumpmaptype>0)
|
|
{
|
|
switch (mapvals.bumpmaptype)
|
|
{
|
|
case 1:
|
|
map=logmap;
|
|
break;
|
|
case 2:
|
|
map=sinemap;
|
|
break;
|
|
default:
|
|
map=spheremap;
|
|
break;
|
|
}
|
|
for (n=0;n<(x2-x1);n++)
|
|
heights[2][n]=(gdouble)mapvals.bumpmax*(gdouble)map[bumprow[n]]/255.0;
|
|
}
|
|
else for (n=0;n<(x2-x1);n++)
|
|
heights[2][n]=(gdouble)mapvals.bumpmax*(gdouble)bumprow[n]/255.0;
|
|
|
|
/* Compute triangle normals */
|
|
/* ======================== */
|
|
|
|
i=0;
|
|
for (n=0;n<(x2-x1-1);n++)
|
|
{
|
|
p1.x=0.0;
|
|
p1.y=ystep;
|
|
p1.z=heights[2][n]-heights[1][n];
|
|
|
|
p2.x=xstep;
|
|
p2.y=ystep;
|
|
p2.z=heights[2][n+1]-heights[1][n];
|
|
|
|
p3.x=xstep;
|
|
p3.y=0.0;
|
|
p3.z=heights[1][n+1]-heights[1][n];
|
|
|
|
triangle_normals[1][i]=gck_vector3_cross_product(&p2,&p1);
|
|
triangle_normals[1][i+1]=gck_vector3_cross_product(&p3,&p2);
|
|
|
|
gck_vector3_normalize(&triangle_normals[1][i]);
|
|
gck_vector3_normalize(&triangle_normals[1][i+1]);
|
|
|
|
i+=2;
|
|
}
|
|
|
|
/* Compute vertex normals */
|
|
/* ====================== */
|
|
|
|
i=0;
|
|
gck_vector3_set(&normal, 0.0,0.0,0.0);
|
|
for (n=0;n<(x2-x1-1);n++)
|
|
{
|
|
nv=0;
|
|
if (n>0)
|
|
{
|
|
if (y>0)
|
|
{
|
|
gck_vector3_add(&normal, &normal, &triangle_normals[0][i-1]);
|
|
gck_vector3_add(&normal, &normal, &triangle_normals[0][i-2]);
|
|
nv+=2;
|
|
}
|
|
if (y<pre_h)
|
|
{
|
|
gck_vector3_add(&normal, &normal, &triangle_normals[1][i-1]);
|
|
nv++;
|
|
}
|
|
}
|
|
if (n<pre_w)
|
|
{
|
|
if (y>0)
|
|
{
|
|
gck_vector3_add(&normal, &normal, &triangle_normals[0][i]);
|
|
gck_vector3_add(&normal, &normal, &triangle_normals[0][i+1]);
|
|
nv+=2;
|
|
}
|
|
if (y<pre_h)
|
|
{
|
|
gck_vector3_add(&normal, &normal, &triangle_normals[1][i]);
|
|
gck_vector3_add(&normal, &normal, &triangle_normals[1][i+1]);
|
|
nv+=2;
|
|
}
|
|
}
|
|
|
|
gck_vector3_mul(&normal, 1.0/(gdouble)nv);
|
|
gck_vector3_normalize(&normal);
|
|
vertex_normals[1][n]=normal;
|
|
|
|
i+=2;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************/
|
|
/* Compute the reflected ray given the normalized normal and ins. vec. */
|
|
/***********************************************************************/
|
|
|
|
GckVector3 compute_reflected_ray(GckVector3 *normal,GckVector3 *view)
|
|
{
|
|
GckVector3 ref;
|
|
gdouble nl;
|
|
|
|
nl = 2.0*gck_vector3_inner_product(normal,view);
|
|
|
|
ref = *normal;
|
|
|
|
gck_vector3_mul(&ref,nl);
|
|
gck_vector3_sub(&ref,&ref,view);
|
|
|
|
return(ref);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Given the NorthPole, Equator and a third vector (normal) compute */
|
|
/* the conversion from spherical coordinates to image space coordinates */
|
|
/************************************************************************/
|
|
|
|
void sphere_to_image(GckVector3 *normal,gdouble *u,gdouble *v)
|
|
{
|
|
static gdouble alpha,fac;
|
|
static GckVector3 cross_prod;
|
|
static GckVector3 firstaxis = { 1.0, 0.0, 0.0 };
|
|
static GckVector3 secondaxis = { 0.0, 1.0, 0.0 };
|
|
|
|
alpha=acos(-gck_vector3_inner_product(&secondaxis,normal));
|
|
|
|
*v=alpha/M_PI;
|
|
|
|
if (*v==0.0 || *v==1.0) *u=0.0;
|
|
else
|
|
{
|
|
fac=gck_vector3_inner_product(&firstaxis,normal)/sin(alpha);
|
|
|
|
/* Make sure that we map to -1.0..1.0 (take care of rounding errors) */
|
|
/* ================================================================= */
|
|
|
|
if (fac>1.0)
|
|
fac=1.0;
|
|
else if (fac<-1.0)
|
|
fac=-1.0;
|
|
|
|
*u=acos(fac)/(2.0*M_PI);
|
|
|
|
cross_prod=gck_vector3_cross_product(&secondaxis,&firstaxis);
|
|
|
|
if (gck_vector3_inner_product(&cross_prod,normal)<0.0)
|
|
*u=1.0-*u;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************/
|
|
/* These routines computes the color of the surface at a given point */
|
|
/*********************************************************************/
|
|
|
|
GckRGB get_ray_color(GckVector3 *position)
|
|
{
|
|
GckRGB color;
|
|
gint x,f;
|
|
gdouble xf,yf;
|
|
GckVector3 normal,*p;
|
|
|
|
pos_to_float(position->x,position->y,&xf,&yf);
|
|
|
|
x = (gint)(xf+0.5);
|
|
|
|
if (mapvals.transparent_background && heights[1][x]==0)
|
|
color.a=0.0;
|
|
else
|
|
{
|
|
color=get_image_color(xf,yf,&f);
|
|
|
|
if (mapvals.lightsource.type==POINT_LIGHT)
|
|
p=&mapvals.lightsource.position;
|
|
else
|
|
p=&mapvals.lightsource.direction;
|
|
|
|
if (mapvals.bump_mapped==FALSE || mapvals.bumpmap_id==-1)
|
|
color=phong_shade(position,
|
|
&mapvals.viewpoint,
|
|
&mapvals.planenormal,
|
|
p,
|
|
&color,
|
|
&mapvals.lightsource.color,
|
|
mapvals.lightsource.type);
|
|
else
|
|
{
|
|
normal=vertex_normals[1][(gint)(xf+0.5)];
|
|
|
|
color=phong_shade(position,
|
|
&mapvals.viewpoint,
|
|
&normal,
|
|
p,
|
|
&color,
|
|
&mapvals.lightsource.color,
|
|
mapvals.lightsource.type);
|
|
}
|
|
}
|
|
|
|
return(color);
|
|
}
|
|
|
|
GckRGB get_ray_color_ref(GckVector3 *position)
|
|
{
|
|
GckRGB color,env_color;
|
|
gint x,f;
|
|
gdouble xf,yf;
|
|
GckVector3 normal,*p,v,r;
|
|
|
|
pos_to_float(position->x,position->y,&xf,&yf);
|
|
|
|
x = (gint)(xf+0.5);
|
|
|
|
if (mapvals.transparent_background && heights[1][x]==0)
|
|
color.a=0.0;
|
|
else
|
|
{
|
|
color=get_image_color(xf,yf,&f);
|
|
|
|
if (mapvals.lightsource.type==POINT_LIGHT)
|
|
p=&mapvals.lightsource.position;
|
|
else
|
|
p=&mapvals.lightsource.direction;
|
|
|
|
if (mapvals.bump_mapped==FALSE || mapvals.bumpmap_id==-1)
|
|
color=phong_shade(position,
|
|
&mapvals.viewpoint,
|
|
&mapvals.planenormal,
|
|
p,
|
|
&color,
|
|
&mapvals.lightsource.color,
|
|
mapvals.lightsource.type);
|
|
else
|
|
{
|
|
normal=vertex_normals[1][(gint)(xf+0.5)];
|
|
|
|
gck_vector3_sub(&v,&mapvals.viewpoint,position);
|
|
gck_vector3_normalize(&v);
|
|
|
|
r = compute_reflected_ray(&normal,&v);
|
|
|
|
/* Get color in the direction of r */
|
|
/* =============================== */
|
|
|
|
sphere_to_image(&r,&xf,&yf);
|
|
env_color = peek_env_map((gint)(env_width*xf+0.5),(gint)(env_height*yf+0.5));
|
|
|
|
color=phong_shade(position,
|
|
&mapvals.viewpoint,
|
|
&normal,
|
|
p,
|
|
&env_color,
|
|
&mapvals.lightsource.color,
|
|
mapvals.lightsource.type);
|
|
}
|
|
}
|
|
|
|
return(color);
|
|
}
|
|
|
|
GckRGB get_ray_color_no_bilinear(GckVector3 *position)
|
|
{
|
|
GckRGB color;
|
|
gint x;
|
|
gdouble xf,yf;
|
|
GckVector3 normal,*p;
|
|
|
|
pos_to_float(position->x,position->y,&xf,&yf);
|
|
|
|
x = (gint)(xf+0.5);
|
|
|
|
if (mapvals.transparent_background && heights[1][x]==0)
|
|
color.a=0.0;
|
|
else
|
|
{
|
|
color=peek(x,(gint)(yf+0.5));
|
|
|
|
if (mapvals.lightsource.type==POINT_LIGHT)
|
|
p=&mapvals.lightsource.position;
|
|
else
|
|
p=&mapvals.lightsource.direction;
|
|
|
|
if (mapvals.bump_mapped==FALSE || mapvals.bumpmap_id==-1)
|
|
color=phong_shade(position,
|
|
&mapvals.viewpoint,
|
|
&mapvals.planenormal,
|
|
p,
|
|
&color,
|
|
&mapvals.lightsource.color,
|
|
mapvals.lightsource.type);
|
|
else
|
|
{
|
|
normal=vertex_normals[1][x];
|
|
|
|
color=phong_shade(position,
|
|
&mapvals.viewpoint,
|
|
&normal,
|
|
p,
|
|
&color,
|
|
&mapvals.lightsource.color,
|
|
mapvals.lightsource.type);
|
|
}
|
|
}
|
|
|
|
return(color);
|
|
}
|
|
|
|
GckRGB get_ray_color_no_bilinear_ref(GckVector3 *position)
|
|
{
|
|
GckRGB color,env_color;
|
|
gint x;
|
|
gdouble xf,yf;
|
|
GckVector3 normal,*p,v,r;
|
|
|
|
pos_to_float(position->x,position->y,&xf,&yf);
|
|
|
|
x = (gint)(xf+0.5);
|
|
|
|
if (mapvals.transparent_background && heights[1][x]==0)
|
|
color.a=0.0;
|
|
else
|
|
{
|
|
color=peek((gint)(xf+0.5),(gint)(yf+0.5));
|
|
|
|
if (mapvals.lightsource.type==POINT_LIGHT)
|
|
p=&mapvals.lightsource.position;
|
|
else
|
|
p=&mapvals.lightsource.direction;
|
|
|
|
if (mapvals.bump_mapped==FALSE || mapvals.bumpmap_id==-1)
|
|
{
|
|
pos_to_float(position->x,position->y,&xf,&yf);
|
|
|
|
color=peek((gint)(xf+0.5),(gint)(yf+0.5));
|
|
|
|
gck_vector3_sub(&v,&mapvals.viewpoint,position);
|
|
gck_vector3_normalize(&v);
|
|
|
|
r = compute_reflected_ray(&mapvals.planenormal,&v);
|
|
|
|
/* Get color in the direction of r */
|
|
/* =============================== */
|
|
|
|
sphere_to_image(&r,&xf,&yf);
|
|
env_color = peek_env_map((gint)(env_width*xf+0.5),(gint)(env_height*yf+0.5));
|
|
|
|
color=phong_shade(position,
|
|
&mapvals.viewpoint,
|
|
&mapvals.planenormal,
|
|
p,
|
|
&env_color,
|
|
&mapvals.lightsource.color,
|
|
mapvals.lightsource.type);
|
|
}
|
|
else
|
|
{
|
|
normal=vertex_normals[1][(gint)(xf+0.5)];
|
|
|
|
pos_to_float(position->x,position->y,&xf,&yf);
|
|
color=peek((gint)(xf+0.5),(gint)(yf+0.5));
|
|
|
|
gck_vector3_sub(&v,&mapvals.viewpoint,position);
|
|
gck_vector3_normalize(&v);
|
|
|
|
r = compute_reflected_ray(&normal,&v);
|
|
|
|
/* Get color in the direction of r */
|
|
/* =============================== */
|
|
|
|
sphere_to_image(&r,&xf,&yf);
|
|
env_color = peek_env_map((gint)(env_width*xf+0.5),(gint)(env_height*yf+0.5));
|
|
|
|
color=phong_shade(position,
|
|
&mapvals.viewpoint,
|
|
&normal,
|
|
p,
|
|
&env_color,
|
|
&mapvals.lightsource.color,
|
|
mapvals.lightsource.type);
|
|
}
|
|
}
|
|
|
|
return(color);
|
|
}
|
|
|