[Scummvm-git-logs] scummvm master -> f1df317abc7ba470bff092d8dd18be599d49b2dd

mgerhardy noreply at scummvm.org
Sat Jan 21 14:23:06 UTC 2023 

This automated email contains information about 2 new commits which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .

Summary:
fa2cdce750 TWINE: getting closer to the original source release
f1df317abc TWINE: fixed bug #13871 (rendering error with opened door)


Commit: fa2cdce750505271023fe456b7ca009c2a379448
    https://github.com/scummvm/scummvm/commit/fa2cdce750505271023fe456b7ca009c2a379448
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2023-01-21T15:23:00+01:00

Commit Message:
TWINE: getting closer to the original source release

Changed paths:
    engines/twine/debugger/debug_scene.cpp
    engines/twine/holomap.cpp
    engines/twine/renderer/redraw.cpp
    engines/twine/renderer/renderer.cpp
    engines/twine/renderer/renderer.h
    engines/twine/scene/extra.cpp
    engines/twine/scene/extra.h
    engines/twine/scene/gamestate.cpp
    engines/twine/scene/grid.cpp
    engines/twine/shared.h
    engines/twine/twine.cpp
    engines/twine/twine.h


diff --git a/engines/twine/debugger/debug_scene.cpp b/engines/twine/debugger/debug_scene.cpp
index 2967e65b144..19428f16358 100644
--- a/engines/twine/debugger/debug_scene.cpp
+++ b/engines/twine/debugger/debug_scene.cpp
@@ -41,7 +41,7 @@ void DebugScene::drawClip(const Common::Rect &rect) {
 }
 
 void DebugScene::projectBoundingBoxPoints(IVec3 *pPoint3d, IVec3 *pPoint3dProjected) {
-	*pPoint3dProjected = _engine->_renderer->projectPositionOnScreen(*pPoint3d);
+	*pPoint3dProjected = _engine->_renderer->projectPoint(*pPoint3d);
 }
 
 bool DebugScene::checkZoneType(ZoneType type) const {
diff --git a/engines/twine/holomap.cpp b/engines/twine/holomap.cpp
index 2795dd2ddeb..3c0fdd56281 100644
--- a/engines/twine/holomap.cpp
+++ b/engines/twine/holomap.cpp
@@ -215,14 +215,14 @@ void Holomap::computeGlobeProj() {
 				_holomapSort[holomapSortArrayIdx].projectedPosIdx = _projectedSurfaceIndex;
 				++holomapSortArrayIdx;
 			}
-			const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(destPos);
+			const IVec3 &projPos = _engine->_renderer->projectPoint(destPos);
 			_projectedSurfacePositions[_projectedSurfaceIndex].x1 = projPos.x;
 			_projectedSurfacePositions[_projectedSurfaceIndex].y1 = projPos.y;
 			++_projectedSurfaceIndex;
 		}
 		IVec3 *vec = &_holomapSurface[holomapSurfaceArrayIdx++];
 		const IVec3 &destPos = _engine->_renderer->worldRotatePoint(*vec);
-		const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(destPos);
+		const IVec3 &projPos = _engine->_renderer->projectPoint(destPos);
 		_projectedSurfacePositions[_projectedSurfaceIndex].x1 = projPos.x;
 		_projectedSurfacePositions[_projectedSurfaceIndex].y1 = projPos.y;
 		++_projectedSurfaceIndex;
diff --git a/engines/twine/renderer/redraw.cpp b/engines/twine/renderer/redraw.cpp
index 24989f52932..8d5504092bc 100644
--- a/engines/twine/renderer/redraw.cpp
+++ b/engines/twine/renderer/redraw.cpp
@@ -210,7 +210,7 @@ int32 Redraw::fillActorDrawingList(DrawListStruct *drawList, bool flagflip) {
 		// no redraw required
 		if (actor->_staticFlags.bIsBackgrounded && !flagflip) {
 			// get actor position on screen
-			const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(actor->posObj() - _engine->_grid->_worldCube);
+			const IVec3 &projPos = _engine->_renderer->projectPoint(actor->posObj() - _engine->_grid->_worldCube);
 			// check if actor is visible on screen, otherwise don't display it
 			if (projPos.x > VIEW_X0 && projPos.x < VIEW_X1(_engine) && projPos.y > VIEW_Y0 && projPos.y < VIEW_Y1(_engine)) {
 				actor->_dynamicFlags.bIsDrawn = 1;
@@ -222,7 +222,7 @@ int32 Redraw::fillActorDrawingList(DrawListStruct *drawList, bool flagflip) {
 			continue;
 		}
 		// get actor position on screen
-		const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(actor->posObj() - _engine->_grid->_worldCube);
+		const IVec3 &projPos = _engine->_renderer->projectPoint(actor->posObj() - _engine->_grid->_worldCube);
 
 		if ((actor->_staticFlags.bUsesClipping && projPos.x > -112 && projPos.x < _engine->width() + 112 && projPos.y > -50 && projPos.y < _engine->height() + 171) ||
 		    ((!actor->_staticFlags.bUsesClipping) && projPos.x > VIEW_X0 && projPos.x < VIEW_X1(_engine) && projPos.y > VIEW_Y0 && projPos.y < VIEW_Y1(_engine))) {
@@ -299,7 +299,7 @@ int32 Redraw::fillExtraDrawingList(DrawListStruct *drawList, int32 drawListPos)
 				}
 			}
 		}
-		const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(extra->pos - _engine->_grid->_worldCube);
+		const IVec3 &projPos = _engine->_renderer->projectPoint(extra->pos - _engine->_grid->_worldCube);
 
 		if (projPos.x > VIEW_X0 && projPos.x < VIEW_X1(_engine) && projPos.y > VIEW_Y0 && projPos.y < VIEW_Y1(_engine)) {
 			const int16 tmpVal = extra->pos.x - _engine->_grid->_worldCube.x + extra->pos.z - _engine->_grid->_worldCube.z;
@@ -327,7 +327,7 @@ int32 Redraw::fillExtraDrawingList(DrawListStruct *drawList, int32 drawListPos)
 
 void Redraw::processDrawListShadows(const DrawListStruct &drawCmd) {
 	// get actor position on screen
-	const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(drawCmd.x - _engine->_grid->_worldCube.x, drawCmd.y - _engine->_grid->_worldCube.y, drawCmd.z - _engine->_grid->_worldCube.z);
+	const IVec3 &projPos = _engine->_renderer->projectPoint(drawCmd.x - _engine->_grid->_worldCube.x, drawCmd.y - _engine->_grid->_worldCube.y, drawCmd.z - _engine->_grid->_worldCube.z);
 
 	int32 spriteWidth = _engine->_resources->_spriteShadowPtr.surface(drawCmd.offset).w;
 	int32 spriteHeight = _engine->_resources->_spriteShadowPtr.surface(drawCmd.offset).h;
@@ -408,7 +408,7 @@ void Redraw::processDrawListActorSprites(const DrawListStruct &drawCmd, bool bgR
 	const uint8 *spritePtr = _engine->_resources->_spriteTable[actor->_body];
 
 	// get actor position on screen
-	const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(actor->posObj() - _engine->_grid->_worldCube);
+	const IVec3 &projPos = _engine->_renderer->projectPoint(actor->posObj() - _engine->_grid->_worldCube);
 
 	const int32 spriteWidth = spriteData.surface().w;
 	const int32 spriteHeight = spriteData.surface().h;
@@ -465,11 +465,11 @@ void Redraw::processDrawListExtras(const DrawListStruct &drawCmd) {
 	int32 extraIdx = drawCmd.actorIdx;
 	ExtraListStruct *extra = &_engine->_extra->_extraList[extraIdx];
 
-	const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(extra->pos - _engine->_grid->_worldCube);
+	const IVec3 &projPos = _engine->_renderer->projectPoint(extra->pos - _engine->_grid->_worldCube);
 
 	Common::Rect renderRect;
 	if (extra->sprite & EXTRA_SPECIAL_MASK) {
-		_engine->_extra->drawExtraSpecial(extraIdx, projPos.x, projPos.y, renderRect);
+		_engine->_extra->affSpecial(extraIdx, projPos.x, projPos.y, renderRect);
 	} else {
 		const SpriteData &spritePtr = _engine->_resources->_spriteData[extra->sprite];
 		const int32 spriteWidth = spritePtr.surface().w;
@@ -649,7 +649,7 @@ void Redraw::renderOverlays() {
 			case OverlayPosType::koFollowActor: {
 				ActorStruct *actor2 = _engine->_scene->getActor(overlay->info1);
 
-				const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(actor2->_pos.x - _engine->_grid->_worldCube.x, actor2->_pos.y + actor2->_boundingBox.maxs.y - _engine->_grid->_worldCube.y, actor2->_pos.z - _engine->_grid->_worldCube.z);
+				const IVec3 &projPos = _engine->_renderer->projectPoint(actor2->_pos.x - _engine->_grid->_worldCube.x, actor2->_pos.y + actor2->_boundingBox.maxs.y - _engine->_grid->_worldCube.y, actor2->_pos.z - _engine->_grid->_worldCube.z);
 
 				overlay->x = projPos.x;
 				overlay->y = projPos.y;
@@ -819,7 +819,7 @@ void Redraw::redrawEngineActions(bool bgRedraw) { // AffScene
 		_engine->_screens->clearScreen();
 
 		_engine->_grid->redrawGrid();
-		const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(-_engine->_grid->_worldCube);
+		const IVec3 &projPos = _engine->_renderer->projectPoint(-_engine->_grid->_worldCube);
 		_projPosScreen.x = projPos.x;
 		_projPosScreen.y = projPos.y;
 
@@ -881,7 +881,7 @@ void Redraw::drawBubble(int32 actorIdx) {
 	ActorStruct *actor = _engine->_scene->getActor(actorIdx);
 
 	// get actor position on screen
-	const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(actor->_pos.x - _engine->_grid->_worldCube.x, actor->_pos.y + actor->_boundingBox.maxs.y - _engine->_grid->_worldCube.y, actor->_pos.z - _engine->_grid->_worldCube.z);
+	const IVec3 &projPos = _engine->_renderer->projectPoint(actor->_pos.x - _engine->_grid->_worldCube.x, actor->_pos.y + actor->_boundingBox.maxs.y - _engine->_grid->_worldCube.y, actor->_pos.z - _engine->_grid->_worldCube.z);
 
 	if (actorIdx != _bubbleActor) {
 		_bubbleSpriteIndex = _bubbleSpriteIndex ^ 1;
diff --git a/engines/twine/renderer/renderer.cpp b/engines/twine/renderer/renderer.cpp
index 5a6a27551f0..2876a82047c 100644
--- a/engines/twine/renderer/renderer.cpp
+++ b/engines/twine/renderer/renderer.cpp
@@ -69,19 +69,24 @@ void Renderer::init(int32 w, int32 h) {
 	_tabx1 = _tabCoulD;
 }
 
-IVec3 &Renderer::projectPositionOnScreen(int32 cX, int32 cY, int32 cZ) { // ProjettePoint
+void Renderer::projIso(IVec3 &pos, int32 x, int32 y, int32 z) {
+	pos.x = (int16)((((x - z) * 24) / ISO_SCALE) + _projectionCenter.x);
+	pos.y = (int16)(((((x + z) * 12) - (y * 30)) / ISO_SCALE) + _projectionCenter.y);
+	pos.z = 0;
+}
+
+IVec3 Renderer::projectPoint(int32 cX, int32 cY, int32 cZ) { // ProjettePoint
+	IVec3 pos;
 	if (_isUsingIsoProjection) {
-		_projPos.x = ((cX - cZ) * 24) / ISO_SCALE + _projectionCenter.x;
-		_projPos.y = (((cX + cZ) * 12) - cY * 30) / ISO_SCALE + _projectionCenter.y;
-		_projPos.z = cZ - cY - cX;
-		return _projPos;
+		projIso(pos, cX, cY, cZ);
+		return pos;
 	}
 
 	if (_cameraRot.z - cZ < 0) {
-		_projPos.x = 0;
-		_projPos.y = 0;
-		_projPos.z = 0;
-		return _projPos;
+		pos.x = 0;
+		pos.y = 0;
+		pos.z = 0;
+		return pos;
 	}
 
 	cX -= _cameraRot.x;
@@ -93,10 +98,10 @@ IVec3 &Renderer::projectPositionOnScreen(int32 cX, int32 cY, int32 cZ) { // Proj
 		posZ = 0x7FFF;
 	}
 
-	_projPos.x = (cX * _lFactorX) / posZ + _projectionCenter.x;
-	_projPos.y = (-cY * _lFactorY) / posZ + _projectionCenter.y;
-	_projPos.z = posZ;
-	return _projPos;
+	pos.x = (cX * _lFactorX) / posZ + _projectionCenter.x;
+	pos.y = (-cY * _lFactorY) / posZ + _projectionCenter.y;
+	pos.z = posZ;
+	return pos;
 }
 
 void Renderer::setProjection(int32 x, int32 y, int32 kfact, int32 lfactx, int32 lfacty) {
@@ -1575,13 +1580,12 @@ void Renderer::animModel(ModelData *modelData, const BodyData &bodyData, RenderC
 	const I16Vec3 *pointPtr = &modelData->computedPoints[0];
 	I16Vec3 *pointPtrDest = &modelData->flattenPoints[0];
 
-	if (_isUsingIsoProjection) { // use standard projection
+	if (_isUsingIsoProjection) {
 		do {
 			const int32 coX = pointPtr->x + renderPos.x;
 			const int32 coY = pointPtr->y + renderPos.y;
 			const int32 coZ = -(pointPtr->z + renderPos.z);
 
-			// TODO: use projectPositionOnScreen()
 			pointPtrDest->x = (coX + coZ) * 24 / ISO_SCALE + _projectionCenter.x;
 			pointPtrDest->y = (((coX - coZ) * 12) - coY * 30) / ISO_SCALE + _projectionCenter.y;
 			pointPtrDest->z = coZ - coX - coY;
@@ -1605,61 +1609,39 @@ void Renderer::animModel(ModelData *modelData, const BodyData &bodyData, RenderC
 		} while (--numOfPrimitives);
 	} else {
 		do {
-			int32 coX = pointPtr->x + renderPos.x;
-			int32 coY = pointPtr->y + renderPos.y;
-			int32 coZ = -(pointPtr->z + renderPos.z);
-
-			coZ += _kFactor;
-
+			int32 coZ = _kFactor - (pointPtr->z + renderPos.z);
 			if (coZ <= 0) {
 				coZ = 0x7FFFFFFF;
 			}
 
-			// X projection
-			{
-				coX = _projectionCenter.x + ((coX * _lFactorX) / coZ);
-
-				if (coX > 0xFFFF) {
-					coX = 0x7FFF;
-				}
-
-				pointPtrDest->x = coX;
-
-				if (pointPtrDest->x < modelRect.left) {
-					modelRect.left = pointPtrDest->x;
-				}
-
-				if (pointPtrDest->x > modelRect.right) {
-					modelRect.right = pointPtrDest->x;
-				}
+			int32 coX = (((pointPtr->x + renderPos.x) * _lFactorX) / coZ) + _projectionCenter.x;
+			if (coX > 0xFFFF) {
+				coX = 0x7FFF;
 			}
-
-			// Y projection
-			{
-				coY = _projectionCenter.y + ((-coY * _lFactorY) / coZ);
-
-				if (coY > 0xFFFF) {
-					coY = 0x7FFF;
-				}
-
-				pointPtrDest->y = coY;
-
-				if (pointPtrDest->y < modelRect.top) {
-					modelRect.top = pointPtrDest->y;
-				}
-				if (pointPtrDest->y > modelRect.bottom) {
-					modelRect.bottom = pointPtrDest->y;
-				}
+			pointPtrDest->x = coX;
+			if (pointPtrDest->x < modelRect.left) {
+				modelRect.left = pointPtrDest->x;
+			}
+			if (pointPtrDest->x > modelRect.right) {
+				modelRect.right = pointPtrDest->x;
 			}
 
-			// Z projection
-			{
-				if (coZ > 0xFFFF) {
-					coZ = 0x7FFF;
-				}
+			int32 coY = _projectionCenter.y - (((pointPtr->y + renderPos.y) * _lFactorY) / coZ);
+			if (coY > 0xFFFF) {
+				coY = 0x7FFF;
+			}
+			pointPtrDest->y = coY;
+			if (pointPtrDest->y < modelRect.top) {
+				modelRect.top = pointPtrDest->y;
+			}
+			if (pointPtrDest->y > modelRect.bottom) {
+				modelRect.bottom = pointPtrDest->y;
+			}
 
-				pointPtrDest->z = coZ;
+			if (coZ > 0xFFFF) {
+				coZ = 0x7FFF;
 			}
+			pointPtrDest->z = coZ;
 
 			pointPtr++;
 			pointPtrDest++;
diff --git a/engines/twine/renderer/renderer.h b/engines/twine/renderer/renderer.h
index 98d06058203..9b251078d2f 100644
--- a/engines/twine/renderer/renderer.h
+++ b/engines/twine/renderer/renderer.h
@@ -151,6 +151,7 @@ private:
 
 	ModelData _modelData;
 
+	// AnimNuage
 	void animModel(ModelData *modelData, const BodyData &bodyData, RenderCommand *renderCmds, const IVec3 &angleVec, const IVec3 &renderPos, Common::Rect &modelRect);
 	bool computeSphere(int32 x, int32 y, int32 radius, int &vtop, int &vbottom);
 	bool renderObjectIso(const BodyData &bodyData, RenderCommand **renderCmds, ModelData *modelData, Common::Rect &modelRect); // RenderObjetIso
@@ -231,8 +232,6 @@ public:
 
 	void init(int32 w, int32 h);
 
-	IVec3 _projPos;
-
 	void setCameraRotation(int32 x, int32 y, int32 z);
 	IVec3 getHolomapRotation(const int32 angleX, const int32 angleY, const int32 angleZ) const;
 
@@ -244,11 +243,13 @@ public:
 	void fillVertices(int16 vtop, int16 vbottom, uint8 renderType, uint16 color);
 	void renderPolygons(const CmdRenderPolygon &polygon, ComputedVertex *vertices, int vtop, int vbottom);
 
-	inline IVec3 &projectPositionOnScreen(const IVec3& pos) { // ProjettePoint
-		return projectPositionOnScreen(pos.x, pos.y, pos.z);
+	inline IVec3 projectPoint(const IVec3& pos) { // ProjettePoint
+		return projectPoint(pos.x, pos.y, pos.z);
 	}
 
-	IVec3 &projectPositionOnScreen(int32 cX, int32 cY, int32 cZ);
+	void projIso(IVec3 &pos, int32 x, int32 y, int32 z);
+
+	IVec3 projectPoint(int32 cX, int32 cY, int32 cZ);
 
 	void setFollowCamera(int32 transPosX, int32 transPosY, int32 transPosZ, int32 cameraAlpha, int32 cameraBeta, int32 cameraGamma, int32 cameraZoom);
 	void setPosCamera(int32 x, int32 y, int32 z);
diff --git a/engines/twine/scene/extra.cpp b/engines/twine/scene/extra.cpp
index d6a840ef0d3..974a5fb94a3 100644
--- a/engines/twine/scene/extra.cpp
+++ b/engines/twine/scene/extra.cpp
@@ -394,106 +394,64 @@ void Extra::addExtraThrowMagicball(int32 x, int32 y, int32 z, int32 xAngle, int3
 	}
 }
 
-void Extra::drawSpecialShape(const ExtraShape &shapeTable, int32 x, int32 y, int32 color, int32 angle, int32 size, Common::Rect &renderRect) {
+void Extra::aff2DShape(const ExtraShape &shapeTable, int32 x, int32 y, int32 color, int32 angle, int32 zoom, Common::Rect &renderRect) {
 	int shapeDataIndex = 0;
-	int16 shapeX = shapeTable.data[shapeDataIndex].x * size / 16;
-	int16 shapeZ = shapeTable.data[shapeDataIndex].z * size / 16;
+	int16 shapeX = shapeTable.data[shapeDataIndex].x * zoom / 16;
+	int16 shapeZ = shapeTable.data[shapeDataIndex].z * zoom / 16;
 
 	++shapeDataIndex;
 
-	renderRect.left = 0x7D00; // SCENE_SIZE_MAX
-	renderRect.right = -0x7D00;
-	renderRect.top = 0x7D00;
-	renderRect.bottom = -0x7D00;
+	_engine->clearScreenMinMax(renderRect);
 
 	IVec3 destPos = _engine->_movements->rotate(shapeX, shapeZ, angle);
 
 	const int32 computedX = destPos.x + x;
 	const int32 computedY = destPos.z + y;
 
-	if (computedX < renderRect.left) {
-		renderRect.left = computedX;
-	}
-
-	if (computedX > renderRect.right) {
-		renderRect.right = computedX;
-	}
-
-	if (computedY < renderRect.top) {
-		renderRect.top = computedY;
-	}
-
-	if (computedY > renderRect.bottom) {
-		renderRect.bottom = computedY;
-	}
+	_engine->adjustScreenMax(renderRect, computedX, computedY);
 
 	int32 currentX = computedX;
 	int32 currentY = computedY;
 
 	for (int32 numEntries = 1; numEntries < shapeTable.n; ++numEntries) {
-		shapeX = shapeTable.data[shapeDataIndex].x * size / 16;
-		shapeZ = shapeTable.data[shapeDataIndex].z * size / 16;
+		shapeX = shapeTable.data[shapeDataIndex].x * zoom / 16;
+		shapeZ = shapeTable.data[shapeDataIndex].z * zoom / 16;
 		++shapeDataIndex;
 
 		const int32 oldComputedX = currentX;
 		const int32 oldComputedY = currentY;
 
-		_engine->_renderer->_projPos.x = currentX;
-		_engine->_renderer->_projPos.y = currentY;
-
 		destPos = _engine->_movements->rotate(shapeX, shapeZ, angle);
 
 		currentX = destPos.x + x;
 		currentY = destPos.z + y;
 
-		if (currentX < renderRect.left) {
-			renderRect.left = currentX;
-		}
-
-		if (currentX > renderRect.right) {
-			renderRect.right = currentX;
-		}
-
-		if (currentY < renderRect.top) {
-			renderRect.top = currentY;
-		}
-
-		if (currentY > renderRect.bottom) {
-			renderRect.bottom = currentY;
-		}
-
-		_engine->_renderer->_projPos.x = currentX;
-		_engine->_renderer->_projPos.y = currentY;
-
+		_engine->adjustScreenMax(renderRect, currentX, currentY);
 		_engine->_interface->drawLine(oldComputedX, oldComputedY, currentX, currentY, color);
-
-		currentX = _engine->_renderer->_projPos.x;
-		currentY = _engine->_renderer->_projPos.y;
 	}
-
-	_engine->_renderer->_projPos.x = currentX;
-	_engine->_renderer->_projPos.y = currentY;
 	_engine->_interface->drawLine(currentX, currentY, computedX, computedY, color);
 }
 
-void Extra::drawExtraSpecial(int32 extraIdx, int32 x, int32 y, Common::Rect &renderRect) {
+void Extra::affSpecial(int32 extraIdx, int32 x, int32 y, Common::Rect &renderRect) {
 	ExtraListStruct *extra = &_extraList[extraIdx];
 	ExtraSpecialType specialType = (ExtraSpecialType)(extra->sprite & (EXTRA_SPECIAL_MASK - 1));
 
 	switch (specialType) {
 	case ExtraSpecialType::kHitStars:
-		drawSpecialShape(hitStarsShape, x, y, COLOR_WHITE, (_engine->_lbaTime * 32) & LBAAngles::ANGLE_270, 4, renderRect);
+		aff2DShape(hitStarsShape, x, y, COLOR_WHITE, (_engine->_lbaTime * 32) & LBAAngles::ANGLE_270, 4, renderRect);
 		break;
 	case ExtraSpecialType::kExplodeCloud: {
-		int32 cloudTime = 1 + _engine->_lbaTime - extra->spawnTime;
+		int32 zoom = 1 + _engine->_lbaTime - extra->spawnTime;
 
-		if (cloudTime > 32) {
-			cloudTime = 32;
+		if (zoom > 32) {
+			zoom = 32;
 		}
 
-		drawSpecialShape(explodeCloudShape, x, y, COLOR_WHITE, LBAAngles::ANGLE_0, cloudTime, renderRect);
+		aff2DShape(explodeCloudShape, x, y, COLOR_WHITE, LBAAngles::ANGLE_0, zoom, renderRect);
 		break;
 	}
+	case ExtraSpecialType::kFountain:
+		break;
 	}
 }
 
@@ -656,7 +614,7 @@ void Extra::gereExtras() {
 				_engine->_sound->playSample(Samples::ItemFound, 1, _engine->_scene->_sceneHero->posObj(), OWN_ACTOR_SCENE_INDEX);
 
 				if (extraKey->info1 > 1) {
-					const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(extraKey->pos - _engine->_grid->_worldCube);
+					const IVec3 &projPos = _engine->_renderer->projectPoint(extraKey->pos - _engine->_grid->_worldCube);
 					_engine->_redraw->addOverlay(OverlayType::koNumber, extraKey->info1, projPos.x, projPos.y, COLOR_BLACK, OverlayPosType::koNormal, 2);
 				}
 
@@ -689,7 +647,7 @@ void Extra::gereExtras() {
 				_engine->_sound->playSample(Samples::ItemFound, 1, _engine->_scene->_sceneHero->posObj(), OWN_ACTOR_SCENE_INDEX);
 
 				if (extraKey->info1 > 1) {
-					const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(extraKey->pos - _engine->_grid->_worldCube);
+					const IVec3 &projPos = _engine->_renderer->projectPoint(extraKey->pos - _engine->_grid->_worldCube);
 					_engine->_redraw->addOverlay(OverlayType::koNumber, extraKey->info1, projPos.x, projPos.y, COLOR_BLACK, OverlayPosType::koNormal, 2);
 				}
 
@@ -837,7 +795,7 @@ void Extra::gereExtras() {
 				_engine->_sound->playSample(Samples::ItemFound, 1, extra->pos);
 
 				if (extra->info1 > 1) {
-					const IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(extra->pos - _engine->_grid->_worldCube);
+					const IVec3 &projPos = _engine->_renderer->projectPoint(extra->pos - _engine->_grid->_worldCube);
 					const int16 fontColor = COLOR_158;
 					_engine->_redraw->addOverlay(OverlayType::koNumber, extra->info1, projPos.x, projPos.y, fontColor, OverlayPosType::koNormal, 2);
 				}
diff --git a/engines/twine/scene/extra.h b/engines/twine/scene/extra.h
index 6f1bd69da73..6068307b2ec 100644
--- a/engines/twine/scene/extra.h
+++ b/engines/twine/scene/extra.h
@@ -92,7 +92,7 @@ private:
 	void bounceExtra(ExtraListStruct *extra, int32 x, int32 y, int32 z);
 	int32 searchBonusKey() const;
 	int32 extraSearchKey(int32 actorIdx, int32 x, int32 y, int32 z, int32 spriteIdx, int32 extraIdx);
-	void drawSpecialShape(const ExtraShape &shapeTable, int32 x, int32 y, int32 color, int32 angle, int32 size, Common::Rect &renderRect);
+	void aff2DShape(const ExtraShape &shapeTable, int32 x, int32 y, int32 color, int32 angle, int32 zoom, Common::Rect &renderRect);
 
 public:
 	Extra(TwinEEngine *engine);
@@ -126,7 +126,7 @@ public:
 	int32 addExtraAiming(int32 actorIdx, int32 x, int32 y, int32 z, int32 spriteIdx, int32 targetActorIdx, int32 finalAngle, int32 strengthOfHit);
 	void addExtraThrowMagicball(int32 x, int32 y, int32 z, int32 xAngle, int32 yAngle, int32 xRotPoint, int32 extraAngle);
 
-	void drawExtraSpecial(int32 extraIdx, int32 x, int32 y, Common::Rect &renderRect);
+	void affSpecial(int32 extraIdx, int32 x, int32 y, Common::Rect &renderRect);
 
 	int getBonusSprite(BonusParameter bonusParameter) const;
 
diff --git a/engines/twine/scene/gamestate.cpp b/engines/twine/scene/gamestate.cpp
index 4fed1e787c3..f4b1c976e86 100644
--- a/engines/twine/scene/gamestate.cpp
+++ b/engines/twine/scene/gamestate.cpp
@@ -46,6 +46,8 @@
 #include "twine/text.h"
 #include "twine/twine.h"
 
+#define SIZE_FOUND_OBJ 130
+
 namespace TwinE {
 
 GameState::GameState(TwinEEngine *engine) : _engine(engine) {
@@ -335,13 +337,13 @@ void GameState::doFoundObj(InventoryItems item) {
 
 	_engine->_grid->drawOverBrick(itemX, itemY, itemZ);
 
-	IVec3 &projPos = _engine->_renderer->projectPositionOnScreen(bodyPos);
+	IVec3 projPos = _engine->_renderer->projectPoint(bodyPos);
 	projPos.y -= 150;
 
-	const int32 boxTopLeftX = projPos.x - 65;
-	const int32 boxTopLeftY = projPos.y - 65;
-	const int32 boxBottomRightX = projPos.x + 65;
-	const int32 boxBottomRightY = projPos.y + 65;
+	const int32 boxTopLeftX = projPos.x - (SIZE_FOUND_OBJ / 2);
+	const int32 boxTopLeftY = projPos.y - (SIZE_FOUND_OBJ / 2);
+	const int32 boxBottomRightX = projPos.x + (SIZE_FOUND_OBJ / 2);
+	const int32 boxBottomRightY = projPos.y + (SIZE_FOUND_OBJ / 2);
 	const Common::Rect boxRect(boxTopLeftX, boxTopLeftY, boxBottomRightX, boxBottomRightY);
 	_engine->_sound->playSample(Samples::BigItemFound);
 
@@ -381,7 +383,7 @@ void GameState::doFoundObj(InventoryItems item) {
 
 		itemAngle += LBAAngles::ANGLE_2;
 
-		_engine->_renderer->draw3dObject(_engine->_renderer->_projPos.x, _engine->_renderer->_projPos.y, _engine->_resources->_inventoryTable[item], itemAngle, 10000);
+		_engine->_renderer->draw3dObject(projPos.x, projPos.y, _engine->_resources->_inventoryTable[item], itemAngle, 10000);
 
 		_engine->_menu->drawRectBorders(boxRect);
 		_engine->_redraw->addRedrawArea(boxRect);
diff --git a/engines/twine/scene/grid.cpp b/engines/twine/scene/grid.cpp
index 73e62f604d6..7c3356bdc87 100644
--- a/engines/twine/scene/grid.cpp
+++ b/engines/twine/scene/grid.cpp
@@ -846,11 +846,11 @@ void Grid::centerScreenOnActor() {
 	}
 
 	ActorStruct *actor = _engine->_scene->getActor(_engine->_scene->_currentlyFollowedActor);
-	_engine->_renderer->projectPositionOnScreen(actor->_pos.x - (_newCamera.x * SIZE_BRICK_XZ),
+	const IVec3 projPos = _engine->_renderer->projectPoint(actor->_pos.x - (_newCamera.x * SIZE_BRICK_XZ),
 	                                   actor->_pos.y - (_newCamera.y * SIZE_BRICK_Y),
 	                                   actor->_pos.z - (_newCamera.z * SIZE_BRICK_XZ));
 	// TODO: these border values should get scaled for higher resolutions
-	if (_engine->_renderer->_projPos.x < 80 || _engine->_renderer->_projPos.x >= _engine->width() - 60 || _engine->_renderer->_projPos.y < 80 || _engine->_renderer->_projPos.y >= _engine->height() - 50) {
+	if (projPos.x < 80 || projPos.x >= _engine->width() - 60 || projPos.y < 80 || projPos.y >= _engine->height() - 50) {
 		_newCamera.x = ((actor->_pos.x + SIZE_BRICK_Y) / SIZE_BRICK_XZ) + (((actor->_pos.x + SIZE_BRICK_Y) / SIZE_BRICK_XZ) - _newCamera.x) / 2;
 		_newCamera.y = actor->_pos.y / SIZE_BRICK_Y;
 		_newCamera.z = ((actor->_pos.z + SIZE_BRICK_Y) / SIZE_BRICK_XZ) + (((actor->_pos.z + SIZE_BRICK_Y) / SIZE_BRICK_XZ) - _newCamera.z) / 2;
diff --git a/engines/twine/shared.h b/engines/twine/shared.h
index 41dd811c033..8e50781391e 100644
--- a/engines/twine/shared.h
+++ b/engines/twine/shared.h
@@ -342,7 +342,8 @@ enum class BodyType {
 
 enum class ExtraSpecialType {
 	kHitStars = 0,
-	kExplodeCloud = 1
+	kExplodeCloud = 1,
+	kFountain = 2
 };
 
 enum class ZoneType {
diff --git a/engines/twine/twine.cpp b/engines/twine/twine.cpp
index af0ca46aaa3..8accc3897d9 100644
--- a/engines/twine/twine.cpp
+++ b/engines/twine/twine.cpp
@@ -532,6 +532,31 @@ void TwinEEngine::queueMovie(const char *filename) {
 	_queuedFlaMovie = filename;
 }
 
+void TwinEEngine::adjustScreenMax(Common::Rect &rect, int16 x, int16 y) {
+	if (x < rect.left) {
+		rect.left = x;
+	}
+
+	if (x > rect.right) {
+		rect.right = x;
+	}
+
+	if (y < rect.top) {
+		rect.top = y;
+	}
+
+	if (y > rect.bottom) {
+		rect.bottom = y;
+	}
+}
+
+void TwinEEngine::clearScreenMinMax(Common::Rect &rect) {
+	rect.left = 0x7D00; // SCENE_SIZE_MAX
+	rect.right = -0x7D00;
+	rect.top = 0x7D00;
+	rect.bottom = -0x7D00;
+}
+
 void TwinEEngine::playIntro() {
 	_input->enableKeyMap(cutsceneKeyMapId);
 	// Display company logo
@@ -1004,7 +1029,7 @@ bool TwinEEngine::runGameEngine() { // mainLoopInteration
 						if (!_actor->_cropBottomScreen) {
 							_animations->initAnim(AnimationTypes::kDrawn, AnimType::kAnimationSet, AnimationTypes::kStanding, OWN_ACTOR_SCENE_INDEX);
 						}
-						const IVec3 &projPos = _renderer->projectPositionOnScreen(actor->posObj() - _grid->_worldCube);
+						const IVec3 &projPos = _renderer->projectPoint(actor->posObj() - _grid->_worldCube);
 						actor->_controlMode = ControlMode::kNoMove;
 						actor->setLife(-1);
 						_actor->_cropBottomScreen = projPos.y;
diff --git a/engines/twine/twine.h b/engines/twine/twine.h
index 7f0c87ea59d..230176a0c53 100644
--- a/engines/twine/twine.h
+++ b/engines/twine/twine.h
@@ -328,6 +328,9 @@ public:
 
 	void queueMovie(const char *filename);
 
+	void clearScreenMinMax(Common::Rect &rect);
+	void adjustScreenMax(Common::Rect &rect, int16 x, int16 y);
+
 	/**
 	 * @return A random value between [0-max)
 	 */


Commit: f1df317abc7ba470bff092d8dd18be599d49b2dd
    https://github.com/scummvm/scummvm/commit/f1df317abc7ba470bff092d8dd18be599d49b2dd
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2023-01-21T15:23:00+01:00

Commit Message:
TWINE: fixed bug #13871 (rendering error with opened door)

https://bugs.scummvm.org/ticket/13871

the z level correction was done, but the sorting did not take the corrected
depth values into account

Changed paths:
    engines/twine/renderer/redraw.cpp


diff --git a/engines/twine/renderer/redraw.cpp b/engines/twine/renderer/redraw.cpp
index 8d5504092bc..3fc0f7546e1 100644
--- a/engines/twine/renderer/redraw.cpp
+++ b/engines/twine/renderer/redraw.cpp
@@ -836,10 +836,10 @@ void Redraw::redrawEngineActions(bool bgRedraw) { // AffScene
 	DrawListStruct drawList[NUM_MAX_ACTORS + EXTRA_MAX_ENTRIES]; // ListTri[MAX_OBJECTS + MAX_EXTRAS]
 	int32 drawListPos = fillActorDrawingList(drawList, bgRedraw);
 	drawListPos = fillExtraDrawingList(drawList, drawListPos);
-	sortDrawingList(drawList, drawListPos);
 
 	_currNumOfRedrawBox = 0;
 	correctZLevels(drawList, drawListPos);
+	sortDrawingList(drawList, drawListPos);
 	processDrawList(drawList, drawListPos, bgRedraw);
 
 	if (_engine->_cfgfile.Debug) {

More information about the Scummvm-git-logs mailing list