DBL image_pattern(VECTOR EPoint, TPATTERN *TPattern)
{
DBL xcoor = 0.0, ycoor = 0.0;
int index;
COLOUR colour;
IMAGE *Image = TPattern->Vals.Image;
DBL Value;
Make_ColourA(colour, 0.0, 0.0, 0.0, 0.0, 0.0);
/* going to have to change this */
/* need to know if bump point is off of image for all 3 points */
if (map(EPoint, (TPATTERN *) TPattern, &xcoor, &ycoor))
{
return 0.0;
}
else
{
image_colour_at(Image, xcoor, ycoor, colour, &index);
}
if (Image->Colour_Map == NULL || Image->Use_Colour_Flag)
{
if (Image->Use_Colour_Flag == USE_ALPHA)
{
/* use alpha channel or red channel */
if ((Image->Image_Type & IS16BITIMAGE) == IS16BITIMAGE)
{
if (Image->data.rgb16_lines[0].transm != NULL)
Value = colour[pTRANSM];
else
Value = colour[pRED]; /* otherwise, just use the red channel */
}
else
{
if (Image->data.rgb8_lines[0].transm != NULL)
Value = colour[pTRANSM];
else
Value = colour[pRED]; /* otherwise, just use the red channel */
}
}
else
/* use grey-scaled version of the color */
Value = GREY_SCALE(colour);
}
else
Value = index / 255.0;
if (Value<0) Value = 0;
else if (Value>1.0) Value = 1.0;
return Value;
}
void extract_colors(COLOUR Colour, unsigned char *Red, unsigned char *Green, unsigned char *Blue, unsigned char *Alpha, DBL *grey)
{
COLOUR ColourG;
Clip_Colour(ColourG, Colour);
gamma_correct(ColourG);
if (opts.PaletteOption == GREY)
{
*grey = ColourG[pRED] * GREY_SCALE(ColourG);
*Red = *Green = *Blue = (unsigned char)((*grey) * maxclr);
}
else
{
*Red = (unsigned char)(ColourG[pRED] * maxclr);
*Green = (unsigned char)(ColourG[pGREEN] * maxclr);
*Blue = (unsigned char)(ColourG[pBLUE] * maxclr);
*Alpha = (unsigned char)(ColourG[pTRANSM] * maxclr);
}
}
void extract_colors_nocorrect(COLOUR Colour, unsigned char *Red, unsigned char *Green, unsigned char *Blue, unsigned char *Alpha, DBL *grey)
{
int RedU, GreenU, BlueU, AlphaU;
if (opts.PaletteOption == GREY)
{
*grey = Colour[pRED] * GREY_SCALE(Colour);
RedU = GreenU = BlueU = (int)((*grey) * maxclr);
AlphaU = 0;
}
else
{
RedU = (int)(Colour[pRED] * maxclr);
GreenU = (int)(Colour[pGREEN] * maxclr);
BlueU = (int)(Colour[pBLUE] * maxclr);
AlphaU = (int)(Colour[pTRANSM] * maxclr);
}
if (RedU > UCHAR_MAX) RedU = UCHAR_MAX;
else if (RedU < 0) RedU = 0;
if (GreenU > UCHAR_MAX) GreenU = UCHAR_MAX;
else if (GreenU < 0) GreenU = 0;
if (BlueU > UCHAR_MAX) BlueU = UCHAR_MAX;
else if (BlueU < 0) BlueU = 0;
if (AlphaU > UCHAR_MAX) AlphaU = UCHAR_MAX;
else if (AlphaU < 0) AlphaU = 0;
*Red = RedU;
*Green = GreenU;
*Blue = BlueU;
*Alpha = AlphaU;
}
void bump_map(VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal)
{
DBL xcoor = 0.0, ycoor = 0.0;
int index, index2, index3;
COLOUR colour1, colour2, colour3;
VECTOR p1, p2, p3;
VECTOR bump_normal;
VECTOR xprime, yprime, zprime, Temp;
DBL Length;
DBL Amount = Tnormal->Amount;
IMAGE *Image = Tnormal->Vals.Image;
Make_ColourA(colour1, 0.0, 0.0, 0.0, 0.0, 0.0);
Make_ColourA(colour2, 0.0, 0.0, 0.0, 0.0, 0.0);
Make_ColourA(colour3, 0.0, 0.0, 0.0, 0.0, 0.0);
/* going to have to change this */
/* need to know if bump point is off of image for all 3 points */
if (map(EPoint, (TPATTERN *) Tnormal, &xcoor, &ycoor))
{
return;
}
else
{
image_colour_at(Image, xcoor, ycoor, colour1, &index);
}
xcoor--;
ycoor++;
if (xcoor < 0.0)
{
xcoor += (DBL)Image->iwidth;
}
else
{
if (xcoor >= Image->iwidth)
{
xcoor -= (DBL)Image->iwidth;
}
}
if (ycoor < 0.0)
{
ycoor += (DBL)Image->iheight;
}
else
{
if (ycoor >= (DBL)Image->iheight)
{
ycoor -= (DBL)Image->iheight;
}
}
image_colour_at(Image, xcoor, ycoor, colour2, &index2);
xcoor += 2.0;
if (xcoor < 0.0)
{
xcoor += (DBL)Image->iwidth;
}
else
{
if (xcoor >= Image->iwidth)
{
xcoor -= (DBL)Image->iwidth;
}
}
image_colour_at(Image, xcoor, ycoor, colour3, &index3);
if (Image->Colour_Map == NULL || Image->Use_Colour_Flag)
{
p1[X] = 0;
p1[Y] = Amount * (GREY_SCALE( colour1 ));
p1[Z] = 0;
p2[X] = -1;
p2[Y] = Amount * (GREY_SCALE( colour2 ));
p2[Z] = 1;
p3[X] = 1;
p3[Y] = Amount * (GREY_SCALE( colour3 ));
p3[Z] = 1;
}
else
{
p1[X] = 0;
p1[Y] = Amount * index;
p1[Z] = 0;
p2[X] = -1;
p2[Y] = Amount * index2;
p2[Z] = 1;
p3[X] = 1;
p3[Y] = Amount * index3;
p3[Z] = 1;
}
/* we have points 1,2,3 for a triangle now we need the surface normal for it */
VSub(xprime, p1, p2);
VSub(yprime, p3, p2);
VCross(bump_normal, yprime, xprime);
VNormalize(bump_normal, bump_normal);
Assign_Vector(yprime, normal);
Make_Vector(Temp, 0.0, 1.0, 0.0);
VCross(xprime, yprime, Temp);
VLength(Length, xprime);
if (Length < EPSILON)
{
if (fabs(normal[Y] - 1.0) < Small_Tolerance)
{
Make_Vector(yprime, 0.0, 1.0, 0.0);
Make_Vector(xprime, 1.0, 0.0, 0.0);
Length = 1.0;
}
else
{
Make_Vector(yprime, 0.0, -1.0, 0.0);
Make_Vector(xprime, 1.0, 0.0, 0.0);
Length = 1.0;
}
}
VScaleEq(xprime, 1.0 / Length);
VCross(zprime, xprime, yprime);
VNormalizeEq(zprime);
VScaleEq(xprime, bump_normal[X]);
VScaleEq(yprime, bump_normal[Y]);
VScaleEq(zprime, bump_normal[Z]);
VAdd(Temp, xprime, yprime);
VScaleEq(zprime, -1);
VAdd(normal, Temp, zprime);
}
static void do_fog(RAY *Ray, INTERSECTION *Intersection, COLOUR Colour, int Light_Ray_Flag)
{
DBL att, att_inv, width;
COLOUR Col_Fog;
COLOUR sum_att; /* total attenuation. */
COLOUR sum_col; /* total color. */
FOG *Fog;
/* Why are we here. */
if (Frame.Fog == NULL)
{
return;
}
/* Init total attenuation and total color. */
Make_ColourA(sum_att, 1.0, 1.0, 1.0, 1.0, 1.0);
Make_ColourA(sum_col, 0.0, 0.0, 0.0, 0.0, 0.0);
/* Loop over all fogs. */
for (Fog = Frame.Fog; Fog != NULL; Fog = Fog->Next)
{
/* Don't care about fogs with zero distance. */
if (fabs(Fog->Distance) > EPSILON)
{
width = Intersection->Depth;
switch (Fog->Type)
{
case GROUND_MIST:
att = ground_fog(Ray, 0.0, width, Fog, Col_Fog);
break;
default:
att = constant_fog(Ray, 0.0, width, Fog, Col_Fog);
break;
}
/* Check for minimum transmittance. */
if (att < Col_Fog[pTRANSM])
{
att = Col_Fog[pTRANSM];
}
/* Get attenuation sum due to filtered/unfiltered translucency. */
sum_att[pRED] *= att * ((1.0 - Col_Fog[pFILTER]) + Col_Fog[pFILTER] * Col_Fog[pRED]);
sum_att[pGREEN] *= att * ((1.0 - Col_Fog[pFILTER]) + Col_Fog[pFILTER] * Col_Fog[pGREEN]);
sum_att[pBLUE] *= att * ((1.0 - Col_Fog[pFILTER]) + Col_Fog[pFILTER] * Col_Fog[pBLUE]);
sum_att[pFILTER] *= att * Col_Fog[pFILTER];
sum_att[pTRANSM] *= att * Col_Fog[pTRANSM];
if (!Light_Ray_Flag)
{
att_inv = 1.0 - att;
CRGBAddScaledEq(sum_col, att_inv, Col_Fog);
}
}
}
/* Add light coming from background. */
Colour[pRED] = sum_col[pRED] + sum_att[pRED] * Colour[pRED];
Colour[pGREEN] = sum_col[pGREEN] + sum_att[pGREEN] * Colour[pGREEN];
Colour[pBLUE] = sum_col[pBLUE] + sum_att[pBLUE] * Colour[pBLUE];
Colour[pTRANSM] *= GREY_SCALE(sum_att);
}
