TextureMapsImpl.mesa
Copyright © 1984 by Xerox Corporation. All rights reserved.
Last Edited by: Crow, May 27, 1986 4:52:28 pm PDT
DIRECTORY
Atom     USING [GetPropFromList, PutPropOnList],
Real     USING [LargestNumber, Float, Fix],
RealFns    USING [SqRt, ArcTanDeg],
Rope     USING [ROPE],
Pixels     USING [PixelBuffer, SampleSet, GetSampleSet, Create, Copy,
        SampleSetSequence, GetScanSeg, GetValue],
ThreeDScenes  USING [Context, ShapeInstance, Create, PutShading, GetShading],
ThreeDSurfaces  USING [PtrPatchSequence],
ScanConvert   USING [Spot],
Vector2    USING [VEC],
Vector3d    USING [Normalize, Mul, Triple],
AISAnimation  USING [GetAIS],
TextureMaps   USING [TextureMap, IntSequence, ScanSequence, SummedTexture];
TextureMapsImpl: CEDAR PROGRAM
IMPORTS Atom, Real, RealFns, ThreeDScenes, AISAnimation, Pixels, Vector3d
EXPORTS TextureMaps
= BEGIN
Internal Declarations
TextureMapsError: PUBLIC SIGNAL [reason: ATOM] ~ CODE;
Pair: TYPE ~ Vector2.VEC;           -- [ x, y: REAL];
Triple: TYPE ~ Vector3d.Triple;
TextureMap: TYPE ~ TextureMaps.TextureMap;
IntSequence: TYPE ~ TextureMaps.IntSequence;
ScanSequence: TYPE ~ TextureMaps.ScanSequence;
SummedTexture: TYPE ~ TextureMaps.SummedTexture;
Sqr: PROCEDURE [number: REAL] RETURNS [REAL] ~ INLINE { RETURN[number * number]; };
Sgn: PROCEDURE [number: REAL] RETURNS [REAL] ~ INLINE {
IF number < 0. THEN RETURN[-1.] ELSE RETURN[1.];
};
Procedures for Computing Texture Coordinates
MakeTxtrCoordsFromVtxNos: PUBLIC PROC[ shape: REF ThreeDScenes.ShapeInstance,
              vtcesInRow, numberOfRows: NAT,
        row0col0, rowNcol0, rowNcolM, row0ColM: Pair] ~ {
texture: REF TextureMap;
args: LIST OF REAL;
IF shape.shade.length # CARDINAL[vtcesInRow * numberOfRows] THEN {
SIGNAL TextureMapsError[$WrongNumberOfVertices];
RETURN[];
};
IF row0ColM.x - row0col0.x > .3 * vtcesInRow
OR rowNcolM.x - rowNcol0.x > .3 * vtcesInRow
OR rowNcolM.y - row0ColM.y > .3 * numberOfRows
OR rowNcol0.y - row0col0.y > .3 * numberOfRows
THEN SIGNAL TextureMapsError[$TextureTooDense];
FOR i: NAT IN [0..shape.shade.length) DO
lPosX, lPosY, rPosX, rPosY: REAL;
shape.shade[i].txtrX ← Real.Float[i MOD vtcesInRow] / vtcesInRow; -- pct along row
shape.shade[i].txtrY ← Real.Float[i / vtcesInRow] / numberOfRows; -- pct across rows
Stretch as indicated by corner coordinates
lPosX ← row0col0.x + shape.shade[i].txtrY * (rowNcol0.x - row0col0.x); -- interp across rows
lPosY ← row0col0.y + shape.shade[i].txtrY * (rowNcol0.y - row0col0.y);
rPosX ← row0ColM.x + shape.shade[i].txtrY * (rowNcolM.x - row0ColM.x);
rPosY ← row0ColM.y + shape.shade[i].txtrY * (rowNcolM.y - row0ColM.y);
shape.shade[i].txtrX ← lPosX + shape.shade[i].txtrX * (rPosX - lPosX); -- interp along row
shape.shade[i].txtrY ← lPosY + shape.shade[i].txtrX * (rPosY - lPosY);
ENDLOOP;
texture ← NARROW[ThreeDScenes.GetShading[shape, $TextureMap], REF TextureMap];
IF texture = NIL THEN texture ← NEW[TextureMap];
texture.props ← Atom.PutPropOnList[texture.props, $CoordType, $FromVtxNos];
args ← CONS[row0ColM.y, NIL]; args ← CONS[row0ColM.x, args];
args ← CONS[rowNcolM.y, args]; args ← CONS[rowNcolM.x, args];
args ← CONS[rowNcol0.y, args]; args ← CONS[rowNcol0.x, args];
args ← CONS[row0col0.y, args]; args ← CONS[row0col0.x, args];
args ← CONS[Real.Float[numberOfRows], args]; args ← CONS[Real.Float[vtcesInRow], args];
texture.props ← Atom.PutPropOnList[texture.props, $Coords, args];
ThreeDScenes.PutShading[shape, $TextureMap, texture];
};
MakeTxtrCoordsFromNormals: PUBLIC PROC[ shape: REF ThreeDScenes.ShapeInstance,
        botLeft: Pair ← [0.0, 0.0], topLeft: Pair ← [0.0, 1.0],
        topRight: Pair ← [1.0, 1.0], botRight: Pair ← [1.0, 0.0],
           sw: Pair ← [-180.0, -90.0], nw: Pair ← [-180.0, 90.0],
           ne: Pair ← [180.0, 90.0], se: Pair ← [180.0, -90.0] ] ~ {
texture: REF TextureMap;
args: LIST OF REAL;
poly: REF ThreeDSurfaces.PtrPatchSequence ← NARROW[shape.surface];
polyTags: ARRAY [0..8) OF BOOLEAN;
IF shape.shade.length # shape.vertex.length THEN {
SIGNAL TextureMapsError[$WrongNumberOfVertices];
RETURN[];
};
IF ABS[nw.y - sw.y] < 0.001 THEN nw.y ← sw.y + Sgn[nw.y - sw.y] * 0.001; -- stop div errs
IF ABS[ne.y - se.y] < 0.001 THEN ne.y ← se.y + Sgn[ne.y - se.y] * 0.001;
IF ABS[sw.x - se.x] < 0.001 THEN sw.x ← se.x + Sgn[sw.x - se.x] * 0.001;
IF ABS[nw.x - ne.x] < 0.001 THEN nw.x ← ne.x + Sgn[nw.x - ne.x] * 0.001;
FOR polyNumber: NAT IN [0..poly.length) DO
minTxtrX, minTxtrY: REAL ← Real.LargestNumber;
maxTxtrX: REAL ← 0.;
FOR i: NAT IN [0..poly[polyNumber].nVtces) DO
Map from sphere to Cartesian coordinates 1st quadrant 0 - 1 range.
vtx: NAT ← poly[polyNumber].vtxPtr[i];
hypotenuse: REAL ← RealFns.SqRt[Sqr[shape.shade[vtx].yn] + Sqr[shape.shade[vtx].xn]];
longitude: REAL ← RealFns.ArcTanDeg[shape.shade[vtx].yn, shape.shade[vtx].xn];
latitude: REAL ← RealFns.ArcTanDeg[shape.shade[vtx].zn, hypotenuse];
Map polar coordinates into quadrilateral given by sw, nw, ne, se
lPosY: REAL ← (latitude - sw.y) / (nw.y - sw.y); -- percentage of distance on left edge
rPosY: REAL ← (latitude - se.y) / (ne.y - se.y);
lPosX: REAL ← sw.x + lPosY * (nw.x - sw.x);   -- weighted average of positions
rPosX: REAL ← se.x + rPosY * (ne.x - se.x);
shape.shade[vtx].txtrX ← (longitude - lPosX) / (rPosX - lPosX);  -- percentage across
shape.shade[vtx].txtrY ← lPosY + shape.shade[vtx].txtrX * (rPosY - lPosY); -- wtd av. %
shape.shade[vtx].txtrX ← MIN[ 1.0, MAX[0.0, shape.shade[vtx].txtrX]];
shape.shade[vtx].txtrY ← MIN[ 1.0, MAX[0.0, shape.shade[vtx].txtrY]];
IF hypotenuse < 0.00001 THEN polyTags[i] ← TRUE   -- catch unstable arithmetic
ELSE {
polyTags[i] ← FALSE;
IF shape.shade[vtx].txtrX < minTxtrX THEN minTxtrX ← shape.shade[vtx].txtrX;
IF shape.shade[vtx].txtrX > maxTxtrX THEN maxTxtrX ← shape.shade[vtx].txtrX;
};
ENDLOOP;
IF maxTxtrX - minTxtrX > .5    -- wrapping around seam, fix up coords
THEN FOR i: NAT IN [0..poly[polyNumber].nVtces) DO
vtx: NAT ← poly[polyNumber].vtxPtr[i];
IF maxTxtrX - shape.shade[vtx].txtrX > .5
THEN shape.shade[vtx].txtrX ← shape.shade[vtx].txtrX + 1.;
ENDLOOP;
minTxtrX ← Real.LargestNumber;
maxTxtrX ← 0.;
FOR i: NAT IN [0..poly[polyNumber].nVtces) DO   -- get corrected max and min
IF polyTags[i] = FALSE THEN {
vtx: NAT ← poly[polyNumber].vtxPtr[i];
IF shape.shade[vtx].txtrX < minTxtrX THEN minTxtrX ← shape.shade[vtx].txtrX;
IF shape.shade[vtx].txtrX > maxTxtrX THEN maxTxtrX ← shape.shade[vtx].txtrX;
};
ENDLOOP;
FOR i: NAT IN [0..poly[polyNumber].nVtces) DO -- fix up unstable vertical normals
vtx: NAT ← poly[polyNumber].vtxPtr[i];
IF polyTags[i] = TRUE THEN shape.shade[vtx].txtrX ← (maxTxtrX + minTxtrX) / 2.;
ENDLOOP;
minTxtrX ← minTxtrY ← Real.LargestNumber;
FOR i: NAT IN [0..poly[polyNumber].nVtces) DO  -- slew according to corner coords
vtx: NAT ← poly[polyNumber].vtxPtr[i];
lPosX: REAL ← botLeft.x + shape.shade[vtx].txtrY * (topLeft.x - botLeft.x);
lPosY: REAL ← botLeft.y + shape.shade[vtx].txtrY * (topLeft.y - botLeft.y);
rPosX: REAL ← botRight.x + shape.shade[vtx].txtrY * (topRight.x - botRight.x);
rPosY: REAL ← botRight.y + shape.shade[vtx].txtrY * (topRight.y - botRight.y);
shape.shade[vtx].txtrX ← lPosX + shape.shade[vtx].txtrX * (rPosX - lPosX);
shape.shade[vtx].txtrY ← lPosY + shape.shade[vtx].txtrX * (rPosY - lPosY);
IF shape.shade[vtx].txtrX < minTxtrX THEN minTxtrX ← shape.shade[vtx].txtrX;
IF shape.shade[vtx].txtrY < minTxtrY THEN minTxtrY ← shape.shade[vtx].txtrY;
ENDLOOP;
minTxtrX ← Real.Float[Real.Fix[minTxtrX]];
minTxtrY ← Real.Float[Real.Fix[minTxtrY]];
FOR i: NAT IN [0..poly[polyNumber].nVtces) DO   -- translate to origin
vtx: NAT ← poly[polyNumber].vtxPtr[i];
shape.shade[vtx].txtrX ← shape.shade[vtx].txtrX - minTxtrX;
shape.shade[vtx].txtrY ← shape.shade[vtx].txtrY - minTxtrY;
ENDLOOP;
ENDLOOP;
texture ← NARROW[ThreeDScenes.GetShading[shape, $TextureMap], REF TextureMap];
IF texture = NIL THEN texture ← NEW[TextureMap];
texture.props ← Atom.PutPropOnList[texture.props, $CoordType, $FromNormals];
args ← CONS[botRight.y, NIL]; args ← CONS[botRight.x, args];
args ← CONS[topRight.y, args]; args ← CONS[topRight.x, args];
args ← CONS[topLeft.y, args]; args ← CONS[topLeft.x, args];
args ← CONS[botLeft.y, args]; args ← CONS[botLeft.x, args];
texture.props ← Atom.PutPropOnList[texture.props, $Coords, args];
ThreeDScenes.PutShading[shape, $TextureMap, texture];
};
Procedures for Reading and Preparing Texture Files
TextureFromAIS: PUBLIC PROC[context: REF ThreeDScenes.Context, fileName: Rope.ROPE,
          type: ATOM ← $Intensity]
      RETURNS[texture: REF TextureMap] ~ {
Create context and load texture into it
width, height: NAT ← 1024;
buf: REF Pixels.PixelBuffer ← NEW[ Pixels.PixelBuffer ];
pixelSizes: Pixels.SampleSet;
renderMode: ATOM ← IF type = $Color THEN $FullClr ELSE $Grey;
firstBuf: NAT ← IF context.alphaBuffer THEN 1 ELSE 0;
bufContext: REF ThreeDScenes.Context ← ThreeDScenes.Create[width, height, renderMode];
bufContext.props ← context.props;      -- bring along working directory, etc.
[width, height] ← AISAnimation.GetAIS[bufContext, fileName];  -- load it with AIS bits
IF width > bufContext.display.width OR height > bufContext.display.height THEN {
bufContext ← ThreeDScenes.Create[width, height, renderMode];
bufContext.props ← context.props;      -- bring along working directory, etc.
[width, height] ← AISAnimation.GetAIS[bufContext, fileName];
};
SELECT bufContext.renderMode FROM
$Dithered, $PseudoClr, $Grey =>
{ pixelSizes ← Pixels.GetSampleSet[1]; pixelSizes[0] ← 8; };
$FullClr, $Dorado24  => {
pixelSizes ← Pixels.GetSampleSet[3];
pixelSizes[0] ← pixelSizes[1] ← pixelSizes[2] ← 8;
};
ENDCASE;
texture ← NEW[TextureMap];
buf^ ← Pixels.Create[width, height, pixelSizes];  -- get properly sized buffer
texture.pixels ← buf;
Pixels.Copy[buf^, bufContext.display,        -- copy texture pixels to it
[0, 0, width, height],
[ (bufContext.display.width - width) / 2,
(bufContext.display.height - height) / 2,
width,
height
]
];
texture.pixels ← buf;
texture.type ← type;
texture.props ← Atom.PutPropOnList[texture.props, $FileName, fileName];
};
SetTexture: PUBLIC PROC[shape: REF ThreeDScenes.ShapeInstance, texture: REF TextureMap] ~ {
oldTexture: REF TextureMap ← NARROW[ ThreeDScenes.GetShading[shape, $TextureMap] ];
IF oldTexture # NIL AND texture # NIL THEN {
oldTexture.pixels ← texture.pixels;
oldTexture.type ← texture.type;
oldTexture.props ← Atom.PutPropOnList[ oldTexture.props, $FileName,
            Atom.GetPropFromList[texture.props, $FileName]
           ];
texture ← oldTexture;
};
ThreeDScenes.PutShading[shape, $TextureMap, texture];
};
SumTexture: PUBLIC PROC[shape: REF ThreeDScenes.ShapeInstance] ~ {
SumOneLine: PROC[ line: Pixels.SampleSet, sumMap: REF ScanSequence, y: NAT ]
     RETURNS[REF ScanSequence] ~ {
IF sumMap = NIL THEN sumMap ← NEW[ ScanSequence[buf.height] ];
IF sumMap[y] = NIL THEN sumMap[y] ← NEW[ IntSequence[buf.width] ];
FOR x: NAT IN [0..line.length) DO
sumMap[y][x] ← line[x];
IF x > 0 THEN {
sumMap[y][x] ← sumMap[y][x] + sumMap[y][x - 1]; --add area to left
IF y > 0 THEN  -- x > 0 and y > 0: add area below minus area below and to left
sumMap[y][x] ← sumMap[y][x] + (sumMap[y - 1][x] - sumMap[y - 1][x - 1]);
}
ELSE IF y > 0 THEN
sumMap[y][x] ← sumMap[y][x] + sumMap[y - 1][x];  --add area below
ENDLOOP;
RETURN[sumMap];
};
buf: Pixels.PixelBuffer;
scanLine: REF Pixels.SampleSetSequence;
summedTexture: REF SummedTexture;
texture: REF TextureMap ← NARROW[ ThreeDScenes.GetShading[shape, $TextureMap] ];
IF texture = NIL THEN RETURN[];
buf ← NARROW[ texture.pixels, REF Pixels.PixelBuffer ]^;
summedTexture ← NEW[ SummedTexture[buf.samplesPerPixel] ];
FOR y: NAT IN [0..buf.height) DO
scanLine ← Pixels.GetScanSeg[buf, 0, y, buf.width, scanLine];
FOR i: NAT IN [0..buf.samplesPerPixel) DO
summedTexture[i] ← SumOneLine[ scanLine[i], summedTexture[i], y ];
ENDLOOP;
ENDLOOP;
texture.pixels ← summedTexture;
ThreeDScenes.PutShading[shape, $TextureMap, texture]
};
Procedures for Evaluating Texture at a Spot
GetTxtrAt: PUBLIC PROC[spot: ScanConvert.Spot] RETURNS[ScanConvert.Spot] ~ {
texture: REF TextureMap ← NARROW[ Atom.GetPropFromList[spot.props, $TextureMap] ];
WITH texture.pixels SELECT FROM
buf: REF Pixels.PixelBuffer => IF texture.type = $Bump
THEN SIGNAL TextureMapsError[$SumYourTexture]
ELSE spot ← SimpleTexture[spot, buf^];
sumMap: REF SummedTexture => IF texture.type = $Bump
THEN spot ← BumpTexture[spot, sumMap]
ELSE spot ← SumMapTexture[spot, sumMap];
ENDCASE => ERROR;
RETURN[spot];
};
SimpleTexture: PROC[spot: ScanConvert.Spot, map: Pixels.PixelBuffer]
     RETURNS[ScanConvert.Spot] ~ {
GetTxtrAddress: PROC[buf: Pixels.PixelBuffer, x, y: REAL]
 RETURNS[ txtrX, txtrY: INTEGER ] ~ {
txtrX ← Real.Fix[x * buf.width] MOD buf.width;
IF txtrX < 0 THEN txtrX ← txtrX + buf.width;
txtrY ← Real.Fix[y * buf.height] MOD buf.height;
IF txtrY < 0 THEN txtrY ← txtrY + buf.height;
};
x, y: INTEGER;
txtrX: NAT ~ NARROW[ Atom.GetPropFromList[spot.props, $MapVals], REF NAT ]^;
txtrY: NAT ~ txtrX+1;
[x, y] ← GetTxtrAddress[map, spot.val[txtrX], spot.val[txtrY]];
SELECT map.samplesPerPixel FROM
1,2 => {
txtrValue: REAL ← Pixels.GetValue[map, x, y, 0] / 256.0 ;
FOR i: NAT IN [0..3) DO spot.val[i] ← spot.val[i] * txtrValue; ENDLOOP;
};
3,4 => FOR i: NAT IN [0..3) DO
spot.val[i] ← spot.val[i] * Pixels.GetValue[map, x, y, i] / 256.0;
ENDLOOP;
ENDCASE  => SIGNAL TextureMapsError[$BadTextureSize];
RETURN[spot];
};
SumMapTexture: PROC[spot: ScanConvert.Spot, txtrSum: REF SummedTexture]
       RETURNS[ScanConvert.Spot] ~ {
maxTxtrX: REAL ← txtrSum[0][0].length;    -- width (thus max x address) of texture
maxTxtrY: REAL ← txtrSum[0].length;     -- height (thus max y address) of texture
txtrX: NAT ~ NARROW[ Atom.GetPropFromList[spot.props, $MapVals], REF NAT ]^;
txtrY: NAT ~ txtrX+1;
txtrXIncr: REAL ← MAX[ .001, ABS[spot.yIncr[txtrX]], ABS[spot.xIncr[txtrX]] ] / 2.0; -- incmnts in x&y
txtrYIncr: REAL ← MAX[ .001, ABS[spot.yIncr[txtrY]], ABS[spot.xIncr[txtrY]] ] / 2.0;
area: REAL ← 4 * txtrXIncr * maxTxtrX * txtrYIncr * maxTxtrY;
WHILE spot.val[txtrX] - txtrXIncr < 0.0 DO spot.val[txtrX] ← spot.val[txtrX] + 1.0; ENDLOOP;
WHILE spot.val[txtrY] - txtrYIncr < 0.0 DO spot.val[txtrY] ← spot.val[txtrY] + 1.0; ENDLOOP;
SELECT txtrSum.length FROM
1 => {
txtrValue: REAL ←
   SumValues[spot, txtrSum[0], txtrX, txtrY, txtrXIncr, txtrYIncr, area] / 256.0;
IF txtrValue < 0.0 THEN txtrValue ← 0.0;
FOR i: NAT IN [0..3) DO spot.val[i] ← spot.val[i] * txtrValue; ENDLOOP;
};
3 => FOR i: NAT IN [0..3) DO
txtrValue: REAL ←
   SumValues[spot, txtrSum[i], txtrX, txtrY, txtrXIncr, txtrYIncr, area] / 256.0;
spot.val[i] ← MAX[ 0.0, spot.val[i] * txtrValue];
ENDLOOP;
ENDCASE  => SIGNAL TextureMapsError[$BadTextureSize];
RETURN[spot];
};
BumpTexture: PROC[spot: ScanConvert.Spot, pixels: REF] RETURNS[ScanConvert.Spot] ~ {
txtrX: NAT ~ NARROW[ Atom.GetPropFromList[spot.props, $MapVals], REF NAT ]^;
txtrY: NAT ~ txtrX+1;
Positivize: PROC[] ~ {
WHILE spot.val[txtrX] - txtrXIncr < 0.0 DO spot.val[txtrX] ← spot.val[txtrX] + 1.0; ENDLOOP;
WHILE spot.val[txtrY] - txtrYIncr < 0.0 DO spot.val[txtrY] ← spot.val[txtrY] + 1.0; ENDLOOP;
};
txtrSum: REF SummedTexture ← NARROW[pixels, REF SummedTexture];
maxTxtrX: REAL ← txtrSum[0][0].length;    -- width (thus max x address) of texture
maxTxtrY: REAL ← txtrSum[0].length;     -- height (thus max y address) of texture
txtrXIncr: REAL ← MAX[ .001, ABS[spot.yIncr[txtrX]], ABS[spot.xIncr[txtrX]] ] / 2.0;
txtrYIncr: REAL ← MAX[ .001, ABS[spot.yIncr[txtrY]], ABS[spot.xIncr[txtrY]] ] / 2.0;
area: REAL ← 4 * txtrXIncr * maxTxtrX * txtrYIncr * maxTxtrY;
nmlX: NAT ~ 4; nmlY: NAT ~ nmlX + 1; nmlZ: NAT ~ nmlX + 2;
nmlXIncr: Triple ← Vector3d.Normalize[
          [ spot.xIncr[nmlX], spot.xIncr[nmlY], spot.xIncr[nmlZ] ] ];
nmlYIncr: Triple ← Vector3d.Normalize[
          [ spot.yIncr[nmlX], spot.yIncr[nmlY], spot.yIncr[nmlZ] ] ];
SELECT txtrSum.length FROM
1 => {
txtrValue, txtrValueX, txtrValueY: REAL;
Positivize[];         -- ensure positive texture coordinate values
txtrValue ← SumValues[spot, txtrSum[0], txtrX, txtrY, txtrXIncr, txtrYIncr, area] / 256.0;
spot.val[txtrX] ← spot.val[txtrX] + spot.xIncr[txtrX]; -- get txtr offset one pixel to right
spot.val[txtrY] ← spot.val[txtrY] + spot.xIncr[txtrY];
Positivize[];
txtrValueX ← SumValues[spot, txtrSum[0], txtrX, txtrY, txtrXIncr, txtrYIncr, area] / 256.0;
spot.val[txtrX] ← spot.val[txtrX] - spot.xIncr[txtrX]; -- get original texture value back
spot.val[txtrY] ← spot.val[txtrY] - spot.xIncr[txtrY];
spot.val[txtrX] ← spot.val[txtrX] + spot.yIncr[txtrX]; -- get txtr offset one pixel above
spot.val[txtrY] ← spot.val[txtrY] + spot.yIncr[txtrY];
Positivize[];
txtrValueY ← SumValues[spot, txtrSum[0], txtrX, txtrY, txtrXIncr, txtrYIncr, area] / 256.0;
nmlXIncr ← Vector3d.Mul[ nmlXIncr, txtrValueX - txtrValue]; -- perturb in x
nmlYIncr ← Vector3d.Mul[ nmlYIncr, txtrValueY - txtrValue]; -- perturb in y
spot.val[nmlX] ← spot.val[nmlX] + nmlXIncr.x + nmlYIncr.x;
spot.val[nmlY] ← spot.val[nmlY] + nmlXIncr.y + nmlYIncr.y;
spot.val[nmlZ] ← spot.val[nmlZ] + nmlXIncr.z + nmlYIncr.z;
};
ENDCASE  => SIGNAL TextureMapsError[$BadTextureSize];
RETURN[spot];
};
Support Procedures for Summed Textures
GetLerpedValue: PROC[ llVal, ulVal, urVal, lrVal: INT, xPos, yPos: REAL ]
RETURNS[ REAL ] ~ {
lowerValue: REAL ← llVal + xPos * (lrVal - llVal);
upperValue: REAL ← ulVal + xPos * (urVal - ulVal);
RETURN [ lowerValue + yPos * (upperValue - lowerValue) ];
};
CorrectSum: PROC[txtrSum: REF ScanSequence, x, y: NAT] RETURNS[INT] ~ {
maxTxtrX: NAT ← txtrSum[0].length-1;
maxTxtrY: NAT ← txtrSum.length-1;
IF x < txtrSum[0].length AND y < txtrSum.length THEN {
RETURN[ txtrSum[y][x] ]
}
ELSE IF x >= txtrSum[0].length AND y >= txtrSum.length THEN {
x ← x - txtrSum[0].length;  y ← y - txtrSum.length;
RETURN[  CorrectSum[txtrSum, x, y]    + txtrSum[maxTxtrY][maxTxtrX]
   + CorrectSum[txtrSum, x, maxTxtrY]  + CorrectSum[txtrSum, maxTxtrX, y] ];
}
ELSE IF x >= txtrSum[0].length THEN {
x ← x - txtrSum[0].length;  
RETURN[ CorrectSum[txtrSum, x, y] + txtrSum[y][maxTxtrX] ];
}
ELSE {            -- IF y >= txtrSum.length
y ← y - txtrSum.length;
RETURN[ CorrectSum[txtrSum, x, y] + txtrSum[maxTxtrY][x] ];
};
};
GetValueAt: PROC[txtrSum: REF ScanSequence, x, y: REAL] RETURNS[ REAL ] ~ {
xPos, yPos: REAL;  lX, lY, rX, uY: NAT;
xPos ← x * txtrSum[0].length;
lX ← Real.Fix[xPos]; rX ← lX + 1;
yPos ← y * txtrSum.length;
lY ← Real.Fix[yPos]; uY ← lY + 1;
xPos ← xPos - Real.Fix[xPos];         -- get fractional part
yPos ← yPos - Real.Fix[yPos];
RETURN [ GetLerpedValue[ CorrectSum[txtrSum, lX, lY], CorrectSum[txtrSum, lX, uY],
         CorrectSum[txtrSum, rX, uY], CorrectSum[txtrSum, rX, lY],
        xPos, yPos
       ]
  ];
};
SumValues: PROC[ spot: ScanConvert.Spot, txtrSum: REF ScanSequence, txtrX, txtrY: NAT,
      txtrXIncr, txtrYIncr, area: REAL ]
    RETURNS[ txtrValue: REAL ] ~ {
txtrValue ← GetValueAt[ txtrSum,  spot.val[txtrX] + txtrXIncr, spot.val[txtrY] + txtrYIncr ]
  + GetValueAt[ txtrSum, spot.val[txtrX] - txtrXIncr, spot.val[txtrY] - txtrYIncr ]
  - GetValueAt[ txtrSum, spot.val[txtrX] + txtrXIncr, spot.val[txtrY] - txtrYIncr ]
  - GetValueAt[ txtrSum, spot.val[txtrX] - txtrXIncr, spot.val[txtrY] + txtrYIncr ];
txtrValue ← txtrValue / area;
};
END.