TEXTURE *material_map(const Vector3d& EPoint, const TEXTURE *Texture)
{
int reg_number = -1;
int Material_Number;
DBL xcoor = 0.0, ycoor = 0.0;
RGBFTColour colour;
/*
* Now we have transformed x, y, z we use image mapping routine to determine
* texture index.
*/
if(map_pos(EPoint, Texture->pattern.get(), &xcoor, &ycoor))
Material_Number = 0;
else
{
if (const ImagePatternImpl *pattern = dynamic_cast<ImagePatternImpl*>(Texture->pattern.get()))
image_colour_at(pattern->pImage, xcoor, ycoor, colour, ®_number); // TODO ALPHA - we should decide whether we prefer premultiplied or non-premultiplied alpha
else
POV_PATTERN_ASSERT(false);
if(reg_number == -1)
Material_Number = (int)(colour.red() * 255.0);
else
Material_Number = reg_number;
}
if(Material_Number > Texture->Materials.size())
Material_Number %= Texture->Materials.size();
return Texture->Materials[Material_Number % Texture->Materials.size()];
}
bool image_map(const Vector3d& EPoint, const PIGMENT *Pigment, TransColour& colour)
{
// TODO ALPHA - the caller does expect non-premultiplied data, but maybe he could profit from premultiplied data?
int reg_number;
DBL xcoor = 0.0, ycoor = 0.0;
// If outside map coverage area, return clear
if(map_pos(EPoint, Pigment->pattern.get(), &xcoor, &ycoor))
{
colour = ToTransColour(RGBFTColour(1.0, 1.0, 1.0, 0.0, 1.0));
return false;
}
else
{
RGBFTColour rgbft;
if (const ImagePatternImpl *pattern = dynamic_cast<ImagePatternImpl*>(Pigment->pattern.get()))
image_colour_at(pattern->pImage, xcoor, ycoor, rgbft, ®_number, false);
else
POV_PATTERN_ASSERT(false);
colour = ToTransColour(rgbft);
return true;
}
}
void image_colour_at(const ImageData *image, DBL xcoor, DBL ycoor, RGBFTColour& colour, int *index)
{
// TODO ALPHA - caller should decide whether to prefer premultiplied or non-premultiplied alpha
// As the caller isn't sure whether to prefer premultiplied or non-premultiplied alpha,
// we'll just give him what the original image source provided.
image_colour_at(image, xcoor, ycoor, colour, index, image->data->IsPremultiplied());
}
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;
}
TEXTURE *material_map(VECTOR EPoint, TEXTURE *Texture)
{
int reg_number = 0;
int Material_Number;
int numtex;
DBL xcoor = 0.0, ycoor = 0.0;
COLOUR colour;
TEXTURE *Temp_Tex;
/*
* Now we have transformed x, y, z we use image mapping routine to determine
* texture index.
*/
if (map(EPoint, ((TPATTERN *) Texture), &xcoor, &ycoor))
{
Material_Number = 0;
}
else
{
Make_ColourA(colour, 0.0, 0.0, 0.0, 0.0, 0.0);
image_colour_at(Texture->Vals.Image, xcoor, ycoor, colour, ®_number);
if (Texture->Vals.Image->Colour_Map == NULL)
{
Material_Number = (int)(colour[pRED] * 255.0);
}
else
{
Material_Number = reg_number;
}
}
if (Material_Number > Texture->Num_Of_Mats)
{
Material_Number %= Texture->Num_Of_Mats;
}
for (numtex = 0, Temp_Tex = Texture->Materials;
(Temp_Tex->Next_Material != NULL) && (numtex < Material_Number);
Temp_Tex = Temp_Tex->Next_Material, numtex++)
{
/* do nothing */
}
return (Temp_Tex);
}
DBL image_pattern(const Vector3d& EPoint, const BasicPattern* pPattern)
{
DBL xcoor = 0.0, ycoor = 0.0;
int index = -1;
RGBFTColour colour;
const ImageData *image = dynamic_cast<const ImagePatternImpl*>(pPattern)->pImage;
DBL Value;
colour.Clear();
// going to have to change this
// need to know if bump point is off of image for all 3 points
if(map_pos(EPoint, pPattern, &xcoor, &ycoor))
return 0.0;
else
image_colour_at(image, xcoor, ycoor, colour, &index); // TODO ALPHA - we should decide whether we prefer premultiplied or non-premultiplied alpha
if((index == -1) || image->Use)
{
if(image->Use == USE_ALPHA)
{
// use alpha channel or red channel
if(image->data->HasTransparency() == true)
Value = colour.transm();
else
Value = colour.red(); // otherwise, just use the red channel
}
else
// use grey-scaled version of the color
Value = colour.Greyscale();
}
else
Value = index / 255.0;
if(Value < 0)
Value = 0;
else if(Value > 1.0)
Value = 1.0;
return Value;
}
int image_map(VECTOR EPoint, PIGMENT *Pigment, COLOUR colour)
{
int reg_number;
DBL xcoor = 0.0, ycoor = 0.0;
/* If outside map coverage area, return clear */
if (map(EPoint, ((TPATTERN *) Pigment), &xcoor, &ycoor))
{
Make_ColourA(colour, 1.0, 1.0, 1.0, 0.0, 1.0);
return(false);
}
else
{
image_colour_at(Pigment->Vals.Image, xcoor, ycoor, colour, ®_number);
}
return(true);
}
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);
}
void bump_map(const Vector3d& EPoint, const TNORMAL *Tnormal, Vector3d& normal)
{
DBL xcoor = 0.0, ycoor = 0.0;
int index = -1, index2 = -1, index3 = -1;
RGBFTColour colour1, colour2, colour3;
Vector3d p1, p2, p3;
Vector3d bump_normal;
Vector3d xprime, yprime, zprime;
DBL Length;
DBL Amount = Tnormal->Amount;
const ImageData *image;
if (const ImagePatternImpl *pattern = dynamic_cast<ImagePatternImpl*>(Tnormal->pattern.get()))
image = pattern->pImage;
else
POV_PATTERN_ASSERT(false);
// going to have to change this
// need to know if bump point is off of image for all 3 points
if(map_pos(EPoint, Tnormal->pattern.get(), &xcoor, &ycoor))
return;
else
image_colour_at(image, xcoor, ycoor, colour1, &index); // TODO ALPHA - we should decide whether we prefer premultiplied or non-premultiplied alpha
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); // TODO ALPHA - we should decide whether we prefer premultiplied or non-premultiplied alpha
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); // TODO ALPHA - we should decide whether we prefer premultiplied or non-premultiplied alpha
if(image->Use || (index == -1) || (index2 == -1) || (index3 == -1))
{
p1[X] = 0;
p1[Y] = Amount * colour1.Greyscale();
p1[Z] = 0;
p2[X] = -1;
p2[Y] = Amount * colour2.Greyscale();
p2[Z] = 1;
p3[X] = 1;
p3[Y] = Amount * colour3.Greyscale();
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
xprime = p1 - p2;
yprime = p3 - p2;
bump_normal = cross(yprime, xprime).normalized();
yprime = normal;
xprime = cross(yprime, Vector3d(0.0, 1.0, 0.0));
Length = xprime.length();
if(Length < EPSILON)
{
if(fabs(normal[Y] - 1.0) < EPSILON)
{
yprime = Vector3d(0.0, 1.0, 0.0);
xprime = Vector3d(1.0, 0.0, 0.0);
Length = 1.0;
}
else
{
yprime = Vector3d(0.0,-1.0, 0.0);
xprime = Vector3d(1.0, 0.0, 0.0);
Length = 1.0;
}
}
xprime /= Length;
zprime = cross(xprime, yprime).normalized();
xprime *= bump_normal[X];
yprime *= bump_normal[Y];
zprime *= bump_normal[Z];
normal = xprime + yprime - zprime;
}
