thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

SAGA2: Rename metatile metric constants

Browse source
This commit is contained in:
a/ 2021-06-18 15:59:19 +09:00 • committed by Eugene Sandulenko
parent 6dad132e83
commit 500a6ba468
No known key found for this signature in database
GPG key ID: 014D387312D34F08
7 changed files with 170 additions and 170 deletions
Download patch file Download diff file Expand all files Collapse all files

32
engines/saga2/idtypes.h
View file

@ -306,32 +306,32 @@ enum {
// Metatile metrics // Metatile metrics
enum { enum {
metaTileWidth = kTileWidth * kPlatformWidth, kMetaTileWidth = kTileWidth * kPlatformWidth,
metaTileHeight = kTileHeight * kPlatformWidth, kMetaTileHeight = kTileHeight * kPlatformWidth,
metaDX = metaTileWidth / 2, kMetaDX = kMetaTileWidth / 2,
metaDY = metaTileHeight / 2 kMetaDY = kMetaTileHeight / 2
}; };
enum { enum {
subTileSize = 4, kSubTileSize = 4,
subTileMask = subTileSize - 1, kSubTileMask = kSubTileSize - 1,
subTileShift = 2, kSubTileShift = 2,
tileSubSize = 4, kTileSubSize = 4,
tileSubMask = tileSubSize - 1, kTileSubMask = kTileSubSize - 1,
tileSubShift = 2 kTileSubShift = 2
}; };
// Constants to convert an X,Y into subtile coordinates // Constants to convert an X,Y into subtile coordinates
enum { enum {
subTileDX = (kTileDX / 4), kSubTileDX = (kTileDX / 4),
subTileDY = (kTileDY / 4), kSubTileDY = (kTileDY / 4),
subTileDXShift = (kTileDXShift - 2), kSubTileDXShift = (kTileDXShift - 2),
subTileDYShift = (kTileDYShift - 2) kSubTileDYShift = (kTileDYShift - 2)
}; };
enum { enum {
subTileMaskUShift = 4, kSubTileMaskUShift = 4,
subTileMaskVShift = 1 kSubTileMaskVShift = 1
}; };
// Maximum height that a character can climb w/o steps or ladders // Maximum height that a character can climb w/o steps or ladders

48
engines/saga2/motion.cpp
View file

@ -3028,17 +3028,17 @@ void MotionTask::upLadderAction(void) {
uint16 footPrintMask = 0xFFFF, uint16 footPrintMask = 0xFFFF,
ladderMask; ladderMask;
TilePoint subTileLoc( TilePoint subTileLoc(
tileLoc.u << tileSubShift, tileLoc.u << kTileSubShift,
tileLoc.v << tileSubShift, tileLoc.v << kTileSubShift,
0); 0);
TileRegion actorSubTileReg; TileRegion actorSubTileReg;
actorSubTileReg.min.u = (loc.u - crossSection) >> subTileShift; actorSubTileReg.min.u = (loc.u - crossSection) >> kSubTileShift;
actorSubTileReg.min.v = (loc.v - crossSection) >> subTileShift; actorSubTileReg.min.v = (loc.v - crossSection) >> kSubTileShift;
actorSubTileReg.max.u = actorSubTileReg.max.u =
(loc.u + crossSection + subTileMask) >> subTileShift; (loc.u + crossSection + kSubTileMask) >> kSubTileShift;
actorSubTileReg.max.v = actorSubTileReg.max.v =
(loc.v + crossSection + subTileMask) >> subTileShift; (loc.v + crossSection + kSubTileMask) >> kSubTileShift;
if (actorSubTileReg.min.u >= subTileLoc.u) if (actorSubTileReg.min.u >= subTileLoc.u)
footPrintMask &= footPrintMask &=
@ -3048,11 +3048,11 @@ void MotionTask::upLadderAction(void) {
footPrintMask &= footPrintMask &=
vMinMasks[actorSubTileReg.min.v - subTileLoc.v]; vMinMasks[actorSubTileReg.min.v - subTileLoc.v];
if (actorSubTileReg.max.u < subTileLoc.u + tileSubSize) if (actorSubTileReg.max.u < subTileLoc.u + kTileSubSize)
footPrintMask &= footPrintMask &=
uMaxMasks[actorSubTileReg.max.u - subTileLoc.u]; uMaxMasks[actorSubTileReg.max.u - subTileLoc.u];
if (actorSubTileReg.max.v < subTileLoc.v + tileSubSize) if (actorSubTileReg.max.v < subTileLoc.v + kTileSubSize)
footPrintMask &= footPrintMask &=
vMaxMasks[actorSubTileReg.max.v - subTileLoc.v]; vMaxMasks[actorSubTileReg.max.v - subTileLoc.v];
@ -3150,17 +3150,17 @@ void MotionTask::downLadderAction(void) {
uint16 footPrintMask = 0xFFFF, uint16 footPrintMask = 0xFFFF,
ladderMask; ladderMask;
TilePoint subTileLoc( TilePoint subTileLoc(
tileLoc.u << tileSubShift, tileLoc.u << kTileSubShift,
tileLoc.v << tileSubShift, tileLoc.v << kTileSubShift,
0); 0);
TileRegion actorSubTileReg; TileRegion actorSubTileReg;
actorSubTileReg.min.u = (loc.u - crossSection) >> subTileShift; actorSubTileReg.min.u = (loc.u - crossSection) >> kSubTileShift;
actorSubTileReg.min.v = (loc.v - crossSection) >> subTileShift; actorSubTileReg.min.v = (loc.v - crossSection) >> kSubTileShift;
actorSubTileReg.max.u = actorSubTileReg.max.u =
(loc.u + crossSection + subTileMask) >> subTileShift; (loc.u + crossSection + kSubTileMask) >> kSubTileShift;
actorSubTileReg.max.v = actorSubTileReg.max.v =
(loc.v + crossSection + subTileMask) >> subTileShift; (loc.v + crossSection + kSubTileMask) >> kSubTileShift;
if (actorSubTileReg.min.u >= subTileLoc.u) if (actorSubTileReg.min.u >= subTileLoc.u)
footPrintMask &= footPrintMask &=
@ -3170,11 +3170,11 @@ void MotionTask::downLadderAction(void) {
footPrintMask &= footPrintMask &=
vMinMasks[actorSubTileReg.min.v - subTileLoc.v]; vMinMasks[actorSubTileReg.min.v - subTileLoc.v];
if (actorSubTileReg.max.u < subTileLoc.u + tileSubSize) if (actorSubTileReg.max.u < subTileLoc.u + kTileSubSize)
footPrintMask &= footPrintMask &=
uMaxMasks[actorSubTileReg.max.u - subTileLoc.u]; uMaxMasks[actorSubTileReg.max.u - subTileLoc.u];
if (actorSubTileReg.max.v < subTileLoc.v + tileSubSize) if (actorSubTileReg.max.v < subTileLoc.v + kTileSubSize)
footPrintMask &= footPrintMask &=
vMaxMasks[actorSubTileReg.max.v - subTileLoc.v]; vMaxMasks[actorSubTileReg.max.v - subTileLoc.v];
@ -4873,17 +4873,17 @@ bool checkLadder(Actor *a, const TilePoint &loc) {
uint16 footPrintMask = 0xFFFF, uint16 footPrintMask = 0xFFFF,
ladderMask; ladderMask;
TilePoint subTileLoc( TilePoint subTileLoc(
tileLoc.u << tileSubShift, tileLoc.u << kTileSubShift,
tileLoc.v << tileSubShift, tileLoc.v << kTileSubShift,
0); 0);
TileRegion actorSubTileReg; TileRegion actorSubTileReg;
actorSubTileReg.min.u = (loc.u - crossSection) >> subTileShift; actorSubTileReg.min.u = (loc.u - crossSection) >> kSubTileShift;
actorSubTileReg.min.v = (loc.v - crossSection) >> subTileShift; actorSubTileReg.min.v = (loc.v - crossSection) >> kSubTileShift;
actorSubTileReg.max.u = actorSubTileReg.max.u =
(loc.u + crossSection + subTileMask) >> subTileShift; (loc.u + crossSection + kSubTileMask) >> kSubTileShift;
actorSubTileReg.max.v = actorSubTileReg.max.v =
(loc.v + crossSection + subTileMask) >> subTileShift; (loc.v + crossSection + kSubTileMask) >> kSubTileShift;
if (actorSubTileReg.min.u >= subTileLoc.u) if (actorSubTileReg.min.u >= subTileLoc.u)
footPrintMask &= footPrintMask &=
@ -4893,11 +4893,11 @@ bool checkLadder(Actor *a, const TilePoint &loc) {
footPrintMask &= footPrintMask &=
vMinMasks[actorSubTileReg.min.v - subTileLoc.v]; vMinMasks[actorSubTileReg.min.v - subTileLoc.v];
if (actorSubTileReg.max.u < subTileLoc.u + tileSubSize) if (actorSubTileReg.max.u < subTileLoc.u + kTileSubSize)
footPrintMask &= footPrintMask &=
uMaxMasks[actorSubTileReg.max.u - subTileLoc.u]; uMaxMasks[actorSubTileReg.max.u - subTileLoc.u];
if (actorSubTileReg.max.v < subTileLoc.v + tileSubSize) if (actorSubTileReg.max.v < subTileLoc.v + kTileSubSize)
footPrintMask &= footPrintMask &=
vMaxMasks[actorSubTileReg.max.v - subTileLoc.v]; vMaxMasks[actorSubTileReg.max.v - subTileLoc.v];

4
engines/saga2/objects.cpp
View file

@ -1415,8 +1415,8 @@ void GameObject::updateState(void) {
if (!(location.z >= 0 || prototype->height > 8 - location.z)) if (!(location.z >= 0 || prototype->height > 8 - location.z))
drown(this); drown(this);
TilePoint subTile((location.u >> subTileShift) & subTileMask, TilePoint subTile((location.u >> kSubTileShift) & kSubTileMask,
(location.v >> subTileShift) & subTileMask, (location.v >> kSubTileShift) & kSubTileMask,
0); 0);

28
engines/saga2/path.cpp
View file

@ -746,8 +746,8 @@ void DirMaskGroup::computeMask(uint8 objSection) {
// Calculate the area in subtiles the object occupies. Since U and // Calculate the area in subtiles the object occupies. Since U and
// V coordinates will alway equal each other, there is no need to // V coordinates will alway equal each other, there is no need to
// calculate both. // calculate both.
area.min = ((kTileUVSize / 2) - objSection) >> subTileShift; area.min = ((kTileUVSize / 2) - objSection) >> kSubTileShift;
area.max = ((kTileUVSize / 2) + objSection + subTileMask) >> subTileShift; area.max = ((kTileUVSize / 2) + objSection + kSubTileMask) >> kSubTileShift;
// Determine if the cross section is wide enough that the diaginal // Determine if the cross section is wide enough that the diaginal
// masks need to be expanded outward one subtile // masks need to be expanded outward one subtile
@ -793,16 +793,16 @@ void DirMaskGroup::computeMask(uint8 objSection) {
ptMaskArea.min = baseMaskArea.min + tDirTable2[dir] * (ptNum + 1); ptMaskArea.min = baseMaskArea.min + tDirTable2[dir] * (ptNum + 1);
ptMaskArea.max = baseMaskArea.max + tDirTable2[dir] * (ptNum + 1); ptMaskArea.max = baseMaskArea.max + tDirTable2[dir] * (ptNum + 1);
ptMask->offset.u = ptMaskArea.min.u >> tileSubShift; ptMask->offset.u = ptMaskArea.min.u >> kTileSubShift;
ptMask->offset.v = ptMaskArea.min.v >> tileSubShift; ptMask->offset.v = ptMaskArea.min.v >> kTileSubShift;
ptMaskArea.max.u -= ptMaskArea.min.u & ~subTileMask; ptMaskArea.max.u -= ptMaskArea.min.u & ~kSubTileMask;
ptMaskArea.min.u &= subTileMask; ptMaskArea.min.u &= kSubTileMask;
ptMaskArea.max.v -= ptMaskArea.min.v & ~subTileMask; ptMaskArea.max.v -= ptMaskArea.min.v & ~kSubTileMask;
ptMaskArea.min.v &= subTileMask; ptMaskArea.min.v &= kSubTileMask;
ptMask->size.u = (ptMaskArea.max.u + tileSubMask) >> tileSubShift; ptMask->size.u = (ptMaskArea.max.u + kTileSubMask) >> kTileSubShift;
ptMask->size.v = (ptMaskArea.max.v + tileSubMask) >> tileSubShift; ptMask->size.v = (ptMaskArea.max.v + kTileSubMask) >> kTileSubShift;
memset(tempMask, 0, sizeof(tempMask)); memset(tempMask, 0, sizeof(tempMask));
@ -957,8 +957,8 @@ int16 tileSlopeHeight(
// Calculate coordinates of tile and subtile // Calculate coordinates of tile and subtile
TilePoint tileCoords = pt >> kTileUVShift, TilePoint tileCoords = pt >> kTileUVShift,
subTile( subTile(
(pt.u >> subTileShift) & subTileMask, (pt.u >> kSubTileShift) & kSubTileMask,
(pt.v >> subTileShift) & subTileMask, (pt.v >> kSubTileShift) & kSubTileMask,
0); 0);
PathTileInfo highestTile, PathTileInfo highestTile,
@ -2667,7 +2667,7 @@ TilePoint selectNearbySite(
// If it's too high to step, then don't continue // If it's too high to step, then don't continue
// if (testPt.z - qi.z > maxStepHeight) continue; // if (testPt.z - qi.z > maxStepHeight) continue;
fromSubPt = centerPt; fromSubPt = centerPt;
for (i = 0; i < tileSubSize; i++) { for (i = 0; i < kTileSubSize; i++) {
int16 deltaZ; int16 deltaZ;
// Next sub tile // Next sub tile
@ -2961,7 +2961,7 @@ bool checkPath(
testPt.z = tileSlopeHeight(testPt, mapNum, height, &sti); testPt.z = tileSlopeHeight(testPt, mapNum, height, &sti);
fromSubPt = centerPt; fromSubPt = centerPt;
for (i = 0; i < tileSubSize; i++) { for (i = 0; i < kTileSubSize; i++) {
int16 deltaZ; int16 deltaZ;
// Next sub tile // Next sub tile

4
engines/saga2/spelcast.cpp
View file

@ -904,8 +904,8 @@ int16 tileNopeHeight(
metaCoords = tileCoords >> kPlatShift, metaCoords = tileCoords >> kPlatShift,
origin = metaCoords << kPlatShift, origin = metaCoords << kPlatShift,
coords = tileCoords - origin, coords = tileCoords - origin,
subTile((pt.u >> subTileShift) & subTileMask, subTile((pt.u >> kSubTileShift) & kSubTileMask,
(pt.v >> subTileShift) & subTileMask, (pt.v >> kSubTileShift) & kSubTileMask,
0); 0);
MetaTilePtr metaPtr; MetaTilePtr metaPtr;

94
engines/saga2/terrain.cpp
View file

@ -224,24 +224,24 @@ uint32 volumeTerrain(int16 mapNum, const TileRegion &vol) {
volume; volume;
// Convert to subtile coords // Convert to subtile coords
volume.min.u = vol.min.u >> subTileShift; volume.min.u = vol.min.u >> kSubTileShift;
volume.min.v = vol.min.v >> subTileShift; volume.min.v = vol.min.v >> kSubTileShift;
volume.max.u = (vol.max.u + subTileMask) >> subTileShift; volume.max.u = (vol.max.u + kSubTileMask) >> kSubTileShift;
volume.max.v = (vol.max.v + subTileMask) >> subTileShift; volume.max.v = (vol.max.v + kSubTileMask) >> kSubTileShift;
volume.min.z = vol.min.z; volume.min.z = vol.min.z;
volume.max.z = vol.max.z; volume.max.z = vol.max.z;
// Calculate the footprint of the object (in subtile coords) // Calculate the footprint of the object (in subtile coords)
footprint.min.u = volume.min.u >> tileSubShift; footprint.min.u = volume.min.u >> kTileSubShift;
footprint.min.v = volume.min.v >> tileSubShift; footprint.min.v = volume.min.v >> kTileSubShift;
footprint.max.u = volume.max.u >> tileSubShift; footprint.max.u = volume.max.u >> kTileSubShift;
footprint.max.v = volume.max.v >> tileSubShift; footprint.max.v = volume.max.v >> kTileSubShift;
// Calculate which subtiles the region falls upon. // Calculate which subtiles the region falls upon.
subPos.min.u = volume.min.u & subTileMask; subPos.min.u = volume.min.u & kSubTileMask;
subPos.min.v = volume.min.v & subTileMask; subPos.min.v = volume.min.v & kSubTileMask;
subPos.max.u = volume.max.u & subTileMask; subPos.max.u = volume.max.u & kSubTileMask;
subPos.max.v = volume.max.v & subTileMask; subPos.max.v = volume.max.v & kSubTileMask;
tilePt.z = 0; tilePt.z = 0;
@ -389,17 +389,17 @@ uint32 lineTerrain(
#endif #endif
// Calculate starting subtile coordinates // Calculate starting subtile coordinates
curSubTile.u = from.u >> subTileShift; curSubTile.u = from.u >> kSubTileShift;
curSubTile.v = from.v >> subTileShift; curSubTile.v = from.v >> kSubTileShift;
curSubTile.z = tileStartZ = from.z; curSubTile.z = tileStartZ = from.z;
// Calculate destination subtil coordinates // Calculate destination subtil coordinates
destSubTile.u = to.u >> subTileShift; destSubTile.u = to.u >> kSubTileShift;
destSubTile.v = to.v >> subTileShift; destSubTile.v = to.v >> kSubTileShift;
destSubTile.z = to.z; destSubTile.z = to.z;
tilePt.u = curSubTile.u >> tileSubShift; tilePt.u = curSubTile.u >> kTileSubShift;
tilePt.v = curSubTile.v >> tileSubShift; tilePt.v = curSubTile.v >> kTileSubShift;
tilePt.z = 0; tilePt.z = 0;
if (destSubTile.u > curSubTile.u) { if (destSubTile.u > curSubTile.u) {
@ -440,7 +440,7 @@ uint32 lineTerrain(
curSubTile.u += uStep) { curSubTile.u += uStep) {
curZ += zStep; curZ += zStep;
if ((curSubTile.u >> tileSubShift) != tilePt.u) { if ((curSubTile.u >> kTileSubShift) != tilePt.u) {
curSubTile.z = curZ >> 16; curSubTile.z = curZ >> 16;
terrain |= tileTerrain( terrain |= tileTerrain(
@ -451,16 +451,16 @@ uint32 lineTerrain(
*maxZ + 1); *maxZ + 1);
if (terrain & opaqueTerrain) return terrain; if (terrain & opaqueTerrain) return terrain;
tilePt.u = curSubTile.u >> tileSubShift; tilePt.u = curSubTile.u >> kTileSubShift;
tileStartZ = curSubTile.z; tileStartZ = curSubTile.z;
subTileMask_ = 0; subTileMask_ = 0;
} }
subTileMask_ |= (uMask[curSubTile.u & subTileMask] & subTileMask_ |= (uMask[curSubTile.u & kSubTileMask] &
vMask[curSubTile.v & subTileMask]); vMask[curSubTile.v & kSubTileMask]);
#if DEBUG && VISUAL2 #if DEBUG && VISUAL2
tempPoint.u = curSubTile.u << tileSubShift; tempPoint.u = curSubTile.u << kTileSubShift;
tempPoint.v = curSubTile.v << tileSubShift; tempPoint.v = curSubTile.v << kTileSubShift;
tempPoint.z = curSubTile.z; tempPoint.z = curSubTile.z;
TPLine(prevPoint, tempPoint); TPLine(prevPoint, tempPoint);
prevPoint = tempPoint; prevPoint = tempPoint;
@ -471,7 +471,7 @@ uint32 lineTerrain(
errorTerm -= uDiff; errorTerm -= uDiff;
curSubTile.v += vStep; curSubTile.v += vStep;
if ((curSubTile.v >> tileSubShift) != tilePt.z) { if ((curSubTile.v >> kTileSubShift) != tilePt.z) {
curSubTile.z = curZ >> 16; curSubTile.z = curZ >> 16;
terrain |= tileTerrain( terrain |= tileTerrain(
@ -482,16 +482,16 @@ uint32 lineTerrain(
*maxZ + 1); *maxZ + 1);
if (terrain & opaqueTerrain) return terrain; if (terrain & opaqueTerrain) return terrain;
tilePt.v = curSubTile.v >> tileSubShift; tilePt.v = curSubTile.v >> kTileSubShift;
tileStartZ = curSubTile.z; tileStartZ = curSubTile.z;
subTileMask_ = 0; subTileMask_ = 0;
} }
subTileMask_ |= (uMask[curSubTile.u & subTileMask] & subTileMask_ |= (uMask[curSubTile.u & kSubTileMask] &
vMask[curSubTile.v & subTileMask]); vMask[curSubTile.v & kSubTileMask]);
#if DEBUG && VISUAL2 #if DEBUG && VISUAL2
tempPoint.u = curSubTile.u << tileSubShift; tempPoint.u = curSubTile.u << kTileSubShift;
tempPoint.v = curSubTile.v << tileSubShift; tempPoint.v = curSubTile.v << kTileSubShift;
tempPoint.z = curSubTile.z; tempPoint.z = curSubTile.z;
TPLine(prevPoint, tempPoint); TPLine(prevPoint, tempPoint);
prevPoint = tempPoint; prevPoint = tempPoint;
@ -509,7 +509,7 @@ uint32 lineTerrain(
curSubTile.v += vStep) { curSubTile.v += vStep) {
curZ += zStep; curZ += zStep;
if ((curSubTile.v >> tileSubShift) != tilePt.v) { if ((curSubTile.v >> kTileSubShift) != tilePt.v) {
curSubTile.z = curZ >> 16; curSubTile.z = curZ >> 16;
terrain |= tileTerrain( terrain |= tileTerrain(
@ -520,17 +520,17 @@ uint32 lineTerrain(
*maxZ + 1); *maxZ + 1);
if (terrain & opaqueTerrain) return terrain; if (terrain & opaqueTerrain) return terrain;
tilePt.v = curSubTile.v >> tileSubShift; tilePt.v = curSubTile.v >> kTileSubShift;
tileStartZ = curSubTile.z; tileStartZ = curSubTile.z;
subTileMask_ = 0; subTileMask_ = 0;
} }
subTileMask_ |= (uMask[curSubTile.u & subTileMask] & subTileMask_ |= (uMask[curSubTile.u & kSubTileMask] &
vMask[curSubTile.v & subTileMask]); vMask[curSubTile.v & kSubTileMask]);
#if DEBUG && VISUAL2 #if DEBUG && VISUAL2
tempPoint.u = curSubTile.u << tileSubShift; tempPoint.u = curSubTile.u << kTileSubShift;
tempPoint.v = curSubTile.v << tileSubShift; tempPoint.v = curSubTile.v << kTileSubShift;
tempPoint.z = curSubTile.z; tempPoint.z = curSubTile.z;
TPLine(prevPoint, tempPoint); TPLine(prevPoint, tempPoint);
prevPoint = tempPoint; prevPoint = tempPoint;
@ -541,7 +541,7 @@ uint32 lineTerrain(
errorTerm -= vDiff; errorTerm -= vDiff;
curSubTile.u += uStep; curSubTile.u += uStep;
if ((curSubTile.u >> tileSubShift) != tilePt.u) { if ((curSubTile.u >> kTileSubShift) != tilePt.u) {
curSubTile.z = curZ >> 16; curSubTile.z = curZ >> 16;
terrain |= tileTerrain( terrain |= tileTerrain(
@ -552,16 +552,16 @@ uint32 lineTerrain(
*maxZ + 1); *maxZ + 1);
if (terrain & opaqueTerrain) return terrain; if (terrain & opaqueTerrain) return terrain;
tilePt.u = curSubTile.u >> tileSubShift; tilePt.u = curSubTile.u >> kTileSubShift;
tileStartZ = curSubTile.z; tileStartZ = curSubTile.z;
subTileMask_ = 0; subTileMask_ = 0;
} }
subTileMask_ |= (uMask[curSubTile.u & subTileMask] & subTileMask_ |= (uMask[curSubTile.u & kSubTileMask] &
vMask[curSubTile.v & subTileMask]); vMask[curSubTile.v & kSubTileMask]);
#if DEBUG && VISUAL2 #if DEBUG && VISUAL2
tempPoint.u = curSubTile.u << tileSubShift; tempPoint.u = curSubTile.u << kTileSubShift;
tempPoint.v = curSubTile.v << tileSubShift; tempPoint.v = curSubTile.v << kTileSubShift;
tempPoint.z = curSubTile.z; tempPoint.z = curSubTile.z;
TPLine(prevPoint, tempPoint); TPLine(prevPoint, tempPoint);
prevPoint = tempPoint; prevPoint = tempPoint;
@ -608,8 +608,8 @@ int16 tileSlopeHeight(
metaCoords = tileCoords >> kPlatShift, metaCoords = tileCoords >> kPlatShift,
origin = metaCoords << kPlatShift, origin = metaCoords << kPlatShift,
coords = tileCoords - origin, coords = tileCoords - origin,
subTile((pt.u >> subTileShift) & subTileMask, subTile((pt.u >> kSubTileShift) & kSubTileMask,
(pt.v >> subTileShift) & subTileMask, (pt.v >> kSubTileShift) & kSubTileMask,
0); 0);
MetaTilePtr metaPtr; MetaTilePtr metaPtr;
@ -866,9 +866,9 @@ int16 checkWalkable(
subTileV, subTileV,
mask; mask;
subTileU = (loc.u & kTileUVMask) >> subTileShift; subTileU = (loc.u & kTileUVMask) >> kSubTileShift;
subTileV = (loc.v & kTileUVMask) >> subTileShift; subTileV = (loc.v & kTileUVMask) >> kSubTileShift;
mask = 1 << ((subTileU << subTileShift) + subTileV); mask = 1 << ((subTileU << kSubTileShift) + subTileV);
// If the suporting subtile is funiture consider this blocked // If the suporting subtile is funiture consider this blocked
if (sti.surfaceTile->attrs.testTerrain(mask) & terrainFurniture) if (sti.surfaceTile->attrs.testTerrain(mask) & terrainFurniture)

130
engines/saga2/tile.cpp
View file

@ -1638,7 +1638,7 @@ void initMaps(void) {
mapData->mapSize = mapData->map->size; mapData->mapSize = mapData->map->size;
// Compute the height of the map in pixels // Compute the height of the map in pixels
mapData->mapHeight = mapData->mapSize * metaTileHeight; mapData->mapHeight = mapData->mapSize * kMetaTileHeight;
// Build an active item instance hash table // Build an active item instance hash table
mapData->buildInstanceHash(); mapData->buildInstanceHash();
@ -2683,12 +2683,12 @@ inline void drawMetaRow(TilePoint coords, Point16 pos) {
for (; for (;
pos.x < tileDrawMap.size.x + metaDX; pos.x < tileDrawMap.size.x + kMetaDX;
coords.u++, coords.u++,
coords.v--, coords.v--,
uOrg += kPlatformWidth, uOrg += kPlatformWidth,
vOrg -= kPlatformWidth, vOrg -= kPlatformWidth,
pos.x += metaTileWidth pos.x += kMetaTileWidth
) { ) {
TilePoint clipCoords; TilePoint clipCoords;
int16 mtile; int16 mtile;
@ -2960,9 +2960,9 @@ inline void drawMetaTiles(void) {
// coordinates of the view window upper left corner in U,V // coordinates of the view window upper left corner in U,V
baseCoords.u = ((2 * (viewPos.y >> kTileDXShift) + metaDY / 16) + viewPos.x) baseCoords.u = ((2 * (viewPos.y >> kTileDXShift) + kMetaDY / 16) + viewPos.x)
/ (kPlatformWidth * 2); / (kPlatformWidth * 2);
baseCoords.v = ((2 * (viewPos.y >> kTileDXShift) + metaDY / 16) - viewPos.x) baseCoords.v = ((2 * (viewPos.y >> kTileDXShift) + kMetaDY / 16) - viewPos.x)
/ (kPlatformWidth * 2); / (kPlatformWidth * 2);
baseCoords.z = 0; baseCoords.z = 0;
@ -2973,11 +2973,11 @@ inline void drawMetaTiles(void) {
updateHandleRefs(baseCoords); // viewPoint, &sti ); updateHandleRefs(baseCoords); // viewPoint, &sti );
// coordinates of current metatile (in X,Y), relative to screen // coordinates of current metatile (in X,Y), relative to screen
metaPos.x = (baseCoords.u - baseCoords.v) * metaDX metaPos.x = (baseCoords.u - baseCoords.v) * kMetaDX
- viewPos.x * kTileDX; - viewPos.x * kTileDX;
metaPos.y = viewPos.y metaPos.y = viewPos.y
- (baseCoords.u + baseCoords.v) * metaDY; - (baseCoords.u + baseCoords.v) * kMetaDY;
debugC(2, kDebugTiles, "metaPos = (%d,%d)", metaPos.x, metaPos.y); debugC(2, kDebugTiles, "metaPos = (%d,%d)", metaPos.x, metaPos.y);
@ -2986,19 +2986,19 @@ inline void drawMetaTiles(void) {
// (replace 256 constant with better value) // (replace 256 constant with better value)
for (; for (;
metaPos.y < tileDrawMap.size.y + metaTileHeight * 4 ; metaPos.y < tileDrawMap.size.y + kMetaTileHeight * 4 ;
baseCoords.u--, baseCoords.u--,
baseCoords.v-- baseCoords.v--
) { ) {
drawMetaRow(baseCoords, metaPos); drawMetaRow(baseCoords, metaPos);
metaPos.y += metaDY; metaPos.y += kMetaDY;
metaPos.x -= metaDX; metaPos.x -= kMetaDX;
drawMetaRow(TilePoint(baseCoords.u - 1, baseCoords.v, 0), metaPos); drawMetaRow(TilePoint(baseCoords.u - 1, baseCoords.v, 0), metaPos);
metaPos.y += metaDY; metaPos.y += kMetaDY;
metaPos.x += metaDX; metaPos.x += kMetaDX;
} }
} }
@ -3318,14 +3318,14 @@ void maskMetaRow(
int16 layerLimit; int16 layerLimit;
for (; for (;
pos.x < sMap.size.x + metaDX; pos.x < sMap.size.x + kMetaDX;
coords.u++, coords.u++,
coords.v--, coords.v--,
relLoc.u += kPlatUVSize, relLoc.u += kPlatUVSize,
relLoc.v -= kPlatUVSize, relLoc.v -= kPlatUVSize,
uOrg += kPlatformWidth, uOrg += kPlatformWidth,
vOrg -= kPlatformWidth, vOrg -= kPlatformWidth,
pos.x += metaTileWidth pos.x += kMetaTileWidth
) { ) {
TilePoint clipCoords; TilePoint clipCoords;
int16 mtile; int16 mtile;
@ -3425,19 +3425,19 @@ void drawTileMask(
// coordinates of the view window upper left corner in U,V // coordinates of the view window upper left corner in U,V
baseCoords.u = ((2 * (viewPos.y >> kTileDXShift) + metaDY / 16) + viewPos.x) baseCoords.u = ((2 * (viewPos.y >> kTileDXShift) + kMetaDY / 16) + viewPos.x)
/ (kPlatformWidth * 2); / (kPlatformWidth * 2);
baseCoords.v = ((2 * (viewPos.y >> kTileDXShift) + metaDY / 16) - viewPos.x) baseCoords.v = ((2 * (viewPos.y >> kTileDXShift) + kMetaDY / 16) - viewPos.x)
/ (kPlatformWidth * 2); / (kPlatformWidth * 2);
baseCoords.z = 0; baseCoords.z = 0;
// coordinates of current metatile (in X,Y), relative to screen // coordinates of current metatile (in X,Y), relative to screen
metaPos.x = (baseCoords.u - baseCoords.v) * metaDX metaPos.x = (baseCoords.u - baseCoords.v) * kMetaDX
- viewPos.x * kTileDX; - viewPos.x * kTileDX;
metaPos.y = viewPos.y metaPos.y = viewPos.y
- (baseCoords.u + baseCoords.v) * metaDY; - (baseCoords.u + baseCoords.v) * kMetaDY;
// Compute where the object is relative to the metatile coords // Compute where the object is relative to the metatile coords
@ -3450,22 +3450,22 @@ void drawTileMask(
// (replace 256 constant with better value) // (replace 256 constant with better value)
for (; for (;
metaPos.y < sMap.size.y + metaTileHeight * 4 ; metaPos.y < sMap.size.y + kMetaTileHeight * 4 ;
baseCoords.u--, baseCoords.u--,
baseCoords.v-- baseCoords.v--
) { ) {
maskMetaRow(sMap, baseCoords, relLoc, metaPos, roofID); maskMetaRow(sMap, baseCoords, relLoc, metaPos, roofID);
metaPos.y += metaDY; metaPos.y += kMetaDY;
metaPos.x -= metaDX; metaPos.x -= kMetaDX;
relLoc.u -= kPlatUVSize; relLoc.u -= kPlatUVSize;
maskMetaRow(sMap, TilePoint(baseCoords.u - 1, baseCoords.v, 0), maskMetaRow(sMap, TilePoint(baseCoords.u - 1, baseCoords.v, 0),
relLoc, metaPos, roofID); relLoc, metaPos, roofID);
metaPos.y += metaDY; metaPos.y += kMetaDY;
metaPos.x += metaDX; metaPos.x += kMetaDX;
relLoc.v -= kPlatUVSize; relLoc.v -= kPlatUVSize;
} }
@ -3675,7 +3675,7 @@ SurfaceType pointOnTile(TileInfo *ti,
while (subUVPointRel >= 0 && while (subUVPointRel >= 0 &&
subUVPoint.u < 16 && subUVPoint.u < 16 &&
subUVPoint.v < 16) { subUVPoint.v < 16) {
if (subUVPointRel < pointH + (subTileDY * 2) / subTileSize) { if (subUVPointRel < pointH + (kSubTileDY * 2) / kSubTileSize) {
pickCoords = (tCoords << kTileUVShift); pickCoords = (tCoords << kTileUVShift);
pickCoords.u += subUVPoint.u; pickCoords.u += subUVPoint.u;
pickCoords.v += subUVPoint.v; pickCoords.v += subUVPoint.v;
@ -3688,7 +3688,7 @@ SurfaceType pointOnTile(TileInfo *ti,
subUVPoint.u++; subUVPoint.u++;
subUVPoint.v++; subUVPoint.v++;
if (subUVPoint.u < 16 && subUVPoint.v < 16) { if (subUVPoint.u < 16 && subUVPoint.v < 16) {
subUVPointRel -= (subTileDY * 2) / subTileSize; subUVPointRel -= (kSubTileDY * 2) / kSubTileSize;
// Compute the terrain height of point // Compute the terrain height of point
pointH = ptHeight(subUVPoint, ti->attrs.cornerHeight); pointH = ptHeight(subUVPoint, ti->attrs.cornerHeight);
@ -3698,7 +3698,7 @@ SurfaceType pointOnTile(TileInfo *ti,
// last point checked. // last point checked.
subUVPoint.u--; subUVPoint.u--;
subUVPoint.v--; subUVPoint.v--;
subUVPointRel = pointH + ((subTileDY * 2) / subTileSize) - 1; subUVPointRel = pointH + ((kSubTileDY * 2) / kSubTileSize) - 1;
} }
} }
@ -3716,15 +3716,15 @@ SurfaceType pointOnTile(TileInfo *ti,
// relative to that subtile. // relative to that subtile.
if (relPos.x > 0) { if (relPos.x > 0) {
subTile.u = relPos.x >> subTileDXShift; subTile.u = relPos.x >> kSubTileDXShift;
subTile.v = 0; subTile.v = 0;
subTileRel.x = relPos.x - (subTile.u << subTileDXShift); subTileRel.x = relPos.x - (subTile.u << kSubTileDXShift);
subTileRel.y = relPos.y - (subTile.u << subTileDYShift) - h; subTileRel.y = relPos.y - (subTile.u << kSubTileDYShift) - h;
} else { } else {
subTile.u = 0; subTile.u = 0;
subTile.v = (-relPos.x + 1) >> subTileDXShift; subTile.v = (-relPos.x + 1) >> kSubTileDXShift;
subTileRel.x = relPos.x + (subTile.v << subTileDXShift); subTileRel.x = relPos.x + (subTile.v << kSubTileDXShift);
subTileRel.y = relPos.y - (subTile.v << subTileDYShift) - h; subTileRel.y = relPos.y - (subTile.v << kSubTileDYShift) - h;
} }
// Compute the mask which represents the subtile // Compute the mask which represents the subtile
@ -3741,8 +3741,8 @@ SurfaceType pointOnTile(TileInfo *ti,
if (subTileRel.y < if (subTileRel.y <
ti->attrs.terrainHeight + yBound) { ti->attrs.terrainHeight + yBound) {
pickCoords = (tCoords << kTileUVShift); pickCoords = (tCoords << kTileUVShift);
pickCoords.u += (subTile.u << subTileShift); pickCoords.u += (subTile.u << kSubTileShift);
pickCoords.v += (subTile.v << subTileShift); pickCoords.v += (subTile.v << kSubTileShift);
if (subTileRel.x > 1) { if (subTileRel.x > 1) {
pickCoords.u += yBound; pickCoords.u += yBound;
type = surfaceVertU; type = surfaceVertU;
@ -3801,12 +3801,12 @@ SurfaceType pointOnTile(TileInfo *ti,
} }
// mouse is on top of raised section // mouse is on top of raised section
if (subTileRel.y < if (subTileRel.y <
ti->attrs.terrainHeight + subTileDY * 2 - yBound) { ti->attrs.terrainHeight + kSubTileDY * 2 - yBound) {
pickCoords = (tCoords << kTileUVShift); pickCoords = (tCoords << kTileUVShift);
y = subTileRel.y - ti->attrs.terrainHeight; y = subTileRel.y - ti->attrs.terrainHeight;
pickCoords.u += (subTile.u << subTileShift) + pickCoords.u += (subTile.u << kSubTileShift) +
(((subTileRel.x >> 1) + y) >> 1); (((subTileRel.x >> 1) + y) >> 1);
pickCoords.v += (subTile.v << subTileShift) + pickCoords.v += (subTile.v << kSubTileShift) +
((y - (subTileRel.x >> 1)) >> 1); ((y - (subTileRel.x >> 1)) >> 1);
pickCoords.z = h + ti->attrs.terrainHeight; pickCoords.z = h + ti->attrs.terrainHeight;
floorCoords = pickCoords; floorCoords = pickCoords;
@ -3835,10 +3835,10 @@ SurfaceType pointOnTile(TileInfo *ti,
while (subUVPointRel >= 0 && while (subUVPointRel >= 0 &&
subUVPoint.u < 4 && subUVPoint.u < 4 &&
subUVPoint.v < 4) { subUVPoint.v < 4) {
if (subUVPointRel < pointH + (subTileDY * 2) / subTileSize) { if (subUVPointRel < pointH + (kSubTileDY * 2) / kSubTileSize) {
pickCoords = (tCoords << kTileUVShift); pickCoords = (tCoords << kTileUVShift);
pickCoords.u += (subTile.u << subTileShift) + subUVPoint.u; pickCoords.u += (subTile.u << kSubTileShift) + subUVPoint.u;
pickCoords.v += (subTile.v << subTileShift) + subUVPoint.v; pickCoords.v += (subTile.v << kSubTileShift) + subUVPoint.v;
pickCoords.z = h + pointH; pickCoords.z = h + pointH;
floorCoords = pickCoords; floorCoords = pickCoords;
foundPoint = true; foundPoint = true;
@ -3848,8 +3848,8 @@ SurfaceType pointOnTile(TileInfo *ti,
// Test next point on subtile // Test next point on subtile
subUVPoint.u++; subUVPoint.u++;
subUVPoint.v++; subUVPoint.v++;
subUVPointRel -= (subTileDY * 2) / subTileSize; subUVPointRel -= (kSubTileDY * 2) / kSubTileSize;
pointH = ptHeight((subTile << subTileShift) + subUVPoint, pointH = ptHeight((subTile << kSubTileShift) + subUVPoint,
ti->attrs.cornerHeight); ti->attrs.cornerHeight);
} }
if (foundPoint) break; if (foundPoint) break;
@ -3859,21 +3859,21 @@ SurfaceType pointOnTile(TileInfo *ti,
if (subTileRel.x & 0xFFFE) { // if subTileRel.x != 0 or 1 if (subTileRel.x & 0xFFFE) { // if subTileRel.x != 0 or 1
// crabwalk up the subtiles // crabwalk up the subtiles
if (subTileRel.x > 0) { if (subTileRel.x > 0) {
subTileRel.x -= subTileDX; subTileRel.x -= kSubTileDX;
subTile.u++; subTile.u++;
sMask <<= subTileMaskUShift; sMask <<= kSubTileMaskUShift;
} else { } else {
subTileRel.x += subTileDX; subTileRel.x += kSubTileDX;
subTile.v++; subTile.v++;
sMask <<= subTileMaskVShift; sMask <<= kSubTileMaskVShift;
} }
subTileRel.y -= subTileDY; subTileRel.y -= kSubTileDY;
} else { // subTileRel.x == 0 or 1 } else { // subTileRel.x == 0 or 1
// move up to the next vertical subtile // move up to the next vertical subtile
subTile.u++; subTile.u++;
subTile.v++; subTile.v++;
sMask <<= subTileMaskUShift + subTileMaskVShift; sMask <<= kSubTileMaskUShift + kSubTileMaskVShift;
subTileRel.y -= subTileDY * 2; subTileRel.y -= kSubTileDY * 2;
} }
yBound = abs(subTileRel.x >> 1); yBound = abs(subTileRel.x >> 1);
@ -3887,8 +3887,8 @@ SurfaceType pointOnTile(TileInfo *ti,
subTile = lastRaisedSubTile; subTile = lastRaisedSubTile;
subTileRel.x = relPos.x - subTileRel.x = relPos.x -
((subTile.u - subTile.v) << subTileDXShift); ((subTile.u - subTile.v) << kSubTileDXShift);
subTileRel.y = ti->attrs.terrainHeight + subTileDY * 2 - subTileRel.y = ti->attrs.terrainHeight + kSubTileDY * 2 -
abs(subTileRel.x >> 1) - 1; abs(subTileRel.x >> 1) - 1;
sMask = calcSubTileMask(subTile.u, subTile.v); sMask = calcSubTileMask(subTile.u, subTile.v);
@ -3904,20 +3904,20 @@ SurfaceType pointOnTile(TileInfo *ti,
raisedCol = -4; raisedCol = -4;
if (relPos.x & (subTileDX - 1) & 0xFFFE) { if (relPos.x & (kSubTileDX - 1) & 0xFFFE) {
if (relPos.x > 0) { if (relPos.x > 0) {
curSubTileCol = relPos.x >> subTileDXShift; curSubTileCol = relPos.x >> kSubTileDXShift;
rightSubTileCol = curSubTileCol + 2; rightSubTileCol = curSubTileCol + 2;
leftSubTileCol = curSubTileCol - 1; leftSubTileCol = curSubTileCol - 1;
goto testLeft; goto testLeft;
} else { } else {
curSubTileCol = curSubTileCol =
(relPos.x + subTileDX - 1) >> subTileDXShift; (relPos.x + kSubTileDX - 1) >> kSubTileDXShift;
leftSubTileCol = curSubTileCol - 2; leftSubTileCol = curSubTileCol - 2;
rightSubTileCol = curSubTileCol + 1; rightSubTileCol = curSubTileCol + 1;
} }
} else { } else {
curSubTileCol = relPos.x >> subTileDXShift; curSubTileCol = relPos.x >> kSubTileDXShift;
rightSubTileCol = curSubTileCol + 1; rightSubTileCol = curSubTileCol + 1;
leftSubTileCol = curSubTileCol - 1; leftSubTileCol = curSubTileCol - 1;
} }
@ -3934,7 +3934,7 @@ SurfaceType pointOnTile(TileInfo *ti,
if (ti->attrs.testTerrain(colMask) & terrainRaised) { if (ti->attrs.testTerrain(colMask) & terrainRaised) {
raisedCol = rightSubTileCol; raisedCol = rightSubTileCol;
subTileRel.x = -subTileDX + 2; subTileRel.x = -kSubTileDX + 2;
break; break;
} }
@ -3950,7 +3950,7 @@ testLeft:
if (ti->attrs.testTerrain(colMask) & terrainRaised) { if (ti->attrs.testTerrain(colMask) & terrainRaised) {
raisedCol = leftSubTileCol; raisedCol = leftSubTileCol;
subTileRel.x = subTileDX - 1; subTileRel.x = kSubTileDX - 1;
break; break;
} }
@ -3963,7 +3963,7 @@ testLeft:
// compute the number of subtiles in column // compute the number of subtiles in column
int8 subsInCol = 4 - abs(raisedCol); int8 subsInCol = 4 - abs(raisedCol);
relPos.x = (raisedCol << subTileDXShift) + subTileRel.x; relPos.x = (raisedCol << kSubTileDXShift) + subTileRel.x;
if (raisedCol > 0) { if (raisedCol > 0) {
colMask = 0x0001 << (raisedCol << 2); colMask = 0x0001 << (raisedCol << 2);
@ -3986,7 +3986,7 @@ testLeft:
// subTile is now the first raised subtile in // subTile is now the first raised subtile in
// column // column
subTileRel.y = relPos.y - ((subTile.u + subTile.v) * subTileDY) - h; subTileRel.y = relPos.y - ((subTile.u + subTile.v) * kSubTileDY) - h;
sMask = calcSubTileMask(subTile.u, subTile.v); sMask = calcSubTileMask(subTile.u, subTile.v);
yBound = abs(subTileRel.x >> 1); yBound = abs(subTileRel.x >> 1);
} }
@ -4034,11 +4034,11 @@ bool pointOnHiddenSurface(
if (surfaceType == surfaceVertV) { if (surfaceType == surfaceVertV) {
assert(testCoords.u == 0); assert(testCoords.u == 0);
adjTCoords.u--; adjTCoords.u--;
adjSubMask = 0x1000 << (testCoords.v >> subTileShift); adjSubMask = 0x1000 << (testCoords.v >> kSubTileShift);
} else { } else {
assert(testCoords.v == 0); assert(testCoords.v == 0);
adjTCoords.v--; adjTCoords.v--;
adjSubMask = 0x0008 << (testCoords.u & ~subTileMask); adjSubMask = 0x0008 << (testCoords.u & ~kSubTileMask);
} }
mCoords = adjTCoords >> kPlatShift; mCoords = adjTCoords >> kPlatShift;
@ -4498,10 +4498,10 @@ uint16 objRoofID(GameObject *obj, int16 objMapNum, const TilePoint &objCoords) {
objHeight = objCoords.z; objHeight = objCoords.z;
objTileReg.min.u = (objCoords.u - subTileSize) >> kTileUVShift; objTileReg.min.u = (objCoords.u - kSubTileSize) >> kTileUVShift;
objTileReg.min.v = (objCoords.v - subTileSize) >> kTileUVShift; objTileReg.min.v = (objCoords.v - kSubTileSize) >> kTileUVShift;
objTileReg.max.u = (objCoords.u + subTileSize + kTileUVMask) >> kTileUVShift; objTileReg.max.u = (objCoords.u + kSubTileSize + kTileUVMask) >> kTileUVShift;
objTileReg.max.v = (objCoords.v + subTileSize + kTileUVMask) >> kTileUVShift; objTileReg.max.v = (objCoords.v + kSubTileSize + kTileUVMask) >> kTileUVShift;
debugC(3, kDebugTiles, "objTileReg = ((%d,%d), (%d,%d))", objTileReg.min.u, objTileReg.min.v, objTileReg.max.u, objTileReg.max.v); debugC(3, kDebugTiles, "objTileReg = ((%d,%d), (%d,%d))", objTileReg.min.u, objTileReg.min.v, objTileReg.max.u, objTileReg.max.v);