Initial revision

1 files changed, 369 insertions, 0 deletions

diff --git a/src/win95/plat_shp.c b/src/win95/plat_shp.c
new file mode 100644
index 0000000..8a67984
--- /dev/null
+++ b/src/win95/plat_shp.c
@@ -0,0 +1,369 @@
+/*RWH moved to a seperate file*/
+
+
+#include "3dc.h"
+#include "module.h"
+#include "inline.h"
+
+#include "gameplat.h"
+#include "gamedef.h"
+
+
+#include "dynblock.h"
+#include "dynamics.h"
+#define UseLocalAssert No
+#include "ourasert.h"
+
+
+/*						   *
+						   *
+						   *
+						*  *  *
+						 * * *
+						  ***
+                           *
+*/
+/*KJL***********************************************
+* Polygon Access Functions V1.0, 18:12:27 11/07/96 *
+***********************************************KJL*/
+
+int SetupPolygonAccess(DISPLAYBLOCK *objectPtr);
+void AccessNextPolygon(void);
+void GetPolygonVertices(struct ColPolyTag *polyPtr);
+void GetPolygonNormal(struct ColPolyTag *polyPtr);
+int SetupPolygonAccessFromShapeIndex(int shapeIndex);
+
+
+/* the following are needed for morphing support */
+#if SupportMorphing
+extern MORPHDISPLAY MorphDisplay;
+extern VECTORCH MorphedPts[];
+#endif
+
+VECTORCH *ShapePointsPtr;
+int *ShapeNormalsPtr;
+int *Shape2NormalsPtr;
+char ShapeIsMorphed;
+int **ItemArrayPtr;
+POLYHEADER *PolyheaderPtr;
+
+int SetupPolygonAccess(DISPLAYBLOCK *objectPtr)
+{
+	SHAPEHEADER *shape1Ptr;
+
+	#if SupportMorphing
+  	if (objectPtr->ObMorphCtrl) /* morphable object? */
+	{
+		VECTORCH *shape1PointsPtr;
+		VECTORCH *shape2PointsPtr;
+						
+		/* Set up the morph data */
+		GetMorphDisplay(&MorphDisplay, objectPtr);
+
+		shape1Ptr = MorphDisplay.md_sptr1;
+
+		if(MorphDisplay.md_lerp == 0x0000)
+		{
+			
+			ShapePointsPtr = (VECTORCH *)*shape1Ptr->points;
+			ShapeNormalsPtr = (int *) *(shape1Ptr->sh_normals);
+			ShapeIsMorphed=0;
+				
+		}
+		else if(MorphDisplay.md_lerp == 0xffff)
+		{
+			SHAPEHEADER *shape2Ptr;
+			shape2Ptr = MorphDisplay.md_sptr2;
+			
+			ShapePointsPtr = (VECTORCH *)*shape2Ptr->points;	
+			ShapeNormalsPtr = (int *) *(shape2Ptr->sh_normals);
+			ShapeIsMorphed=0;
+		}
+		else
+		{
+			SHAPEHEADER *shape2Ptr;
+			shape2Ptr = MorphDisplay.md_sptr2;
+		    
+			shape1PointsPtr = (VECTORCH *)(*shape1Ptr->points);
+			shape2PointsPtr = (VECTORCH *)(*shape2Ptr->points);
+
+			/* you're going to need all the points so you might as well morph them all at once now */
+			{
+		    	int numberOfPoints = shape1Ptr->numpoints;
+				VECTORCH *morphedPointsPtr = (VECTORCH *) MorphedPts;
+		    
+				while(numberOfPoints--)
+				{
+				   	VECTORCH vertex1 = *shape1PointsPtr;
+				   	VECTORCH vertex2 = *shape2PointsPtr;
+				
+					if( (vertex1.vx == vertex2.vx && vertex1.vy == vertex2.vy && vertex1.vz == vertex2.vz) )
+					{
+						*morphedPointsPtr = vertex1;
+					}
+					else
+					{
+						/* KJL 15:27:20 05/22/97 - I've changed this to speed things up, If a vertex
+						component has a magnitude greater than 32768 things will go wrong. */
+						morphedPointsPtr->vx = vertex1.vx + (((vertex2.vx-vertex1.vx)*MorphDisplay.md_lerp)>>16);
+						morphedPointsPtr->vy = vertex1.vy + (((vertex2.vy-vertex1.vy)*MorphDisplay.md_lerp)>>16);
+						morphedPointsPtr->vz = vertex1.vz + (((vertex2.vz-vertex1.vz)*MorphDisplay.md_lerp)>>16);
+					}
+
+		            shape1PointsPtr++;
+		            shape2PointsPtr++;
+					morphedPointsPtr++;
+				}
+			}
+
+		    ShapePointsPtr = (VECTORCH *)MorphedPts;
+			ShapeNormalsPtr = (int *) *(shape1Ptr->sh_normals);
+			Shape2NormalsPtr = (int *) *(shape2Ptr->sh_normals);
+			ShapeIsMorphed=1;
+		}
+		ItemArrayPtr = (int **)shape1Ptr->items;
+	}
+  	else /* not a morphing object */
+  	#endif
+  	{
+		shape1Ptr = GetShapeData(objectPtr->ObShape);
+
+		ShapePointsPtr  = (VECTORCH *)(*shape1Ptr->points);
+		ShapeNormalsPtr = (int *)(*shape1Ptr->sh_normals);
+		ItemArrayPtr = (int **)shape1Ptr->items;
+        ShapeIsMorphed=0;
+	}	
+	
+	{
+		int *itemPtr = *ItemArrayPtr;
+		PolyheaderPtr = (POLYHEADER *) itemPtr;
+	}
+    
+    return shape1Ptr->numitems;
+}
+void AccessNextPolygon(void)
+{
+	int *itemPtr = *(ItemArrayPtr++);
+	PolyheaderPtr = (POLYHEADER *) itemPtr;
+    return;
+}											 
+
+void GetPolygonVertices(struct ColPolyTag *polyPtr)
+{
+	int *vertexNumberPtr = &PolyheaderPtr->Poly1stPt;
+
+  	polyPtr->PolyPoint[0] = *(ShapePointsPtr + *vertexNumberPtr++);
+    polyPtr->PolyPoint[1] = *(ShapePointsPtr + *vertexNumberPtr++);
+    polyPtr->PolyPoint[2] = *(ShapePointsPtr + *vertexNumberPtr++);
+    
+	if (*vertexNumberPtr != Term)
+	{
+	    polyPtr->PolyPoint[3] = *(ShapePointsPtr + *vertexNumberPtr);
+	   	polyPtr->NumberOfVertices=4; 
+	}
+	else
+	{
+	   	polyPtr->NumberOfVertices=3; 
+	}
+
+    return;
+}
+void GetPolygonNormal(struct ColPolyTag *polyPtr)
+{	  
+	if (ShapeIsMorphed)
+	{
+		VECTORCH n1Ptr = *(VECTORCH*)(ShapeNormalsPtr + PolyheaderPtr->PolyNormalIndex);
+		VECTORCH n2Ptr = *(VECTORCH*)(Shape2NormalsPtr + PolyheaderPtr->PolyNormalIndex);
+        
+		if( ((n1Ptr.vx == n2Ptr.vx)
+		  && (n1Ptr.vy == n2Ptr.vy)
+		  && (n1Ptr.vz == n2Ptr.vz))
+		  || (MorphDisplay.md_lerp == 0) )
+		{
+			polyPtr->PolyNormal = n1Ptr;
+		}
+		else if(MorphDisplay.md_lerp == 0xffff)
+		{
+			polyPtr->PolyNormal = n2Ptr;
+		}
+		else
+		{
+			VECTORCH *pointPtr[3];
+ 			int *vertexNumPtr = &PolyheaderPtr->Poly1stPt;
+
+			pointPtr[0] = (ShapePointsPtr + *vertexNumPtr++);
+			pointPtr[1] = (ShapePointsPtr + *vertexNumPtr++);
+			pointPtr[2] = (ShapePointsPtr + *vertexNumPtr);
+
+			MakeNormal
+			(
+				pointPtr[0],
+				pointPtr[1],
+				pointPtr[2],
+				&polyPtr->PolyNormal
+			);
+		}
+	}
+    else /* not morphed */
+    {
+     	polyPtr->PolyNormal = *(VECTORCH*)(ShapeNormalsPtr + PolyheaderPtr->PolyNormalIndex);
+    	
+    	/* KJL 20:55:36 05/14/97 - turned off for alpha */
+    	#if 0
+    	if(	(polyPtr->PolyNormal.vx==0)
+		  &&(polyPtr->PolyNormal.vy==0)
+		  &&(polyPtr->PolyNormal.vz==0) )
+		{
+			textprint("shape data has zero normal\n");
+		}
+		#endif
+
+    }
+    return;
+}	
+
+/*-----------------------Patrick 1/12/96--------------------------
+  I have added this function to initialise polygon access for a
+  module based on the shape index specified in its mapblock....
+  Specifically, this is for setting up location data for modules
+  during game initialisation, and so doesn't support morphing.
+  ----------------------------------------------------------------*/
+int SetupPolygonAccessFromShapeIndex(int shapeIndex)
+{
+	SHAPEHEADER *shape1Ptr;
+	
+	shape1Ptr = GetShapeData(shapeIndex);
+	ShapePointsPtr  = (VECTORCH *)(*shape1Ptr->points);
+	ShapeNormalsPtr = (int *)(*shape1Ptr->sh_normals);
+	ItemArrayPtr = (int **)shape1Ptr->items;
+    ShapeIsMorphed=0;
+	
+	{
+		int *itemPtr = *ItemArrayPtr;
+		PolyheaderPtr = (POLYHEADER *) itemPtr;
+	}
+    
+    return shape1Ptr->numitems;
+}
+
+/*--------------------Patrick 17/12/96----------------------------
+  I have added some more shape data access functions......
+  PSX versions are required.
+  ----------------------------------------------------------------*/
+
+static VECTORCH patPointData;
+static int patPolyVertexIndices[4];
+static VECTORCH *patShapePointsPtr;
+
+int SetupPointAccessFromShapeIndex(int shapeIndex)
+{
+	SHAPEHEADER *shapePtr;
+
+	shapePtr = GetShapeData(shapeIndex);
+	patShapePointsPtr  = (VECTORCH *)(*shapePtr->points);
+	    
+    return shapePtr->numpoints;
+}
+
+
+VECTORCH* AccessNextPoint(void)
+{
+	patPointData = *patShapePointsPtr++;
+	return &patPointData;
+}
+
+VECTORCH* AccessPointFromIndex(int index)
+{
+	patPointData = patShapePointsPtr[index];
+	return &patPointData;
+}		
+
+/* KJL 18:51:08 21/11/98 - similiar function for polys */									 
+POLYHEADER *AccessPolyFromIndex(int index)
+{
+	int *itemPtr = *(ItemArrayPtr+index);
+	PolyheaderPtr = (POLYHEADER *) itemPtr;
+	return PolyheaderPtr;
+}
+
+void DestroyPolygon(int shapeIndex,int polyIndex)
+{
+	SHAPEHEADER *shapePtr = GetShapeData(shapeIndex);
+	shapePtr->numitems--;
+	*(ItemArrayPtr+polyIndex) = *(ItemArrayPtr+shapePtr->numitems);
+}
+
+void ReplaceVertexInPolygon(int polyIndex, int oldVertex, int newVertex)
+{
+	int *vertexNumberPtr;
+	int *itemPtr = *(ItemArrayPtr+polyIndex);
+	PolyheaderPtr = (POLYHEADER *) itemPtr;
+	
+	vertexNumberPtr = &PolyheaderPtr->Poly1stPt;
+
+    while(*vertexNumberPtr != Term)
+	{
+    	if (*vertexNumberPtr == oldVertex)
+		{
+			*vertexNumberPtr = newVertex;
+		}
+		vertexNumberPtr++; 
+	}
+
+	{
+		VECTORCH newNormal;
+		VECTORCH *pointPtr[3];
+		int *vertexNumPtr = &PolyheaderPtr->Poly1stPt;
+		pointPtr[0] = (ShapePointsPtr + *vertexNumPtr++);
+		pointPtr[1] = (ShapePointsPtr + *vertexNumPtr++);
+		pointPtr[2] = (ShapePointsPtr + *vertexNumPtr);
+		MakeNormal
+		(
+			pointPtr[0],
+			pointPtr[1],
+			pointPtr[2],
+			&newNormal
+		);
+	   	*(VECTORCH*)(ShapeNormalsPtr + PolyheaderPtr->PolyNormalIndex)=newNormal;
+	}
+    	
+
+}
+VECTORCH *GetPolygonNormalFromIndex(void)
+{
+	return (VECTORCH*)(ShapeNormalsPtr + PolyheaderPtr->PolyNormalIndex);
+}
+
+int *GetPolygonVertexIndices(void)
+{
+	int *vertexNumberPtr = &PolyheaderPtr->Poly1stPt;
+    int numberOfVertices=0;
+
+    patPolyVertexIndices[3]	= -1;
+
+    while(*vertexNumberPtr != Term)
+	{
+    	patPolyVertexIndices[numberOfVertices++] = (*vertexNumberPtr);
+		vertexNumberPtr++; 
+	}
+
+    return &patPolyVertexIndices[0];
+}
+
+
+/*--------------------Roxby 3/7/97----------------------------
+  I have added some more shape data access functions......
+  taken from PSX versions 
+  ----------------------------------------------------------------*/
+
+
+void SetupPolygonFlagAccessForShape(SHAPEHEADER *shape) 
+{
+}
+		
+		
+int Request_PolyFlags(void *polygon) 
+{
+	POLYHEADER *poly = (POLYHEADER*)polygon;
+	return poly->PolyFlags;
+}