bool RenderQueue::rectIntersectsItem(const Common::Rect &rect) {
for (RenderQueueArray::iterator iter = _currQueue->begin(); iter != _currQueue->end(); iter++) {
const RenderQueueItem *item = &(*iter);
if (rect.intersects(item->rect))
return true;
}
return false;
}
void SurfaceList::render(Graphics::Surface *surface, const Common::Rect & clip) const {
for(uint i = 0; i < surfaces_n; ++i) {
const Surface &s = surfaces[i];
Common::Rect r(s.x, s.y, s.x + s.w, s.y + s.h);
if (r.bottom < clip.bottom || !clip.intersects(r))
continue;
r.clip(clip);
r.translate(-s.x, -s.y);
s.render(surface, r.left, r.top, false, r);
}
}
void RenderQueue::invalidateItemsByRect(const Common::Rect &rect, const RenderQueueItem *item) {
for (RenderQueueArray::iterator iter = _currQueue->begin(); iter != _currQueue->end(); iter++) {
RenderQueueItem *subItem = &(*iter);
if (item != subItem &&
subItem->flags == kUnchanged &&
rect.intersects(subItem->rect)) {
subItem->flags = kRefresh;
invalidateItemsByRect(subItem->rect, subItem);
}
}
}
void OSystem_IPHONE::drawMouseCursorOnRectUpdate(const Common::Rect& updatedRect, const Common::Rect& mouseRect) {
//draw mouse on top
if (_mouseVisible && (updatedRect.intersects(mouseRect))) {
int srcX = 0;
int srcY = 0;
int left = _mouseX - _mouseHotspotX;
if (left < 0) {
srcX -= left;
left = 0;
}
int top = _mouseY - _mouseHotspotY;
if (top < 0) {
srcY -= top;
top = 0;
}
int bottom = top + _mouseHeight;
if (bottom > _screenWidth)
bottom = _screenWidth;
int displayWidth = _mouseWidth;
if (_mouseWidth + left > _screenWidth)
displayWidth = _screenWidth - left;
int displayHeight = _mouseHeight;
if (_mouseHeight + top > _screenHeight)
displayHeight = _screenHeight - top;
byte *src = &_mouseBuf[srcY * _mouseWidth + srcX];
uint16 *dst = &_fullscreen[top * _screenWidth + left];
for (int y = displayHeight; y > srcY; y--) {
for (int x = displayWidth; x > srcX; x--) {
if (*src != _mouseKeyColour)
*dst = _palette[*src];
dst++;
src++;
}
dst += _screenWidth - displayWidth + srcX;
src += _mouseWidth - displayWidth + srcX;
}
}
}
void Slide::drawSlideElement(const Common::Rect &drawRect, const Common::Rect &oldBounds, DisplayElement *picture) {
if (picture && drawRect.intersects(oldBounds)) {
picture->moveElementTo(oldBounds.left, oldBounds.top);
picture->draw(drawRect.findIntersectingRect(oldBounds));
}
}
void RenderTicket::drawToSurface(Graphics::Surface *_targetSurface, Common::Rect *dstRect, Common::Rect *clipRect) const {
TransparentSurface src(*getSurface(), false);
bool doDelete = false;
if (!clipRect) {
doDelete = true;
clipRect = new Common::Rect();
clipRect->setWidth(getSurface()->w * _transform._numTimesX);
clipRect->setHeight(getSurface()->h * _transform._numTimesY);
}
if (_owner) {
if (_transform._alphaDisable) {
src.setAlphaMode(TransparentSurface::ALPHA_OPAQUE);
} else {
src.setAlphaMode(_owner->getAlphaType());
}
}
if (_transform._numTimesX * _transform._numTimesY == 1) {
src.blit(*_targetSurface, dstRect->left, dstRect->top, _transform._flip, clipRect, _transform._rgbaMod, clipRect->width(), clipRect->height(), _transform._blendMode);
} else {
// clipRect is a subrect of the full numTimesX*numTimesY rect
Common::Rect subRect;
int y = 0;
int w = getSurface()->w;
int h = getSurface()->h;
assert(w == _dstRect.width() / _transform._numTimesX);
assert(h == _dstRect.height() / _transform._numTimesY);
int basex = dstRect->left - clipRect->left;
int basey = dstRect->top - clipRect->top;
for (int ry = 0; ry < _transform._numTimesY; ++ry) {
int x = 0;
for (int rx = 0; rx < _transform._numTimesX; ++rx) {
subRect.left = x;
subRect.top = y;
subRect.setWidth(w);
subRect.setHeight(h);
if (subRect.intersects(*clipRect)) {
subRect.clip(*clipRect);
subRect.translate(-x, -y);
src.blit(*_targetSurface, basex + x + subRect.left, basey + y + subRect.top, _transform._flip, &subRect, _transform._rgbaMod, subRect.width(), subRect.height(), _transform._blendMode);
}
x += w;
}
y += h;
}
}
if (doDelete) {
delete clipRect;
}
}
Common::Rect ScreenItem::getNowSeenRect(const Plane &plane) const {
CelObj &celObj = getCelObj();
Common::Rect celObjRect(celObj._width, celObj._height);
Common::Rect nsRect;
if (_useInsetRect) {
if (_insetRect.intersects(celObjRect)) {
nsRect = _insetRect;
nsRect.clip(celObjRect);
} else {
nsRect = Common::Rect();
}
} else {
nsRect = celObjRect;
}
const uint16 scriptWidth = g_sci->_gfxFrameout->getCurrentBuffer().scriptWidth;
const uint16 scriptHeight = g_sci->_gfxFrameout->getCurrentBuffer().scriptHeight;
Ratio scaleX, scaleY;
if (_scale.signal & kScaleSignalDoScaling32) {
if (_scale.signal & kScaleSignalUseVanishingPoint) {
int num = _scale.max * (_position.y - plane._vanishingPoint.y) / (scriptWidth - plane._vanishingPoint.y);
scaleX = Ratio(num, 128);
scaleY = Ratio(num, 128);
} else {
scaleX = Ratio(_scale.x, 128);
scaleY = Ratio(_scale.y, 128);
}
}
if (scaleX.getNumerator() == 0 || scaleY.getNumerator() == 0) {
return Common::Rect();
}
int16 displaceX = celObj._displace.x;
int16 displaceY = celObj._displace.y;
if (_mirrorX != celObj._mirrorX && _celInfo.type != kCelTypePic) {
displaceX = celObj._width - displaceX - 1;
}
if (celObj._scaledWidth != kLowResX || celObj._scaledHeight != kLowResY) {
// high resolution coordinates
if (_useInsetRect) {
Ratio scriptToCelX(celObj._scaledWidth, scriptWidth);
Ratio scriptToCelY(celObj._scaledHeight, scriptHeight);
mulru(nsRect, scriptToCelX, scriptToCelY, 0);
if (nsRect.intersects(celObjRect)) {
nsRect.clip(celObjRect);
} else {
nsRect = Common::Rect();
}
}
if (!scaleX.isOne() || !scaleY.isOne()) {
// Different games use a different cel scaling mode, but the
// difference isn't consistent across SCI versions; instead,
// it seems to be related to an update that happened during
// SCI2.1mid where games started using hi-resolution game
// scripts
if (scriptWidth == kLowResX) {
mulinc(nsRect, scaleX, scaleY);
// TODO: This was in the original code, baked into the
// multiplication though it is not immediately clear
// why this is the only one that reduces the BR corner
nsRect.right -= 1;
nsRect.bottom -= 1;
} else {
nsRect.left = (nsRect.left * scaleX).toInt();
nsRect.top = (nsRect.top * scaleY).toInt();
if (scaleX.getNumerator() > scaleX.getDenominator()) {
nsRect.right = (nsRect.right * scaleX).toInt();
} else {
nsRect.right = ((nsRect.right - 1) * scaleX).toInt() + 1;
}
if (scaleY.getNumerator() > scaleY.getDenominator()) {
nsRect.bottom = (nsRect.bottom * scaleY).toInt();
} else {
nsRect.bottom = ((nsRect.bottom - 1) * scaleY).toInt() + 1;
}
}
}
Ratio celToScriptX(scriptWidth, celObj._scaledWidth);
Ratio celToScriptY(scriptHeight, celObj._scaledHeight);
displaceX = (displaceX * scaleX * celToScriptX).toInt();
displaceY = (displaceY * scaleY * celToScriptY).toInt();
mulinc(nsRect, celToScriptX, celToScriptY);
nsRect.translate(_position.x - displaceX, _position.y - displaceY);
} else {
// low resolution coordinates
if (!scaleX.isOne() || !scaleY.isOne()) {
mulinc(nsRect, scaleX, scaleY);
// TODO: This was in the original code, baked into the
// multiplication though it is not immediately clear
// why this is the only one that reduces the BR corner
nsRect.right -= 1;
nsRect.bottom -= 1;
}
displaceX = (displaceX * scaleX).toInt();
displaceY = (displaceY * scaleY).toInt();
nsRect.translate(_position.x - displaceX, _position.y - displaceY);
if (_mirrorX != celObj._mirrorX && _celInfo.type != kCelTypePic) {
nsRect.translate(plane._gameRect.width() - nsRect.width(), 0);
}
}
return nsRect;
}