scummvm/engines/tinsel/cliprect.cpp
2009-11-02 21:54:57 +00:00

313 lines
9.0 KiB
C++

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
* This file contains the clipping rectangle code.
*/
#include "tinsel/cliprect.h" // object clip rect defs
#include "tinsel/graphics.h" // normal object drawing
#include "tinsel/object.h"
#include "tinsel/palette.h"
namespace Tinsel {
/** list of all clip rectangles */
static RectList s_rectList;
/**
* Resets the clipping rectangle allocator.
*/
void ResetClipRect() {
s_rectList.clear();
}
/**
* Allocate a clipping rectangle from the free list.
* @param pClip clip rectangle dimensions to allocate
*/
void AddClipRect(const Common::Rect &pClip) {
s_rectList.push_back(pClip);
}
const RectList &GetClipRects() {
return s_rectList;
}
/**
* Creates the intersection of two rectangles.
* Returns True if there is a intersection.
* @param pDest Pointer to destination rectangle that is to receive the intersection
* @param pSrc1 Pointer to a source rectangle
* @param pSrc2 Pointer to a source rectangle
*/
bool IntersectRectangle(Common::Rect &pDest, const Common::Rect &pSrc1, const Common::Rect &pSrc2) {
pDest.left = MAX(pSrc1.left, pSrc2.left);
pDest.top = MAX(pSrc1.top, pSrc2.top);
pDest.right = MIN(pSrc1.right, pSrc2.right);
pDest.bottom = MIN(pSrc1.bottom, pSrc2.bottom);
return !pDest.isEmpty();
}
/**
* Creates the union of two rectangles.
* Returns True if there is a union.
* @param pDest destination rectangle that is to receive the new union
* @param pSrc1 a source rectangle
* @param pSrc2 a source rectangle
*/
bool UnionRectangle(Common::Rect &pDest, const Common::Rect &pSrc1, const Common::Rect &pSrc2) {
pDest.left = MIN(pSrc1.left, pSrc2.left);
pDest.top = MIN(pSrc1.top, pSrc2.top);
pDest.right = MAX(pSrc1.right, pSrc2.right);
pDest.bottom = MAX(pSrc1.bottom, pSrc2.bottom);
return !pDest.isEmpty();
}
/**
* Check if the two rectangles are next to each other.
* @param pSrc1 a source rectangle
* @param pSrc2 a source rectangle
*/
static bool LooseIntersectRectangle(const Common::Rect &pSrc1, const Common::Rect &pSrc2) {
Common::Rect pDest;
pDest.left = MAX(pSrc1.left, pSrc2.left);
pDest.top = MAX(pSrc1.top, pSrc2.top);
pDest.right = MIN(pSrc1.right, pSrc2.right);
pDest.bottom = MIN(pSrc1.bottom, pSrc2.bottom);
return pDest.isValidRect();
}
/**
* Adds velocities and creates clipping rectangles for all the
* objects that have moved on the specified object list.
* @param pObjList Playfield display list to draw
* @param pWin Playfield window top left position
* @param pClip Playfield clipping rectangle
* @param bNoVelocity When reset, objects pos is updated with velocity
* @param bScrolled) When set, playfield has scrolled
*/
void FindMovingObjects(OBJECT *pObjList, Common::Point *pWin, Common::Rect *pClip, bool bNoVelocity, bool bScrolled) {
OBJECT *pObj; // object list traversal pointer
for (pObj = pObjList->pNext; pObj != NULL; pObj = pObj->pNext) {
if (!bNoVelocity) {
// we want to add velocities to objects position
if (bScrolled) {
// this playfield has scrolled
// indicate change
pObj->flags |= DMA_CHANGED;
}
}
if ((pObj->flags & DMA_CHANGED) || // object changed
HasPalMoved(pObj->pPal)) { // or palette moved
// object has changed in some way
Common::Rect rcClip; // objects clipped bounding rectangle
Common::Rect rcObj; // objects bounding rectangle
// calc intersection of objects previous bounding rectangle
// NOTE: previous position is in screen co-ords
if (IntersectRectangle(rcClip, pObj->rcPrev, *pClip)) {
// previous position is within clipping rect
AddClipRect(rcClip);
}
// calc objects current bounding rectangle
if (pObj->flags & DMA_ABS) {
// object position is absolute
rcObj.left = fracToInt(pObj->xPos);
rcObj.top = fracToInt(pObj->yPos);
} else {
// object position is relative to window
rcObj.left = fracToInt(pObj->xPos) - pWin->x;
rcObj.top = fracToInt(pObj->yPos) - pWin->y;
}
rcObj.right = rcObj.left + pObj->width;
rcObj.bottom = rcObj.top + pObj->height;
// calc intersection of object with clipping rect
if (IntersectRectangle(rcClip, rcObj, *pClip)) {
// current position is within clipping rect
AddClipRect(rcClip);
// update previous position
pObj->rcPrev = rcClip;
} else {
// clear previous position
pObj->rcPrev = Common::Rect();
}
// clear changed flag
pObj->flags &= ~DMA_CHANGED;
}
}
}
/**
* Merges any clipping rectangles that overlap to try and reduce
* the total number of clip rectangles.
*/
void MergeClipRect() {
if (s_rectList.size() <= 1)
return;
RectList::iterator rOuter, rInner;
for (rOuter = s_rectList.begin(); rOuter != s_rectList.end(); ++rOuter) {
rInner = rOuter;
while (++rInner != s_rectList.end()) {
if (LooseIntersectRectangle(*rOuter, *rInner)) {
// these two rectangles overlap or
// are next to each other - merge them
UnionRectangle(*rOuter, *rOuter, *rInner);
// remove the inner rect from the list
s_rectList.erase(rInner);
// move back to beginning of list
rInner = rOuter;
}
}
}
}
/**
* Redraws all objects within this clipping rectangle.
* @param pObjList Object list to draw
* @param pWin Window top left position
* @param pClip Pointer to clip rectangle
*/
void UpdateClipRect(OBJECT *pObjList, Common::Point *pWin, Common::Rect *pClip) {
int x, y, right, bottom; // object corners
int hclip, vclip; // total size of object clipping
DRAWOBJECT currentObj; // filled in to draw the current object in list
OBJECT *pObj; // object list iterator
// Initialise the fields of the drawing object to empty
memset(&currentObj, 0, sizeof(DRAWOBJECT));
for (pObj = pObjList->pNext; pObj != NULL; pObj = pObj->pNext) {
if (pObj->flags & DMA_ABS) {
// object position is absolute
x = fracToInt(pObj->xPos);
y = fracToInt(pObj->yPos);
} else {
// object position is relative to window
x = fracToInt(pObj->xPos) - pWin->x;
y = fracToInt(pObj->yPos) - pWin->y;
}
// calc object right
right = x + pObj->width;
if (right < 0)
// totally clipped if negative
continue;
// calc object bottom
bottom = y + pObj->height;
if (bottom < 0)
// totally clipped if negative
continue;
// bottom clip = low right y - clip low right y
currentObj.botClip = bottom - pClip->bottom;
if (currentObj.botClip < 0) {
// negative - object is not clipped
currentObj.botClip = 0;
}
// right clip = low right x - clip low right x
currentObj.rightClip = right - pClip->right;
if (currentObj.rightClip < 0) {
// negative - object is not clipped
currentObj.rightClip = 0;
}
// top clip = clip top left y - top left y
currentObj.topClip = pClip->top - y;
if (currentObj.topClip < 0) {
// negative - object is not clipped
currentObj.topClip = 0;
} else { // clipped - adjust start position to top of clip rect
y = pClip->top;
}
// left clip = clip top left x - top left x
currentObj.leftClip = pClip->left - x;
if (currentObj.leftClip < 0) {
// negative - object is not clipped
currentObj.leftClip = 0;
} else {
// NOTE: This else statement is disabled in tinsel v1
// clipped - adjust start position to left of clip rect
x = pClip->left;
}
// calc object total horizontal clipping
hclip = currentObj.leftClip + currentObj.rightClip;
// calc object total vertical clipping
vclip = currentObj.topClip + currentObj.botClip;
if (hclip + vclip != 0) {
// object is clipped in some way
if (pObj->width <= hclip)
// object totally clipped horizontally - ignore
continue;
if (pObj->height <= vclip)
// object totally clipped vertically - ignore
continue;
// set clip bit in objects flags
currentObj.flags = pObj->flags | DMA_CLIP;
} else { // object is not clipped - copy flags
currentObj.flags = pObj->flags;
}
// copy objects properties to local object
currentObj.width = pObj->width;
currentObj.height = pObj->height;
currentObj.xPos = (short)x;
currentObj.yPos = (short)y;
currentObj.pPal = pObj->pPal;
currentObj.constant = pObj->constant;
currentObj.hBits = pObj->hBits;
// draw the object
DrawObject(&currentObj);
}
}
} // End of namespace Tinsel