summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--premake5.lua13
-rw-r--r--rwsdk/include/d3d8/baaplylt.c793
-rw-r--r--rwsdk/include/d3d8/errcom.def60
-rw-r--r--rwsdk/include/d3d8/errcore.def117
-rw-r--r--rwsdk/include/d3d8/rpanisot.h54
-rw-r--r--rwsdk/include/d3d8/rpanisot.rpe639
-rw-r--r--rwsdk/include/d3d8/rpcollis.h372
-rw-r--r--rwsdk/include/d3d8/rpcollis.rpe637
-rw-r--r--rwsdk/include/d3d8/rpcriter.h572
-rw-r--r--rwsdk/include/d3d8/rpdbgerr.c90
-rw-r--r--rwsdk/include/d3d8/rpdbgerr.h278
-rw-r--r--rwsdk/include/d3d8/rpdmorph.h311
-rw-r--r--rwsdk/include/d3d8/rpdmorph.rpe639
-rw-r--r--rwsdk/include/d3d8/rperror.h32
-rw-r--r--rwsdk/include/d3d8/rphanim.h873
-rw-r--r--rwsdk/include/d3d8/rphanim.rpe644
-rw-r--r--rwsdk/include/d3d8/rplodatm.h131
-rw-r--r--rwsdk/include/d3d8/rplodatm.rpe642
-rw-r--r--rwsdk/include/d3d8/rplogo.h83
-rw-r--r--rwsdk/include/d3d8/rplogo.rpe639
-rw-r--r--rwsdk/include/d3d8/rpltmap.h90
-rw-r--r--rwsdk/include/d3d8/rpltmap.rpe638
-rw-r--r--rwsdk/include/d3d8/rpmatfx.h237
-rw-r--r--rwsdk/include/d3d8/rpmatfx.rpe638
-rw-r--r--rwsdk/include/d3d8/rpmipkl.h38
-rw-r--r--rwsdk/include/d3d8/rpmipkl.rpe639
-rw-r--r--rwsdk/include/d3d8/rpmorph.h138
-rw-r--r--rwsdk/include/d3d8/rpmorph.rpe641
-rw-r--r--rwsdk/include/d3d8/rppatch.h683
-rw-r--r--rwsdk/include/d3d8/rppatch.rpe638
-rw-r--r--rwsdk/include/d3d8/rpprtstd.h1026
-rw-r--r--rwsdk/include/d3d8/rpprtstd.rpe639
-rw-r--r--rwsdk/include/d3d8/rpptank.h781
-rw-r--r--rwsdk/include/d3d8/rpptank.rpe643
-rw-r--r--rwsdk/include/d3d8/rppvs.h395
-rw-r--r--rwsdk/include/d3d8/rppvs.rpe640
-rw-r--r--rwsdk/include/d3d8/rprandom.h65
-rw-r--r--rwsdk/include/d3d8/rprandom.rpe638
-rw-r--r--rwsdk/include/d3d8/rpskin.h222
-rw-r--r--rwsdk/include/d3d8/rpskin.rpe638
-rw-r--r--rwsdk/include/d3d8/rpspline.h141
-rw-r--r--rwsdk/include/d3d8/rpspline.rpe642
-rw-r--r--rwsdk/include/d3d8/rpstereo.h141
-rw-r--r--rwsdk/include/d3d8/rpstereo.rpe641
-rw-r--r--rwsdk/include/d3d8/rpusrdat.h124
-rw-r--r--rwsdk/include/d3d8/rpusrdat.rpe639
-rw-r--r--rwsdk/include/d3d8/rpworld.h3735
-rw-r--r--rwsdk/include/d3d8/rpworld.rpe63
-rw-r--r--rwsdk/include/d3d8/rt2d.h911
-rw-r--r--rwsdk/include/d3d8/rt2d.rpe629
-rw-r--r--rwsdk/include/d3d8/rt2danim.h1056
-rw-r--r--rwsdk/include/d3d8/rt2danim.rpe629
-rw-r--r--rwsdk/include/d3d8/rtbary.h141
-rw-r--r--rwsdk/include/d3d8/rtbary.rpe645
-rw-r--r--rwsdk/include/d3d8/rtbezpat.h401
-rw-r--r--rwsdk/include/d3d8/rtbezpat.rpe629
-rw-r--r--rwsdk/include/d3d8/rtbmp.h51
-rw-r--r--rwsdk/include/d3d8/rtbmp.rpe629
-rw-r--r--rwsdk/include/d3d8/rtcharse.h111
-rw-r--r--rwsdk/include/d3d8/rtcharse.rpe629
-rw-r--r--rwsdk/include/d3d8/rtimport.h1278
-rw-r--r--rwsdk/include/d3d8/rtimport.rpe640
-rw-r--r--rwsdk/include/d3d8/rtintel.h1206
-rw-r--r--rwsdk/include/d3d8/rtintel.rpe645
-rw-r--r--rwsdk/include/d3d8/rtintsec.h138
-rw-r--r--rwsdk/include/d3d8/rtintsec.rpe628
-rw-r--r--rwsdk/include/d3d8/rtltmap.h601
-rw-r--r--rwsdk/include/d3d8/rtltmap.rpe638
-rw-r--r--rwsdk/include/d3d8/rtmipk.h58
-rw-r--r--rwsdk/include/d3d8/rtmipk.rpe628
-rw-r--r--rwsdk/include/d3d8/rtpick.h59
-rw-r--r--rwsdk/include/d3d8/rtpick.rpe628
-rw-r--r--rwsdk/include/d3d8/rtpitexd.h74
-rw-r--r--rwsdk/include/d3d8/rtpitexd.rpe682
-rw-r--r--rwsdk/include/d3d8/rtpng.h49
-rw-r--r--rwsdk/include/d3d8/rtpng.rpe629
-rw-r--r--rwsdk/include/d3d8/rtquat.h646
-rw-r--r--rwsdk/include/d3d8/rtquat.rpe645
-rw-r--r--rwsdk/include/d3d8/rtras.h54
-rw-r--r--rwsdk/include/d3d8/rtras.rpe629
-rw-r--r--rwsdk/include/d3d8/rtray.h61
-rw-r--r--rwsdk/include/d3d8/rtray.rpe628
-rw-r--r--rwsdk/include/d3d8/rtslerp.h262
-rw-r--r--rwsdk/include/d3d8/rtslerp.rpe646
-rw-r--r--rwsdk/include/d3d8/rtsplpvs.h65
-rw-r--r--rwsdk/include/d3d8/rtsplpvs.rpe628
-rw-r--r--rwsdk/include/d3d8/rttiff.h47
-rw-r--r--rwsdk/include/d3d8/rttiff.rpe629
-rw-r--r--rwsdk/include/d3d8/rttilerd.h70
-rw-r--r--rwsdk/include/d3d8/rttilerd.rpe629
-rw-r--r--rwsdk/include/d3d8/rttoc.h99
-rw-r--r--rwsdk/include/d3d8/rttoc.rpe629
-rw-r--r--rwsdk/include/d3d8/rtvcat.h38
-rw-r--r--rwsdk/include/d3d8/rtvcat.rpe629
-rw-r--r--rwsdk/include/d3d8/rtworld.h85
-rw-r--r--rwsdk/include/d3d8/rtworld.rpe628
-rw-r--r--rwsdk/include/d3d8/rwcore.h4791
-rw-r--r--rwsdk/include/d3d8/rwplcore.h6080
-rw-r--r--src/SurfaceTable.cpp53
-rw-r--r--src/SurfaceTable.h6
-rw-r--r--src/audio/DMAudio.cpp5
-rw-r--r--src/audio/DMAudio.h9
-rw-r--r--src/control/CarCtrl.cpp5
-rw-r--r--src/control/CarCtrl.h9
-rw-r--r--src/entities/Physical.cpp398
-rw-r--r--src/entities/Physical.h11
106 files changed, 57865 insertions, 103 deletions
diff --git a/premake5.lua b/premake5.lua
index f7e54d31..67766af5 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -7,11 +7,16 @@ workspace "re3"
files { "src/modelinfo/*.*" }
files { "src/entities/*.*" }
files { "src/render/*.*" }
+ files { "src/control/*.*" }
+ files { "src/audio/*.*" }
- includedirs { "src", "src/modelinfo" }
- includedirs { "src", "src/entities" }
- includedirs { "src", "src/render" }
- includedirs { os.getenv("RWSDK33") }
+ includedirs { "src" }
+ includedirs { "src/modelinfo" }
+ includedirs { "src/entities" }
+ includedirs { "src/render" }
+ includedirs { "src/control" }
+ includedirs { "src/audio" }
+ includedirs { "rwsdk/include/d3d8" }
project "re3"
kind "SharedLib"
diff --git a/rwsdk/include/d3d8/baaplylt.c b/rwsdk/include/d3d8/baaplylt.c
new file mode 100644
index 00000000..ad518e6a
--- /dev/null
+++ b/rwsdk/include/d3d8/baaplylt.c
@@ -0,0 +1,793 @@
+
+/* If this file is used outside of the core RW SDK,
+ * the following things need to be defined
+ */
+#if (!defined(RWASSERT))
+#define RWASSERT(_assertval) /* No op */
+#endif
+#if (!defined(RWFUNCTION))
+#define RWFUNCTION(_rwfunctionstring) /* No op */
+#endif
+#if (!defined(RWRETURN))
+#define RWRETURN(_rwreturnval) return(_rwreturnval)
+#endif
+#if (!defined(RWRETURNVOID))
+#define RWRETURNVOID() return
+#endif
+
+/* These are used by specular lighting,
+ * sorry I have to leave them in here... IDBS
+ * I'll make it neater when I have time.
+ */
+#if (!defined(FALLOFFAMBIENT))
+#define FALLOFFAMBIENT() /* No op */
+#endif
+#if (!defined(FALLOFFDIRECTIONAL))
+#define FALLOFFDIRECTIONAL() /* No op */
+#endif
+#if (!defined(FALLOFFPOINT))
+#define FALLOFFPOINT() /* No op */
+#endif
+#if (!defined(FALLOFFSPOT))
+#define FALLOFFSPOT() /* No op */
+#endif
+#if (!defined(FALLOFFSOFTSPOT))
+#define FALLOFFSOFTSPOT() /* No op */
+#endif
+
+/***************************************************************************
+ _rwApplyAmbientLight
+
+ On entry : Instanced data
+ : Light
+ : Optional inverse object matrix
+ : (to transform light to object space)
+ : Inverse scale of object
+ : Surface properties of the light
+ On exit :
+ */
+
+static void
+_rwApplyAmbientLight(VERTSARG,
+ const void *voidLight,
+ const RwMatrix * __RWUNUSED__ inverseMat,
+ RwReal __RWUNUSED__ invScale,
+ const RwSurfaceProperties * surfaceProps)
+{
+ CAMVERTDECL;
+ NUMVERTDECL;
+ const RpLight *light = (const RpLight *) voidLight;
+ RwReal scale;
+ RwV3d vertToLight;
+
+ RWFUNCTION(RWSTRING("_rwApplyAmbientLight"));
+ RWASSERT(light);
+ RWASSERT(surfaceProps);
+
+ CAMVERTINIT();
+ NUMVERTINIT();
+
+ /* No directional component:
+ * (this is used in CAMVERTADDRGBA in a specular lighting node) */
+ vertToLight.x = 0;
+ vertToLight.y = 0;
+ vertToLight.z = 0;
+
+ /* rpLIGHTAMBIENT - Constant illumination on all vertices
+ */
+ if (rwObjectTestPrivateFlags(light, rpLIGHTPRIVATENOCHROMA))
+ {
+ scale = 255.0f * light->color.red * surfaceProps->ambient;
+
+ /* Ambient light affects all vertices the same */
+ while (numVert--)
+ {
+ RwReal lum = scale;
+
+#undef FALLOFFCALC
+#define FALLOFFCALC FALLOFFAMBIENT
+ CAMVERTADDRGBA(1, 1, 1, 0);
+ CAMVERTINC();
+ }
+ }
+ else
+ /* perform for coloured lights */
+ {
+ scale = 255.0f * surfaceProps->ambient;
+
+ /* Ambient light affects all vertices the same */
+ while (numVert--)
+ {
+ RwReal lum = scale;
+
+#undef FALLOFFCALC
+#define FALLOFFCALC FALLOFFAMBIENT
+ CAMVERTADDRGBA(light->color.red, light->color.green,
+ light->color.blue, 0);
+ CAMVERTINC();
+ }
+ }
+ RWRETURNVOID();
+}
+
+/***************************************************************************
+ _rwApplyDirectionalLight
+
+ On entry : Instanced data
+ : Light
+ : Optional inverse object matrix
+ : (to transform light to object space)
+ : Inverse scale of object
+ : Surface properties of the light
+ On exit :
+ */
+
+static void
+_rwApplyDirectionalLight(VERTSARG,
+ const void *voidLight,
+ const RwMatrix * inverseMat,
+ RwReal __RWUNUSED__ invScale,
+ const RwSurfaceProperties * surfaceProps)
+{
+ OBJCAMVERTDECL;
+ NUMVERTDECL;
+ const RpLight *light = (const RpLight *) voidLight;
+ RwV3d vertToLight;
+ RwReal scale;
+ RwReal dot;
+ RwFrame *lightFrame;
+
+ RWFUNCTION(RWSTRING("_rwApplyDirectionalLight"));
+ RWASSERT(light);
+ RWASSERT(surfaceProps);
+
+ OBJCAMVERTINIT();
+ NUMVERTINIT();
+
+ /* rpLIGHTDIRECTIONAL - Lighting scaled by dot product
+ * of vertex normal and light lookAt vector.
+ */
+ /* This may not have a frame - we need to check */
+ lightFrame = RpLightGetFrame(light);
+ if (lightFrame)
+ {
+ vertToLight = RwFrameGetLTM(lightFrame)->at;
+
+ /* Transform the light into object space if necessary */
+ if (inverseMat)
+ {
+ RwV3dTransformVectors(&vertToLight, &vertToLight, 1, inverseMat);
+ _rwV3dNormalize(&vertToLight, &vertToLight);
+ }
+
+ /* Vert TO light */
+ RwV3dScale(&vertToLight, &vertToLight, -1);
+
+ /* Optimise for grey lights? */
+ if (rwObjectTestPrivateFlags(light, rpLIGHTPRIVATENOCHROMA))
+ {
+ /* Use one of the light colour intensities as general intensity */
+ /* light vector tests are to be identical to others */
+ scale = 255.0f * light->color.red * surfaceProps->diffuse;
+
+ /* Loop through each of the vertices */
+ while (numVert--)
+ {
+ RwV3d objNormal;
+
+ OBJVERTGETNORMAL(&objNormal);
+ /* Calculate angle between vertex normal and light vector */
+ dot = RwV3dDotProduct(&vertToLight, &objNormal);
+
+ /* Ensure vector is facing light,
+ * don't light areas not facing */
+
+ if (dot > 0.0f)
+ {
+ RwReal lum = dot * scale;
+
+#undef FALLOFFCALC
+#define FALLOFFCALC FALLOFFDIRECTIONAL
+ CAMVERTADDRGBA(1, 1, 1, 0);
+ }
+
+ /* Next vertex */
+ OBJCAMVERTINC();
+ }
+ }
+ else
+ /* perform for coloured lights */
+ {
+ scale = 255.0f * surfaceProps->diffuse;
+
+ /* Loop through each of the vertices */
+ while (numVert--)
+ {
+ RwV3d objNormal;
+
+ OBJVERTGETNORMAL(&objNormal);
+ /* Calculate angle between vertex normal and light vector */
+ dot = RwV3dDotProduct(&vertToLight, &objNormal);
+
+ /* Ensure vector is facing light,
+ * don't light areas not facing */
+
+ if (dot > 0.0f)
+ {
+ RwReal lum = dot * scale;
+
+#define FALLOFFCALC FALLOFFDIRECTIONAL
+ CAMVERTADDRGBA(light->color.red, light->color.green,
+ light->color.blue, 0);
+ }
+
+ /* Next vertex */
+ OBJCAMVERTINC();
+ }
+ }
+ }
+
+ RWRETURNVOID();
+}
+
+/***************************************************************************
+ _rwApplyPointLight
+
+ On entry : Instanced data
+ : Light
+ : Optional inverse object matrix
+ : (to transform light to object space)
+ : Inverse scale of object
+ : Surface properties of the light
+ On exit :
+ */
+
+static void
+_rwApplyPointLight(VERTSARG, const void *voidLight,
+ const RwMatrix * inverseMat,
+ RwReal invScale, const RwSurfaceProperties * surfaceProps)
+{
+ OBJCAMVERTDECL;
+ NUMVERTDECL;
+ const RpLight *light = (const RpLight *) voidLight;
+ RwReal scale, recipRad;
+ RwV3d lightPos, vertToLight;
+ RwReal radSquared;
+
+ RWFUNCTION(RWSTRING("_rwApplyPointLight"));
+ RWASSERT(light);
+ RWASSERT(surfaceProps);
+
+ OBJCAMVERTINIT();
+ NUMVERTINIT();
+
+ /* rpLIGHTPOINT - Linear falloff with distance, scaled by
+ * dot product of vertex normal and light to vertex vector.
+ */
+ lightPos = RwFrameGetLTM(RpLightGetFrame(light))->pos;
+
+ if (inverseMat)
+ {
+ RwReal scaledRad;
+
+ scaledRad = ((light->radius) * (invScale));
+ radSquared = ((scaledRad) * (scaledRad));
+ recipRad = (((RwReal) (1)) / (scaledRad));
+
+ /* Transform light into object space */
+ RwV3dTransformPoints(&lightPos, &lightPos, 1, inverseMat);
+ }
+ else
+ {
+ radSquared = ((light->radius) * (light->radius));
+ recipRad = (((RwReal) (1)) / (light->radius));
+ }
+
+ if (rwObjectTestPrivateFlags(light, rpLIGHTPRIVATENOCHROMA))
+ {
+ /* The scale encapsulates the common elements to do
+ * with light intensity and surface lighting properties
+ */
+ scale =
+ ((((RwReal) (255)) * (light->color.red))) *
+ (surfaceProps->diffuse);
+
+ while (numVert--)
+ {
+ RwV3d objVertex, objNormal;
+ RwReal dot, dist2;
+
+ OBJVERTGETPOS(&objVertex);
+ OBJVERTGETNORMAL(&objNormal);
+
+ /* Discover the vector between vertex and light and it's length */
+ RwV3dSub(&vertToLight, &lightPos, &objVertex);
+
+ /* Ensure that this vertex is facing the light source */
+ dot = RwV3dDotProduct(&vertToLight, &objNormal);
+ if (dot > 0.0f)
+ {
+ /* Ensure vertex lies within the light's radius */
+ dist2 = RwV3dDotProduct(&vertToLight, &vertToLight);
+ if (dist2 < radSquared)
+ {
+ RwReal lum;
+ RwReal recipDist;
+ RwReal dist;
+
+ rwSqrt(&dist, dist2);
+ recipDist =
+ (dist > 0.0f) ? (((RwReal) 1) / dist) : 0.0f;
+
+ /*
+ * The following simplifies down to:
+ *
+ * -scale *
+ * (dot/dist) *
+ * (1 - dist/lightRadius)
+ *
+ * Where
+ * scale
+ * takes care of the light intensity and
+ * diffuse lighting coefficient
+ * (dot/dist)
+ * is a normalised dot product of
+ * light->vertex vector and vertex normal
+ * (1 - dist/lightRadius)
+ * is a linear falloff factor
+ */
+ lum = scale * dot * (recipDist - recipRad);
+
+ /* Calculate the luminance at vertex */
+#undef FALLOFFCALC
+#define FALLOFFCALC FALLOFFPOINT
+ CAMVERTADDRGBA(1, 1, 1, 0);
+ }
+ }
+
+ OBJCAMVERTINC();
+ }
+ }
+ else
+ {
+ scale = (((RwReal) (255)) * (surfaceProps->diffuse));
+
+ while (numVert--)
+ {
+ RwV3d objVertex, objNormal;
+ RwReal dot, dist2;
+
+ OBJVERTGETPOS(&objVertex);
+ OBJVERTGETNORMAL(&objNormal);
+
+ /* Discover the vector between vertex and light and it's length */
+ RwV3dSub(&vertToLight, &lightPos, &objVertex);
+
+ /* Ensure that this vertex is facing the light source */
+ dot = RwV3dDotProduct(&vertToLight, &objNormal);
+ if (dot > 0.0f)
+ {
+ dist2 = RwV3dDotProduct(&vertToLight, &vertToLight);
+
+ /* Ensure vertex lies within the light's radius */
+ if (dist2 < radSquared)
+ {
+ RwReal lum;
+ RwReal recipDist;
+ RwReal dist;
+
+ /* Only now calculate the actual length of vector */
+ rwSqrt(&dist, dist2);
+ recipDist =
+ (dist > 0.0f) ? (((RwReal) 1) / dist) : 0.0f;
+
+ lum = scale * dot * (recipDist - recipRad);
+ /* Alter the luminance according to light colour */
+#define FALLOFFCALC FALLOFFPOINT
+ CAMVERTADDRGBA(light->color.red, light->color.green,
+ light->color.blue, 0);
+ }
+ }
+
+ /* Next point */
+ OBJCAMVERTINC();
+ }
+ }
+ RWRETURNVOID();
+}
+
+/***************************************************************************
+ _rwApplySpotLight
+
+ On entry : Instanced data
+ : Light
+ : Optional inverse object matrix
+ : (to transform light to object space)
+ : Inverse scale of object
+ : Surface properties of the light
+ On exit :
+ */
+
+static void
+_rwApplySpotLight(VERTSARG,
+ const void *voidLight,
+ const RwMatrix * inverseMat,
+ RwReal invScale, const RwSurfaceProperties * surfaceProps)
+{
+ OBJCAMVERTDECL;
+ NUMVERTDECL;
+ const RpLight *light = (const RpLight *) voidLight;
+ RwReal recipRad;
+ RwReal radSquared;
+ RwV3d lightPos, at;
+
+ RWFUNCTION(RWSTRING("_rwApplySpotLight"));
+ RWASSERT(light);
+ RWASSERT(surfaceProps);
+
+ OBJCAMVERTINIT();
+ NUMVERTINIT();
+
+ /* rpLIGHTSPOT - Linear falloff with distance, cone to restrict
+ * angle that light has effect, constant intensity across cone,
+ * scaled by dot product of vertex normal and light to vertex vector.
+ */
+
+ lightPos = RwFrameGetLTM(RpLightGetFrame(light))->pos;
+ at = RwFrameGetLTM(RpLightGetFrame(light))->at;
+
+ if (inverseMat)
+ {
+ RwReal scaledRad;
+
+ scaledRad = ((light->radius) * (invScale));
+ recipRad = (((RwReal) (1)) / (scaledRad));
+ radSquared = ((scaledRad) * (scaledRad));
+
+ /* Transform light into object space */
+ /* The at is required to ensure within cone */
+ RwV3dTransformPoints(&lightPos, &lightPos, 1, inverseMat);
+ RwV3dTransformVectors(&at, &at, 1, inverseMat);
+ _rwV3dNormalize(&at, &at);
+ }
+ else
+ {
+ recipRad = (((RwReal) (1)) / (light->radius));
+ radSquared = ((light->radius) * (light->radius));
+ }
+
+ if (rwObjectTestPrivateFlags(light, rpLIGHTPRIVATENOCHROMA))
+ {
+ RwReal scale =
+
+ ((RwReal) 255) * (light->color.red) * (surfaceProps->diffuse);
+
+ while (numVert--)
+ {
+ RwV3d vertToLight, objVertex, objNormal;
+ RwReal dot;
+
+ OBJVERTGETPOS(&objVertex);
+ OBJVERTGETNORMAL(&objNormal);
+
+ /* Find the squared distance from light point to vertex */
+ RwV3dSub(&vertToLight, &lightPos, &objVertex);
+
+ /* Ensure that this vertex is facing the light source */
+ dot = RwV3dDotProduct(&vertToLight, &objNormal);
+ if (dot > 0.0f)
+ {
+ RwReal dist2;
+
+ /* Ensure vertex lies within the light's radius */
+ dist2 = RwV3dDotProduct(&vertToLight, &vertToLight);
+ if (dist2 < radSquared)
+ {
+ RwReal dist;
+ RwReal compare;
+ RwReal proj;
+
+ rwSqrt(&dist, dist2);
+ compare = dist * light->minusCosAngle;
+ proj = RwV3dDotProduct(&vertToLight, &at);
+
+ if (proj < compare)
+ {
+ RwReal lum;
+ RwReal recipDist;
+
+ /* Get the real distance from the light
+ * to the vertex (not squared) */
+ recipDist =
+ (dist > 0.0f) ? (((RwReal) 1) / dist) : 0.0f;
+
+ /* This model is the same as the point source
+ * inside the cone, zero outside the cone */
+ lum = scale * dot * (recipDist - recipRad);
+#undef FALLOFFCALC
+#define FALLOFFCALC FALLOFFSPOT
+ CAMVERTADDRGBA(1, 1, 1, 0);
+ }
+ }
+ /* Next vertex */
+ OBJCAMVERTINC();
+ }
+ }
+ }
+ else
+ {
+ RwReal scale =
+
+ (((RwReal) (255)) * (surfaceProps->diffuse));
+
+ while (numVert--)
+ {
+ RwV3d vertToLight, objVertex, objNormal;
+ RwReal dot;
+
+ OBJVERTGETPOS(&objVertex);
+ OBJVERTGETNORMAL(&objNormal);
+
+ /* Find the squared distance from light point to vertex */
+ RwV3dSub(&vertToLight, &lightPos, &objVertex);
+
+ /* Ensure that this vertex is facing the light source */
+ dot = RwV3dDotProduct(&vertToLight, &objNormal);
+ if (dot > 0.0f)
+ {
+ RwReal dist2;
+
+ /* Ensure vertex lies within the light's radius */
+ dist2 = RwV3dDotProduct(&vertToLight, &vertToLight);
+ if (dist2 < radSquared)
+ {
+ RwReal dist;
+ RwReal compare;
+ RwReal proj;
+
+ rwSqrt(&dist, dist2);
+ compare = dist * light->minusCosAngle;
+ proj = RwV3dDotProduct(&vertToLight, &at);
+
+ if (proj < compare)
+ {
+ RwReal lum;
+ RwReal recipDist;
+
+ recipDist =
+ (dist > 0.0f) ? (((RwReal) 1) / dist) : 0.0f;
+
+ /* This model is the same as the point source
+ * inside the cone, zero outside the cone */
+ lum = scale * dot * (recipDist - recipRad);
+
+ /* Introduce the light colours as a
+ * scaling factor for luminance */
+#define FALLOFFCALC FALLOFFSPOT
+ CAMVERTADDRGBA(light->color.red,
+ light->color.green, light->color.blue,
+ 0);
+ }
+ }
+ }
+
+ /* Next */
+ OBJCAMVERTINC();
+ }
+ }
+
+ RWRETURNVOID();
+}
+
+/***************************************************************************
+ _rwApplySpotSoftLight
+
+ On entry : Instanced data
+ : Light
+ : Optional inverse object matrix
+ : (to transform light to object space)
+ : Inverse scale of object
+ : Surface properties of the light
+ On exit :
+ */
+
+static void
+_rwApplySpotSoftLight(VERTSARG, const void *voidLight,
+ const RwMatrix * inverseMat, RwReal invScale,
+ const RwSurfaceProperties * surfaceProps)
+{
+ OBJCAMVERTDECL;
+ NUMVERTDECL;
+ const RpLight *light = (const RpLight *) voidLight;
+ RwReal recipRad;
+ RwReal radSquared;
+ RwV3d lightPos, at;
+
+ RWFUNCTION(RWSTRING("_rwApplySpotSoftLight"));
+ RWASSERT(light);
+ RWASSERT(surfaceProps);
+
+ OBJCAMVERTINIT();
+ NUMVERTINIT();
+
+ /* rpLIGHTSPOTSOFT - Linear falloff with distance, cone to restrict
+ * angle that light has effect, falloff to edge of cone, scaled by
+ * dot product of vertex normal and light to vertex vector.
+ */
+
+ lightPos = RwFrameGetLTM(RpLightGetFrame(light))->pos;
+ at = RwFrameGetLTM(RpLightGetFrame(light))->at;
+
+ if (inverseMat)
+ {
+ RwReal scaledRad;
+
+ scaledRad = ((light->radius) * (invScale));
+ recipRad = (((RwReal) (1)) / (scaledRad));
+ radSquared = ((scaledRad) * (scaledRad));
+
+ /* Transform light into object space */
+ /* The at is required to ensure within cone */
+ RwV3dTransformPoints(&lightPos, &lightPos, 1, inverseMat);
+ RwV3dTransformVectors(&at, &at, 1, inverseMat);
+ _rwV3dNormalize(&at, &at);
+ }
+ else
+ {
+ recipRad = 1.0f / light->radius;
+ radSquared = light->radius * light->radius;
+ }
+
+ if (rwObjectTestPrivateFlags(light, rpLIGHTPRIVATENOCHROMA))
+ {
+ RwReal scale =
+
+ ((RwReal) 255) * (light->color.red) * (surfaceProps->diffuse);
+
+ while (numVert--)
+ {
+ RwV3d vertToLight, objVertex, objNormal;
+ RwReal dot;
+
+ OBJVERTGETPOS(&objVertex);
+ OBJVERTGETNORMAL(&objNormal);
+
+ /* Find the squared distance from light point to vertex */
+ RwV3dSub(&vertToLight, &lightPos, &objVertex);
+
+ /* Ensure that this vertex is facing the light source */
+ dot = RwV3dDotProduct(&vertToLight, &objNormal);
+ if (dot > 0.0f)
+ {
+ RwReal dist2;
+
+ /* Ensure vertex lies within the light's radius */
+ dist2 = RwV3dDotProduct(&vertToLight, &vertToLight);
+ if (dist2 < radSquared)
+ {
+ RwReal dist;
+ RwReal compare;
+ RwReal proj;
+
+ rwSqrt(&dist, dist2);
+ compare = dist * light->minusCosAngle;
+ proj = RwV3dDotProduct(&vertToLight, &at);
+
+ if (proj < compare)
+ {
+ RwReal lum;
+ RwReal recipDist;
+ RwReal normalise;
+
+ recipDist =
+ (dist > 0.0f) ? (((RwReal) 1) / dist) : 0.0f;
+
+ /* This model is the same as the point source
+ * inside the cone, zero outside the cone */
+ lum = scale * dot * (recipDist - recipRad);
+
+ /* It has an extra term for quadratic falloff
+ * across the cone though */
+ normalise = (dist + compare);
+ RWASSERT(normalise >= 0.0f);
+ if (normalise > 0.0f)
+ {
+ normalise = (dist + proj) / normalise;
+
+ normalise *= normalise;
+ lum *= (((RwReal) 1) - normalise);
+ }
+
+#undef FALLOFFCALC
+#define FALLOFFCALC FALLOFFSOFTSPOT
+ CAMVERTADDRGBA(1, 1, 1, 0);
+ }
+ }
+ }
+
+ /* Next */
+ OBJCAMVERTINC();
+ }
+ }
+
+ else
+ {
+ RwReal scale = 255.0f * surfaceProps->diffuse;
+
+ while (numVert--)
+ {
+ RwV3d vertToLight, objVertex, objNormal;
+ RwReal dot;
+
+ OBJVERTGETPOS(&objVertex);
+ OBJVERTGETNORMAL(&objNormal);
+
+ /* Find the squared distance from light point to vertex */
+ RwV3dSub(&vertToLight, &lightPos, &objVertex);
+
+ /* Ensure that this vertex is facing the light source */
+ dot = RwV3dDotProduct(&vertToLight, &objNormal);
+ if (dot > 0.0f)
+ {
+ RwReal dist2;
+
+ /* Ensure vertex lies within the light's radius */
+ dist2 = RwV3dDotProduct(&vertToLight, &vertToLight);
+ if (dist2 < radSquared)
+ {
+ RwReal dist;
+ RwReal compare;
+ RwReal proj;
+
+ rwSqrt(&dist, dist2);
+ compare = dist * light->minusCosAngle;
+ proj = RwV3dDotProduct(&vertToLight, &at);
+
+ if (proj < compare)
+ {
+
+ RwReal lum;
+ RwReal normalise;
+ RwReal recipDist;
+
+ /* Get the real distance from the light
+ * to the vertex (not squared) */
+ recipDist =
+ (dist > 0.0f) ? (((RwReal) 1) / dist) : 0.0f;
+
+ /* This model is the same as the point source
+ * inside the cone, zero outside the cone */
+ lum = scale * dot * (recipDist - recipRad);
+
+ /* It has an extra term for quadratic falloff
+ * across the cone though */
+ /* It has an extra term for quadratic falloff
+ * across the cone though */
+ normalise = (dist + compare);
+ RWASSERT(normalise >= 0.0f);
+ if (normalise > 0.0f)
+ {
+ normalise = (dist + proj) / normalise;
+
+ normalise *= normalise;
+ lum *= (((RwReal) 1) - normalise);
+
+ }
+ /* Introduce the light colours as a
+ * scaling factor for luminance */
+#undef FALLOFFCALC
+#define FALLOFFCALC FALLOFFSOFTSPOT
+ CAMVERTADDRGBA(light->color.red,
+ light->color.green,
+ light->color.blue, 0);
+ }
+ }
+ }
+
+ /* Next */
+ OBJCAMVERTINC();
+ }
+ }
+
+ RWRETURNVOID();
+}
diff --git a/rwsdk/include/d3d8/errcom.def b/rwsdk/include/d3d8/errcom.def
new file mode 100644
index 00000000..25f44e1e
--- /dev/null
+++ b/rwsdk/include/d3d8/errcom.def
@@ -0,0 +1,60 @@
+RWECODE(E_RW_BADENGINESTATE,
+ "Engine in incorrect state for this operation")
+RWECODE(E_RW_BADOPEN,
+ "Error opening the file %s")
+RWECODE(E_RW_BADPARAM,
+ "Invalid Parameter passed. %s")
+RWECODE(E_RW_BADVERSION,
+ "The binary file format version is incompatible with this library")
+RWECODE(E_RW_DEBUGSTACK,
+ "Debug Library has Stack Depth mismatch")
+RWECODE(E_RW_DEFAULTPIPELINECREATION,
+ "Creation of a default pipeline (%s) failed")
+RWECODE(E_RW_FRAMENOMATRIX,
+ "The frame does not have an associated matrix")
+RWECODE(E_RW_INVIMAGEDEPTH,
+ "Invalid Image Depth")
+RWECODE(E_RW_INVIMAGEFORMAT,
+ "Image has no pixel memory allocated")
+RWECODE(E_RW_INVIMAGEMASK,
+ "The mask and image are not the same size")
+RWECODE(E_RW_INVIMAGESIZE,
+ "Destination and source images are of differing sizes")
+RWECODE(E_RW_INVRASTERDEPTH,
+ "Invalid Raster depth")
+RWECODE(E_RW_INVRASTERFORMAT,
+ "Unrecognized raster format")
+RWECODE(E_RW_INVRASTERLOCKREQ,
+ "Invalid Raster lock request")
+RWECODE(E_RW_INVRASTERMIPLEVEL,
+ "Invalid Raster mipmap level")
+RWECODE(E_RW_INVRASTERSIZE,
+ "Invalid Raster size")
+RWECODE(E_RW_INVRASTERUNLOCKREQ,
+ "Invalid Raster unlock request")
+RWECODE(E_RW_NOFRAME,
+ "Unable to find Frame")
+RWECODE(E_RW_NOMEM,
+ "Unable to allocate %d bytes of memory")
+RWECODE(E_RW_NOMIPMAPGENERATIONCALLBACK,
+ "No Mipmap generation callback set - use RtMipmapUseDefaultMipmapGenerationCallback")
+RWECODE(E_RW_NOTSSEENABLEDCPU,
+ "Not SSE enabled CPU")
+RWECODE(E_RW_NULLP,
+ "NULL pointer passed to library routine")
+RWECODE(E_RW_PLUGININIT,
+ "Plugin has already been initialized")
+RWECODE(E_RW_PLUGINNOTINIT,
+ "Plugin not initialized")
+RWECODE(E_RW_RANGE,
+ "A supplied parameter was outside the expected range")
+RWECODE(E_RW_READ,
+ "Read error on stream")
+RWECODE(E_RW_REDUNDANT_FUNCTION,
+ "Call to redundant function - scheduled to be dropped from future releases")
+RWECODE(E_RW_WRITE,
+ "Write error on stream")
+RWECODE(E_RX_MESHES_RANGES_OVERLAP,
+ "\n Geometry is in an invalid format for RxPipeline rendering.\n There may be visible artifacts and/or decreased performance.\n Use RpGeometrySortByMaterial.\n [stream %p type %s]")
+RWECODE(E_RW_STRING_TRUNCATION,
+ "strlen(%s) >= %d; truncating at character #%d == %c")
diff --git a/rwsdk/include/d3d8/errcore.def b/rwsdk/include/d3d8/errcore.def
new file mode 100644
index 00000000..c71eed5a
--- /dev/null
+++ b/rwsdk/include/d3d8/errcore.def
@@ -0,0 +1,117 @@
+RWECODE(E_RW_BADWINDOW,
+ "Invalid view window dimensions supplied")
+RWECODE(E_RW_CHUNKTYPEGET,
+ "Unable to get a chunk of the given type")
+RWECODE(E_RW_DEVICEERROR,
+ "Device specific error: %s")
+RWECODE(E_RW_DEVICEOPEN,
+ "Request to open device system refused")
+RWECODE(E_RW_DEVICESTART,
+ "Attempt to start Device failed")
+RWECODE(E_RW_ENDOFSTREAM,
+ "At the end of the stream.")
+RWECODE(E_RW_FRAMEDESTROYSTATIC,
+ "RwFrameDestroy called on static frame.")
+RWECODE(E_RW_FRAMEBUFFERMISMATCH,
+ "Resolutions of parent rasters of frame buffer and Z buffer are different")
+RWECODE(E_RW_FREELISTFREED,
+ "Free List value already on the free list")
+RWECODE(E_RW_FREELISTINVADDRESS,
+ "Invalid Free List memory address")
+RWECODE(E_RW_FREELISTINVMEMBOUND,
+ "Invalid Free List memory boundary")
+RWECODE(E_RW_FREELISTTRASH,
+ "An unused Free List entry has been overwritten")
+RWECODE(E_RW_INSUFFICIENTRESOURCES,
+ "Insufficient resources to satisfy the allocation of %d bytes.")
+RWECODE(E_RW_INVSTREAMACCESSTYPE,
+ "Invalid stream access type.")
+RWECODE(E_RW_INVSTREAMTYPE,
+ "Invalid stream type.")
+RWECODE(E_RW_NEGCLIPPLANE,
+ "Negative positioned clip planes are invalid")
+RWECODE(E_RW_NOCAMERA,
+ "Cannot render until a Camera has been created")
+RWECODE(E_RW_NOFRAMEBUFFER,
+ "Camera has no frame buffer raster")
+RWECODE(E_RW_NOPARENT,
+ "The given object has no parent")
+RWECODE(E_RW_RASTERRECT,
+ "Rectangle is not totally within Raster")
+RWECODE(E_RW_RASTERSTACK,
+ "Insufficient Raster stack space available")
+RWECODE(E_RW_RASTERSTACKEMPTY,
+ "No Raster Currently on Stack")
+RWECODE(E_RW_READTEXMASK,
+ "Unable to read Texture %s / Mask %s")
+RWECODE(E_RW_STREAMOPEN,
+ "Unable to open stream : %s")
+RWECODE(E_RW_SYSTEMREQUEST,
+ "A system request call has failed, request code : 0x%x")
+RWECODE(E_RW_ZEROLENGTH,
+ "A Vector of Zero Length was passed for normalizing")
+RWECODE(E_RX_CANNOT_TRANSFER_BETWEEN_NODES,
+ "Node %s cannot output to node %s")
+RWECODE(E_RX_CANNOT_TRANSFER_FROM_NODE_TO_PIPELINE,
+ "Node %s cannot output to specified pipeline")
+RWECODE(E_RX_CYCLICPIPELINE,
+ "Pipeline contains cycles; illegal")
+RWECODE(E_RX_DEP_DEPENDENCIESMISMATCH,
+ "\n"
+ "*** dependencies cannot be satisfied.\n"
+ "*** rxCLREQ_REQUIRED on cluster %s, originating\n"
+ "*** with node %s, not serviced by a rxCLVALID_VALID -\n"
+ "*** blocked at node %s, output #%ld (\"%s\").")
+RWECODE(E_RX_DEP_DUPLICATECLUSTERDEFS,
+ "\n"
+ "*** Node %s specifies RxClusterDefinition for cluster %s more than once in\n"
+ "*** clusters of interest array. Distinct clusters within a pipeline must reference\n"
+ "*** distinct RxClusterDefinitions, even if the clusters contain the same data type\n")
+RWECODE(E_RX_DEP_NULLCLUSTERDEF,
+ "Node %s specified with RxClusterDefinition pointer NULL for cluster of interest %d\n")
+RWECODE(E_RX_DEP_OUTOFMEMORY,
+ "Dependency chasing; memory alloc failed")
+RWECODE(E_RX_EMPTYPIPELINE,
+ "RwPipeline2Execute cannot execute a pipeline with no nodes :)")
+RWECODE(E_RX_FRAGMENTEDPIPELINE,
+ "Pipeline forms two or more unconnected graphs; illegal")
+RWECODE(E_RX_IM3DNOTACTIVE,
+ "Cannot render Im3D primitives outside of a RwIm3dTransform()/RwIm3dEnd() pair")
+RWECODE(E_RX_INVALIDENTRYPOINT,
+ "Pipeline has an invalid entry point")
+RWECODE(E_RX_INVALIDPRIMTYPE,
+ "Unknown primitive type %d")
+RWECODE(E_RX_INVALIDRESUMEPIPELINE,
+ "RwPipeline2Execute cannot resume a different pipeline to the one previously interrupted")
+RWECODE(E_RX_LOCKEDPIPE,
+ "Illegal operation on a locked pipeline")
+RWECODE(E_RX_NODETOOMANYCLUSTERSOFINTEREST,
+ "Node contains more than RXNODEMAXCLUSTERSOFINTEREST clusters of interest; illegal")
+RWECODE(E_RX_NODETOOMANYOUTPUTS,
+ "Node contains more than RXNODEMAXOUTPUTS outputs; illegal")
+RWECODE(E_RX_PIPELINETOOMANYNODES,
+ "Maximum nodes per pipeline exceeded! You may increase the limit by changing the value of _rxPipelineMaxNodes BEFORE starting RenderWare")
+RWECODE(E_RX_NODE_EXECUTION_FAILED,
+ "Node execution failed - %s")
+RWECODE(E_RX_NOVERTS,
+ "Cannot render Im3D primitive - not enough vertices transformed")
+RWECODE(E_RX_PACKETPTRINVALID,
+ "Value of input/output interruption packets pointer not as expected")
+RWECODE(E_RX_PACKETSCOPYFAILED,
+ "Failed to make copies of packets input to RxPipelineExecute()")
+RWECODE(E_RX_RUNFROMNOTVALID,
+ "RunFrom node not a member of the specified pipeline")
+RWECODE(E_RX_RUNTOANDRUNFROM,
+ "RwPipeline2Execute cannot accept both RunTo *and* RunFrom")
+RWECODE(E_RX_RUNTONOTVALID,
+ "RunTo node not a member of the specified pipeline")
+RWECODE(E_RX_TOOMANYVERTS,
+ "More than 65536 vertices passed to RwIm3DTransform; illegal")
+RWECODE(E_RX_UNFINISHEDPIPELINE,
+ "RwPipeline2Execute must resume and finish an interrupted pipeline")
+RWECODE(E_RX_UNLOCKEDPIPE,
+ "Illegal operation on an unlocked pipeline")
+RWECODE(E_RX_UNPROCESSED_PACKETS,
+ "Unprocessed packets found in finished execution context")
+RWECODE(E_RX_UNSATISFIED_REQUIREMENTS,
+ "Cannot send packet between pipelines, requirements not satisfied. Cluster '%s' is missing")
diff --git a/rwsdk/include/d3d8/rpanisot.h b/rwsdk/include/d3d8/rpanisot.h
new file mode 100644
index 00000000..4f4445a4
--- /dev/null
+++ b/rwsdk/include/d3d8/rpanisot.h
@@ -0,0 +1,54 @@
+/**
+ * Anisotropic Texture Sampling Plugin for RenderWare.
+ */
+
+#ifndef RPANISOTPLUGIN_H
+#define RPANISOTPLUGIN_H
+
+/**
+ * \defgroup rpanisot RpAnisot
+ * \ingroup rpplugin
+ *
+ * Anisotropic Texture Sampling Plugin for RenderWare Graphics.
+ */
+
+/**
+ * \ingroup rpanisot
+ * \page rpanisotoverview RpAnisot Plugin Overview
+ *
+ * \par Requirements
+ * \li \b Headers: rwcore.h, rpworld.h, rpanisot.h
+ * \li \b Libraries: rwcore, rpworld, rpanisot
+ * \li \b Plugin \b attachments: \ref RpWorldPluginAttach, \ref RpAnisotPluginAttach
+ *
+ * \subsection anisotoverview Overview
+ * The RpAnisot plugin is used to extend an RwTexture with a maximum
+ * anisotropy value that will be used when a particular texture is drawn.
+ * When textured polygons are viewed nearly edge on, for example when looking
+ * dowm a road or a football pitch, distant pixels are not sampled very well
+ * by trilinear mipmapping and the texture looks smeary.
+ * Anisotropic sampling takes additional samples, resulting in sharper looking
+ * textures. Higher numbers of samples will produce better quality results but
+ * run slower, so should be used in moderation.
+ *
+ */
+
+#include <rwcore.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern RwInt8 RpAnisotGetMaxSupportedMaxAnisotropy(void);
+
+extern RwTexture *RpAnisotTextureSetMaxAnisotropy(RwTexture *tex, RwInt8 val);
+extern RwInt8 RpAnisotTextureGetMaxAnisotropy(RwTexture *tex);
+
+extern RwBool RpAnisotPluginAttach(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RPANISOTPLUGIN_H */
diff --git a/rwsdk/include/d3d8/rpanisot.rpe b/rwsdk/include/d3d8/rpanisot.rpe
new file mode 100644
index 00000000..5216ec9c
--- /dev/null
+++ b/rwsdk/include/d3d8/rpanisot.rpe
@@ -0,0 +1,639 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionLabel
+{
+
+
+
+ e_rwdb_CriterionLabelLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionLabel e_rwdb_CriterionLabel;
+
+
diff --git a/rwsdk/include/d3d8/rpcollis.h b/rwsdk/include/d3d8/rpcollis.h
new file mode 100644
index 00000000..908fb68e
--- /dev/null
+++ b/rwsdk/include/d3d8/rpcollis.h
@@ -0,0 +1,372 @@
+
+/*****************************************************************************
+ *
+ * File : rpcollis.h
+ *
+ * Abstract : World collision plugin for Renderware.
+ *
+ *****************************************************************************
+ *
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd. or
+ * Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. will not, under any
+ * circumstances, be liable for any lost revenue or other damages arising
+ * from the use of this file.
+ *
+ * Copyright (c) 2000 Criterion Software Ltd.
+ * All Rights Reserved.
+ *
+ * RenderWare is a trademark of Canon Inc.
+ *
+ *****************************************************************************/
+
+#ifndef RPCOLLIS_H
+#define RPCOLLIS_H
+
+/* Doxygen plugin groups. */
+
+/**
+ * \defgroup rpcollis RpCollision
+ * \ingroup rpplugin
+ *
+ * Collision Plugin for RenderWare Graphics.
+ */
+
+/******************************************************************************
+ * Include files
+ */
+
+#include <rwcore.h>
+#include <rpworld.h>
+
+#include "rpcollis.rpe" /* automatically generated header file */
+
+/******************************************************************************
+ * Global Types
+ */
+
+/**
+ * \ingroup rpcollis
+ * RpIntersectType, this type represents the different types of
+ * primitives that can be used to intersect with an object (for example, see
+ * \ref RpCollisionWorldForAllIntersections):
+ */
+enum RpIntersectType
+{
+ rpINTERSECTNONE = 0,
+ rpINTERSECTLINE, /**<Line Intersection */
+ rpINTERSECTPOINT, /**<Point Intersection */
+ rpINTERSECTSPHERE, /**<Sphere Intersection */
+ rpINTERSECTBOX, /**<Box intersection */
+ rpINTERSECTATOMIC, /**<Atomic Intersection based on bounding sphere */
+ rpINTERSECTTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpIntersectType RpIntersectType;
+
+/**
+ * \ingroup rpcollis
+ * RpIntersectData, this union type is used to specify the parameters
+ * for an intersection primitive of the desired type (\ref RpIntersectType)
+ */
+typedef union RpIntersectData RpIntersectData;
+union RpIntersectData
+{
+ RwLine line; /**<For type rpINTERSECTLINE */
+ RwV3d point; /**<For type rpINTERSECTPOINT */
+ RwSphere sphere; /**<For type rpINTERSECTSPHERE */
+ RwBBox box; /**<For type rpINTERSECTBOX */
+ void *object; /**<For type rpINTERSECTATOMIC - this
+ * should hold a pointer to the atomic */
+};
+
+typedef struct RpIntersection RpIntersection;
+/**
+ * \ingroup rpcollis
+ * \struct RpIntersection
+ * Intersection Object. This type represents data for an
+ * intersection primitive. It specifies the intersection type
+ * (line, sphere, etc.) (type) and parameters describing the given type (t):
+ */
+struct RpIntersection
+{
+ RpIntersectData t; /**< Intersection data. Union type - one
+ * of line, point, sphere or RW object */
+ RpIntersectType type; /**< Intersection type - see
+ * \ref RpIntersectType */
+};
+
+typedef struct RpCollisionTriangle RpCollisionTriangle;
+/**
+ * \ingroup rpcollis
+ * \struct RpCollisionTriangle
+ * A structure representing a collision between
+ * an \ref RpIntersection primitive and a triangle.
+ * The collision is specified by the triangle's plane normal
+ * (normal), the first triangle vertex (point), an index to the triangle in
+ * the object geometry's triangle list (index) and the positions of the
+ * triangle's vertices (vertices). Note all vector components are in object
+ * space.
+ *
+ * \see RpCollisionWorldForAllIntersections
+ * \see RpCollisionGeometryForAllIntersections
+ * \see RpAtomicForAllIntersections
+ * \see RpIntersectionCallBackWorldTriangle
+ * \see RpIntersectionCallBackGeometryTriangle
+ */
+struct RpCollisionTriangle
+{
+ RwV3d normal; /**< Triangle normal */
+ RwV3d point; /**< First triangle vertex */
+ RwInt32 index; /**< Index of triangle in object (if applicable) */
+ RwV3d *vertices[3]; /**< Pointers to three triangle vertices */
+};
+
+typedef struct RpCollisionBuildParam RpCollisionBuildParam;
+/**
+ * \ingroup rpcollis
+ * \struct RpCollisionBuildParam
+ * This structure is a place-holder for parameters that may be
+ * introduced in future to control the generation of collision data when using
+ * the functions \ref RpCollisionWorldSectorBuildData,
+ * \ref RpCollisionWorldBuildData or \ref RpCollisionGeometryBuildData.
+ * Currently, a NULL pointer should be passed to these functions, as no
+ * parameters are defined. If parameters are introduced, a NULL pointer will
+ * indicate that default values should be used.
+ */
+struct RpCollisionBuildParam
+{
+ RwInt32 dummy; /**< Not used */
+};
+
+/**
+ * \ingroup rpcollis
+ * \typedef RpIntersectionCallBackWorldTriangle
+ * \ref RpIntersectionCallBackWorldTriangle represents the function called
+ * from \ref RpCollisionWorldForAllIntersections for all intersections between
+ * the specified primitive and the static geometry in a given world. This
+ * function should return a pointer to the current collision triangle to
+ * indicate success. The callback may return NULL to terminate further
+ * callbacks on the world.
+ *
+ * \param intersection Pointer to the intersection primitive.
+ * \param sector Pointer to the world sector containing the triangle.
+ * \param collTriangle Pointer to the \ref RpCollisionTriangle representing
+ * the triangle in the world's static geometry that is intersected.
+ * \param distance The distance to the intersection point(s).
+ * Note that the distance returned depends on the intersection type and is
+ * normalized for the given intersection primitive.
+ * \li rpINTERSECTLINE Distance from start of line to collision
+ * triangle, normalized to length of line.
+ * \li rpINTERSECTSPHERE Distance of sphere's center from the collision
+ * triangle along the direction of the normal, and normalized
+ * to the sphere's radius (may be negative if the sphere center
+ * is behind the triangle's plane with respect to the direction
+ * of the normal).
+ * \li rpINTERSECTBOX Distance is undefined.
+ * \li rpINTERSECTATOMIC Distance of atomic's bounding-sphere center
+ * from the collision triangle along the direction of the normal
+ * and normalized to sphere's radius.
+ * \param data User defined data pointer
+ *
+ * \return Pointer to the current collision triangle.
+ */
+typedef RpCollisionTriangle *(*RpIntersectionCallBackWorldTriangle)
+ (RpIntersection * intersection,
+ RpWorldSector * sector,
+ RpCollisionTriangle * collTriangle, RwReal distance, void *data);
+
+/**
+ * \ingroup rpcollis
+ * \typedef RpIntersectionCallBackAtomic
+ * \ref RpIntersectionCallBackAtomic represents the function called from
+ * \ref RpWorldForAllAtomicIntersections for all intersections between the
+ * specified primitive and collision atomics in a given world. This function
+ * should return the current atomic to indicate success. The callback may
+ * return NULL to terminate further callbacks on the world.
+ *
+ * \param intersection Pointer to the intersection primitive.
+ * \param sector Pointer to the world sector containing
+ * the intersected triangles.
+ * \param atomic Pointer to the intersected atomic.
+ * \param distance The collision distance. The distance returned
+ * depends on the intersection type which is defined in \ref RpIntersectType.
+ * \li rpINTERSECTPOINT Distance of point from atomic's bounding
+ * sphere center, normalized to sphere's radius.
+ * \li rpINTERSECTLINE Distance of atomic's bounding-sphere center from
+ * start of line, projected onto the line, normalized to length of line.
+ * Note that by this definition, if the line starts or ends inside the
+ * sphere, this distance maybe negative or greater than one.
+ * \li rpINTERSECTSPHERE Distance of atomic's bounding-sphere center
+ * from sphere's center, normalized to sum of spheres' radii.
+ * \li rpINTERSECTBOX Distance undefined.
+ * \li rpINTERSECTATOMIC Distance between atomics' bounding-sphere
+ * centers, normalized to sum of spheres' radii.
+ * \param data User defined data pointer.
+ *
+ * \return Pointer to the current atomic.
+ */
+typedef RpAtomic *(*RpIntersectionCallBackAtomic)
+ (RpIntersection * intersection,
+ RpWorldSector * sector, RpAtomic * atomic, RwReal distance, void *data);
+
+/**
+ * \ingroup rpcollis
+ * \typedef RpIntersectionCallBackWorldSector
+ * \ref RpIntersectionCallBackWorldSector represents the function called from
+ * \ref RpWorldForAllWorldSectorIntersections for all intersections between the
+ * specified primitive and world sectors in a given world. This function should
+ * return the current world sector to indicate success. The callback may return
+ * NULL to terminate further callbacks on the world.
+ *
+ * \param intersection Pointer to the intersection primitive.
+ * \param sector Pointer to the world sector containing the intersected
+ * polygons.
+ * \param data User defined data pointer
+ *
+ * \return Pointer to the current world sector.
+ */
+typedef RpWorldSector *(*RpIntersectionCallBackWorldSector)
+ (RpIntersection * intersection, RpWorldSector * worldSector, void *data);
+
+/**
+ * \ingroup rpcollis
+ * \typedef RpIntersectionCallBackGeometryTriangle
+ * \ref RpIntersectionCallBackGeometryTriangle represents the function called
+ * from \ref RpAtomicForAllIntersections and
+ * \ref RpCollisionGeometryForAllIntersections
+ * for all intersections between the specified primitive and a given atomic.
+ * This function should return a pointer to the current collision triangle to
+ * indicate success. The callback may return NULL to terminate further
+ * callbacks on the atomic.
+ *
+ * Note that the vertices and normal of the collision triangle are given
+ * in the coordinate space of the geometry. If they are required in world
+ * coordinates, they must be transformed using \ref RwV3dTransformPoints and
+ * \ref RwV3dTransformVectors with the LTM of the atomic's frame. This must
+ * be passed via the user-defined data if required.
+ *
+ * \param intersection Pointer to the intersection primitive.
+ * \param collTri Pointer to the \ref RpCollisionTriangle
+ * representing the triangle in the atomic that is intersected.
+ * \param distance The distance to the intersection point(s).
+ * Note that the distance returned depends on the intersection type and is
+ * normalized for the given intersection primitive.
+ * \li rpINTERSECTLINE Distance from start of line to collision
+ * triangle, normalized to length of line.
+ * \li rpINTERSECTSPHERE Distance of sphere's center from the collision
+ * triangle along the direction of the normal, and normalized
+ * to the sphere's radius (may be negative if the sphere center
+ * is behind the triangle's plane with respect to the direction
+ * of the normal).
+ * \li rpINTERSECTATOMIC Distance of atomic's bounding-sphere center
+ * from the collision triangle along the direction of the normal, and
+ * normalized to sphere's radius.
+ * \param data User defined data pointer
+ *
+ * \return Pointer to the current collision triangle.
+ */
+typedef RpCollisionTriangle *(*RpIntersectionCallBackGeometryTriangle)
+ (RpIntersection *intersection, RpCollisionTriangle *collTriangle,
+ RwReal distance, void *data);
+
+
+/******************************************************************************
+ * Plugin API Functions
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Plugin attachment */
+extern RwBool
+RpCollisionPluginAttach(void);
+
+/* World collisions */
+extern RpWorldSector *
+RpCollisionWorldSectorBuildData(
+ RpWorldSector *worldSector,
+ RpCollisionBuildParam *param);
+
+extern RpWorldSector *
+RpCollisionWorldSectorDestroyData(
+ RpWorldSector *worldSector);
+
+extern RwBool
+RpCollisionWorldSectorQueryData(
+ RpWorldSector *worldSector);
+
+extern RpWorld *
+RpCollisionWorldBuildData(
+ RpWorld *world,
+ RpCollisionBuildParam *param);
+
+extern RpWorld *
+RpCollisionWorldDestroyData(
+ RpWorld *world);
+
+extern RwBool
+RpCollisionWorldQueryData(
+ RpWorld *world);
+
+
+extern RpWorld *
+RpWorldForAllWorldSectorIntersections(
+ RpWorld *world,
+ RpIntersection *intersection,
+ RpIntersectionCallBackWorldSector callBack,
+ void *data);
+
+extern RpWorld *
+RpWorldForAllAtomicIntersections(
+ RpWorld *world,
+ RpIntersection *intersection,
+ RpIntersectionCallBackAtomic callBack,
+ void *data);
+
+extern RpWorld *
+RpCollisionWorldForAllIntersections(
+ RpWorld *world,
+ RpIntersection *intersection,
+ RpIntersectionCallBackWorldTriangle callBack,
+ void *data);
+
+/* Geometry and atomic collisions */
+extern RpGeometry *
+RpCollisionGeometryBuildData(
+ RpGeometry *geometry,
+ RpCollisionBuildParam *param);
+
+extern RwBool
+RpCollisionGeometryQueryData(
+ RpGeometry *geometry);
+
+extern RpGeometry *
+RpCollisionGeometryDestroyData(
+ RpGeometry *geometry);
+
+extern RpGeometry *
+RpCollisionGeometryForAllIntersections(
+ RpGeometry *geometry,
+ RpIntersection *intersection,
+ RpIntersectionCallBackGeometryTriangle callBack,
+ void *data);
+
+extern RpAtomic *
+RpAtomicForAllIntersections(
+ RpAtomic *atomic,
+ RpIntersection *intersection,
+ RpIntersectionCallBackGeometryTriangle callBack,
+ void *data);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RPCOLLIS_H */
+
diff --git a/rwsdk/include/d3d8/rpcollis.rpe b/rwsdk/include/d3d8/rpcollis.rpe
new file mode 100644
index 00000000..3e891755
--- /dev/null
+++ b/rwsdk/include/d3d8/rpcollis.rpe
@@ -0,0 +1,637 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionCollis
+{
+
+E_RP_COLLIS_INV_INTERSECTION,
+
+ e_rwdb_CriterionCollisLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionCollis e_rwdb_CriterionCollis;
+
+
diff --git a/rwsdk/include/d3d8/rpcriter.h b/rwsdk/include/d3d8/rpcriter.h
new file mode 100644
index 00000000..c1af25b8
--- /dev/null
+++ b/rwsdk/include/d3d8/rpcriter.h
@@ -0,0 +1,572 @@
+/* Doxygen Core Library groups */
+
+/**
+ * \defgroup rwcore Core Library
+ *
+ * Core Library
+ */
+
+/**
+ * \defgroup datatypes Data Types
+ * \ingroup rwcore
+ *
+ * Basic Data Types
+ */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwbbox RwBBox
+ * \ingroup rwcore
+ *
+ * Bounding Box
+ */
+#endif /* RWPLCORE */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwcamera RwCamera
+ * \ingroup rwcore
+ *
+ * Cameras define how and what things can be seen. They also define the
+ * depth and width of the view by the use of clip-planes and the view
+ * window.
+ */
+#endif /* RWPLCORE */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwcameravertex RwCameraVertex
+ * \ingroup rwcore
+ *
+ * Camera space vertex data access
+ */
+#endif /* RWPLCORE */
+
+/**
+ * \defgroup rwdebug RwDebug
+ * \ingroup rwcore
+ *
+ * Debug handling
+ */
+
+/**
+ * \defgroup rwengine RwEngine
+ * \ingroup rwcore
+ *
+ * Device handling.
+ */
+
+/**
+ * \defgroup rwerror RwError
+ * \ingroup rwcore
+ *
+ * Error code handling
+ */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwframe RwFrame
+ * \ingroup rwcore
+ *
+ * Frames define relationships between objects and the world
+ */
+#endif /* RWPLCORE */
+
+/**
+ * \defgroup rwfreelist RwFreeList
+ * \ingroup rwcore
+ *
+ * Free lists
+ */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwimage RwImage
+ * \ingroup rwcore
+ *
+ * Image handling.
+ */
+#endif /* RWPLCORE */
+
+/**
+ * \defgroup rwim2d RwIm2D
+ * \ingroup rwcore
+ *
+ * 2D immediate mode support
+ */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwim2dcameravertex RwIm2DCameraVertex
+ * \ingroup rwcore
+ *
+ * 2D Camera space vertex data access
+ */
+#endif /* RWPLCORE */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwim2dvertex RwIm2DVertex
+ * \ingroup rwcore
+ *
+ * Im2D Vertex data access
+ */
+#endif /* RWPLCORE */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwim3d RwIm3D
+ * \ingroup rwcore
+ *
+ * 3D immediate mode support
+ */
+#endif /* RWPLCORE */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwim3dvertex RwIm3DVertex
+ * \ingroup rwcore
+ *
+ * Im3D Vertex data access
+ */
+#endif /* RWPLCORE */
+
+/**
+ * \defgroup rwmatrix RwMatrix
+ * \ingroup rwcore
+ *
+ * Handling binary matrix representations.
+ */
+
+/**
+ * \defgroup rwmem RwMem
+ * \ingroup rwcore
+ *
+ * Memory
+ */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwobject RwObject
+ * \ingroup rwcore
+ *
+ * object
+ */
+#endif /* RWPLCORE */
+
+/**
+ * \defgroup rwos RwOs
+ * \ingroup rwcore
+ *
+ * Operating System
+ */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwraster RwRaster
+ * \ingroup rwcore
+ *
+ * Image/raster coupling handling.
+ */
+#endif /* RWPLCORE */
+
+/**
+ * \defgroup rwrenderstate RwRenderState
+ * \ingroup rwcore
+ *
+ * Render states
+ */
+
+/**
+ * \defgroup rwresources RwResources
+ * \ingroup rwcore
+ *
+ * Resource handling.
+ * Resources are used to instance objects into.
+ */
+
+
+/**
+ * \defgroup rwrgba RwRGBA
+ * \ingroup rwcore
+ *
+ * Color space functionality.
+ */
+
+
+/**
+ * \defgroup rwstream RwStream
+ * \ingroup rwcore
+ *
+ * Stream
+ */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwtexdict RwTexDictionary
+ * \ingroup rwcore
+ *
+ * Texture Dictionary
+ */
+#endif /* RWPLCORE */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwtexture RwTexture
+ * \ingroup rwcore
+ *
+ * Texture handling.
+ * Textures are special cases of rasters that can be applied to polygons.
+ */
+#endif /* RWPLCORE */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwv2d RwV2d
+ * \ingroup rwcore
+ *
+ * 2D Vector mathematics.
+ */
+#endif /* RWPLCORE */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwv3d RwV3d
+ * \ingroup rwcore
+ *
+ * 3D Vector mathematics.
+ */
+#endif /* RWPLCORE */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwcorepowerpipe PowerPipe
+ * \ingroup rwcore
+ *
+ * PowerPipe
+ */
+#endif /* RWPLCORE */
+
+#ifndef RWPLCORE
+/**
+ * \defgroup rwcoregeneric Generic
+ * \ingroup rwcorepowerpipe
+ *
+ * Generic Pipeline
+ *
+ */
+#endif /* RWPLCORE */
+
+/* These are plugins */
+#define rwID_METRICSPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x01)
+#define rwID_SPLINEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x02)
+#define rwID_STEREOPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x03)
+#define rwID_VRMLPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x04)
+#define rwID_MORPHPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x05)
+#define rwID_PVSPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x06)
+#define rwID_MEMLEAKPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x07)
+#define rwID_ANIMPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x08)
+#define rwID_GLOSSPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x09)
+#define rwID_LOGOPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x0a)
+#define rwID_MEMINFOPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x0b)
+#define rwID_RANDOMPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x0c)
+#define rwID_PNGIMAGEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x0d)
+#define rwID_BONEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x0e)
+#define rwID_VRMLANIMPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x0f)
+#define rwID_SKYMIPMAPVAL MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x10)
+#define rwID_MRMPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x11)
+#define rwID_LODATMPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x12)
+#define rwID_MEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x13)
+#define rwID_LTMAPPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x14)
+#define rwID_REFINEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x15)
+#define rwID_SKINPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x16)
+#define rwID_LABELPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x17)
+#define rwID_PARTICLESPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x18)
+#define rwID_GEOMTXPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x19)
+#define rwID_SYNTHCOREPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x1a)
+#define rwID_STQPPPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x1b)
+#define rwID_PARTPPPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x1c)
+#define rwID_COLLISPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x1d)
+#define rwID_HANIMPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x1e)
+#define rwID_USERDATAPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x1f)
+#define rwID_MATERIALEFFECTSPLUGIN \
+ MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x20)
+#define rwID_PARTICLESYSTEMPLUGIN \
+ MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x21)
+#define rwID_DMORPHPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x22)
+#define rwID_PATCHPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x23)
+#define rwID_TEAMPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x24)
+#define rwID_CROWDPPPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x25)
+#define rwID_MIPSPLITPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x26)
+#define rwID_ANISOTPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x27)
+/* #define THIS SPACE FREE! MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x28) */
+#define rwID_GCNMATPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x29)
+#define rwID_GPVSPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x2a)
+#define rwID_XBOXMATPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x2b)
+#define rwID_MULTITEXPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x2c)
+#define rwID_CHAINPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x2d)
+#define rwID_TOONPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x2e)
+#define rwID_PTANKPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x2f)
+
+#define rwID_PRTSTDPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x30)
+
+
+/********************************************************/
+
+/* Doxygen plugin groups. */
+
+#ifndef RWPLCORE
+
+/**
+ * \defgroup rpplugin Plugins
+ *
+ * API Plugins
+ *
+ */
+
+/**
+ * \defgroup rpworld RpWorld
+ * \ingroup rpplugin
+ *
+ * World handling Plugin
+ *
+ * Gives objects context,
+ * and provides a mechanism for efficient static object rendering.
+ */
+
+/********************************************************/
+
+/**
+ * \defgroup rpworlddatatypes Data Types
+ * \ingroup rpworld
+ *
+ * RpWorld Data types
+ */
+
+/**
+ * \defgroup rpatomic RpAtomic
+ * \ingroup rpworld
+ *
+ * Atomics
+ */
+
+/**
+ * \defgroup rpclump RpClump
+ * \ingroup rpworld
+ *
+ * Clumps
+ */
+
+/**
+ * \defgroup rpgeometry RpGeometry
+ * \ingroup rpworld
+ *
+ * Handling atomic's geometry
+ */
+
+
+/**
+ * \defgroup rpinterpolator RpInterpolator
+ * \ingroup rpworld
+ *
+ * Interpolators
+ */
+
+/**
+ * \defgroup rplight RpLight
+ * \ingroup rpworld
+ *
+ * Lighting 3D objects.
+ * Lights are used to illuminate atomics and worlds
+ */
+
+/**
+ * \defgroup rpmaterial RpMaterial
+ * \ingroup rpworld
+ *
+ * Handling surface materials
+ * Materials describe how things are to appear when rendered
+ */
+
+/**
+ * \defgroup rpmesh RpMesh
+ * \ingroup rpworld
+ *
+ * Provide construction and enumeration facilities for meshes.
+ */
+
+/**
+ * \defgroup rpmorphtarget RpMorphTarget
+ * \ingroup rpworld
+ *
+ * Morph Targets
+ */
+
+/**
+ * \defgroup rpworldsub RpWorld
+ * \ingroup rpworld
+ *
+ * RpWorld sub group
+ */
+
+/**
+ * \defgroup rpworldsector RpWorldSector
+ * \ingroup rpworld
+ *
+ * Handling atomic sectors
+ */
+
+/**
+ * \defgroup rpworldrwcamera RwCamera
+ * \ingroup rpworld
+ *
+ * Cameras
+ */
+
+/**
+ * \defgroup rpworldpowerpipe PowerPipe
+ * \ingroup rpworld
+ *
+ * PowerPipe
+ */
+
+/**
+ * \defgroup rpworldp2generic Generic
+ * \ingroup rpworldpowerpipe
+ *
+ * Generic
+ */
+#endif /* RWPLCORE */
+
+/* These are toolkits */
+#define rwID_CHARSEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x80)
+#define rwID_NOHSWORLDPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x81)
+#define rwID_IMPUTILPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x82)
+#define rwID_SLERPPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x83)
+#define rwID_OPTIMPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x84)
+#define rwID_TLWORLDPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x85)
+#define rwID_DATABASEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x86)
+#define rwID_RAYTRACEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x87)
+#define rwID_RAYPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x88)
+#define rwID_LIBRARYPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x89)
+#define rwID_2DPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x90)
+#define rwID_TILERENDPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x91)
+#define rwID_JPEGIMAGEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x92)
+#define rwID_TGAIMAGEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x93)
+#define rwID_GIFIMAGEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x94)
+#define rwID_QUATPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x95)
+#define rwID_SPLINEPVSPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x96)
+#define rwID_MIPMAPPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x97)
+#define rwID_MIPMAPKPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x98)
+#define rwID_2DFONT MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x99)
+#define rwID_INTSECPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x9a)
+#define rwID_TIFFIMAGEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x9b)
+#define rwID_PICKPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x9c)
+#define rwID_BMPIMAGEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x9d)
+#define rwID_RASIMAGEPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x9e)
+#define rwID_SKINFXPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x9f)
+#define rwID_VCATPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xa0)
+#define rwID_2DPATH MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xa1)
+#define rwID_2DBRUSH MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xa2)
+#define rwID_2DOBJECT MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xa3)
+#define rwID_2DSHAPE MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xa4)
+#define rwID_2DSCENE MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xa5)
+#define rwID_2DPICKREGION MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xa6)
+#define rwID_2DOBJECTSTRING MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xa7)
+#define rwID_2DANIMPLUGIN MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xa8)
+#define rwID_2DANIM MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xa9)
+#define rwID_2DKEYFRAME MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xb0)
+#define rwID_2DMAESTRO MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xb1)
+#define rwID_BARYCENTRIC MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xb2)
+#define rwID_PITEXDICTIONARYTK MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xb3)
+#define rwID_TOCTOOLKIT MAKECHUNKID(rwVENDORID_CRITERIONTK, 0xb4)
+
+/**********************************************************************/
+
+/* Doxygen Toolkit groups */
+
+/**
+ * \defgroup rttool Toolkits
+ *
+ * API Toolkits
+ */
+
+/**
+ * \defgroup fxpack FXPack
+ *
+ * FXPack component group
+ */
+
+/**********************************************************************/
+
+/**
+ * \defgroup platformspecific Platform Specific
+ *
+ * Links to all platform specific information in the API Reference can
+ * be found in this folder.
+ */
+
+/**********************************************************************/
+
+/* Index Page definition for API Reference. Don't mess with it unless you know what you're doing. */
+
+
+/**
+ * \mainpage RenderWare Graphics API Reference
+ *
+ * \image html rwglogo.jpg
+ *
+ * This document provides an API Reference for release 3.3 of the RenderWare
+ * Graphics SDK.
+ *
+ * You do not have to wait for a major release to obtain a current API
+ * Reference. An up-to-date API Reference is compiled every week and goes out
+ * with the weekly build. The footer declares when it was generated.
+ *
+ * \section otherdocs Documentation Available
+ * RenderWare Graphics is supplied with:
+ *
+ * - A top-level README.PDF -- If you read nothing else, at least read this!
+ * - this API Reference
+ * - the User Guide
+ * - Artist's documentation (if installed)
+ * - Examples documentation
+ * - Maestro documentation
+ * - Tools documentation
+ * - White Papers
+ * - readme.txt files for each of the supplied Examples
+ *
+ * \section contactus Contact Us
+ *
+ * \subsection csl Criterion Software Ltd.
+ * For general information about RenderWare e-mail info@csl.com.
+ *
+ * \subsection devrels Developer Relations
+ *
+ * For information regarding Support please email devrels@csl.com
+ *
+ * \subsection sales Sales
+ *
+ * For sales information contact: rw-sales@csl.com
+ *
+ * \section copyright Copyright Notice
+ *
+ * The information in this document is subject to change without notice and does not represent
+ * a commitment on the part of Criterion Software Ltd. The software described in this document is
+ * furnished under a license agreement or a non-disclosure agreement. The software may be used or
+ * copied only in accordance with the terms of the agreement. It is against the law to copy the
+ * software on any medium except as specifically allowed in the license or non-disclosure agreement.
+ *
+ * No part of this documentation may be reproduced or transmitted in any form or by any means for any
+ * purpose without the express written permis­sion of Criterion Software Ltd.
+ *
+ * Copyright © 1993 - 2002 Criterion Software Ltd. All rights reserved.
+ *
+ * Canon and RenderWare are registered trademarks of Canon Inc. Nintendo is a registered trademark
+ * and NINTENDO GAMECUBE a trademark of Nintendo Co., Ltd. Microsoft is a registered trademark and
+ * Xbox is a trademark of Microsoft Corporation. PlayStation is a registered trademark of Sony Computer
+ * Entertainment Inc.
+ *
+ * All other trademarks mentioned herein are the property of their respective companies.
+ *
+ */
diff --git a/rwsdk/include/d3d8/rpdbgerr.c b/rwsdk/include/d3d8/rpdbgerr.c
new file mode 100644
index 00000000..0c83c04e
--- /dev/null
+++ b/rwsdk/include/d3d8/rpdbgerr.c
@@ -0,0 +1,90 @@
+/*
+ * Debug handling
+ *
+ ****************************************************************************
+ *
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd. or
+ * Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. will not, under any
+ * circumstances, be liable for any lost revenue or other damages arising
+ * from the use of this file.
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+ * All Rights Reserved.
+ *
+ * RenderWare is a trademark of Canon Inc.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ Includes
+ */
+
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <rwcore.h>
+#include <rpdbgerr.h>
+
+static const char rcsid[] __RWUNUSED__ = "@@(#)$Id: //RenderWare/RW33Active/dev/rwsdk/src/plcore/rpdbgerr.c#1 $";
+
+#ifdef RWDEBUG
+
+/****************************************************************************
+ Defines
+ */
+
+ /****************************************************************************
+ Local (static) Globals
+ */
+
+/* The strings used in the debug error reporting are derived from the
+ * .def files
+ */
+
+#define RWECODE(a,b) RWSTRING(b),
+
+static const RwChar *rw_err_str[] =
+{
+#include "rperror.def"
+ RWSTRING("Last Error")
+};
+
+#undef RWECODE
+#define RWECODE(a,b) RWSTRING(#a),
+
+static const RwChar *rw_err_cstr[] =
+{
+#include "rperror.def"
+ RWSTRING("E_RW_LAST")
+};
+
+#undef RWECODE
+
+static RwChar dberr[512];
+
+RwChar *
+rwPLUGIN_ERRFUNC(RwInt32 code,...)
+{
+ va_list ap;
+
+#if (0)
+ RWFUNCTION(RWSTRING("rwPLUGIN_ERRFUNC"));
+#endif /* (0) */
+
+ va_start(ap, code);
+
+ rwstrcpy(dberr, rw_err_cstr[code]);
+ rwstrcat(dberr, RWSTRING(" : "));
+ rwvsprintf(&dberr[rwstrlen(dberr)], rw_err_str[code], ap);
+ va_end(ap);
+ return dberr;
+}
+
+#endif /* RWDEBUG */
+
diff --git a/rwsdk/include/d3d8/rpdbgerr.h b/rwsdk/include/d3d8/rpdbgerr.h
new file mode 100644
index 00000000..6918469a
--- /dev/null
+++ b/rwsdk/include/d3d8/rpdbgerr.h
@@ -0,0 +1,278 @@
+/***************************************************************************
+ * *
+ * Module : badebug.h *
+ * *
+ * Purpose : Debug handling *
+ * *
+ **************************************************************************/
+
+#ifndef RWDEBUG_H
+#define RWDEBUG_H
+
+#if (defined(RWDEBUG) && defined(RWVERBOSE))
+#if (defined(_MSC_VER))
+#if (_MSC_VER>=1000)
+
+/* Pick up _ASSERTE macro */
+#ifdef _XBOX
+#include <xtl.h>
+#else /* _XBOX */
+#include <windows.h>
+#endif /* _XBOX */
+#if (defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC))
+#define _CRTDBG_MAP_ALLOC
+#endif /* defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) */
+#include <crtdbg.h>
+#undef RWASSERTE
+#define RWASSERTE(_condition) _ASSERTE(_condition)
+#endif /* (_MSC_VER>=1000) */
+#endif /* (defined(_MSC_VER)) */
+#endif /* (defined(RWDEBUG) && defined(RWVERBOSE)) */
+
+#if (!defined(RWASSERTE))
+#define RWASSERTE(_condition) /* No-Op */
+#endif /* (!defined(RWASSERTE)) */
+
+#if (!defined(RWPENTER))
+#define RWPENTER(_func) /* No-Op */
+#endif /* (!defined(RWPENTER)) */
+
+#if (!defined(RWPEXIT))
+#define RWPEXIT(_func) /* No-Op */
+#endif /* (!defined(RWPEXIT)) */
+
+/****************************************************************************
+ Includes
+ */
+
+#include <rwcore.h>
+
+#include "rpplugin.h"
+
+/****************************************************************************
+ Defines
+ */
+
+#ifdef RWDEBUG
+
+#if (!(defined(RWDEBUGSTACKDEPTH)))
+#define RWDEBUGSTACKDEPTH (RWSRCGLOBAL(debugStackDepth))
+#endif /* (!(defined(RWDEBUGSTACKDEPTH))) */
+
+/* Message macros */
+
+#ifdef RWTRACE
+
+/* Note RWTRACE should only be defined for internal builds. It should
+ * also only be used rarely. It will cause the generation of Trace
+ * messages for all functions. Not just those directly called from
+ * the application
+ */
+
+#define RWAPIFUNCTION(function) \
+static const RwChar __dbFunctionName[] = function; \
+const RwInt32 startstackdepth = RWDEBUGSTACKDEPTH++; \
+RWPENTER(__dbFunctionName); \
+if (RWSRCGLOBAL(debugTrace)) \
+{ \
+ RwDebugSendMessage(rwDEBUGTRACE, \
+ __dbFunctionName, \
+ _rwdbsprintf("Enter %s [Depth %d]", \
+ (startstackdepth)?"SPI":"API", \
+ (int)startstackdepth)); \
+}
+
+#define RWFUNCTION(function) RWAPIFUNCTION(function)
+
+#define RWRETURN(result) \
+do \
+{ \
+ RwInt32 _validateStackDepth = --RWDEBUGSTACKDEPTH; \
+ if (_validateStackDepth != startstackdepth) \
+ { \
+ RwDebugSendMessage(rwDEBUGERROR, \
+ __dbFunctionName, \
+ _rwdberrcommon(E_RW_DEBUGSTACK)); \
+ RWDEBUGSTACKDEPTH = startstackdepth; \
+ } \
+ if (RWSRCGLOBAL(debugTrace)) \
+ { \
+ RwDebugSendMessage(rwDEBUGTRACE, \
+ __dbFunctionName, RWSTRING("Exit")); \
+ } \
+ RWASSERTE(_validateStackDepth == startstackdepth); \
+ RWPEXIT(__dbFunctionName); \
+ return (result); \
+} \
+while (0)
+
+#define RWRETURNVOID() \
+do \
+{ \
+ RwInt32 _validateStackDepth = --RWDEBUGSTACKDEPTH; \
+ if (_validateStackDepth != startstackdepth) \
+ { \
+ RwDebugSendMessage(rwDEBUGERROR, \
+ __dbFunctionName, \
+ _rwdberrcommon (E_RW_DEBUGSTACK)); \
+ RWDEBUGSTACKDEPTH = startstackdepth; \
+ } \
+ if (RWSRCGLOBAL(debugTrace)) \
+ { \
+ RwDebugSendMessage(rwDEBUGTRACE, \
+ __dbFunctionName, RWSTRING("Exit")); \
+ } \
+ RWASSERTE(_validateStackDepth == startstackdepth); \
+ RWPEXIT(__dbFunctionName); \
+ return; \
+} \
+while(0)
+
+#else /* RWTRACE */
+
+#define RWAPIFUNCTION(function) \
+static const RwChar __dbFunctionName[] = function; \
+const RwInt32 startstackdepth = RWDEBUGSTACKDEPTH++; \
+RWPENTER(__dbFunctionName); \
+if (RWSRCGLOBAL(debugTrace) && !startstackdepth) \
+{ \
+ RwDebugSendMessage(rwDEBUGTRACE, \
+ __dbFunctionName, RWSTRING("Enter")); \
+}
+
+#define RWFUNCTION(function) RWAPIFUNCTION(function)
+
+#define RWRETURN(result) \
+do \
+{ \
+ RwInt32 _validateStackDepth = --RWDEBUGSTACKDEPTH; \
+ if (_validateStackDepth != startstackdepth) \
+ { \
+ RwDebugSendMessage(rwDEBUGERROR, \
+ __dbFunctionName, \
+ _rwdberrcommon(E_RW_DEBUGSTACK)); \
+ RWDEBUGSTACKDEPTH = startstackdepth; \
+ } \
+ if (RWSRCGLOBAL(debugTrace) && (!startstackdepth)) \
+ { \
+ RwDebugSendMessage(rwDEBUGTRACE, \
+ __dbFunctionName, RWSTRING("Exit")); \
+ } \
+ RWASSERTE(_validateStackDepth == startstackdepth); \
+ RWPEXIT(__dbFunctionName); \
+ return (result); \
+} \
+while (0)
+
+#define RWRETURNVOID() \
+do \
+{ \
+ RwInt32 _validateStackDepth = --RWDEBUGSTACKDEPTH; \
+ if (_validateStackDepth != startstackdepth) \
+ { \
+ RwDebugSendMessage(rwDEBUGERROR, \
+ __dbFunctionName, \
+ _rwdberrcommon (E_RW_DEBUGSTACK)); \
+ RWDEBUGSTACKDEPTH = startstackdepth; \
+ } \
+ if (RWSRCGLOBAL(debugTrace) && (!startstackdepth)) \
+ { \
+ RwDebugSendMessage(rwDEBUGTRACE, \
+ __dbFunctionName, RWSTRING("Exit")); \
+ } \
+ RWASSERTE(_validateStackDepth == startstackdepth); \
+ RWPEXIT(__dbFunctionName); \
+ return; \
+} \
+while(0)
+
+#endif /* RWTRACE */
+
+#define RWERROR(ecode) \
+do \
+{ \
+ RwError _rwErrorCode; \
+ \
+ _rwErrorCode.pluginID = rwPLUGIN_ID; \
+ _rwErrorCode.errorCode = _rwerror ecode; \
+ \
+ RwErrorSet(&_rwErrorCode); \
+ \
+ if (_rwErrorCode.errorCode & 0x80000000) \
+ { \
+ RwDebugSendMessage(rwDEBUGERROR, \
+ __dbFunctionName, \
+ _rwdberrcommon ecode); \
+ } \
+ else \
+ { \
+ RwDebugSendMessage(rwDEBUGERROR, \
+ __dbFunctionName, \
+ rwPLUGIN_ERRFUNC ecode); \
+ } \
+} \
+while(0);
+
+#define RWMESSAGE(args) \
+do \
+{ \
+ RwDebugSendMessage(rwDEBUGMESSAGE, \
+ __dbFunctionName, \
+ _rwdbsprintf args); \
+} \
+while (0)
+
+#define RWASSERT(condition) \
+do \
+{ \
+ if (!(condition)) \
+ { \
+ RwDebugSendMessage(rwDEBUGASSERT, \
+ __dbFunctionName, \
+ RWSTRING(#condition)); \
+ } \
+ RWASSERTE(condition); \
+} \
+while (0)
+
+#else /* RWDEBUG */
+
+#define RWRETURN(value) return(value)
+#define RWRETURNVOID() return
+#define RWERROR(errorcode) \
+do \
+{ \
+ RwError _rwErrorCode; \
+ \
+ _rwErrorCode.pluginID = rwPLUGIN_ID; \
+ _rwErrorCode.errorCode = _rwerror errorcode; \
+ \
+ RwErrorSet(&_rwErrorCode); \
+} \
+while (0)
+#define RWFUNCTION(name)
+#define RWAPIFUNCTION(name)
+#define RWASSERT(condition)
+#define RWMESSAGE(args)
+
+#endif
+
+#define RWVALIDATEDEBUGSTACKDEPTH() \
+ RWASSERT(1 == (RWDEBUGSTACKDEPTH - startstackdepth))
+
+/****************************************************************************
+ Functions
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+RwChar *rwPLUGIN_ERRFUNC(RwInt32 code, ...);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RWDEBUG_H */
diff --git a/rwsdk/include/d3d8/rpdmorph.h b/rwsdk/include/d3d8/rpdmorph.h
new file mode 100644
index 00000000..1494bf3d
--- /dev/null
+++ b/rwsdk/include/d3d8/rpdmorph.h
@@ -0,0 +1,311 @@
+/*****************************************************************************
+ *
+ * File : rpdmorph.h
+ *
+ * Abstract : DeltaMorph plugin for Renderware.
+ *
+ *****************************************************************************
+ *
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd. or
+ * Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. will not, under any
+ * circumstances, be liable for any lost revenue or other damages arising
+ * from the use of this file.
+ *
+ * Copyright (c) 2000 Criterion Software Ltd.
+ * All Rights Reserved.
+ *
+ * RenderWare is a trademark of Canon Inc.
+ *
+ *****************************************************************************/
+
+#ifndef RPDMORPH_H
+#define RPDMORPH_H
+
+/**
+ * \defgroup rpdmorph RpDMorph
+ * \ingroup rpplugin
+ * \file rpdmorph.h
+ *
+ * Delta Morphing Plugin for RenderWare Graphics.
+ */
+
+/*===========================================================================*
+ *--- Include files ---------------------------------------------------------*
+ *===========================================================================*/
+#include <rwcore.h>
+#include <rpworld.h>
+
+#include "rpdmorph.rpe" /* automatically generated header file */
+
+
+/*===========================================================================*
+ *--- Global Types ----------------------------------------------------------*
+ *===========================================================================*/
+
+/**
+ * \ingroup rpdmorph
+ * \struct RpDMorphTarget
+ * Delta morph target object for defining a target for
+ * a base geometry.
+ * This should be considered an opaque type.
+ * Use the RpDMorphGeometry and RpDMorphTarget API
+ * functions to access.
+ */
+typedef struct RpDMorphTarget RpDMorphTarget;
+
+/**
+ * \ingroup rpdmorph
+ * \struct RpDMorphAnimation
+ * Contains frame sequences for animating delta
+ * morph target objects.
+ * This should be considered an opaque type.
+ * Use the RpDMorphAnimation API
+ * functions to access.
+ */
+typedef struct RpDMorphAnimation RpDMorphAnimation;
+
+#define rpDMORPHNULLFRAME ((RwUInt32)~0)
+
+/*===========================================================================*
+ *--- Global variables ------------------------------------------------------*
+ *===========================================================================*/
+
+extern RwModuleInfo rpDMorphModule;
+
+/*===========================================================================*
+ *--- Plugin API Functions --------------------------------------------------*
+ *===========================================================================*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/*--- DMorphPlugin functions ------------------------------------------------*/
+extern RwBool
+RpDMorphPluginAttach( void );
+
+/*--- DMorphGeometry functions ----------------------------------------------
+ *
+ * These functios work on the DMorphGeometry level.
+ * Each DMorphGeometry has a list of DMorphTargets.
+ */
+extern RpGeometry *
+RpDMorphGeometryCreateDMorphTargets( RpGeometry *geometry,
+ RwUInt32 number );
+
+extern RpGeometry *
+RpDMorphGeometryDestroyDMorphTargets( RpGeometry *geometry );
+
+extern RpGeometry *
+RpDMorphGeometryAddDMorphTarget( RpGeometry *geometry,
+ RwUInt32 index,
+ RwV3d *vertices,
+ RwV3d *normals,
+ RwRGBA *preLightColors,
+ RwTexCoords *texCoords,
+ RwUInt32 flags );
+
+extern RpGeometry *
+RpDMorphGeometryRemoveDMorphTarget( RpGeometry *geometry,
+ RwUInt32 index );
+
+extern RpDMorphTarget *
+RpDMorphGeometryGetDMorphTarget( const RpGeometry *geometry,
+ RwUInt32 index );
+
+extern RwUInt32
+RpDMorphGeometryGetNumDMorphTargets( const RpGeometry *geometry );
+
+extern RpGeometry *
+RpDMorphGeometryTransformDMorphTargets( RpGeometry *geometry,
+ const RwMatrix *matrix );
+
+/*--- DMorphTarget functions ------------------------------------------------
+ *
+ * These functios work on the DMorphGeometry level.
+ * Each DMorphGeometry has a list of DMorphTargets.
+ */
+
+extern const RwSphere *
+RpDMorphTargetGetBoundingSphere( const RpDMorphTarget *dMorphTarget );
+
+extern RpDMorphTarget *
+RpDMorphTargetSetName( RpDMorphTarget *dMorphTarget,
+ RwChar *name );
+
+extern RwChar *
+RpDMorphTargetGetName( RpDMorphTarget *dMorphTarget );
+
+extern RpGeometryFlag
+RpDMorphTargetGetFlags( RpDMorphTarget *dMorphTarget );
+
+
+/*--- ANIMATION SYSTEM ------------------------------------------------------
+ */
+
+/*--- DMorphAtomic functions ------------------------------------------------
+ *
+ * These functions work at the DMorphAtomic level.
+ */
+extern RpAtomic *
+RpDMorphAtomicInitalize( RpAtomic *atomic );
+
+extern RwReal *
+RpDMorphAtomicGetDMorphValues( RpAtomic *atomic );
+
+extern RpAtomic *
+RpDMorphAtomicSetAnimation( RpAtomic *atomic,
+ RpDMorphAnimation *animation );
+
+extern RpDMorphAnimation *
+RpDMorphAtomicGetAnimation( const RpAtomic *atomic );
+
+extern RpAtomic *
+RpDMorphAtomicAddTime( RpAtomic *atomic,
+ RwReal time );
+
+extern RwReal
+RpDMorphAtomicGetAnimTime( const RpAtomic *atomic );
+
+extern RpAtomic *
+RpDMorphAtomicSetAnimLoopCallBack( RpAtomic *atomic,
+ RpAtomicCallBack callBack,
+ void *data );
+
+extern RpAtomicCallBack
+RpDMorphAtomicGetAnimLoopCallBack( const RpAtomic *atomic,
+ void **callBackData );
+
+extern RpAtomic *
+RpDMorphAtomicSetAnimFrame( RpAtomic *atomic,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 index );
+
+extern RwUInt32
+RpDMorphAtomicGetAnimFrame( const RpAtomic *atomic,
+ RwUInt32 dMorphTargetIndex );
+
+
+extern RpAtomic *
+RpDMorphAtomicSetAnimFrameTime( RpAtomic *atomic,
+ RwUInt32 dMorphTargetIndex,
+ RwReal time );
+
+extern RwReal
+RpDMorphAtomicGetAnimFrameTime( const RpAtomic *atomic,
+ RwUInt32 dMorphTargetIndex );
+
+/*--- Animation Functions --------------------------------------------------
+ */
+extern RpDMorphAnimation *
+RpDMorphAnimationCreate(RwUInt32 numDMorphTargets);
+
+extern RpDMorphAnimation *
+RpDMorphAnimationDestroy(RpDMorphAnimation *anim);
+
+extern RwUInt32
+RpDMorphAnimationGetNumDMorphTargets(RpDMorphAnimation *animation);
+
+/* Animation Frames */
+extern RpDMorphAnimation *
+RpDMorphAnimationCreateFrames(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 numFrames);
+
+extern RpDMorphAnimation *
+RpDMorphAnimationDestroyFrames(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex);
+
+extern RwUInt32
+RpDMorphAnimationGetNumFrames(RpDMorphAnimation *animation,
+ RwUInt32 dMorphTargetIndex);
+
+/* Stream I/O */
+extern RpDMorphAnimation *
+RpDMorphAnimationStreamRead(RwStream *stream);
+
+extern RpDMorphAnimation *
+RpDMorphAnimationStreamWrite(RpDMorphAnimation *animation,
+ RwStream *stream);
+
+extern RwUInt32
+RpDMorphAnimationStreamGetSize(RpDMorphAnimation *animation);
+
+extern RpDMorphAnimation *
+RpDMorphAnimationRead(const RwChar *filename);
+
+extern RpDMorphAnimation *
+RpDMorphAnimationWrite(RpDMorphAnimation *animation, const RwChar *filename);
+
+/*--- Animation Frame Functions --------------------------------------------
+ *
+ * These functions work on the DMorphAnimationFrame level.
+ * Each Frame can have a reference to the next Frame for the
+ * DMorphTarget.
+ */
+extern RpDMorphAnimation *
+RpDMorphAnimationFrameSetNext(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 frameIndex,
+ RwUInt32 nextFrame );
+
+extern RwUInt32
+RpDMorphAnimationFrameGetNext(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 frameIndex );
+
+extern RpDMorphAnimation *
+RpDMorphAnimationFrameSet(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 frameIndex,
+ RwReal startValue,
+ RwReal endValue,
+ RwReal duration,
+ RwUInt32 nextFrame );
+
+extern RpDMorphAnimation *
+RpDMorphAnimationFrameSetStartValue(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 frameIndex,
+ RwReal startValue );
+
+extern RwReal
+RpDMorphAnimationFrameGetStartValue(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 frameIndex );
+
+extern RpDMorphAnimation *
+RpDMorphAnimationFrameSetEndValue(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 frameIndex,
+ RwReal endValue );
+
+extern RwReal
+RpDMorphAnimationFrameGetEndValue(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 frameIndex );
+
+extern RpDMorphAnimation *
+RpDMorphAnimationFrameSetDuration(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 frameIndex,
+ RwReal duration );
+
+extern RwReal
+RpDMorphAnimationFrameGetDuration(RpDMorphAnimation *anim,
+ RwUInt32 dMorphTargetIndex,
+ RwUInt32 frameIndex );
+
+/*--------------------------------------------------------------------------*/
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RPDMORPH_H */
+
diff --git a/rwsdk/include/d3d8/rpdmorph.rpe b/rwsdk/include/d3d8/rpdmorph.rpe
new file mode 100644
index 00000000..a5202425
--- /dev/null
+++ b/rwsdk/include/d3d8/rpdmorph.rpe
@@ -0,0 +1,639 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionDMorph
+{
+
+
+
+ e_rwdb_CriterionDMorphLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionDMorph e_rwdb_CriterionDMorph;
+
+
diff --git a/rwsdk/include/d3d8/rperror.h b/rwsdk/include/d3d8/rperror.h
new file mode 100644
index 00000000..2a8c5630
--- /dev/null
+++ b/rwsdk/include/d3d8/rperror.h
@@ -0,0 +1,32 @@
+/***************************************************************************
+ * *
+ * Module : rperror.h *
+ * *
+ * Purpose : Used to generate error codes *
+ * *
+ **************************************************************************/
+
+#ifndef RPERROR_H
+#define RPERROR_H
+
+/****************************************************************************
+ Includes
+ */
+
+#include "rpplugin.h"
+
+/****************************************************************************
+ Defines
+ */
+
+#define RWECODE(a,b) a,
+
+enum rwPLUGIN_ERRENUM
+{
+#include "rperror.def"
+ rwPLUGIN_ERRENUMLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum rwPLUGIN_ERRENUM rwPLUGIN_ERRENUM;
+
+#endif /* RPERROR_H */
diff --git a/rwsdk/include/d3d8/rphanim.h b/rwsdk/include/d3d8/rphanim.h
new file mode 100644
index 00000000..a9b0438a
--- /dev/null
+++ b/rwsdk/include/d3d8/rphanim.h
@@ -0,0 +1,873 @@
+/******************************************
+ * *
+ * RenderWare(TM) Graphics Library *
+ * *
+ ******************************************/
+
+/*
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd.
+ * or Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. and Canon Inc. will not, under any
+ * circumstances, be liable for any lost revenue or other damages
+ * arising from the use of this file.
+ *
+ * Copyright (c) 1998. Criterion Software Ltd.
+ * All Rights Reserved.
+ */
+
+/***************************************************************************
+ * *
+ * Module : rpanim.h *
+ * *
+ * Purpose : Hierarchical animation *
+ * *
+ **************************************************************************/
+
+#ifndef RPHANIM_H
+#define RPHANIM_H
+
+/**
+ * Hierarchal animation plugin
+ */
+
+/* Doxygen plugin groups. */
+
+/**
+ * \defgroup rphanim RpHAnim
+ * \ingroup rpplugin
+ *
+ * Hierarchical Animation Plugin for RenderWare Graphics.
+ */
+
+/**
+ * \defgroup rphanimchanges RpHAnim Changes
+ * \ingroup rphanim
+ *
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <rwcore.h>
+#include <rpworld.h>
+
+#include <rpcriter.h> /* Note: each vendor can choose their own method for
+ * allocation of unique ID's. This file defines
+ * the ID's used by Criterion.
+ */
+#include <rphanim.rpe> /* automatically generated header file */
+#include <rtquat.h>
+
+#define rpHANIMSTREAMCURRENTVERSION 0x100
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimAtomicGlobalVars typedef for struct RpHAnimAtomicGlobalVars
+ */
+typedef struct RpHAnimAtomicGlobalVars RpHAnimAtomicGlobalVars;
+
+/**
+ * \ingroup rphanim
+ * \struct RpHAnimAtomicGlobalVars
+ */
+struct RpHAnimAtomicGlobalVars
+{
+ RwInt32 engineOffset ; /* Offset into global data */
+ RwFreeList *HAnimFreeList;
+ RwFreeList *HAnimAnimationFreeList;
+};
+
+extern RpHAnimAtomicGlobalVars RpHAnimAtomicGlobals;
+
+#define rpHANIMSTDKEYFRAMESIZE sizeof(RpHAnimStdKeyFrame)
+#define rpHANIMSTDKEYFRAMETYPEID 0x1
+
+#define RwAnimMalloc() \
+ RwFreeListAlloc(RpHAnimAtomicGlobals.HAnimFreeList)
+
+#define RwAnimFree(_anim) \
+ RwFreeListFree(RpHAnimAtomicGlobals.HAnimFreeList, (_anim))
+
+#define RwAnimAnimationMalloc() \
+ RwFreeListAlloc(RpHAnimAtomicGlobals.HAnimAnimationFreeList)
+
+#define RwAnimAnimationFree(_animAnimation) \
+ RwFreeListFree(RpHAnimAtomicGlobals.HAnimAnimationFreeList, \
+ (_animAnimation))
+
+#define RpV3dInterpolate(o, a, s, b) \
+MACRO_START \
+{ \
+ (o)->x = (((a)->x) + ((s)) * (((b)->x) - ((a)->x))); \
+ (o)->y = (((a)->y) + ((s)) * (((b)->y) - ((a)->y))); \
+ (o)->z = (((a)->z) + ((s)) * (((b)->z) - ((a)->z))); \
+} \
+MACRO_STOP
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimHierarchy typedef for struct RpHAnimHierarchy
+ */
+typedef struct RpHAnimHierarchy RpHAnimHierarchy;
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimAnimation typedef for struct RpHAnimAnimation
+ */
+typedef struct RpHAnimAnimation RpHAnimAnimation;
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimHierarchyCallBack
+ * This typedef defines a callback function for use with the
+ * \ref RpHAnimHierarchySetAnimCallBack and
+ * \ref RpHAnimHierarchySetAnimLoopCallBack functions.
+ *
+ * \param hierarchy
+ * A pointer to the AnimHierarchy structure.
+ *
+ * \param data User-defined data.
+ * You can use this to pass your own data
+ * structure(s) to the callback function.
+ *
+ * \see RpHAnimHierarchySetAnimCallBack
+ * \see RpHAnimHierarchySetAnimLoopCallBack
+ *
+ */
+
+typedef RpHAnimHierarchy * (*RpHAnimHierarchyCallBack) (RpHAnimHierarchy *hierarchy,
+ void *data);
+
+/*
+ * The following CallBacks are needed for each overloaded interpolation
+ * scheme. See RpHAnimInterpolatorInfo.
+ */
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimKeyFrameToMatrixCallBack
+ * This typedef defines a callback function for converting
+ * an animation keyframe into a modeling matrix. The output matrix will be
+ * used to construct the array of world or local space matrices for the
+ * hierarchy as obtained with \ref RpHAnimHierarchyGetMatrixArray, and
+ * possibly used for updating an external \ref RwFrame hierarchy.
+ *
+ * \param matrix This is the matrix to store the output of the conversion
+ * \param voidIFrame This is a void pointer to the keyframe and should be cast
+ * to the keyframe type this callback is for.
+ */
+typedef void (*RpHAnimKeyFrameToMatrixCallBack) (RwMatrix *matrix, void *voidIFrame);
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimKeyFrameBlendCallBack
+ * This typedef defines a callback function for blending between two animation
+ * keyframes by the given blend factor.
+ *
+ * \param voidOut This is the void pointer for the output of the blend
+ * \param voidIn1 First input keyframe
+ * \param voidIn2 Second input keyframe
+ * \param alpha Blend factor
+ */
+typedef void (*RpHAnimKeyFrameBlendCallBack) (void *voidOut, void *voidIn1,
+ void *voidIn2, RwReal alpha);
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimKeyFrameInterpolateCallBack
+ * This typedef defines a callback function for interpolating between two
+ * animation keyframes according to the given time.
+ *
+ * \param voidOut This is the void pointer for the output of the
+ * interpolation
+ * \param voidIn1 First input keyframe
+ * \param voidIn2 Second input keyframe
+ * \param time Time at which to interpolate
+ */
+typedef void (*RpHAnimKeyFrameInterpolateCallBack) (void *voidOut, void *voidIn1,
+ void *voidIn2, RwReal time);
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimKeyFrameAddCallBack
+ * This typedef defines a callback function for adding together two animation
+ * keyframes. One of the keyframes would usually be a delta.
+ *
+ * \param voidOut This is the void pointer for the output summed keyframe
+ * \param voidIn1 First input keyframe
+ * \param voidIn2 Second input keyframe
+ */
+typedef void (*RpHAnimKeyFrameAddCallBack) (void *voidOut, void *voidIn1,
+ void *voidIn2);
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimKeyFrameMulRecipCallBack
+ * This typedef defines a callback function for multiplying a keyframe
+ * by the inverse of another keyframe
+ *
+ * \param voidFrame This is the void pointer for the keyframe to be modified
+ * \param voidStart First start keyframe to take the reciprocal of.
+ */
+typedef void (*RpHAnimKeyFrameMulRecipCallBack) (void *voidFrame, void *voidStart);
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimKeyFrameStreamReadCallBack
+ * This typedef defines a callback function for reading in keyframes
+ * from an \ref RwStream for the given animation.
+ *
+ * \param stream The stream to read the keyframes from
+ * \param animation The animation to read the keyframes into
+ *
+ * \return Pointer to the animation.
+ */
+typedef RpHAnimAnimation * (*RpHAnimKeyFrameStreamReadCallBack) (RwStream *stream, RpHAnimAnimation *animation);
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimKeyFrameStreamWriteCallBack
+ * This typedef defines a callback function for writing keyframes from the
+ * given animation to an \ref RwStream.
+ *
+ * \param animation The animation to write out from
+ * \param stream The stream to write the keyframes to
+ *
+ * \return TRUE if successful.
+ */
+typedef RwBool (*RpHAnimKeyFrameStreamWriteCallBack) (RpHAnimAnimation *animation, RwStream *stream);
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimKeyFrameStreamGetSizeCallBack
+ * This typedef defines a callback function for calculating the binary stream
+ * size of keyframe data within an animation.
+ *
+ * \param animation The animation to calculate sizes of
+ *
+ * \return Size in bytes of the keyframe data.
+ */
+typedef RwInt32 (*RpHAnimKeyFrameStreamGetSizeCallBack) (RpHAnimAnimation *animation);
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimInterpolatorInfo
+ * typedef for struct \ref RpHAnimInterpolatorInfo
+ */
+typedef struct RpHAnimInterpolatorInfo RpHAnimInterpolatorInfo;
+
+/**
+ * \ingroup rphanim
+ * \struct RpHAnimInterpolatorInfo
+ * This is used to hold information for a keyframe interpolation scheme.
+ *
+ * \see RpHAnimRegisterInterpolationScheme
+ * \see RpHAnimGetInterpolatorInfo
+ */
+struct RpHAnimInterpolatorInfo
+{
+ RwInt32 typeID; /**< The ID of the interpolation scheme */
+ RwInt32 keyFrameSize; /**< Size in bytes of the keyframe structure */
+ RpHAnimKeyFrameToMatrixCallBack keyFrameToMatrixCB; /**< Pointer to a function that converts a keyframe to a matrix */
+ RpHAnimKeyFrameBlendCallBack keyFrameBlendCB; /**< Pointer to a function that blends between a pair of keyframes for a given delta value */
+ RpHAnimKeyFrameInterpolateCallBack keyFrameInterpolateCB; /**< Pointer to a function that interpolates between two keyframes for a given time in between */
+ RpHAnimKeyFrameAddCallBack keyFrameAddCB; /**< Pointer to a function that adds two keyframes (one of which may be a delta) */
+ RpHAnimKeyFrameMulRecipCallBack keyFrameMulRecipCB; /**< Pointer to a function that multiplies a keyframe by the reciprocal of another */
+ RpHAnimKeyFrameStreamReadCallBack keyFrameStreamReadCB; /**< Pointer to a function that reads the keyframes from a stream for a given animation */
+ RpHAnimKeyFrameStreamWriteCallBack keyFrameStreamWriteCB; /**< Pointer to a function that writes the keyframes to a stream for a given animation */
+ RpHAnimKeyFrameStreamGetSizeCallBack keyFrameStreamGetSizeCB; /**< Pointer to a function that returns the binary stream size of the keyframes for a given animation */
+};
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimKeyFrameHeader
+ * typedef for struct RpHAnimKeyFrameHeader
+ */
+typedef struct RpHAnimKeyFrameHeader RpHAnimKeyFrameHeader;
+
+/**
+ * \ingroup rphanim
+ * \struct RpHAnimKeyFrameHeader
+ * Holds header information for a keyframe. All keyframe structures used with
+ * the overloadable interpolation system should start with this data.
+ *
+ * \see RpHAnimStdKeyFrame
+ * \see RpHAnimRegisterInterpolationScheme
+ */
+struct RpHAnimKeyFrameHeader
+{
+ void *prevFrame; /**< Previous keyframe for particular hierarchy node */
+ RwReal time; /**< Time at keyframe */
+};
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimStdKeyFrame
+ * typedef for struct RpHAnimStdKeyFrame
+ */
+typedef struct RpHAnimStdKeyFrame RpHAnimStdKeyFrame;
+
+/**
+ * \ingroup rphanim
+ * \struct RpHAnimStdKeyFrame
+ * A structure representing the standard keyframe data. Sequences of
+ * such keyframes in an \ref RpHAnimAnimation defines the animation of each
+ * node in a hierarchy.
+ */
+struct RpHAnimStdKeyFrame
+{
+ RpHAnimStdKeyFrame *prevFrame; /**< Previous keyframe for particular hierarchy node */
+ RwReal time; /**< Time at keyframe */
+ RtQuat q; /**< Quaternion rotation at keyframe */
+ RwV3d t; /**< Translation at keyframe */
+};
+
+/* Flags for FrameInfos */
+
+#define rpHANIMPOPPARENTMATRIX 0x01
+#define rpHANIMPUSHPARENTMATRIX 0x02
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimNodeInfo
+ * typedef for struct RpHAnimNodeInfo
+ */
+typedef struct RpHAnimNodeInfo RpHAnimNodeInfo;
+
+/**
+ * \ingroup rphanim
+ * \struct RpHAnimNodeInfo
+ *
+ */
+struct RpHAnimNodeInfo
+{
+ RwInt32 nodeID; /**< User defined ID for this node */
+ RwInt32 nodeIndex; /**< Array index of node */
+ RwInt32 flags; /**< Matrix push/pop flags */
+ RwFrame * pFrame; /**< Pointer to an attached RwFrame (see \ref RpHAnimHierarchyAttach) */
+};
+
+/**
+ * \ingroup rphanim
+ * \struct RpHAnimAnimation
+ * A hierarchical animation consists of an array of keyframe structures,
+ * along with some flags and a duration.
+ *
+ * The keyframes should be presented in the order they are needed
+ * to animate forwards through time. Pointers link all of the keyframes
+ * for a particular node backwards through time in a list.
+ *
+ * For example, a 3 node animation, with keyframes at the following times:
+ *
+ * Node 1: 0.0, 1.0, 2.0, 3.0
+ * Node 2: 0.0, 3.0
+ * Node 3: 0.0, 2.0, 2.5, 3.0
+ *
+ * should be formatted in an RpHAnimAnimation animation like this:
+ *
+ * B1,0.0 B2,0.0 B3,0.0 B1,1.0, B2,3.0, B3,2.0, B1,2.0, B1,3.0, B3,2.5 B3,3.0
+ *
+ * Each node MUST start at time = 0.0, and each node must terminate with a keyframe
+ * at time = duration of animation.
+ *
+ * \see RpHAnimAnimationCreate
+ */
+struct RpHAnimAnimation
+{
+ RpHAnimInterpolatorInfo *interpInfo; /**< Pointer to interpolation scheme information */
+ RwInt32 numFrames; /**< Number of keyframes in the animation */
+ RwInt32 flags; /**< Specifies details about animation, relative translation modes etc */
+ RwReal duration; /**< Duration of animation in seconds */
+ void *pFrames; /**< Pointer to the animation keyframes */
+};
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimHierarchyFlag defines type and update modes in HAnimHierarchies
+ *
+ * \see RpAnimHierarchyFlag
+ */
+enum RpHAnimHierarchyFlag
+{
+ /* creation flags */
+ rpHANIMHIERARCHYSUBHIERARCHY = 0x01, /**< This hierarchy is a sub-hierarchy */
+ rpHANIMHIERARCHYNOMATRICES = 0x02, /**< This hierarchy has no local matrices */
+
+ /* update flags */
+ rpHANIMHIERARCHYUPDATEMODELLINGMATRICES = 0x1000, /**< This hierarchy updates modeling matrices */
+ rpHANIMHIERARCHYUPDATELTMS = 0x2000, /**< This hierarchy updates LTMs */
+ rpHANIMHIERARCHYLOCALSPACEMATRICES = 0x4000, /**< This hierarchy calculates matrices in a space
+ relative to its root */
+
+ rpHANIMHIERARCHYFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+/**
+ * \ingroup rphanim
+ * \typedef RpHAnimHierarchyFlag
+ * These flags are used to control the creation and
+ * update status of the hierarchy
+ */
+typedef enum RpHAnimHierarchyFlag RpHAnimHierarchyFlag;
+
+/**
+ * \ingroup rphanim
+ * \struct RpHAnimHierarchy
+ * An RpHAnimHierarchy is used to "play back" an animation - it holds the
+ * interpolated keyframe data for the current state of an animation
+ * concatenated on the end of the structure.
+ *
+ * The rpHANIMHIERARCHYGETINTERPFRAME() macro can be used to access the current
+ * interpolated data, for the current time or to write to this data to override
+ * it with procedural animation.
+ *
+ * The structure of a hierarchy is defined by an array
+ * of \ref RpHAnimNodeInfo structures.
+ *
+ * The hierarchy is defined by running through the node array in order,
+ * pushing the parent-node's matrix whenever a child is reached that has
+ * more than one sibling, and popping the parent matrix when a "leaf"
+ * node is encountered.
+ *
+ */
+struct RpHAnimHierarchy
+{
+ RwInt32 flags; /**< Flags for the hierarchy */
+ RwInt32 numNodes; /**< Number of nodes in the hierarchy */
+ RpHAnimAnimation *pCurrentAnim; /**< Current animation applied to hierarchy */
+ RwReal currentTime; /**< Current animation time */
+ void *pNextFrame; /**< Next animation keyframe to be played */
+ RpHAnimHierarchyCallBack pAnimCallBack; /**< Animation callback function pointer */
+ void *pAnimCallBackData; /**< Animation callback function user data */
+ RwReal animCallBackTime; /**< Trigger time for callback function */
+ RpHAnimHierarchyCallBack pAnimLoopCallBack; /**< Animation loop callback function pointer */
+ void *pAnimLoopCallBackData; /**< Animation loop callback function data */
+ RwMatrix *pMatrixArray; /**< Pointer to node matrices*/
+ void *pMatrixArrayUnaligned; /**< Pointer to memory used for node matrices
+ * from which the aligned pMatrixArray is allocated */
+ RpHAnimNodeInfo *pNodeInfo; /**< Array of node information (push/pop flags etc) */
+ RwFrame *parentFrame; /**< Pointer to the Root RwFrame of the hierarchy this
+ * RpHAnimHierarchy represents */
+ RwInt32 maxKeyFrameSize; /**< Maximum size of keyframes usable on this hierarhcy
+ * (set at creation time) */
+ RwInt32 currentKeyFrameSize; /**< Size of keyframes in the current animation */
+ RpHAnimKeyFrameToMatrixCallBack keyFrameToMatrixCB; /**< Internal use */
+ RpHAnimKeyFrameBlendCallBack keyFrameBlendCB; /**< Internal use */
+ RpHAnimKeyFrameInterpolateCallBack keyFrameInterpolateCB; /**< Internal use */
+ RpHAnimKeyFrameAddCallBack keyFrameAddCB; /**< Internal use */
+ RpHAnimHierarchy *parentHierarchy; /**< Internal use */
+ RwInt32 offsetInParent; /**< Internal use */
+ RwInt32 rootParentOffset; /**< Internal use */
+};
+
+#define rpHANIMHIERARCHYGETINTERPFRAME( hierarchy, nodeIndex ) \
+ ( (void *)( ( (RwUInt8 *)&(hierarchy[1]) + \
+ ((nodeIndex) * \
+ hierarchy->currentKeyFrameSize) ) ) )
+
+#define rpHANIMHIERARCHYGETINTERPFRAME1( hierarchy, nodeIndex ) \
+ ( (void *)( ( (RwUInt8 *)&(hierarchy[1]) + \
+ ((hierarchy->numNodes + \
+ (nodeIndex)) * \
+ hierarchy->currentKeyFrameSize) ) ) )
+
+#define rpHANIMHIERARCHYGETINTERPFRAME2( hierarchy, nodeIndex ) \
+ ( (void *)( ( (RwUInt8 *)&(hierarchy[1]) + \
+ ((hierarchy->numNodes * 2 + \
+ (nodeIndex)) * \
+ hierarchy->currentKeyFrameSize) ) ) )
+
+/**
+ * \ingroup rphanim
+ * \ref RpHAnimFrameExtension typedef for struct RpHAnimFrameExtension
+ */
+
+typedef struct RpHAnimFrameExtension RpHAnimFrameExtension;
+
+/**
+ * \ingroup rphanim
+ * \struct RpHAnimFrameExtension
+ */
+struct RpHAnimFrameExtension
+{
+ RwInt32 id; /**< ID given to this RwFrame (default of -1) */
+ RpHAnimHierarchy *hierarchy; /**< Pointer to Animation hierarchy attached to this RwFrame */
+};
+
+/*--- Plugin API Functions ---*/
+
+#define RpHAnimHierarchySetFlagsMacro(hierarchy, _flags) \
+MACRO_START \
+{ \
+ (hierarchy)->flags = _flags; \
+} \
+MACRO_STOP
+
+#define RpHAnimHierarchyGetFlagsMacro(hierarchy) \
+ ((hierarchy)->flags)
+
+#define RpHAnimStdKeyFrameToMatrixMacro(_matrix, _voidIFrame) \
+MACRO_START \
+{ \
+ RpHAnimStdKeyFrame * iFrame = (RpHAnimStdKeyFrame *)(_voidIFrame); \
+ \
+ /* \
+ * RpHAnim uses the same types of quaternion as RtQuat \
+ * hence no conjugate call as in RpSkin \
+ */ \
+ \
+ RtQuatUnitConvertToMatrix(&iFrame->q, (_matrix)); \
+ \
+ (_matrix)->pos.x = iFrame->t.x; \
+ (_matrix)->pos.y = iFrame->t.y; \
+ (_matrix)->pos.z = iFrame->t.z; \
+} \
+MACRO_STOP
+
+
+#if (! defined(RWDEBUG))
+
+#define RpHAnimHierarchySetFlags(hierarchy, _flags) \
+ RpHAnimHierarchySetFlagsMacro(hierarchy, _flags)
+
+#define RpHAnimHierarchyGetFlags(hierarchy) \
+ (RpHAnimHierarchyFlag)RpHAnimHierarchyGetFlagsMacro(hierarchy)
+
+#endif /* (! defined(RWDEBUG)) */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+#if (defined(RWDEBUG))
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchySetFlags(RpHAnimHierarchy *hierarchy,
+ RpHAnimHierarchyFlag flags);
+
+extern RpHAnimHierarchyFlag
+RpHAnimHierarchyGetFlags(RpHAnimHierarchy *hierarchy);
+
+#endif /* (defined(RWDEBUG)) */
+
+/* Keyframe Interpolator Types */
+
+extern RwBool
+RpHAnimRegisterInterpolationScheme(RpHAnimInterpolatorInfo *interpolatorInfo);
+
+extern RpHAnimInterpolatorInfo *
+RpHAnimGetInterpolatorInfo(RwInt32 typeID);
+
+/* Animation hierarchy creation */
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchyCreate(RwInt32 numNodes,
+ RwUInt32 *nodeFlags,
+ RwInt32 *nodeIDs,
+ RpHAnimHierarchyFlag flags,
+ RwInt32 maxKeyFrameSize);
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchyCreateFromHierarchy(RpHAnimHierarchy *hierarchy,
+ RpHAnimHierarchyFlag flags,
+ RwInt32 maxKeyFrameSize);
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchyDestroy(RpHAnimHierarchy *hierarchy);
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchyCreateSubHierarchy(RpHAnimHierarchy *parentHierarchy,
+ RwInt32 startNode,
+ RpHAnimHierarchyFlag flags,
+ RwInt32 maxKeyFrameSize);
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchyAttach(RpHAnimHierarchy *hierarchy);
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchyDetach(RpHAnimHierarchy *hierarchy);
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchyAttachFrameIndex(RpHAnimHierarchy *hierarchy,
+ RwInt32 nodeIndex);
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchyDetachFrameIndex(RpHAnimHierarchy *hierarchy,
+ RwInt32 nodeIndex);
+
+extern RwBool
+RpHAnimFrameSetHierarchy(RwFrame *frame,
+ RpHAnimHierarchy *hierarchy);
+
+extern RpHAnimHierarchy *
+RpHAnimFrameGetHierarchy(RwFrame *frame);
+
+/* Macros for legacy support of old function names */
+#define RpHAnimSetHierarchy(frame, hierarchy) \
+ RpHAnimFrameSetHierarchy(frame, hierarchy)
+#define RpHAnimGetHierarchy(frame) RpHAnimFrameGetHierarchy(frame)
+
+extern RwBool
+RpHAnimHierarchySetKeyFrameCallBacks(RpHAnimHierarchy *hierarchy,
+ RwInt32 keyFrameTypeID);
+
+extern RwBool
+RpHAnimHierarchySetCurrentAnim(RpHAnimHierarchy *hierarchy,
+ RpHAnimAnimation *anim);
+
+extern RwBool
+RpHAnimHierarchySetCurrentAnimTime(RpHAnimHierarchy *hierarchy,
+ RwReal time);
+
+extern RwBool
+RpHAnimHierarchySubAnimTime(RpHAnimHierarchy *hierarchy,
+ RwReal time);
+
+extern RwBool
+RpHAnimHierarchyStdKeyFrameAddAnimTime(RpHAnimHierarchy *hierarchy,
+ RwReal time);
+
+extern RwBool
+RpHAnimHierarchyAddAnimTime(RpHAnimHierarchy *hierarchy,
+ RwReal time);
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchySetAnimCallBack(RpHAnimHierarchy *hierarchy,
+ RpHAnimHierarchyCallBack callBack,
+ RwReal time,
+ void *data );
+
+extern RpHAnimHierarchy *
+RpHAnimHierarchySetAnimLoopCallBack(RpHAnimHierarchy *hierarchy,
+ RpHAnimHierarchyCallBack callBack,
+ void *data );
+
+extern RwMatrix *
+RpHAnimHierarchyGetMatrixArray(RpHAnimHierarchy *hierarchy);
+
+extern RwBool
+RpHAnimHierarchyUpdateMatrices(RpHAnimHierarchy *hierarchy);
+
+/* Macro for legacy support of old function name */
+#define RpHAnimUpdateHierarchyMatrices RpHAnimHierarchyUpdateMatrices
+
+extern RwInt32
+RpHAnimIDGetIndex(RpHAnimHierarchy *hierarchy,
+ RwInt32 ID);
+
+/* Animations */
+
+extern RpHAnimAnimation *
+RpHAnimAnimationCreate(RwInt32 typeID,
+ RwInt32 numFrames,
+ RwInt32 flags,
+ RwReal duration);
+
+extern RpHAnimAnimation *
+RpHAnimAnimationDestroy(RpHAnimAnimation *animation);
+
+#ifdef RWDEBUG
+
+extern RwInt32
+RpHAnimAnimationGetTypeID(RpHAnimAnimation *animation);
+
+#else /* RWDEBUG */
+
+#define RpHAnimAnimationGetTypeID(animation) \
+ (animation->interpInfo->typeID)
+
+#endif /* RWDEBUG */
+
+extern RpHAnimAnimation *
+RpHAnimAnimationRead(const RwChar * filename);
+
+extern RwBool
+RpHAnimAnimationWrite(RpHAnimAnimation *animation,
+ const RwChar * filename);
+
+extern RpHAnimAnimation *
+RpHAnimAnimationStreamRead(RwStream *stream);
+
+extern RwBool
+RpHAnimAnimationStreamWrite(RpHAnimAnimation *animation,
+ RwStream *stream);
+
+extern RwInt32
+RpHAnimAnimationStreamGetSize(RpHAnimAnimation *animation);
+
+extern RwBool
+RpHAnimAnimationMakeDelta(RpHAnimAnimation *animation,
+ RwInt32 numNodes,
+ RwReal time);
+
+/* Plugin support */
+
+extern RwBool
+RpHAnimPluginAttach(void);
+
+/* Overloadable keyframe functions */
+
+#define RpHAnimFrameToMatrixMacro(hierarchy, matrix, iFrame) \
+MACRO_START \
+{ \
+ const RpHAnimKeyFrameToMatrixCallBack keyFrameToMatrixCB = \
+ (hierarchy)->keyFrameToMatrixCB; \
+ \
+ if (RpHAnimStdKeyFrameToMatrix == keyFrameToMatrixCB) \
+ { \
+ RpHAnimStdKeyFrameToMatrixMacro((matrix), (iFrame)); \
+ } \
+ else \
+ { \
+ keyFrameToMatrixCB((matrix), (iFrame)); \
+ } \
+} \
+MACRO_STOP
+
+#define RpHAnimFrameInterpolateMacro(hierarchy, out, in1, in2, time) \
+MACRO_START \
+{ \
+ (hierarchy)->keyFrameInterpolateCB((out), (in1), (in2), (time)); \
+} \
+MACRO_STOP
+
+#define RpHAnimFrameBlendMacro(hierarchy, out, in1, in2, fAlpha) \
+MACRO_START \
+{ \
+ (hierarchy)->keyFrameBlendCB((out), (in1), (in2), (fAlpha)); \
+} \
+MACRO_STOP
+
+#define RpHAnimFrameAddTogetherMacro(hierarchy, out, in1, in2) \
+MACRO_START \
+{ \
+ (hierarchy)->keyFrameAddCB((out), (in1), (in2)); \
+} \
+MACRO_STOP
+
+#ifdef RWDEBUG
+void
+RpHAnimFrameInterpolate(RpHAnimHierarchy *hierarchy,
+ void *out, void *in1,
+ void *in2, RwReal time);
+
+void
+RpHAnimFrameBlend(RpHAnimHierarchy *hierarchy,
+ void *out,
+ void *in1,
+ void *in2,
+ RwReal alpha);
+
+void
+RpHAnimFrameToMatrix(RpHAnimHierarchy *hierarchy,
+ RwMatrix *matrix, void *iFrame);
+
+void
+RpHAnimFrameAddTogether(RpHAnimHierarchy *hierarchy,
+ void *out, void *in1, void *in2);
+
+#else /* RWDEBUG */
+
+#define RpHAnimFrameToMatrix(hierarchy, matrix, iFrame) \
+ RpHAnimFrameToMatrixMacro(hierarchy, matrix, iFrame)
+
+#define RpHAnimFrameInterpolate(hierarchy, out, in1, in2, time) \
+ RpHAnimFrameInterpolateMacro(hierarchy, out, in1, in2, time)
+
+#define RpHAnimFrameBlend(hierarchy, out, in1, in2, alpha) \
+ RpHAnimFrameBlendMacro(hierarchy, out, in1, in2, alpha)
+
+#define RpHAnimFrameAddTogether(hierarchy, out, in1, in2) \
+ RpHAnimFrameAddTogetherMacro(hierarchy, out, in1, in2)
+
+#endif /* RWDEBUG */
+
+/* Standard keyframe functions */
+
+extern void
+RpHAnimStdKeyFrameToMatrix(RwMatrix *matrix,
+ void * voidIFrame);
+
+extern void
+RpHAnimStdKeyFrameBlend(void *voidOut,
+ void *voidIn1,
+ void *voidIn2,
+ RwReal alpha);
+
+extern void
+RpHAnimStdKeyFrameInterpolate(void *voidOut,
+ void *voidIn1,
+ void *voidIn2,
+ RwReal time);
+
+extern void
+RpHAnimStdKeyFrameAdd(void *voidOut,
+ void *voidIn1,
+ void *voidIn2);
+
+extern void
+RpHAnimStdKeyFrameMulRecip(void *voidFrame,
+ void *voidStart);
+
+extern RpHAnimAnimation *
+RpHAnimStdKeyFrameStreamRead(RwStream *stream,
+ RpHAnimAnimation *animation);
+
+extern RwBool
+RpHAnimStdKeyFrameStreamWrite(RpHAnimAnimation *animation,
+ RwStream *stream);
+
+extern RwInt32
+RpHAnimStdKeyFrameStreamGetSize(RpHAnimAnimation *animation);
+
+/* Hierarchy blending/combination functions */
+
+extern RwBool
+RpHAnimHierarchyBlend(RpHAnimHierarchy *outHierarchy,
+ RpHAnimHierarchy *inHierarchy1,
+ RpHAnimHierarchy *inHierarchy2,
+ RwReal alpha);
+extern RwBool
+RpHAnimHierarchyAddTogether(RpHAnimHierarchy *outHierarchy,
+ RpHAnimHierarchy *inHierarchy1,
+ RpHAnimHierarchy *inHierarchy2);
+
+extern RwBool
+RpHAnimHierarchyBlendSubHierarchy(RpHAnimHierarchy *outHierarchy,
+ RpHAnimHierarchy *inHierarchy1,
+ RpHAnimHierarchy *inHierarchy2,
+ RwReal alpha);
+extern RwBool
+RpHAnimHierarchyAddSubHierarchy(RpHAnimHierarchy *outHierarchy,
+ RpHAnimHierarchy *mainHierarchy,
+ RpHAnimHierarchy *subHierarchy);
+
+extern RwBool
+RpHAnimHierarchyCopy(RpHAnimHierarchy *outHierarchy,
+ RpHAnimHierarchy *inHierarchy);
+
+/* Access to RwFrame ID's */
+
+extern RwBool
+RpHAnimFrameSetID(RwFrame *frame,
+ RwInt32 id);
+
+extern RwInt32
+RpHAnimFrameGetID(RwFrame *frame);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* RPHANIM_H */
diff --git a/rwsdk/include/d3d8/rphanim.rpe b/rwsdk/include/d3d8/rphanim.rpe
new file mode 100644
index 00000000..c60f8591
--- /dev/null
+++ b/rwsdk/include/d3d8/rphanim.rpe
@@ -0,0 +1,644 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionHANIM
+{
+
+
+E_RP_HANIM_INTERP_IDINUSE,
+
+E_RP_HANIM_INTERP_BLOCKFULL,
+
+E_RP_HANIM_INTERP_IDUNKNOWN,
+
+ e_rwdb_CriterionHANIMLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionHANIM e_rwdb_CriterionHANIM;
+
+
diff --git a/rwsdk/include/d3d8/rplodatm.h b/rwsdk/include/d3d8/rplodatm.h
new file mode 100644
index 00000000..d4583338
--- /dev/null
+++ b/rwsdk/include/d3d8/rplodatm.h
@@ -0,0 +1,131 @@
+
+/******************************************
+ * *
+ * RenderWare(TM) Graphics Library *
+ * *
+ ******************************************/
+
+/*
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd.
+ * or Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. and Canon Inc. will not, under any
+ * circumstances, be liable for any lost revenue or other damages
+ * arising from the use of this file.
+ *
+ * Copyright (c) 1998. Criterion Software Ltd.
+ * All Rights Reserved.
+ */
+
+/***************************************************************************
+ * *
+ * Module : rplodatm.h *
+ * *
+ * Purpose : LODATM Geometry *
+ * *
+ **************************************************************************/
+
+#ifndef RPLODATM_H
+#define RPLODATM_H
+
+
+/**
+ * \defgroup rplodatm RpLODAtomic
+ * \ingroup rpplugin
+ *
+ * Level of Detail Management Plugin for RenderWare Graphics.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include "rwcore.h"
+#include "rpworld.h"
+
+#include "rpcriter.h" /* Note: each vendor can choose their own method for
+ * allocation of unique ID's. This file defines
+ * the ID's used by Criterion.
+ */
+#include "rplodatm.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Defines
+ */
+#define RPLODATOMICMAXLOD 10
+
+
+/****************************************************************************
+ Type defs
+ */
+typedef RwInt32 (*RpLODAtomicLODCallBack)( RpAtomic *atomic );
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+ extern RwBool
+ RpLODAtomicPluginAttach( void );
+
+ extern RpAtomic *
+ RpLODAtomicSetGeometry(
+ RpAtomic *atomic, RwInt32 lodIdx, RpGeometry *geometry );
+
+ extern RpGeometry *
+ RpLODAtomicGetGeometry(
+ RpAtomic *atomic, RwInt32 lodIdx );
+
+ extern RpAtomic *
+ RpLODAtomicSetCurrentLOD(
+ RpAtomic *atomic, RwInt32 lodIdx );
+
+ extern RwInt32
+ RpLODAtomicGetCurrentLOD(
+ RpAtomic *atomic );
+
+ extern RpAtomic *
+ RpLODAtomicSetRange(
+ RpAtomic *atomic, RwReal farRange );
+
+ extern RwReal
+ RpLODAtomicGetRange(
+ RpAtomic *atomic );
+
+ extern void
+ RpLODAtomicSetCamera(
+ RwCamera *camera );
+
+ extern RpAtomic *
+ RpLODAtomicSetLODCallBack(
+ RpAtomic *atomic, RpLODAtomicLODCallBack callback );
+
+ extern RpAtomic *
+ RpLODAtomicSelectLOD(
+ RpAtomic *atomic );
+
+ extern RpAtomic *
+ RpLODAtomicForAllLODGeometries(
+ RpAtomic *atomic, RpGeometryCallBack callback, void *pData );
+
+ extern RpAtomic *
+ RpLODAtomicHookRender(
+ RpAtomic *atomic );
+
+ extern RpAtomic *
+ RpLODAtomicUnHookRender(
+ RpAtomic *atomic );
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RPLODATM_H */
+
diff --git a/rwsdk/include/d3d8/rplodatm.rpe b/rwsdk/include/d3d8/rplodatm.rpe
new file mode 100644
index 00000000..649bc3bc
--- /dev/null
+++ b/rwsdk/include/d3d8/rplodatm.rpe
@@ -0,0 +1,642 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionLODATM
+{
+
+
+
+ e_rwdb_CriterionLODATMLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionLODATM e_rwdb_CriterionLODATM;
+
+
diff --git a/rwsdk/include/d3d8/rplogo.h b/rwsdk/include/d3d8/rplogo.h
new file mode 100644
index 00000000..ed527a29
--- /dev/null
+++ b/rwsdk/include/d3d8/rplogo.h
@@ -0,0 +1,83 @@
+/**
+ * Logo plugin
+ */
+
+
+/**********************************************************************
+ *
+ * File : rplogo.h
+ *
+ * Abstract : Add CSL Logo
+ *
+ **********************************************************************
+ *
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd. or
+ * Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. will not, under any
+ * circumstances, be liable for any lost revenue or other damages arising
+ * from the use of this file.
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+ * All Rights Reserved.
+ *
+ * RenderWare is a trademark of Canon Inc.
+ *
+ ************************************************************************/
+
+#ifndef RPLOGO_H
+#define RPLOGO_H
+
+/**
+ * \defgroup rplogo RpLogo
+ * \ingroup rpplugin
+ *
+ * Logo Plugin for RenderWare Graphics.
+ */
+
+/*--- Include files ---*/
+#include "rwcore.h"
+
+#include "rplogo.rpe" /* automatically generated header file */
+
+/*--- Global Structures ---*/
+
+enum RpLogoPosition
+{
+ rpNALOGOPOSITION = 0,
+ rpLOGOTOP,
+ rpLOGOCENTER,
+ rpLOGOBOTTOM,
+ rpLOGOLEFT,
+ rpLOGORIGHT,
+ rpLOGOTOPLEFT,
+ rpLOGOTOPRIGHT,
+ rpLOGOBOTTOMLEFT,
+ rpLOGOBOTTOMRIGHT,
+ rpLOGOPOSITIONFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpLogoPosition RpLogoPosition;
+
+/*--- Plugin API Functions ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+ RwBool RpLogoPluginAttach(void);
+ RwBool RpLogoSetPosition(RpLogoPosition pos);
+ RpLogoPosition RpLogoGetPosition(void);
+ RwBool RpLogoSetState(RwCamera * cam, RwBool state);
+ RwBool RpLogoGetState(RwCamera * cam);
+ RwRect *RpLogoGetRenderingRect(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RPLOGO_H */
+
diff --git a/rwsdk/include/d3d8/rplogo.rpe b/rwsdk/include/d3d8/rplogo.rpe
new file mode 100644
index 00000000..f37b6920
--- /dev/null
+++ b/rwsdk/include/d3d8/rplogo.rpe
@@ -0,0 +1,639 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionLogo
+{
+
+
+
+ e_rwdb_CriterionLogoLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionLogo e_rwdb_CriterionLogo;
+
+
diff --git a/rwsdk/include/d3d8/rpltmap.h b/rwsdk/include/d3d8/rpltmap.h
new file mode 100644
index 00000000..5add9a26
--- /dev/null
+++ b/rwsdk/include/d3d8/rpltmap.h
@@ -0,0 +1,90 @@
+
+/**
+ * \defgroup rpltmap RpLtMap
+ * \ingroup rpplugin
+ *
+ * Lightmap Plugin for RenderWare Graphics.
+ */
+
+#ifndef RPLTMAP_H
+#define RPLTMAP_H
+
+/*===========================================================================*
+ *--- Includes --------------------------------------------------------------*
+ *===========================================================================*/
+
+#include "rwcore.h"
+#include "rpworld.h"
+
+
+#define rpLTMAPDEFAULTLIGHTMAPSIZE 128
+#define rpLTMAPMINLIGHTMAPSIZE 16
+#define rpLTMAPMAXLIGHTMAPSIZE 512/*?? any better way of determining this ??*/
+
+#define rpLTMAPMAXPREFIXSTRINGLENGTH 4
+
+#define rpLTMAPDEFAULTMAXAREALIGHTSAMPLESPERMESH 256
+/* The default tolerance for errors induced by area light ROIs is 1
+ * (being the smallest difference in lightmap colour values) */
+#define rpLTMAPDEFAULTAREALIGHTROICUTOFF (1.0f)
+
+
+/**
+ * \ingroup rpltmap
+ * \ref RpLtMapStyle
+ * Flags specifying the rendering style of the lightmap plugin.
+ *
+ * \see RpLtMapGetRenderStyle
+ * \see RpLtMapSetRenderStyle
+ */
+enum RpLtMapStyle
+{
+ rpLTMAPSTYLENASTYLE = 0x0,
+
+ rpLTMAPSTYLERENDERBASE = 0x1, /**< The base texture should be rendered */
+ rpLTMAPSTYLERENDERLIGHTMAP = 0x2, /**< The lightmap should be rendered */
+ rpLTMAPSTYLEPOINTSAMPLE = 0x4, /**< The lightmap should be point-sampled */
+
+ rpLTMAPSTYLEFORCEENUMSIZEINT = 0x7FFFFFFF
+};
+typedef enum RpLtMapStyle RpLtMapStyle;
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+extern RwBool
+RpLtMapPluginAttach(void);
+
+extern RxPipeline *
+RpLtMapGetPlatformAtomicPipeline(void);
+extern RxPipeline *
+RpLtMapGetPlatformWorldSectorPipeline(void);
+
+extern RwBool
+RpLtMapSetRenderStyle(RpLtMapStyle style, RpWorld *world);
+extern RpLtMapStyle
+RpLtMapGetRenderStyle(void);
+
+extern RwUInt32
+RpLtMapWorldLightMapsQuery(RpWorld *world);
+
+extern RwTexture *
+RpLtMapWorldSectorGetLightMap(RpWorldSector *sector);
+extern RpWorldSector *
+RpLtMapWorldSectorSetLightMap(RpWorldSector *sector, RwTexture *lightMap);
+extern RwTexture *
+RpLtMapAtomicGetLightMap(RpAtomic *atomic);
+extern RpAtomic *
+RpLtMapAtomicSetLightMap(RpAtomic *atomic, RwTexture *lightMap);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RPLTMAP_H */
+
+
diff --git a/rwsdk/include/d3d8/rpltmap.rpe b/rwsdk/include/d3d8/rpltmap.rpe
new file mode 100644
index 00000000..413caf4c
--- /dev/null
+++ b/rwsdk/include/d3d8/rpltmap.rpe
@@ -0,0 +1,638 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionLTMAP
+{
+
+
+
+ e_rwdb_CriterionLTMAPLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionLTMAP e_rwdb_CriterionLTMAP;
+
+
diff --git a/rwsdk/include/d3d8/rpmatfx.h b/rwsdk/include/d3d8/rpmatfx.h
new file mode 100644
index 00000000..9b091dd8
--- /dev/null
+++ b/rwsdk/include/d3d8/rpmatfx.h
@@ -0,0 +1,237 @@
+
+#ifndef RPMATFX_H
+#define RPMATFX_H
+
+/*===========================================================================*
+ *--- Include files ---------------------------------------------------------*
+ *===========================================================================*/
+
+#include "rwcore.h"
+#include "rpworld.h"
+
+/*---- start: ./matfx.h----*/
+
+#ifndef RPMATFX_MATFX_H
+#define RPMATFX_MATFX_H
+
+
+/**
+ * \defgroup rpmatfx RpMatFX
+ * \ingroup rpplugin
+ *
+ * Material Effects Plugin for RenderWare Graphics.
+ */
+
+/*===========================================================================*
+ *--- Global Types ----------------------------------------------------------*
+ *===========================================================================*/
+
+/**
+ * \ingroup rpmatfx
+ * RpMatFXMaterialFlags, this type represents the different types of
+ * material effects that can be used on a material. The effects are
+ * initialized with \ref RpMatFXMaterialSetEffects:
+ */
+enum RpMatFXMaterialFlags
+{
+ rpMATFXEFFECTNULL = 0,
+ rpMATFXEFFECTBUMPMAP = 1, /**<Bump mapping */
+ rpMATFXEFFECTENVMAP = 2, /**<Environment mapping */
+ rpMATFXEFFECTBUMPENVMAP = 3, /**<Bump and environment mapping */
+ rpMATFXEFFECTDUAL = 4, /**<Dual pass */
+
+ rpMATFXEFFECTMAX,
+ rpMATFXNUMEFFECTS = rpMATFXEFFECTMAX - 1,
+
+ rpMATFXFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpMatFXMaterialFlags RpMatFXMaterialFlags;
+
+
+/*===========================================================================*
+ *--- Plugin API Functions --------------------------------------------------*
+ *===========================================================================*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/*--- Plugin functions ------------------------------------------------------*/
+extern RwBool
+RpMatFXPluginAttach( void );
+
+/*--- Setup functions -------------------------------------------------------*/
+extern RpAtomic *
+RpMatFXAtomicEnableEffects( RpAtomic *atomic );
+
+extern RwBool
+RpMatFXAtomicQueryEffects( RpAtomic *atomic );
+
+extern RpWorldSector *
+RpMatFXWorldSectorEnableEffects( RpWorldSector *worldSector );
+
+extern RwBool
+RpMatFXWorldSectorQueryEffects( RpWorldSector *worldSector );
+
+extern RpMaterial *
+RpMatFXMaterialSetEffects( RpMaterial *material,
+ RpMatFXMaterialFlags flags );
+
+
+/*--- Setup Effects ---------------------------------------------------------*/
+extern RpMaterial *
+RpMatFXMaterialSetupBumpMap( RpMaterial *material,
+ RwTexture *texture,
+ RwFrame *frame,
+ RwReal coef );
+
+extern RpMaterial *
+RpMatFXMaterialSetupEnvMap( RpMaterial *material,
+ RwTexture *texture,
+ RwFrame *frame,
+ RwBool useFrameBufferAlpha,
+ RwReal coef );
+
+extern RpMaterial *
+RpMatFXMaterialSetupDualTexture( RpMaterial *material,
+ RwTexture *texture,
+ RwBlendFunction srcBlendMode,
+ RwBlendFunction dstBlendMode );
+
+/*--- Tinker with effects ---------------------------------------------------*/
+extern RpMatFXMaterialFlags
+RpMatFXMaterialGetEffects( const RpMaterial *material );
+
+/*--- Bump Map --------------------------------------------------------------*/
+extern RpMaterial *
+RpMatFXMaterialSetBumpMapTexture( RpMaterial *material,
+ RwTexture *texture );
+
+extern RpMaterial *
+RpMatFXMaterialSetBumpMapFrame( RpMaterial *material,
+ RwFrame *frame );
+
+extern RpMaterial *
+RpMatFXMaterialSetBumpMapCoefficient( RpMaterial *material,
+ RwReal coef );
+extern RwTexture *
+RpMatFXMaterialGetBumpMapTexture( const RpMaterial *material );
+
+extern RwTexture *
+RpMatFXMaterialGetBumpMapBumpedTexture( const RpMaterial *material );
+
+extern RwFrame *
+RpMatFXMaterialGetBumpMapFrame( const RpMaterial *material );
+
+extern RwReal
+RpMatFXMaterialGetBumpMapCoefficient( const RpMaterial *material );
+
+/*--- Env Map ---------------------------------------------------------------*/
+extern RpMaterial *
+RpMatFXMaterialSetEnvMapTexture( RpMaterial *material,
+ RwTexture *texture );
+
+extern RpMaterial *
+RpMatFXMaterialSetEnvMapFrame( RpMaterial *material,
+ RwFrame *frame );
+
+extern RpMaterial *
+RpMatFXMaterialSetEnvMapFrameBufferAlpha( RpMaterial *material,
+ RwBool useFrameBufferAlpha );
+
+extern RpMaterial *
+RpMatFXMaterialSetEnvMapCoefficient( RpMaterial *material,
+ RwReal coef );
+
+extern RwTexture *
+RpMatFXMaterialGetEnvMapTexture( const RpMaterial *material );
+
+extern RwFrame *
+RpMatFXMaterialGetEnvMapFrame( const RpMaterial *material );
+
+extern RwBool
+RpMatFXMaterialGetEnvMapFrameBufferAlpha( const RpMaterial *material );
+
+extern RwReal
+RpMatFXMaterialGetEnvMapCoefficient( const RpMaterial *material );
+
+/*--- Dual Pass -------------------------------------------------------------*/
+extern RpMaterial *
+RpMatFXMaterialSetDualTexture( RpMaterial *material,
+ RwTexture *texture );
+
+extern RpMaterial *
+RpMatFXMaterialSetDualBlendModes( RpMaterial *material,
+ RwBlendFunction srcBlendMode,
+ RwBlendFunction dstBlendMode );
+
+extern RwTexture *
+RpMatFXMaterialGetDualTexture( const RpMaterial *material );
+
+extern const RpMaterial *
+RpMatFXMaterialGetDualBlendModes( const RpMaterial *material,
+ RwBlendFunction *srcBlendMode,
+ RwBlendFunction *dstBlendMode );
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* RPMATFX_MATFX_H */
+
+/*---- end: ./matfx.h----*/
+
+/*---- start: c:/daily/rwsdk/plugin/matfx/d3d8/matfxplatform.h----*/
+
+/**
+ * \defgroup rpmatfxd3d8 D3D8
+ * \ingroup rpmatfx
+ *
+ * D3D8 specific documentation.
+ */
+
+
+/******************************************************************************
+ * Enum types
+ */
+
+/**
+ * \ingroup rpmatfxd3d8
+ * \ref RpMatFXD3D8Pipeline
+ */
+enum RpMatFXD3D8Pipeline
+{
+ rpNAMATFXD3D8PIPELINE = 0,
+ rpMATFXD3D8ATOMICPIPELINE = 1, /**<D3D8 atomic material effect rendering pipeline. */
+ rpMATFXD3D8WORLDSECTORPIPELINE = 2, /**<D3D8 world sector material effect rendering pipeline. */
+ rpMATFXD3D8PIPELINEMAX,
+ rpMATFXD3D8PIPELINEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpMatFXD3D8Pipeline RpMatFXD3D8Pipeline;
+
+/******************************************************************************
+ * Global types
+ */
+
+/******************************************************************************
+ * Functions
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxPipeline *
+RpMatFXGetD3D8Pipeline( RpMatFXD3D8Pipeline d3d8Pipeline );
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*---- end: c:/daily/rwsdk/plugin/matfx/d3d8/matfxplatform.h----*/
+
+#endif /* RPMATFX_H */
+
+
diff --git a/rwsdk/include/d3d8/rpmatfx.rpe b/rwsdk/include/d3d8/rpmatfx.rpe
new file mode 100644
index 00000000..bbc588e3
--- /dev/null
+++ b/rwsdk/include/d3d8/rpmatfx.rpe
@@ -0,0 +1,638 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionMATERIALEFFECTS
+{
+
+
+
+ e_rwdb_CriterionMATERIALEFFECTSLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionMATERIALEFFECTS e_rwdb_CriterionMATERIALEFFECTS;
+
+
diff --git a/rwsdk/include/d3d8/rpmipkl.h b/rwsdk/include/d3d8/rpmipkl.h
new file mode 100644
index 00000000..5b8f7e51
--- /dev/null
+++ b/rwsdk/include/d3d8/rpmipkl.h
@@ -0,0 +1,38 @@
+/**
+ * PS2 Mipmap K&L plugin for Renderware.
+ */
+
+#ifndef RPMIPMAPKLPLUGIN_H
+#define RPMIPMAPKLPLUGIN_H
+
+/**
+ * \defgroup rpmipkl RpMipmapKL
+ * \ingroup rpplugin
+ *
+ * PS2/MipMap KL Value Plugin for RenderWare Graphics.
+ */
+
+#include <rwcore.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern RwReal RpMipmapKLTextureSetDefaultK(RwReal val);
+extern RwUInt32 RpMipmapKLTextureSetDefaultL(RwUInt32 val);
+extern RwReal RpMipmapKLTextureGetDefaultK(void);
+extern RwUInt32 RpMipmapKLTextureGetDefaultL(void);
+
+extern RwTexture *RpMipmapKLTextureSetK(RwTexture *tex, RwReal val);
+extern RwTexture *RpMipmapKLTextureSetL(RwTexture *tex, RwUInt32 val);
+extern RwReal RpMipmapKLTextureGetK(RwTexture *tex);
+extern RwUInt32 RpMipmapKLTextureGetL(RwTexture *tex);
+
+extern RwBool RpMipmapKLPluginAttach(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RPMIPMAPKLPLUGIN_H */
diff --git a/rwsdk/include/d3d8/rpmipkl.rpe b/rwsdk/include/d3d8/rpmipkl.rpe
new file mode 100644
index 00000000..5216ec9c
--- /dev/null
+++ b/rwsdk/include/d3d8/rpmipkl.rpe
@@ -0,0 +1,639 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionLabel
+{
+
+
+
+ e_rwdb_CriterionLabelLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionLabel e_rwdb_CriterionLabel;
+
+
diff --git a/rwsdk/include/d3d8/rpmorph.h b/rwsdk/include/d3d8/rpmorph.h
new file mode 100644
index 00000000..4177fba8
--- /dev/null
+++ b/rwsdk/include/d3d8/rpmorph.h
@@ -0,0 +1,138 @@
+
+/******************************************/
+/* */
+/* RenderWare(TM) Graphics Library */
+/* */
+/******************************************/
+
+/*
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd.
+ * or Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. and Canon Inc. will not, under any
+ * circumstances, be liable for any lost revenue or other damages
+ * arising from the use of this file.
+ *
+ * Copyright (c) 1998. Criterion Software Ltd.
+ * All Rights Reserved.
+ */
+
+
+/****************************************************************************
+ *
+ * Morph animation controller
+ * Copyright (C) 1998 Criterion Technologies
+ *
+ * Module : rpmorph.h
+ *
+ * Purpose : Functions for controlling morph target animation
+ *
+ ****************************************************************************/
+
+#ifndef RPMORPH_H
+#define RPMORPH_H
+
+
+/**
+ * \defgroup rpmorph RpMorph
+ * \ingroup rpplugin
+ *
+ * Morphing Plugin for RenderWare Graphics.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include "rwcore.h"
+#include "rpworld.h"
+
+#include "rpmorph.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Global Types
+ */
+typedef struct RpMorphInterpolator RpMorphInterpolator;
+
+/**
+ * \ingroup rpmorph
+ * \struct RpMorphInterpolator
+ * structure describing morph interpolator
+ */
+struct RpMorphInterpolator
+{
+ RwInt32 flags; /**< flags */
+ RwInt16 startMorphTarget; /**< startMorphTarget */
+ RwInt16 endMorphTarget; /**< endMorphTarget */
+ RwReal time; /**< time */
+ RwReal recipTime; /**< recipTime */
+ RpMorphInterpolator *next; /**< next */
+};
+
+/* Morph Animation */
+
+/**
+ * \ingroup rpmorph
+ * \typedef RpMorphGeometryCallBack
+ * This is the callback function supplied to \ref RpMorphGeometrySetCallBack
+ * and returned from \ref RpMorphGeometryGetCallBack.
+ * The supplied function will be passed a pointer to the geometry's parent atomic,
+ * and the position of the current interpolator.
+ * The function will only be called when the position of the geometry's current
+ * interpolator moves out of the current range.
+ *
+ * \param atomic Pointer to the geometry's parent atomic.
+ * \param position Value of the current interpolator.
+ *
+ * \return
+ *
+ * \see RpMorphGeometrySetCallBack
+ * \see RpMorphGeometryGetCallBack
+ */
+typedef RwReal (*RpMorphGeometryCallBack)(RpAtomic *atomic, RwReal position);
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwBool RpMorphPluginAttach(void);
+
+/* Morph Animation */
+extern RpGeometry *RpMorphGeometryCreateInterpolators(RpGeometry *geometry, RwInt32 numInterps);
+extern RpGeometry *RpMorphGeometrySetInterpolator(RpGeometry *geometry,
+ RwInt32 interpNum,
+ RwInt32 startKey, RwInt32 endKey, RwReal time);
+extern RpGeometry *RpMorphGeometrySetNextInterpolator(RpGeometry *geometry,
+ RwInt32 interpNum, RwInt32 interpNumNext);
+extern RpGeometry *RpMorphGeometrySetCallBack(RpGeometry *geometry, RpMorphGeometryCallBack animCB);
+extern RpMorphGeometryCallBack RpMorphGeometryGetCallBack(const RpGeometry *geometry);
+
+extern RpAtomic *RpMorphAtomicSetCurrentInterpolator(RpAtomic *atomic, RwInt32 interpNum);
+extern RwInt32 RpMorphAtomicGetCurrentInterpolator(RpAtomic *atomic);
+
+extern RpMorphInterpolator *RpMorphGeometryGetInterpolator(RpGeometry *geometry, RwInt32 interpNum);
+
+extern RpAtomic *RpMorphAtomicSetTime(RpAtomic *atomic, RwReal time);
+extern RpAtomic *RpMorphAtomicAddTime(RpAtomic *atomic, RwReal time);
+
+
+/* LEGACY-SUPPORT version: */
+extern RpMorphInterpolator *_rpMorphAtomicGetInterpolator(RpAtomic *atomic, RwInt32 interpNum);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define RpMorphAtomicGetInterpolator(_atomic, _interpNum) \
+ _rpMorphAtomicGetInterpolator(_atomic, _interpNum)
+
+#endif /* RPMORPH_H */
+
diff --git a/rwsdk/include/d3d8/rpmorph.rpe b/rwsdk/include/d3d8/rpmorph.rpe
new file mode 100644
index 00000000..14b13076
--- /dev/null
+++ b/rwsdk/include/d3d8/rpmorph.rpe
@@ -0,0 +1,641 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionMorph
+{
+
+
+E_RP_MORPH_INVALIDINTERP,
+
+E_RP_MORPH_NOGEOMETRY,
+
+ e_rwdb_CriterionMorphLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionMorph e_rwdb_CriterionMorph;
+
+
diff --git a/rwsdk/include/d3d8/rppatch.h b/rwsdk/include/d3d8/rppatch.h
new file mode 100644
index 00000000..eb80663f
--- /dev/null
+++ b/rwsdk/include/d3d8/rppatch.h
@@ -0,0 +1,683 @@
+
+#ifndef RPPATCH_H
+#define RPPATCH_H
+
+/**
+ * \defgroup rppatch RpPatch
+ * \ingroup rpplugin
+ *
+ * Bezier patch library
+ *
+ * This library provides efficient evaluation of patches.
+ */
+
+/*===========================================================================*
+ *--- Include files ---------------------------------------------------------*
+ *===========================================================================*/
+#include "rwcore.h"
+#include "rpworld.h"
+
+#include "rpcriter.h"
+#include "rppatch.rpe"
+
+/*===========================================================================*
+ *--- Defines ---------------------------------------------------------------*
+ *===========================================================================*/
+
+/**
+ * \ingroup rppatch
+ * \def rpQUADPATCHNUMCONTROLPOINTS defines the number of control points in
+ * a quadrilateral patch.
+ *
+ * \see RpQuadPatch
+ * \see rpQUADPATCHNUMCONTROLINDICES
+ * \see RpPatchMeshSetQuadPatch
+ */
+#define rpQUADPATCHNUMCONTROLPOINTS (16)
+
+/**
+ * \ingroup rppatch
+ * \def rpTRIPATCHNUMCONTROLPOINTS defines the number of control points in
+ * a triangular patch.
+ *
+ * \see RpTriPatch
+ * \see rpTRIPATCHNUMCONTROLINDICES
+ * \see RpPatchMeshSetTriPatch
+ */
+#define rpTRIPATCHNUMCONTROLPOINTS (10)
+
+/**
+ * \ingroup rppatch
+ * \def rpQUADPATCHNUMCONTROLINDICES defines the number of control point
+ * indices in a \ref RpQuadPatch quadrilateral patch.
+ *
+ * \see rpQUADPATCHNUMCONTROLPOINTS
+ * \see RpPatchMeshSetQuadPatch
+ */
+#define rpQUADPATCHNUMCONTROLINDICES rpQUADPATCHNUMCONTROLPOINTS
+
+/**
+ * \ingroup rppatch
+ * \def rpTRIPATCHNUMCONTROLINDICES defines the number of control points
+ * indices in a \ref RpTriPatch triangular patch.
+ *
+ * \see rpTRIPATCHNUMCONTROLPOINTS
+ * \see RpPatchMeshSetTriPatch
+ */
+#define rpTRIPATCHNUMCONTROLINDICES rpTRIPATCHNUMCONTROLPOINTS
+
+/**
+ * \ingroup rppatch
+ * \def rpPATCHLODMAXVALUE defines the maximum value that can be returned for
+ * the patch evaluation LOD.
+ *
+ * \see rpPATCHSKINLODMAXVALUE
+ * \see rpPATCHLODMINVALUE
+ * \see RpPatchLODCallBack
+ */
+#define rpPATCHLODMAXVALUE (20)
+
+/**
+ * \ingroup rppatch
+ * \def rpPATCHSKINLODMAXVALUE defines the maximum value that can be returned
+ * for the skinned patch evaluation LOD.
+ *
+ * \see rpPATCHLODMAXVALUE
+ * \see rpPATCHLODMINVALUE
+ * \see RpPatchLODCallBack
+ */
+#define rpPATCHSKINLODMAXVALUE (18)
+
+/**
+ * \ingroup rppatch
+ * \def rpPATCHLODMINVALUE defines the minimum value that can be returned for
+ * the patch evaluation LOD.
+ *
+ * \see rpPATCHSKINLODMAXVALUE
+ * \see rpPATCHLODMAXVALUE
+ * \see RpPatchLODCallBack
+ */
+#define rpPATCHLODMINVALUE (4)
+
+/**
+ * \ingroup rppatch
+ * \def rpPATCHMESHTEXCOORDSETS Multi texture coordinate format specifier
+ * for \ref RpPatchMeshCreate(). This should be OR'd into the
+ * \ref RpPatchMeshFlag .
+ */
+#define rpPATCHMESHTEXCOORDSETS(_num) \
+ ((_num & 0xff) << 16)
+
+/**
+ * \ingroup rppatch
+ * \def rpPATCHMESHLOCKTEXCOORDSIDX
+ * Convenience macro for generating a texture coordinate lock flag.
+ */
+#define rpPATCHMESHLOCKTEXCOORDSIDX(_idx) \
+ (rpPATCHMESHLOCKTEXCOORDS1 << (_idx))
+
+/*===========================================================================*
+ *--- Global Types ----------------------------------------------------------*
+ *===========================================================================*/
+
+/**
+ * \ingroup rppatch
+ * \ref RpPatchMeshFlag
+ * When creating a \ref RpPatchMesh, these flags can be OR'ed together to
+ * specify the format along with the \ref rpPATCHMESHTEXCOORDSETS (n) macro
+ * to specify the number of texture coordinate sets required.
+ *
+ * \see RpPatchMeshCreate
+ */
+enum RpPatchMeshFlag
+{
+ rpNAPATCHMESHFLAG = 0,
+ rpPATCHMESHPOSITIONS = 0x01, /**<Patch mesh contains control point
+ positions. */
+ rpPATCHMESHNORMALS = 0x02, /**<Patch mesh contains control point
+ normals. */
+ rpPATCHMESHPRELIGHTS = 0x04, /**<Patch mesh contains control point
+ pre-light color values. */
+ rpPATCHMESHTEXTURED = 0x08, /**<Patch mesh is textured. The number
+ of texture sets must also be
+ defined. */
+ rpPATCHMESHLIGHT = 0x10, /**<Patch mesh will be lit. */
+ rpPATCHMESHMODULATEMATERIALCOLOR = 0x20,
+ /**<Control point color will be
+ modulated with the material color. */
+ rpPATCHMESHSMOOTHNORMALS = 0x40,
+ /**<Patch mesh normals will be
+ smoothed automatically. */
+ rpPATCHMESHFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpPatchMeshFlag RpPatchMeshFlag;
+
+/**
+ * \ingroup rppatch
+ * \ref RpPatchMeshLockMode patch mesh lock flags.
+ *
+ * \see rpPATCHMESHLOCKTEXCOORDSIDX
+ */
+enum RpPatchMeshLockMode
+{
+ rpNAPATCHMESHLOCKMODE = 0,
+ rpPATCHMESHLOCKPATCHES = 0x0001, /**<Lock the mesh patches. */
+ rpPATCHMESHLOCKPOSITIONS = 0x0002, /**<Lock the control point
+ positions. */
+ rpPATCHMESHLOCKNORMALS = 0x0004, /**<Lock the control point
+ normals. */
+ rpPATCHMESHLOCKPRELIGHTS = 0x0008, /**<Lock the control point
+ pre-light color values. */
+ rpPATCHMESHLOCKTEXCOORDS1 = 0x0100, /**<Lock the texture coordinates
+ set 1. */
+ rpPATCHMESHLOCKTEXCOORDS2 = 0x0200, /**<Lock the texture coordinates
+ set 2. */
+ rpPATCHMESHLOCKTEXCOORDS3 = 0x0400, /**<Lock the texture coordinates
+ set 3. */
+ rpPATCHMESHLOCKTEXCOORDS4 = 0x0800, /**<Lock the texture coordinates
+ set 4. */
+ rpPATCHMESHLOCKTEXCOORDS5 = 0x1000, /**<Lock the texture coordinates
+ set 5. */
+ rpPATCHMESHLOCKTEXCOORDS6 = 0x2000, /**<Lock the texture coordinates
+ set 6. */
+ rpPATCHMESHLOCKTEXCOORDS7 = 0x4000, /**<Lock the texture coordinates
+ set 7. */
+ rpPATCHMESHLOCKTEXCOORDS8 = 0x8000, /**<Lock the texture coordinates
+ set 8. */
+ rpPATCHMESHLOCKTEXCOORDSALL = 0xff00, /**<Lock all texture coordinate
+ sets. */
+ rpPATCHMESHLOCKALL = 0xffff, /**<Combination of all the
+ above. */
+ rpPATCHMESHLOCKMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpPatchMeshLockMode RpPatchMeshLockMode;
+
+typedef struct RpPatchMeshDefinition RpPatchMeshDefinition;
+/**
+ * \ingroup rppatch
+ * \struct RpPatchMeshDefinition
+ * holds the definition sizes of the patch mesh. This data should be considered
+ * read only.
+ */
+struct RpPatchMeshDefinition
+{
+ RwUInt32 flag; /**<Patch mesh definition flag. */
+ RwUInt32 numControlPoints; /**<Number of control points. */
+ RwUInt32 numTriPatches; /**<Number of tri patches. */
+ RwUInt32 numQuadPatches; /**<Number of quad patches. */
+ RwUInt32 numTexCoordSets; /**<Number of sets of texture coordinates. */
+};
+
+typedef struct RpPatchMesh RpPatchMesh;
+/**
+ * \ingroup rppatch
+ * \struct RpPatchMesh
+ * holds the control point data for a patch mesh. The patch mesh should be
+ * created with \ref RpPatchMeshCreate. The patch mesh should be locked with
+ * \ref RpPatchMeshLock before the data is edited. Quadrilateral and triangle
+ * patches can be defined from the control points with
+ * \ref RpPatchMeshSetQuadPatch and \ref RpPatchMeshSetTriPatch respectively.
+ * The patch mesh should be unlocked with \ref RpPatchMeshUnlock before it is
+ * added to an \ref RpAtomic with \ref RpPatchAtomicSetPatchMesh.
+ *
+ * \see RpPatchMesDefinition
+ */
+struct RpPatchMesh
+{
+ RwV3d *positions; /**<Control point positions. */
+ RwV3d *normals; /**<Control point normals. */
+ RwRGBA *preLightColors; /**<Control point pre-light colors. */
+ RwTexCoords *texCoords[rwMAXTEXTURECOORDS];
+ /**<Control point texture coordinates. */
+ RpPatchMeshDefinition definition; /**<Patch mesh definition data. */
+};
+
+typedef struct RpQuadPatch RpQuadPatch;
+/**
+ * \ingroup rppatch
+ * \struct RpQuadPatch
+ * holds the control point indices for a quadrilateral patch. There are
+ * \ref rpQUADPATCHNUMCONTROLINDICES indices for a quadrilateral patch.
+ *
+ * \see RpPatchMeshSetQuadPatch
+ */
+struct RpQuadPatch
+{
+ RwUInt32 cpIndices[rpQUADPATCHNUMCONTROLINDICES]; /**<Control point
+ indices. */
+};
+
+typedef struct RpTriPatch RpTriPatch;
+/**
+ * \ingroup rppatch
+ * \struct RpTriPatch
+ * holds the control point indices for a triangle patch. There are
+ * \ref rpTRIPATCHNUMCONTROLINDICES indices for a triangular patch.
+ *
+ * \see RpPatchMeshSetTriPatch
+ */
+struct RpTriPatch
+{
+ RwUInt32 cpIndices[rpTRIPATCHNUMCONTROLINDICES]; /**<Control point
+ indices. */
+};
+
+typedef struct RpPatchLODRange RpPatchLODRange;
+/**
+ * \ingroup rppatch
+ * \struct RpPatchLODRange
+ * holds the variables used by the default atomic LOD call back function.
+ */
+struct RpPatchLODRange
+{
+ RwUInt32 minLod; /**<Minimum LOD value. */
+ RwUInt32 maxLod; /**<Maximum LOD value. */
+ RwReal minRange; /**<Minimum LOD range. */
+ RwReal maxRange; /**<Maximum LOD range. */
+};
+
+/**
+ * \ingroup rppatch
+ * \typedef RpPatchLODUserData
+ * typedef for the user data passed to the \ref RpPatchLODCallBack
+ * function which calculates the atomics' LOD.
+ *
+ * \see RpPatchAtomicSetPatchLODCallBack
+ * \see RpPatchAtomicGetPatchLODCallBack
+ */
+typedef void *RpPatchLODUserData;
+
+/**
+ * \ingroup rppatch
+ * \typedef RpPatchLODCallBack
+ * typedef for the patch atomic LOD calculation function.
+ *
+ * \see RpPatchAtomicSetPatchLODCallBack
+ * \see RpPatchAtomicGetPatchLODCallBack
+ */
+typedef RwUInt32 (* RpPatchLODCallBack)( RpAtomic *atomic,
+ RpPatchLODUserData userData );
+
+/*===========================================================================*
+ *--- Plugin API Functions --------------------------------------------------*
+ *===========================================================================*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/*---------------------------------------------------------------------------*
+ *- Plugin functions -*
+ *---------------------------------------------------------------------------*/
+extern RwBool
+RpPatchPluginAttach(void);
+
+/*---------------------------------------------------------------------------*
+ *- Patch Mesh functions -*
+ *---------------------------------------------------------------------------*/
+extern RpPatchMesh *
+RpPatchMeshCreate( RwUInt32 numQuadPatches,
+ RwUInt32 numTriPatches,
+ RwUInt32 numControlPoints,
+ RwUInt32 definitionFlag );
+
+extern RwBool
+RpPatchMeshDestroy( RpPatchMesh *patchMesh );
+
+extern RpPatchMesh *
+RpPatchMeshLock( RpPatchMesh *patchMesh,
+ RwUInt32 lockMode );
+
+extern RpPatchMesh *
+RpPatchMeshUnlock( RpPatchMesh *patchMesh );
+
+/*---------------------------------------------------------------------------*
+ *- Patch mesh helper functions -*
+ *---------------------------------------------------------------------------*/
+
+extern RpPatchMesh *
+RpPatchMeshTransform( RpPatchMesh *patchMesh,
+ const RwMatrix *matrix );
+
+/*---------------------------------------------------------------------------*/
+#define RpPatchMeshGetFlagsMacro(patchMesh) \
+ (patchMesh->definition.flag)
+
+#define RpPatchMeshSetFlagsMacro(patchMesh, flags) \
+ (patchMesh->definition.flag = flags)
+
+#define RpPatchMeshGetNumControlPointsMacro(patchMesh) \
+ (patchMesh->definition.numControlPoints)
+
+#define RpPatchMeshGetNumTriPatchesMacro(patchMesh) \
+ (patchMesh->definition.numTriPatches)
+
+#define RpPatchMeshGetNumQuadPatchesMacro(patchMesh) \
+ (patchMesh->definition.numQuadPatches)
+
+#define RpPatchMeshGetNumTexCoordSetsMacro(patchMesh) \
+ (patchMesh->definition.numTexCoordSets)
+
+#define RpPatchMeshGetPositionsMacro(patchMesh) \
+ (patchMesh->positions)
+
+#define RpPatchMeshGetNormalsMacro(patchMesh) \
+ (patchMesh->normals)
+
+#define RpPatchMeshGetPreLightColorsMacro(patchMesh) \
+ (patchMesh->preLightColors)
+
+#define RpPatchMeshGetTexCoordsMacro(patchMesh, index) \
+ (patchMesh->texCoords[index - 1])
+/*---------------------------------------------------------------------------*/
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+/*---------------------------------------------------------------------------*/
+extern RwUInt32
+RpPatchMeshGetFlags( const RpPatchMesh *patchMesh );
+
+extern RpPatchMesh *
+RpPatchMeshSetFlags( RpPatchMesh *patchMesh,
+ RwUInt32 flags );
+
+extern RwUInt32
+RpPatchMeshGetNumControlPoints( const RpPatchMesh *patchMesh );
+
+extern RwUInt32
+RpPatchMeshGetNumTriPatches( const RpPatchMesh *patchMesh );
+
+extern RwUInt32
+RpPatchMeshGetNumQuadPatches( const RpPatchMesh *patchMesh );
+
+extern RwUInt32
+RpPatchMeshGetNumTexCoordSets( const RpPatchMesh *patchMesh );
+
+extern RwV3d *
+RpPatchMeshGetPositions( const RpPatchMesh *patchMesh );
+
+extern RwV3d *
+RpPatchMeshGetNormals( const RpPatchMesh *patchMesh );
+
+extern RwRGBA *
+RpPatchMeshGetPreLightColors( const RpPatchMesh *patchMesh );
+
+extern RwTexCoords *
+RpPatchMeshGetTexCoords( const RpPatchMesh *patchMesh,
+ RwTextureCoordinateIndex index );
+/*---------------------------------------------------------------------------*/
+
+#else /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+/*---------------------------------------------------------------------------*/
+#define RpPatchMeshGetFlags(patchMesh) \
+ RpPatchMeshGetFlagsMacro(patchMesh)
+
+#define RpPatchMeshSetFlags(patchMesh, flags) \
+ RpPatchMeshSetFlagsMacro(patchMesh, flags)
+
+#define RpPatchMeshGetNumControlPoints(patchMesh) \
+ RpPatchMeshGetNumControlPointsMacro(patchMesh)
+
+#define RpPatchMeshGetNumTriPatches(patchMesh) \
+ RpPatchMeshGetNumTriPatchesMacro(patchMesh)
+
+#define RpPatchMeshGetNumQuadPatches(patchMesh) \
+ RpPatchMeshGetNumQuadPatchesMacro(patchMesh)
+
+#define RpPatchMeshGetNumTexCoordSets(patchMesh) \
+ RpPatchMeshGetNumTexCoordSetsMacro(patchMesh)
+
+#define RpPatchMeshGetPositions(patchMesh) \
+ RpPatchMeshGetPositionsMacro(patchMesh)
+
+#define RpPatchMeshGetNormals(patchMesh) \
+ RpPatchMeshGetNormalsMacro(patchMesh)
+
+#define RpPatchMeshGetPreLightColors(patchMesh) \
+ RpPatchMeshGetPreLightColorsMacro(patchMesh)
+
+#define RpPatchMeshGetTexCoords(patchMesh, index) \
+ RpPatchMeshGetTexCoordsMacro(patchMesh, index)
+/*---------------------------------------------------------------------------*/
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+/*---------------------------------------------------------------------------*
+ *- Patch streaming functions -*
+ *---------------------------------------------------------------------------*/
+extern RwUInt32
+RpPatchMeshStreamGetSize( const RpPatchMesh *patchMesh );
+
+extern RpPatchMesh *
+RpPatchMeshStreamRead( RwStream *stream );
+
+extern const RpPatchMesh *
+RpPatchMeshStreamWrite( const RpPatchMesh *patchMesh,
+ RwStream *stream );
+
+/*---------------------------------------------------------------------------*
+ *- Patch Mesh patch functions -*
+ *---------------------------------------------------------------------------*/
+extern RpPatchMesh *
+RpPatchMeshSetQuadPatch( RpPatchMesh *patchMesh,
+ RwUInt32 quadIndex,
+ RpQuadPatch *quadPatch );
+
+extern RpPatchMesh *
+RpPatchMeshSetTriPatch( RpPatchMesh *patchMesh,
+ RwUInt32 triIndex,
+ RpTriPatch *triPatch );
+
+extern const RpQuadPatch *
+RpPatchMeshGetQuadPatch( const RpPatchMesh *patchMesh,
+ RwUInt32 quadIndex );
+
+extern const RpTriPatch *
+RpPatchMeshGetTriPatch( const RpPatchMesh *patchMesh,
+ RwUInt32 triIndex );
+
+/*---------------------------------------------------------------------------*
+ *- Patch Mesh material functions -*
+ *---------------------------------------------------------------------------*/
+extern RpPatchMesh *
+RpPatchMeshSetQuadPatchMaterial( RpPatchMesh *patchMesh,
+ RwUInt32 quadIndex,
+ RpMaterial *material );
+
+extern RpPatchMesh *
+RpPatchMeshSetTriPatchMaterial( RpPatchMesh *patchMesh,
+ RwUInt32 triIndex,
+ RpMaterial *material );
+
+extern RpMaterial *
+RpPatchMeshGetQuadPatchMaterial( const RpPatchMesh *patchMesh,
+ RwUInt32 quadIndex );
+
+extern RpMaterial *
+RpPatchMeshGetTriPatchMaterial( const RpPatchMesh *patchMesh,
+ RwUInt32 triIndex );
+
+extern const RpPatchMesh *
+RpPatchMeshForAllMaterials( const RpPatchMesh *patchMesh,
+ RpMaterialCallBack callBack,
+ void *userData );
+
+extern RwUInt32
+RpPatchMeshGetNumMaterials( const RpPatchMesh *patchMesh );
+
+extern RpMaterial *
+RpPatchMeshGetMaterial( const RpPatchMesh *patchMesh,
+ RwUInt32 materialIndex );
+
+/*---------------------------------------------------------------------------*
+ *- Patch Skin functions -*
+ *---------------------------------------------------------------------------*/
+#if (defined(RPSKIN_H))
+
+extern RpSkin *
+RpPatchMeshGetSkin( RpPatchMesh *patchMesh );
+
+extern RpPatchMesh *
+RpPatchMeshSetSkin( RpPatchMesh *patchMesh,
+ RpSkin *skin );
+
+#endif /* (defined(RPSKIN_H)) */
+
+/*---------------------------------------------------------------------------*
+ *- Patch Atomic functions -*
+ *---------------------------------------------------------------------------*/
+extern RpAtomic *
+RpPatchAtomicSetPatchMesh( RpAtomic *atomic,
+ RpPatchMesh *patchMesh );
+
+extern RpPatchMesh *
+RpPatchAtomicGetPatchMesh( const RpAtomic *atomic );
+
+/*---------------------------------------------------------------------------*
+ *- Patch Atomic LOD functions -*
+ *---------------------------------------------------------------------------*/
+extern RwBool
+RpPatchAtomicSetPatchLODCallBack( RpAtomic *atomic,
+ RpPatchLODCallBack callback,
+ RpPatchLODUserData userData );
+
+extern RwBool
+RpPatchAtomicGetPatchLODCallBack( const RpAtomic *atomic,
+ RpPatchLODCallBack *callback,
+ RpPatchLODUserData *userData );
+
+/*---------------------------------------------------------------------------*
+ *- Patch default LOD range -*
+ *---------------------------------------------------------------------------*/
+extern RwBool
+RpPatchSetDefaultLODCallBackRange( RpPatchLODRange *lodRange );
+
+extern RwBool
+RpPatchGetDefaultLODCallBackRange( RpPatchLODRange *lodRange );
+
+/*---------------------------------------------------------------------------*
+ *- Patch pipeline -*
+ *---------------------------------------------------------------------------*/
+
+/**
+ * \ingroup rppatch
+ * \ref RpPatchType defines the different ways a patch atomic can be rendered.
+ * Once a \ref RpPatchMesh has been attached to an \ref RpAtomic with
+ * \ref RpPatchAtomicSetPatchMesh the atomic must be setup with the correct
+ * rendering pipeline with \ref RpPatchAtomicSetType .
+ *
+ * The patch plugin makes no assumptions about how to render the
+ * patch atomics. Once an \ref RpPatchMesh has been attached to an
+ * \ref RpAtomic it is necessary to attach a suitable patch
+ * rendering pipeline. The patch plugin supports four different
+ * rendering types, these are defined in the \ref RpPatchType
+ * enumeration:-
+ * \li \ref rpPATCHTYPEGENERIC
+ * The patch \ref RpAtomic will be rendered with the
+ * default generic patch rendering pipeline.
+ * \li \ref rpPATCHTYPESKIN
+ * The patch \ref RpAtomic will be rendered with a
+ * custom pipeline for rendering skinning patches. Make sure
+ * an \ref RpSkin has been attached to the \ref RpPatchMesh
+ * and an \ref RpHAnimHierarchy has been attached to the
+ * \ref RpAtomic.
+ * \li \ref rpPATCHTYPEMATFX
+ * The patch \ref RpAtomic will be rendered with a
+ * custom pipeline for rendering the material effects
+ * of patches. The
+ * patch matfx pipeline supports all the material effects
+ * defined in the \ref rpmatfx plugin. The patches
+ * materials should be setup as usual.
+ * \li \ref rpPATCHTYPESKINMATFX
+ * The patch \ref RpAtomic will be rendered with a
+ * custom skinned material effects patch rendering pipeline.
+ * The \ref RpPatchMesh, \ref RpAtomic and the patches'
+ * \ref RpMaterial's must be setup correctly.
+ */
+enum RpPatchType
+{
+ rpNAPATCHTYPE = 0, /**<Invalid patch pipeline. */
+ rpPATCHTYPEGENERIC = 1, /**<Generic patch rendering. */
+ rpPATCHTYPESKIN = 2, /**<Skinned patch rendering. */
+ rpPATCHTYPEMATFX = 3, /**<Material effects patch rendering. */
+ rpPATCHTYPESKINMATFX = 4, /**<Skinned material effects patch rendering. */
+ rpPATCHTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpPatchType RpPatchType;
+
+extern RpAtomic *
+RpPatchAtomicSetType( RpAtomic *atomic,
+ RpPatchType type );
+
+extern RpPatchType
+RpPatchAtomicGetType( const RpAtomic *atomic );
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*---- start: ./d3d8/patchplatform.h----*/
+
+/**
+ * \defgroup rppatchd3d8 D3D8
+ * \ingroup rppatch
+ *
+ * D3D8 patch pipeline extension.
+ */
+
+
+/*===========================================================================*
+ *--- D3D8 Defines -----------------------------------------------------------*
+ *===========================================================================*/
+
+/*===========================================================================*
+ *--- D3D8 Global Types ------------------------------------------------------*
+ *===========================================================================*/
+
+/**
+ * \ingroup rppatchd3d8
+ * \ref RpPatchD3D8Pipeline rendering pipelines available within the
+ * \ref rppatch plugin. Use \ref RpPatchGetD3D8Pipeline to retrieve
+ * the \ref RxPipeline s.
+ */
+enum RpPatchD3D8Pipeline
+{
+ rpPATCHD3D8PIPELINEGENERIC = 0, /**<D3D8 generic
+ patch rendering pipeline. */
+ rpPATCHD3D8PIPELINEMATFX = 1, /**<D3D8 material effect
+ (single set of texture coordinates)
+ patch rendering pipeline. */
+ rpPATCHD3D8PIPELINESKINNED = 2, /**<D3D8 skinned
+ patch rendering pipeline. */
+ rpPATCHD3D8PIPELINESKINMATFX = 3, /**<D3D8 skinned material effect
+ (single set of texture coordinates)
+ patch rendering pipeline. */
+ rpPATCHD3D8PIPELINEMAX,
+ rpPATCHD3D8PIPELINEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpPatchD3D8Pipeline RpPatchD3D8Pipeline;
+
+/*===========================================================================*
+ *--- D3D8 Plugin API Functions ----------------------------------------------*
+ *===========================================================================*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+/*---------------------------------------------------------------------------*/
+
+extern RxPipeline *
+RpPatchGetD3D8Pipeline( RpPatchD3D8Pipeline d3d8Pipeline );
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*---- end: ./d3d8/patchplatform.h----*/
+
+#endif /* RPPATCH_H */
+
+
diff --git a/rwsdk/include/d3d8/rppatch.rpe b/rwsdk/include/d3d8/rppatch.rpe
new file mode 100644
index 00000000..6d433990
--- /dev/null
+++ b/rwsdk/include/d3d8/rppatch.rpe
@@ -0,0 +1,638 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionPATCH
+{
+
+
+
+ e_rwdb_CriterionPATCHLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionPATCH e_rwdb_CriterionPATCH;
+
+
diff --git a/rwsdk/include/d3d8/rpprtstd.h b/rwsdk/include/d3d8/rpprtstd.h
new file mode 100644
index 00000000..ad1b87f7
--- /dev/null
+++ b/rwsdk/include/d3d8/rpprtstd.h
@@ -0,0 +1,1026 @@
+
+#ifndef RPPRTSTD_H
+#define RPPRTSTD_H
+
+/*===========================================================================*
+ *--- Include files ---------------------------------------------------------*
+ *===========================================================================*/
+
+#include "rwcore.h"
+#include "rpworld.h"
+
+
+/*---- start: ./prtstd.h----*/
+
+#include "rwcore.h"
+#include "rpworld.h"
+#include "rpptank.h"
+
+#include "rpprtstd.rpe"
+
+
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+/**
+ * \defgroup rpprtstd RpPrtStd
+ * \ingroup rpplugin
+ *
+ * Particle Animation Plugin for RenderWare Graphics.
+ */
+
+/*
+ * Current version stamp
+ */
+#define rpPRTSTDVERSIONSTAMP 2
+
+/*
+ * Random Number Generation Macros
+ */
+#define PRTSTD_SRAND_MAX 0xFFFFFFFF
+#define PRTSTD_SRAND_IMAX ((RwReal) 1.0 / (RwReal) PRTSTD_SRAND_MAX)
+
+#define PRTSTD_SRAND(_seed) ((_seed) = ((_seed) * 196314165 + 907633515))
+
+/* Real rand -1.0 .. + 1.0 */
+#define PRTSTD_RSRAND(_seed) (((RwReal)((RwUInt32) (_seed) * PRTSTD_SRAND_IMAX) * \
+ (RwReal) 2.0) - (RwReal) 1.0)
+
+
+
+#define PRTSTD_RSRAND2(_seed) (((RwReal)((RwReal) (_seed) * PRTSTD_SRAND_IMAX) * \
+ (RwReal)1.0))
+
+/**
+ * \ingroup rpprtstd
+ * \ref RpPrtStdParticleFlags, this type represents the different properties of
+ * a particle.
+ */
+enum RpPrtStdParticleFlags
+{
+ rpPRTSTDPARTICLEFLAGEMITTER = 0x00000001, /**<Particle is an emitter. */
+
+ rpPRTSTDPARTICLEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPrtStdParticleFlags RpPrtStdParticleFlags;
+
+/**
+ * \ingroup rpprtstd
+ * \ref RpPrtStdEmitterFlags, this type represents the different properties of
+ * an emitter.
+ */
+enum RpPrtStdEmitterFlags
+{
+ rpPRTSTDEMITTERFLAGALIVE = 0x00000001, /**< The emitter is alive and should not be removed */
+ rpPRTSTDEMITTERFLAGACTIVE = 0x00000002, /**< This indicates the emitter is active or idle */
+ rpPRTSTDEMITTERFLAGPTANK = 0x00000004, /**< The emitter uses the \ref rpptank */
+ rpPRTSTDEMITTERFLAGEMIT = 0x00000008, /**< This indicates the emitter can emit new particles */
+ rpPRTSTDEMITTERFLAGUPDATE = 0x00000010, /**< This indicates if the emitter is to be updated. */
+ rpPRTSTDEMITTERFLAGUPDATEPARTICLE = 0x00000020, /**< This indicated if the emitter's particles are updated. */
+ rpPRTSTDEMITTERFLAGRENDER = 0x00000040, /**< This indicates if the emitter is rendered. */
+ rpPRTSTDEMITTERFLAGRENDERPARTICLE = 0x00000080, /**< This indicates if the emitter's particles are rendered. */
+ rpPRTSTDEMITTERFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPrtStdEmitterFlags RpPrtStdEmitterFlags;
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+#define rpPRTSTDPARTICLECALLBACKMAX 7
+
+/**
+ * \ingroup rpprtstd
+ * \ref RpPrtStdParticleCallBackCode, this type represents the different callbacks for
+ * processing a \ref RpPrtStdParticleBatch. These callbacks will be called at various point for
+ * processing the particle's custom data.
+ */
+enum RpPrtStdParticleCallBackCode
+{
+ rpPRTSTDPARTICLECALLBACKUPDATE = 0, /**< Particle update callback */
+ rpPRTSTDPARTICLECALLBACKRENDER, /**< Particle render callback */
+ rpPRTSTDPARTICLECALLBACKCREATE, /**< Particle create callback */
+ rpPRTSTDPARTICLECALLBACKDESTROY, /**< Particle destroy callback */
+ rpPRTSTDPARTICLECALLBACKSTREAMREAD, /**< Particle stream input callback */
+ rpPRTSTDPARTICLECALLBACKSTREAMWRITE, /**< Particle stream outout callback */
+ rpPRTSTDPARTICLECALLBACKSTREAMGETSIZE, /**< Particle stream get size callback */
+ rpPRTSTDPARTICLECALLBACKFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPrtStdParticleCallBackCode RpPrtStdParticleCallBackCode;
+
+#define rpPRTSTDEMITTERCALLBACKMAX 10
+
+/**
+ * \ingroup rpprtstd
+ * \ref RpPrtStdEmitterCallBackCode, this type represents the different callbacks for
+ * processing a \ref RpPrtStdEmitter. These callbacks will be called at various point for
+ * processing the emitter's custom data.
+ */
+enum RpPrtStdEmitterCallBackCode
+{
+ rpPRTSTDEMITTERCALLBACKEMIT = 0, /**< Emitter particle emission callback */
+ rpPRTSTDEMITTERCALLBACKBEGINUPDATE, /**< Emitter begin update call back */
+ rpPRTSTDEMITTERCALLBACKENDUPDATE, /**< Emitter end update callback */
+ rpPRTSTDEMITTERCALLBACKBEGINRENDER, /**< Emitter begin render callback */
+ rpPRTSTDEMITTERCALLBACKENDRENDER, /**< Emitter end render callback */
+ rpPRTSTDEMITTERCALLBACKCREATE, /**< Emitter create callback */
+ rpPRTSTDEMITTERCALLBACKDESTROY, /**< Emitter destroy callback */
+ rpPRTSTDEMITTERCALLBACKSTREAMREAD, /**< Emitter stream input callback */
+ rpPRTSTDEMITTERCALLBACKSTREAMWRITE, /**< Emitter stream output callback */
+ rpPRTSTDEMITTERCALLBACKSTREAMGETSIZE, /**< Emitter stream get size callback */
+ rpPRTSTDEMITTERCALLBACKFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPrtStdEmitterCallBackCode RpPrtStdEmitterCallBackCode;
+
+typedef RwInt32 RpPrtStdPropertyCode;
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+typedef struct RpPrtStdEmitter RWALIGN(RpPrtStdEmitter, rwMATRIXALIGNMENT);
+
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdEmitterCallBack
+ * \ref RpPrtStdEmitterCallBack represents the function called for processing
+ * a \ref RpPrtStdEmitter. There can several types of the functions, each performing a
+ * specific task defined by \ref RpPrtStdEmitterCallBackCode.
+ *
+ * \param atomic A pointer to the emitter's parent atomic.
+ * \param emt A pointer to the emitter.
+ * \param data A pointer to user data.
+ *
+ * \return A pointer to the emitter on success. NULL otherwise.
+ */
+typedef RpPrtStdEmitter *
+ (*RpPrtStdEmitterCallBack)
+ (RpAtomic *atomic, RpPrtStdEmitter *emt, void *data);
+
+typedef struct RpPrtStdParticleBatch RWALIGN(RpPrtStdParticleBatch, rwMATRIXALIGNMENT);
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdParticleCallBack
+ * \ref RpPrtStdParticleCallBack represents the function called for processing
+ * a \ref RpPrtStdParticleBatch. There can be several types of the functions, each
+ * performing a specific task defined by \ref RpPrtStdParticleCallBackCode.
+ *
+ * \param emt A pointer to the particle batch's parent emitter.
+ * \param prtBatch A pointer to the particle batch.
+ * \param data A pointer to user data.
+ *
+ * \return A pointer to the particle batch on success. NULL otherwise.
+ */
+typedef RpPrtStdParticleBatch *
+ (*RpPrtStdParticleCallBack)
+ (RpPrtStdEmitter *emt, RpPrtStdParticleBatch *prtBatch, void *data);
+
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdEmitterCallBackArray
+ * \ref RpPrtStdEmitterCallBackArray represents a set of callback functions for
+ * processing a \ref RpPrtStdEmitter. All the functions are of the type \ref
+ * RpPrtStdEmitterCallBack.
+ *
+ * \see RpPrtStdEmitterCallBackCode
+ */
+typedef RpPrtStdEmitterCallBack
+ RpPrtStdEmitterCallBackArray[rpPRTSTDEMITTERCALLBACKMAX];
+
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdParticleCallBackArray
+ * \ref RpPrtStdParticleCallBackArray represents a set of callback functions for
+ * processing a \ref RpPrtStdParticleBatch. All the functions are of the type \ref
+ * RpPrtStdParticleCallBack.
+ *
+ * \see RpPrtStdParticleCallBackCode
+ */
+typedef RpPrtStdParticleCallBack
+ RpPrtStdParticleCallBackArray[rpPRTSTDPARTICLECALLBACKMAX];
+
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+typedef struct RpPrtStdEmitterClass RpPrtStdEmitterClass;
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdEClassSetupCallBack
+ * \ref RpPrtStdEClassSetupCallBack represents the function called for setting up an
+ * emitter class's set of callback function. The callback function is called
+ * after an emitter class is streamed in.
+ *
+ * \param eClass A pointer to an emitter class.
+ *
+ * \return A pointer to the emitter class on success. NULL otherwise.
+ */
+typedef RpPrtStdEmitterClass *
+ (*RpPrtStdEClassSetupCallBack)
+ (RpPrtStdEmitterClass *eClass);
+
+typedef struct RpPrtStdParticleClass RpPrtStdParticleClass;
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdPClassSetupCallBack
+ * \ref RpPrtStdPClassSetupCallBack represents the function called for setting up an
+ * emitter class's set of callback function. The callback function is called
+ * after an emitter class is streamed in.
+ *
+ * \param pClass A pointer to a particle class.
+ *
+ * \return A pointer to the particle class on success. NULL otherwise.
+ */
+typedef RpPrtStdParticleClass *
+ (*RpPrtStdPClassSetupCallBack)
+ (RpPrtStdParticleClass *pClass);
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+typedef struct RpPrtStdPropertyTable RpPrtStdPropertyTable;
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdPropertyTable
+ * A structure representing properties's data present in an emitter or
+ * particle.
+ * An emitter, or particle, are treated as a single block of memory. The
+ * property table is used to describe the data presents in the memory block.
+ * It stores the property's id, offset entry from the start of the memory
+ * block and size in bytes.
+ */
+struct RpPrtStdPropertyTable
+{
+ RwUInt32 *propPtr; /**< Internal usage */
+ RpPrtStdPropertyTable *next; /**< Internal usage */
+
+ RwInt32 id; /**< Property table's id */
+
+ RwInt32 numProp; /**< Number of properties in the table */
+ RwInt32 maxProp; /**< Internal usage */
+ RwInt32 *propID; /**< Array of properties's id */
+ RwInt32 *propOffset; /**< Array of properties's offset */
+ RwInt32 *propSize; /**< Array of properties's size */
+ RwInt32 *propSizeUA; /**< Internal usage */
+};
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitterClass
+ * A structure representing the collection of data and callbacks for an emitter. An emitter
+ * class is used to create emitters that share the same properties and callback functions.
+ * Once created, an emitter class cannot be altered. An emitter class should also not be
+ * destroyed if emitters of the class are still in use.
+ */
+struct RpPrtStdEmitterClass
+{
+ RpPrtStdEmitterClass *next; /**< Internal usage */
+
+ RwInt32 id; /**< Emitter class's id */
+
+ RwInt32 objSize; /**< Size of the emitter */
+ RpPrtStdPropertyTable *propTab; /**< Reference to a table of emitter properties */
+
+ RwInt32 numCallback; /**< Number of callback arrays */
+ RpPrtStdEmitterCallBackArray *callback; /**< Array of emitter callback functions */
+};
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleClass
+ * A structure representing the collection of data and callbacks for a particle. A particle
+ * class is used to create particle that share the same properties and callback functions.
+ * Once created, a particle class cannot be altered. A particle class should also not be
+ * destroyed if particles of the class are still in use.
+ */
+struct RpPrtStdParticleClass
+{
+ RpPrtStdParticleClass *next; /**< Internal usage */
+
+ RwInt32 id; /**< Particle class's id */
+
+ RwInt32 objSize; /**< Size of a particle */
+ RpPrtStdPropertyTable *propTab; /**< Reference to a table of particle properties */
+
+ RwInt32 numCallback; /**< Number of callback sets */
+ RpPrtStdParticleCallBackArray *callback; /**< Array of particle batch callback functions */
+};
+
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleBatch
+ * A structure repsenting a group of particles. For efficient, particles are stored
+ * in batches rather than individually. All live particles are stored at the head
+ * of batch with no gaps of dead particles. A counter is used to record the number of
+ * live particles in the batch. Once a batch has 0 live particles, it will removed
+ * from the emitter's active particle list to the inactive list.
+ * The first particle of the batch is given by an offset from the start of the
+ * particle batch.
+ */
+struct RpPrtStdParticleBatch
+{
+ RpPrtStdParticleBatch *next; /**< Pointer to the next particle batch */
+
+ RpPrtStdParticleClass *prtClass; /**< Pointer to the particle's class */
+
+ RwInt32 numPrt; /**< Number of particles in the batch */
+ RwInt32 maxPrt; /**< Maxium number of particles in batch */
+ RwInt32 newPrt; /**< Start of newly emitted particles in the batch */
+
+ RwInt32 offset; /**< Offset to the first particle, from the start of the
+ * particle batch */
+};
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitter
+ * A structure repsenting the mandatory data set for any emitter. Each emitter contains information of
+ * itself and its particles, via the emitter class and particle class respectively. It also contains the
+ * list of particles, in batches, it had emitted.
+ * Optional data are stored immediately after the mandatory set. The contents of the optional data are
+ * described in the emitter class's property table. The offset from the property table are from the start
+ * of the emitter.
+ *
+ * The type of particles emitted are given by the particle class. Each emitter may have only emitter class
+ * and particle class and these should not be changed during the lifetime of the emitter and its particles.
+ * The emitter maintains two lists of particle batches, an acitive list, contain still active particles,
+ * and an inactive list. The maximum number of particles in each batch is given by the prtBatchMaxPrt field.
+ */
+struct RpPrtStdEmitter
+{
+ RpPrtStdEmitter *next; /**< Pointer to the next emitter */
+
+ RwUInt32 flag; /**< Emitter's property flag */
+
+ RpAtomic *atomic; /**< Pointer to emitter's parent atomic */
+
+ RpPrtStdEmitterClass *emtClass; /**< Pointer the emitter's class */
+
+ RwInt32 prtActive; /**< Number of particles emitted */
+ RwInt32 prtBatchMaxPrt; /**< Maximum number of particles per batch */
+ RpPrtStdParticleClass *prtClass; /**< Pointer to the particle's class */
+
+ RpPrtStdParticleBatch *inactiveBatch, /**< Circular linked list of inactive particle batches */
+ *activeBatch; /**< Circular linked list of active particle batches */
+
+ RwReal boundingSphere; /**< Emitter's bounding sphere. */
+};
+
+
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+#define rpPRTSTDPROPERTYCODEEMITTER 0
+#define rpPRTSTDPROPERTYCODEEMITTERSTANDARD 1
+#define rpPRTSTDPROPERTYCODEEMITTERPRTCOLOR 2
+#define rpPRTSTDPROPERTYCODEEMITTERPRTTEXCOORDS 3
+#define rpPRTSTDPROPERTYCODEEMITTERPRTANIMFRAME 4
+#define rpPRTSTDPROPERTYCODEEMITTERPRTSIZE 5
+#define rpPRTSTDPROPERTYCODEEMITTERPTANK 6
+#define rpPRTSTDPROPERTYCODEEMITTERPRTVELOCITY 7
+#define rpPRTSTDPROPERTYCODEEMITTERPRTMATRIX 8
+
+#define rpPRTSTDEMITTERPROPERTYCOUNT 9
+
+#define rpPRTSTDEMITTERDATAFLAGSTANDARD 0x00000001
+#define rpPRTSTDEMITTERDATAFLAGPRTCOLOR 0x00000002
+#define rpPRTSTDEMITTERDATAFLAGPRTTEXCOORDS 0x00000004
+#define rpPRTSTDEMITTERDATAFLAGPRTANIMFRAME 0x00000008
+#define rpPRTSTDEMITTERDATAFLAGPRTSIZE 0x00000010
+#define rpPRTSTDEMITTERDATAFLAGPTANK 0x00000020
+#define rpPRTSTDEMITTERDATAFLAGPRTMATRIX 0x00000040
+
+
+typedef struct RpPrtStdEmitterStandard RpPrtStdEmitterStandard;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitterStandard
+ * A structure represent the set of properties for a basic emitter. The structure is stored as
+ * a single optional data in the emitter property table.
+ *
+ * The basic emitter uses a 'time' variable to control particle emissions. A large time gap between
+ * emission can give pulse effects where as a small time gap produces a streaming effects. Particles
+ * can be emitted from a single point, line, area or a volume.
+ *
+ * Particles emitted from an emitter are of the same type. An emitter cannot emit different types of
+ * particles. Once an emitter has reached its maximum number of particles, no further particles are
+ * emitted until some of the existing particles have died.
+ *
+ * Most properties have a bias value to vary the property value. This uses the seed field
+ * to give a degreee of randomness.
+ */
+struct RpPrtStdEmitterStandard
+{
+ RwInt32 seed; /**< Seed for random number generator */
+
+ RwInt32 maxPrt; /**< Maximum number of active particles */
+
+ RwReal currTime, /**< Current timestamp for emitter */
+ prevTime; /**< Previous timestamp for emitter */
+ RwV3d force; /**< External force applied to particles */
+
+ RwV3d emtPos, /**< Emitter position */
+ emtSize; /**< Emitter size. This is the volume where new particles
+ * are emitted */
+ RwReal emtEmitGap, /**< Time gap between emission */
+ emtEmitGapBias, /**< Time gap bias */
+ emtPrevEmitTime, /**< Previous particle emission time */
+ emtEmitTime; /**< Next particle emission time */
+ RwInt32 emtPrtEmit, /**< Number of particle emit per emission */
+ emtPrtEmitBias; /**< Particle emission bias */
+
+ RwReal prtInitVel, /**< Particle's initial speed */
+ prtInitVelBias; /**< Particle's initial speed bias */
+ RwReal prtLife, /**< Particle's duration */
+ prtLifeBias; /**< Particle's duration bias */
+
+ RwV3d prtInitDir, /**< Particle's initial direction */
+ prtInitDirBias; /**< particle's initial direction bias */
+
+ RwV2d prtSize; /**< Particle's size */
+
+ RwRGBA prtColor; /**< Particle's color */
+
+ RwTexCoords prtUV[4]; /**< Particle's texture coordindates */
+ RwTexture *texture; /**< Particle's texture */
+
+ RwMatrix *ltm; /**< LTM to transform particle coordinates from local space
+ * to world space */
+};
+
+typedef struct RpPrtStdEmitterPrtColor RpPrtStdEmitterPrtColor;
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitterPrtColor
+ * An optional structure to represent the change in color of a particle from birth to death.
+ * The particles will start with the prtStartCol and ends with endPrtColor. The particle's
+ * life is used to interpolate the colors.
+ *
+ * If this structure is not present, then the particles will have a constant color.
+ */
+struct RpPrtStdEmitterPrtColor
+{
+ RwRGBAReal prtStartCol, /**< Particle start color */
+ prtStartColBias; /**< Particle start color bias */
+ RwRGBAReal prtEndCol, /**< Particle end color */
+ prtEndColBias; /**< Particle end color bias */
+};
+
+typedef struct RpPrtStdEmitterPrtTexCoords RpPrtStdEmitterPrtTexCoords;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitterPrtTexCoords
+ * An optional structure to represent the change in texcoords of a particle from birth to death.
+ * The particles will start with prtStartUV0 and prtStartUV1 and ends with endPrtEndUV0 and endPrtEndUV1.
+ * The particle's life is used to interpolate the texcoords.
+ *
+ * A particle can have two texcoords representing the top left and bottom right respectively. By varying
+ * the texcoords can give an animated texture effect on a particle.
+ *
+ * If this structure is not present, then the particles will have a constant texcoords.
+ */
+struct RpPrtStdEmitterPrtTexCoords
+{
+ RwTexCoords prtStartUV0, /**< Particle start top left texcoords */
+ prtStartUV0Bias; /**< Particle start top left texcoords bias */
+ RwTexCoords prtEndUV0, /**< Particle end top left texcoords */
+ prtEndUV0Bias; /**< Particle end top left texcoords bias */
+ RwTexCoords prtStartUV1, /**< Particle start bottom right texcoords */
+ prtStartUV1Bias; /**< Particle start botton right texcoords bias */
+ RwTexCoords prtEndUV1, /**< Particle end bottom right texcoords */
+ prtEndUV1Bias; /**< Particle end bottom right texcoords bias */
+};
+
+typedef struct RpPrtStdEmitterPrtAnimFrame RpPrtStdEmitterPrtAnimFrame;
+
+struct RpPrtStdEmitterPrtAnimFrame
+{
+ RwInt32 prtNumFrames;
+
+ RwTexCoords *prtAnimFrameTexCoords;
+};
+
+typedef struct RpPrtStdEmitterPrtSize RpPrtStdEmitterPrtSize;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitterPrtSize
+ * An optional structure to represent the change in size of a particle from birth to death.
+ * The particles will start with prtStartSize and ends with prtEndSize. The particle's life
+ * is used to interpolate the size.
+ *
+ * If this structure is not present, then the particles will have a constant size.
+ */
+struct RpPrtStdEmitterPrtSize
+{
+ RwV2d prtStartSize, /**< Particle start size */
+ prtStartSizeBias; /**< Particle start size bias */
+ RwV2d prtEndSize, /**< Particle end size */
+ prtEndSizeBias; /**< Particle end size bias */
+};
+
+typedef struct RpPrtStdEmitterPrtMatrix RWALIGN(RpPrtStdEmitterPrtMatrix, rwMATRIXALIGNMENT);
+
+struct RpPrtStdEmitterPrtMatrix
+{
+ RwMatrix prtCnsMtx;
+
+ RwV3d prtPosMtxAt,
+ prtPosMtxAtBias;
+ RwV3d prtPosMtxUp,
+ prtPosMtxUpBias;
+
+ RwInt32 flags;
+};
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+
+
+enum RpPrtStdPTankPropertyCode
+{
+ rpPRTSTDPTANKPROPPARTICLESMAX = 0,
+ rpPRTSTDPTANKPROPDATAFLAGS,
+ rpPRTSTDPTANKPROPPLATFORMFLAGS,
+ rpPRTSTDPTANKPROPPTANK,
+ rpPRTSTDPTANKPROPFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPrtStdPTankPropertyCode RpPrtStdPTankPropertyCode;
+
+typedef struct RpPrtStdEmitterPTank RpPrtStdEmitterPTank;
+struct RpPrtStdEmitterPTank
+{
+ RwUInt32 dataFlags,
+ platFlags,
+ numPrt,
+ maxPrt,
+ updateFlags,
+ emitFlags;
+ RpAtomic *pTank;
+ RwChar **dataInPtrs,
+ **dataOutPtrs;
+ RwInt32 *dataStride;
+};
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+#define rpPRTSTDPROPERTYCODEPARTICLESTANDARD 0
+#define rpPRTSTDPROPERTYCODEPARTICLEPOSITION 1
+#define rpPRTSTDPROPERTYCODEPARTICLECOLOR 2
+#define rpPRTSTDPROPERTYCODEPARTICLETEXCOORDS 3
+#define rpPRTSTDPROPERTYCODEPARTICLEANIMFRAME 4
+#define rpPRTSTDPROPERTYCODEPARTICLESIZE 5
+#define rpPRTSTDPROPERTYCODEPARTICLEVELOCITY 6
+#define rpPRTSTDPROPERTYCODEPARTICLEMATRIX 7
+
+#define rpPRTSTDPARTICLEPROPERTYCOUNT 8
+
+#define rpPRTSTDPARTICLEDATAFLAGSTANDARD 0x00000001
+#define rpPRTSTDPARTICLEDATAFLAGPOSITION 0x00000002
+#define rpPRTSTDPARTICLEDATAFLAGCOLOR 0x00000004
+#define rpPRTSTDPARTICLEDATAFLAGTEXCOORDS 0x00000008
+#define rpPRTSTDPARTICLEDATAFLAGANIMFRAME 0x00000010
+#define rpPRTSTDPARTICLEDATAFLAGSIZE 0x00000020
+#define rpPRTSTDPARTICLEDATAFLAGVELOCITY 0x00000040
+#define rpPRTSTDPARTICLEDATAFLAGMATRIX 0x00000080
+
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleStandard
+ * A structure represent the set of properties for a basic particle. This structure is mandatory
+ * for all particles.
+ * The structure contain the life duration of the particle. The particle will be removed when the current
+ * time is greater than the end time. The particle timer always starts at zero.
+ *
+ * The inverted end time is for interpolating optional particle properties.
+ */
+typedef struct RpPrtStdParticleStandard RpPrtStdParticleStandard;
+struct RpPrtStdParticleStandard
+{
+ RwInt32 flag; /**< Particle's property flag */
+ RwReal currTime, /**< Particle's curr time */
+ endTime, /**< Particle's end time */
+ invEndTime; /**< Particle's inv end for interpolation */
+};
+
+
+typedef struct RpPrtStdParticleColor RpPrtStdParticleColor;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleColor
+ * A structure representing the change in a particle's color during its life time. The structure is optional
+ * and should not be used if particles have a constant color.
+ */
+struct RpPrtStdParticleColor
+{
+ RwRGBAReal startCol, /**< Particle's end size bias */
+ deltaCol; /**< Particle's color rate of change */
+};
+
+typedef struct RpPrtStdParticleTexCoords RpPrtStdParticleTexCoords;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleTexCoords
+ * A structure representing the change in a particle's texcoords during its life time. The structure is optional
+ * and should not be used if particles have a constant texcoords.
+ */
+struct RpPrtStdParticleTexCoords
+{
+ RwTexCoords startUV0, /**< Particle's starting top left texcoords */
+ startUV1; /**< Particle's starting bottom right texcoords */
+ RwTexCoords deltaUV0, /**< Particle's top left texcoords rate of change */
+ deltaUV1; /**< Particle's bottom right texcoords rate of change */
+};
+
+typedef struct RpPrtStdParticleAnimFrame RpPrtStdParticleAnimFrame;
+
+struct RpPrtStdParticleAnimFrame
+{
+ RwInt32 frame;
+
+ RwReal delta;
+};
+
+typedef struct RpPrtStdParticleSize RpPrtStdParticleSize;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleSize
+ * A structure representing the change in a particle's size during its life time. The structure is optional
+ * and should not be used if particles have a constant size.
+ */
+struct RpPrtStdParticleSize
+{
+ RwV2d startSize, /**< Particle's starting size */
+ deltaSize; /**< Particle's size rate of change */
+ RwV2d currSize, /**< Particle's current size. Internal use only */
+ invCurrSize; /**< Particle's inverse current size. Internal use only */
+};
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/************************************************************************/
+
+extern RwBool
+RpParticleStandardPluginAttach( void );
+
+/************************************************************************/
+
+extern RpAtomic *
+RpPrtStdAtomicCreate(RpPrtStdEmitterClass *eClass, void *data);
+
+extern RpAtomic *
+RpPrtStdAtomicUpdate(RpAtomic *atomic, void *data);
+
+extern RpAtomic *
+RpPrtStdAtomicSetEmitter(RpAtomic *atomic, RpPrtStdEmitter *emt);
+
+extern RpPrtStdEmitter *
+RpPrtStdAtomicGetEmitter(RpAtomic *atomic);
+
+extern RpAtomic *
+RpPrtStdAtomicForAllEmitter(RpAtomic *atomic,
+ RpPrtStdEmitterCallBack callback,
+ void *data);
+
+extern RpAtomic *
+RpPrtStdAtomicAddEmitter(RpAtomic *,
+ RpPrtStdEmitter *emt);
+
+
+/************************************************************************/
+
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterCreate(RpPrtStdEmitterClass *eClass);
+
+extern RwBool
+RpPrtStdEmitterDestroy(RpPrtStdEmitter *emt);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterForAllParticleBatch(RpPrtStdEmitter *emt,
+ RpPrtStdParticleCallBack callback,
+ void * data);
+
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterAddEmitter(RpPrtStdEmitter *emtHead,
+ RpPrtStdEmitter *emt);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterLinkPTank(RpPrtStdEmitter *emt,RpAtomic *ptank);
+
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterDestroyParticleBatch(RpPrtStdEmitter *emt);
+
+extern RpPrtStdParticleBatch *
+RpPrtStdEmitterNewParticleBatch(RpPrtStdEmitter *emt);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterAddParticleBatch(RpPrtStdEmitter *emt,
+ RpPrtStdParticleBatch *prtBatch);
+
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterSetPClass(RpPrtStdEmitter *emt,
+ RpPrtStdParticleClass *pClass,
+ RwInt32 maxPrt);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterGetPClass(RpPrtStdEmitter *emt,
+ RpPrtStdParticleClass **pClass,
+ RwInt32 *maxPrt);
+
+
+/************************************************************************/
+
+extern RpPrtStdParticleBatch *
+RpPrtStdParticleBatchCreate(RpPrtStdParticleClass *pClass, RwInt32 maxPrt);
+
+extern RwBool
+RpPrtStdParticleBatchDestroy(RpPrtStdParticleBatch *prtBatch);
+
+extern RpPrtStdParticleBatch *
+RpPrtStdParticleBatchAddBatch(RpPrtStdParticleBatch *prtBatchHead,
+ RpPrtStdParticleBatch *prtBatch);
+
+/************************************************************************/
+
+extern RpPrtStdPropertyTable *
+RpPrtStdPropTabCreate(RwInt32 numProp,
+ RwInt32 *propID, RwInt32 *propStride);
+
+extern RwBool
+RpPrtStdPropTabDestroy(RpPrtStdPropertyTable *propTab);
+
+
+extern RpPrtStdPropertyTable *
+RpPrtStdPropTabGetProperties(RpPrtStdPropertyTable *propTab,
+ RwInt32 *numProp,
+ RwInt32 **propID,
+ RwInt32 **propOffset,
+ RwInt32 **propSize);
+
+extern RwInt32
+RpPrtStdPropTabGetPropOffset(RpPrtStdPropertyTable *propTab,
+ RwInt32 propID);
+
+extern RwInt32
+RpPrtStdPropTabGetPropIndex(RpPrtStdPropertyTable *propTab,
+ RwInt32 propID);
+
+
+extern RpPrtStdPropertyTable *
+RpPrtStdPropTabGet(RwInt32 id);
+
+extern RpPrtStdPropertyTable *
+RpPrtStdPropTabStreamRead(RwStream *stream);
+
+extern RpPrtStdPropertyTable *
+RpPrtStdPropTabStreamWrite(RpPrtStdPropertyTable *eClass,
+ RwStream *stream);
+
+extern RwInt32
+RpPrtStdPropTabStreamGetSize(RpPrtStdPropertyTable *eClass);
+
+/************************************************************************/
+
+extern RwBool
+RpPrtStdEClassDestroy(RpPrtStdEmitterClass *eClass);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassCreate( void );
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassSetCallBack(RpPrtStdEmitterClass *eClass,
+ RwInt32 numCallback,
+ RpPrtStdEmitterCallBackArray *emtCB);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassGetCallBack(RpPrtStdEmitterClass *eClass,
+ RwInt32 *numCallback,
+ RpPrtStdEmitterCallBackArray **emtCB);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassSetPropTab(RpPrtStdEmitterClass *eClass,
+ RpPrtStdPropertyTable *propTab);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassGetPropTab(RpPrtStdEmitterClass *eClass,
+ RpPrtStdPropertyTable **propTab);
+
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassGet(RwInt32 id);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassStreamRead(RwStream *stream);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassStreamWrite(RpPrtStdEmitterClass *eClass,
+ RwStream *stream);
+
+extern RwInt32
+RpPrtStdEClassStreamGetSize(RpPrtStdEmitterClass *eClass);
+
+/************************************************************************/
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassCreate( void );
+
+extern RwBool
+RpPrtStdPClassDestroy(RpPrtStdParticleClass *pClass);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassSetCallBack(RpPrtStdParticleClass *pClass,
+ RwInt32 numCallback,
+ RpPrtStdParticleCallBackArray *prtCB);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassGetCallBack(RpPrtStdParticleClass *pClass,
+ RwInt32 *numCallback,
+ RpPrtStdParticleCallBackArray **prtCB);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassSetPropTab(RpPrtStdParticleClass *pClass,
+ RpPrtStdPropertyTable *propTab);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassGetPropTab(RpPrtStdParticleClass *pClass,
+ RpPrtStdPropertyTable **propTab);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassGet(RwInt32 id);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassStreamRead(RwStream *stream);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassStreamWrite(RpPrtStdParticleClass *pClass,
+ RwStream *stream);
+
+extern RwInt32
+RpPrtStdPClassStreamGetSize(RpPrtStdParticleClass *pClass);
+
+/************************************************************************/
+
+extern RwBool
+RpPrtStdSetEClassSetupCallBack(RpPrtStdEClassSetupCallBack emtCB);
+
+extern RwBool
+RpPrtStdGetEClassSetupCallBack(RpPrtStdEClassSetupCallBack *emtCB);
+
+extern RwBool
+RpPrtStdSetPClassSetupCallBack(RpPrtStdPClassSetupCallBack prtCB);
+
+extern RwBool
+RpPrtStdGetPClassSetupCallBack(RpPrtStdPClassSetupCallBack *prtCB);
+
+/************************************************************************/
+
+
+extern RwStream *
+RpPrtStdGlobalDataStreamRead(RwStream *stream);
+
+extern RwStream *
+RpPrtStdGlobalDataStreamWrite(RwStream *stream);
+
+extern RwInt32
+RpPrtStdGlobalDataStreamGetSize( void );
+
+
+/************************************************************************/
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterDefaultCB(RpAtomic * atomic,
+ RpPrtStdEmitter *prtEmt, void * data);
+
+
+extern RpPrtStdParticleBatch *
+RpPrtStdParticleDefaultCB(RpPrtStdEmitter * prtEmt,
+ RpPrtStdParticleBatch *prtBatch, void * data);
+
+/************************************************************************/
+
+extern RpPrtStdParticleBatch *
+RpPrtStdParticleStdUpdateCB(RpPrtStdEmitter *emt,
+ RpPrtStdParticleBatch *prtBatch, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdEmitCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdCreateCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdBeginUpdateCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdEndUpdateCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdRenderCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdStreamReadCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdStreamWriteCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdStreamGetSizeCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassStdCreate( RwInt32 dataFlag );
+
+extern RwInt32
+RpPrtStdEClassStdCreateID( RwInt32 dataFlag );
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassStdCreate( RwInt32 dataFlag );
+
+extern RwInt32
+RpPrtStdPClassStdCreateID( RwInt32 dataFlag );
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassStdSetupCB(RpPrtStdEmitterClass *eClass);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassStdSetupCB(RpPrtStdParticleClass *pClass);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*---- end: ./prtstd.h----*/
+
+/*---- start: c:/daily/rwsdk/plugin/prtstd/d3d8/prtstdplatform.h----*/
+/*---- end: c:/daily/rwsdk/plugin/prtstd/d3d8/prtstdplatform.h----*/
+
+#endif /* RPPRTSTD_H */
+
+
diff --git a/rwsdk/include/d3d8/rpprtstd.rpe b/rwsdk/include/d3d8/rpprtstd.rpe
new file mode 100644
index 00000000..df860d45
--- /dev/null
+++ b/rwsdk/include/d3d8/rpprtstd.rpe
@@ -0,0 +1,639 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionParticleStandard
+{
+
+
+
+ e_rwdb_CriterionParticleStandardLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionParticleStandard e_rwdb_CriterionParticleStandard;
+
+
diff --git a/rwsdk/include/d3d8/rpptank.h b/rwsdk/include/d3d8/rpptank.h
new file mode 100644
index 00000000..20931f21
--- /dev/null
+++ b/rwsdk/include/d3d8/rpptank.h
@@ -0,0 +1,781 @@
+
+#ifndef RPPTANK_H
+#define RPPTANK_H
+
+/*===========================================================================*
+ *--- Include files ---------------------------------------------------------*
+ *===========================================================================*/
+
+#include "rwcore.h"
+#include "rpworld.h"
+
+/*---- start: ./ptank.h----*/
+
+/**
+ * \defgroup rpptank RpPTank
+ * \ingroup rpplugin
+ *
+ * PTank Plugin for RenderWare.
+ */
+
+/*--- Include files ---*/
+#include <string.h>
+
+#include "rwcore.h"
+
+#include "rpptank.rpe" /* automatically generated header file */
+
+/******************************************************************************
+ * Global Types
+ */
+
+/**
+ * \ingroup rpptank
+ * Passed to \ref RpPTankAtomicCreate, these flags specify
+ * the type and properties held by the particles.
+ * Some flags are mutually exclusive and should not be mixed.
+ * The debug version of the library will assert and signal these problems.
+ */
+enum RpPTankDataFlags
+{
+ rpPTANKDFLAGNONE = ((int)0x00000000),
+ rpPTANKDFLAGPOSITION = ((int)0x00000001), /**<Uses a position per particle*/
+ rpPTANKDFLAGCOLOR = ((int)0x00000002), /**<Uses a color per particle*/
+ rpPTANKDFLAGSIZE = ((int)0x00000004), /**<Uses a size per particle*/
+ rpPTANKDFLAGMATRIX = ((int)0x00000008), /**<Uses a matrix per particle*/
+ rpPTANKDFLAGNORMAL = ((int)0x00000010), /**<Uses a normal per particle*/
+ rpPTANKDFLAG2DROTATE = ((int)0x00000020), /**<Uses a 2D rotation per particle*/
+ rpPTANKDFLAGVTXCOLOR = ((int)0x00000040), /**<Uses a color per Billboard vertex*/
+ rpPTANKDFLAGVTX2TEXCOORDS = ((int)0x00000080), /**<Uses Top-Left and Bottom-Right Texture coordinates*/
+ rpPTANKDFLAGVTX4TEXCOORDS = ((int)0x00000100), /**<Uses a texture UV per vertex*/
+/* free = ((int)0x00000200), */
+/* free = ((int)0x00000400), */
+/* free = ((int)0x00000800), */
+/* free = ((int)0x00001000), */
+/* free = ((int)0x00002000), */
+/* free = ((int)0x00004000), */
+ rpPTANKDFLAGCNSMATRIX = ((int)0x00008000), /**<Uses a constant matrix*/
+ rpPTANKDFLAGCNSNORMAL = ((int)0x00010000), /**<Uses a constant normal*/
+ rpPTANKDFLAGCNS2DROTATE = ((int)0x00020000), /**<Uses a constant 2D rotation*/
+ rpPTANKDFLAGCNSVTXCOLOR = ((int)0x00040000), /**<Uses a constant color per Billboard vertex*/
+ rpPTANKDFLAGCNSVTX2TEXCOORDS = ((int)0x00080000), /**<Uses constant Top-Left and Bottom-Right Texture coordinates*/
+ rpPTANKDFLAGCNSVTX4TEXCOORDS = ((int)0x00100000), /**<Uses a constant texture UV per vertex*/
+/* free = ((int)0x00200000), */
+/* free = ((int)0x00400000), */
+/* free = ((int)0x00800000), */
+ rpPTANKDFLAGUSECENTER = ((int)0x01000000), /**<The position of the particles are shifted*/
+/* free = ((int)0x04000000), */
+/* free = ((int)0x08000000), */
+ rpPTANKDFLAGARRAY = ((int)0x10000000), /**<Data is organized in an array */
+ rpPTANKDFLAGSTRUCTURE = ((int)0x20000000), /**<Data is organized in a structure */
+
+ RPPTANKDATAFLAGSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpPTankDataFlags RpPTankDataFlags;
+
+#define rpPTANKDFLAGTHINPARTICLES (rpPTANKDFLAGPOSITION)
+#define rpPTANKDFLAGFATPARTICLES ( rpPTANKDFLAGPOSITION | rpPTANKDFLAGSIZE \
+ | rpPTANKDFLAG2DROTATE | rpPTANKDFLAGVTXCOLOR \
+ | rpPTANKDFLAGVTX4TEXCOORDS)
+
+
+/**
+ * \ingroup rpptank
+ * Passed to \ref RpPTankAtomicLock, these flags specify
+ * the data accessed.
+ * those flags are mutually exclusive and should not be mixed.
+ */
+enum RpPTankDataLockFlags
+{
+ rpPTANKLFLAGNONE = ((int)0x00000000),
+ rpPTANKLFLAGPOSITION = ((int)0x00000001), /**<Access the positions buffer*/
+ rpPTANKLFLAGCOLOR = ((int)0x00000002), /**<Access the colors buffer*/
+ rpPTANKLFLAGSIZE = ((int)0x00000004), /**<Access the sizes buffer*/
+ rpPTANKLFLAGMATRIX = ((int)0x00000008), /**<Access the matrixes buffer*/
+ rpPTANKLFLAGNORMAL = ((int)0x00000010), /**<Access the normals buffer*/
+ rpPTANKLFLAG2DROTATE = ((int)0x00000020), /**<Access the 2D rotations buffer*/
+ rpPTANKLFLAGVTXCOLOR = ((int)0x00000040), /**<Access the colors buffer (when using a color per vertex) */
+ rpPTANKLFLAGVTX2TEXCOORDS = ((int)0x00000080), /**<Access the Top-Left and Bottom-Right Texture coordinates buffer*/
+ rpPTANKLFLAGVTX4TEXCOORDS = ((int)0x00000100), /**<Access the texture UVs Buffer (when using a color per vertex)*/
+
+ RPPTANKLOCKFLAGSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpPTankDataLockFlags RpPTankDataLockFlags;
+
+
+#if (!defined(DOXYGEN))
+
+/**
+ * \ingroup rpptank
+ * RpPTankInstanceFlags
+ */
+enum RpPTankInstanceFlags
+{
+ rpPTANKIFLAGNONE = ((int)0x00000000),
+ rpPTANKIFLAGPOSITION = ((int)0x00000001), /**<Particles position changed*/
+ rpPTANKIFLAGCOLOR = ((int)0x00000002), /**<Particles color changed*/
+ rpPTANKIFLAGSIZE = ((int)0x00000004), /**<Particles size changed*/
+ rpPTANKIFLAGMATRIX = ((int)0x00000008), /**<Particles matrix changed*/
+ rpPTANKIFLAGNORMAL = ((int)0x00000010), /**<Particles normal changed*/
+ rpPTANKIFLAG2DROTATE = ((int)0x00000020), /**<Particles 2D rotation changed*/
+ rpPTANKIFLAGVTXCOLOR = ((int)0x00000040), /**<Vertex color changed*/
+ rpPTANKIFLAGVTX2TEXCOORDS = ((int)0x00000080), /**<Vertex 2 Texture coordinates changed*/
+ rpPTANKIFLAGVTX4TEXCOORDS = ((int)0x00000100), /**<Vertex 4 Texture coordinates changed*/
+/* free = ((int)0x00000200), */
+/* free = ((int)0x00000400), */
+/* free = ((int)0x00000800), */
+/* free = ((int)0x00001000), */
+ rpPTANKIFLAGCNSCOLOR = ((int)0x00002000), /**<Constant color changed*/
+ rpPTANKIFLAGCNSSIZE = ((int)0x00004000), /**<Constant size changed*/
+ rpPTANKIFLAGCNSMATRIX = ((int)0x00008000), /**<Constant matrix changed*/
+ rpPTANKIFLAGCNSNORMAL = ((int)0x00010000), /**<Constant normal changed*/
+ rpPTANKIFLAGCNS2DROTATE = ((int)0x00020000), /**<Constant 2D rotation changed*/
+ rpPTANKIFLAGCNSVTXCOLOR = ((int)0x00040000), /**<Constant vertex color changed*/
+ rpPTANKIFLAGCNSVTX2TEXCOORDS = ((int)0x00080000), /**<Constant vertex 2 Texture coordinates changed*/
+ rpPTANKIFLAGCNSVTX4TEXCOORDS = ((int)0x00100000), /**<Constant vertex 4 Texture coordinates changed*/
+/* free = ((int)0x00200000), */
+/* free = ((int)0x00400000), */
+ rpPTANKIFLAGACTNUMCHG = ((int)0x00800000), /**<Number of active particle changed*/
+ rpPTANKIFLAGCENTER = ((int)0x01000000), /**<Center position changed*/
+/* free = ((int)0x04000000), */
+/* free = ((int)0x08000000), */
+/* free = ((int)0x10000000), */
+ rpPTANKIFLAGALL = ((int)0xFFFFFFFF),
+
+ RPPTANKINSTANCEFLAGSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPTankInstanceFlags RpPTankInstanceFlags;
+
+#endif
+
+/**
+ * \ingroup rpptank
+ * Passed to \ref RpPTankAtomicLock to specify the type of access needed.
+ *
+ * Accessing data using \ref rpPTANKLOCKWRITE will force the PTank object to reinstance
+ * the rendered data. The instantiation of this data takes place at rendering
+ * time and is done once per frame.
+ */
+enum RpPTankLockFlags
+{
+ rpPTANKLOCKWRITE = ((int)0x40000000), /**<Lock data for writing. */
+ rpPTANKLOCKREAD = ((int)0x80000000) /**<Lock data for reading. */
+};
+
+typedef enum RpPTankLockFlags RpPTankLockFlags;
+
+typedef struct RpPTankLockStruct RpPTankLockStruct;
+
+/**
+ * \ingroup rpptank
+ * \struct RpPTankLockStruct
+ * Returned by \ref RpPTankAtomicLock
+ */
+struct RpPTankLockStruct{
+ RwUInt8 *data; /**<Pointer to the locked data. */
+ RwInt32 stride; /**<Stride of the data accessed. */
+};
+
+typedef struct RpPTankFormatDescriptor RpPTankFormatDescriptor;
+
+/**
+ * \ingroup rpptank
+ * \struct RpPTankFormatDescriptor
+ * Returned by \ref RpPTankAtomicGetDataFormat
+ */
+struct RpPTankFormatDescriptor
+{
+ RwInt32 numClusters; /**<Number of clusters */
+ RwInt32 stride; /**<Size of a single structure when using
+ * structure organization, 0 otherwise */
+ RwInt32 dataFlags; /**<flags passed to \ref RpPTankAtomicCreate */
+};
+
+#if (!defined(DOXYGEN))
+
+typedef struct RpPTankData RpPTankData;
+
+struct RpPTankData
+{
+ void *data; /* PI data array
+ * in the A form :
+ * Point to the ptrList table
+ * in the S form :
+ * point to the structure
+ *
+ */
+ RpPTankLockStruct clusters[9];
+
+ void *userData; /* void pointer for platform use */
+
+ RpPTankFormatDescriptor format;
+
+ /* constant values */
+ RwUInt32 srcBlend;
+ RwUInt32 dstBlend;
+ RwBool vertexAlphaBlend;
+
+ RwV2d cCenter;
+ RwV2d cSize;
+ RwReal cRotate;
+ RwRGBA cColor;
+ RwRGBA cVtxColor[4];
+ RwTexCoords cUV[4];
+ RwMatrix cMatrix;
+};
+
+
+
+
+/* data piece size */
+extern const RwInt32 datasize[];
+
+#define RPPTANKSIZEPOSITION 0
+#define RPPTANKSIZEMATRIX 1
+#define RPPTANKSIZENORMAL 2
+#define RPPTANKSIZESIZE 3
+#define RPPTANKSIZECOLOR 4
+#define RPPTANKSIZEVTXCOLOR 5
+#define RPPTANKSIZE2DROTATE 6
+#define RPPTANKSIZEVTX2TEXCOORDS 7
+#define RPPTANKSIZEVTX4TEXCOORDS 8
+
+
+/**
+ * \ingroup rpptank
+ * \typedef rpptankAllocCallBack
+ * ...
+ */
+typedef void *(* rpPTankAllocCallBack)(RpPTankData *ptankGlobal,
+ RwInt32 maxPCount,
+ RwUInt32 dataFlags,
+ RwUInt32 platFlags);
+
+/**
+ * \ingroup rpptank
+ * \typedef rpPTankCreateCallBack
+ * ...
+ */
+typedef RwBool (* rpPTankCreateCallBack)(RpAtomic *atomic,
+ RpPTankData *ptankGlobal,
+ RwInt32 maxPCount,
+ RwUInt32 dataFlags,
+ RwUInt32 platFlags);
+
+/**
+ * \ingroup rpptank
+ * \typedef rpPTankInstanceCallBack
+ * ...
+ */
+typedef RwBool (* rpPTankInstanceCallBack)(RpAtomic *atomic,
+ RpPTankData *ptankGlobal,
+ RwInt32 actPCount,
+ RwUInt32 instFlags);
+
+/**
+ * \ingroup rpptank
+ * \typedef rpPTankRenderCallBack
+ * ...
+ */
+typedef RwBool (* rpPTankRenderCallBack)(RpAtomic *atomic,
+ RpPTankData *ptankGlobal,
+ RwInt32 actPCount);
+
+typedef struct rpPTankCallBacks rpPTankCallBacks;
+
+struct rpPTankCallBacks
+{
+ rpPTankAllocCallBack alloc;
+ rpPTankCreateCallBack create;
+ rpPTankInstanceCallBack instance;
+ rpPTankRenderCallBack render;
+};
+
+/* private typedefs */
+typedef struct rpPTANKInstanceSetupData rpPTANKInstanceSetupData;
+
+struct rpPTANKInstanceSetupData
+{
+ RwBool instancePositions;
+ RwBool instanceUVs;
+ RwBool instanceColors;
+ RwBool instanceNormals;
+
+ RpPTankLockStruct positionOut;
+ RpPTankLockStruct UVOut;
+ RpPTankLockStruct colorsOut;
+ RpPTankLockStruct normalsOut;
+
+ RwV3d right;
+ RwV3d up;
+
+};
+
+typedef void (* rpPTankGENInstancePosCallback)(
+ RpPTankLockStruct *dstCluster,
+ RwV3d *right,
+ RwV3d *up,
+ RwInt32 pCount,
+ RpPTankData *ptankGlobal);
+
+typedef void (* rpPTankGENInstanceCallback)(
+ RpPTankLockStruct *dstCluster,
+ RwInt32 pCount,
+ RpPTankData *ptankGlobal);
+
+typedef void (* rpPTankGENInstanceSetupCallback)(
+ rpPTANKInstanceSetupData *data,
+ RpAtomic *atomic,
+ RpPTankData *ptankGlobal,
+ RwInt32 actPCount,
+ RwUInt32 instFlags);
+
+typedef void (* rpPTankGENInstanceEndingCallback)(
+ rpPTANKInstanceSetupData *data,
+ RpAtomic *atomic,
+ RpPTankData *ptankGlobal,
+ RwInt32 actPCount,
+ RwUInt32 instFlags);
+
+typedef struct RpPTankAtomicExtPrv RpPTankAtomicExtPrv;
+
+struct RpPTankAtomicExtPrv
+{
+ RwInt32 maxPCount; /* max number of particles */
+ RwInt32 actPCount; /* number of actives particles */
+
+ RwBool isAStructure; /* is in a structure of array form */
+ void *rawdata; /* unaligned pointer to the PI data */
+
+ /* Rendering callback */
+ RpAtomicCallBackRender defaultRenderCB;
+
+ rpPTankCallBacks ptankCallBacks;
+
+ /* Instancing CallBacks */
+ rpPTankGENInstanceSetupCallback insSetupCB;
+ rpPTankGENInstancePosCallback insPosCB;
+ rpPTankGENInstanceCallback insUVCB;
+ rpPTankGENInstanceCallback insColorsCB;
+ rpPTankGENInstanceCallback insNormalsCB;
+ rpPTankGENInstanceEndingCallback insEndingCB;
+
+ RwUInt32 lockFlags;
+ RwUInt32 instFlags;
+ RwUInt32 platFlags;
+
+ RpPTankData publicData;
+};
+
+/*--- Plugin API Functions ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* private globals */
+extern RwInt32 _rpPTankAtomicDataOffset; /* Offset in RpAtomic */
+
+extern RwInt32 _rpPTankGlobalsOffset; /* Offset in RwEngine */
+
+/* Macro tools */
+#define RPATOMICPTANKPLUGINDATA(atomic) \
+ (*RWPLUGINOFFSET(RpPTankAtomicExtPrv *, (atomic), _rpPTankAtomicDataOffset))
+
+#define GLOBALPTANKPLUGINDATA() \
+ (*RWPLUGINOFFSET(void *, RwEngineInstance, _rpPTankGlobalsOffset))
+
+#endif
+
+
+
+extern RwBool
+RpPTankPluginAttach(void);
+
+
+/*
+ * PTank Management API ******************************************************
+ */
+
+extern RpAtomic *
+RpPTankAtomicCreate(RwInt32 maxParticleNum,
+ RwUInt32 dataFlags,
+ RwUInt32 platFlags);
+
+extern void
+RpPTankAtomicDestroy(RpAtomic *ptank);
+
+extern RwBool
+RpAtomicIsPTank(RpAtomic *atomic);
+
+extern const RpPTankFormatDescriptor *
+RpPTankAtomicGetDataFormat(RpAtomic *atomic);
+
+/*
+ * Particles Management API **************************************************
+ */
+
+#define RpPTankAtomicGetActiveParticlesCountMacro(_atm)\
+ (RPATOMICPTANKPLUGINDATA(_atm)->actPCount)
+
+#define RpPTankAtomicGetMaximumParticlesCountMacro(_atm)\
+ (RPATOMICPTANKPLUGINDATA(_atm)->maxPCount)
+
+#define RpPTankAtomicSetActiveParticlesCountMacro(atm_,cnt_)\
+MACRO_START\
+{\
+ RPATOMICPTANKPLUGINDATA(atm_)->instFlags |= rpPTANKIFLAGACTNUMCHG;\
+ RPATOMICPTANKPLUGINDATA(atm_)->actPCount = cnt_;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicSetTextureMacro(atm_, tex_)\
+MACRO_START\
+{\
+RpMaterialSetTexture(RpGeometryGetMaterial(RpAtomicGetGeometry(atm_),0), tex_);\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetTextureMacro(atm_)\
+ (RpMaterialGetTexture(RpGeometryGetMaterial(RpAtomicGetGeometry(atm_),0)))
+
+#define RpPTankAtomicGetMaterialMacro(atm_)\
+ (RpGeometryGetMaterial(RpAtomicGetGeometry(atm_),0))
+
+#define RpPTankAtomicSetBlendModesMacro(atm_,src_,dst_)\
+MACRO_START\
+{\
+ RPATOMICPTANKPLUGINDATA(atm_)->publicData.srcBlend = src_;\
+ RPATOMICPTANKPLUGINDATA(atm_)->publicData.dstBlend = dst_;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetBlendModesMacro(atm_,src_,dst_)\
+MACRO_START\
+{\
+ *src_ =\
+ (RwBlendFunction)(RPATOMICPTANKPLUGINDATA(atm_)->publicData.srcBlend);\
+ *dst_ =\
+ (RwBlendFunction)(RPATOMICPTANKPLUGINDATA(atm_)->publicData.dstBlend);\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicSetVertexAlphaMacro(atm_, vas_)\
+MACRO_START\
+{\
+ RPATOMICPTANKPLUGINDATA(atm_)->publicData.vertexAlphaBlend = vas_;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetVertexAlphaMacro(atm_)\
+ (RPATOMICPTANKPLUGINDATA(atm_)->publicData.vertexAlphaBlend)
+
+#define RpPTankAtomicSetConstantCenterMacro(atm_, ctr_)\
+MACRO_START\
+{\
+ RPATOMICPTANKPLUGINDATA(atm_)->publicData.cCenter = *ctr_;\
+ RPATOMICPTANKPLUGINDATA(atm_)->instFlags |= rpPTANKIFLAGCENTER;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetConstantCenterMacro(atm_)\
+ (&(RPATOMICPTANKPLUGINDATA(atm_)->publicData.cCenter))
+
+
+#define RpPTankAtomicSetConstantSizeMacro(atm_, size_)\
+MACRO_START\
+{\
+ RPATOMICPTANKPLUGINDATA(atm_)->publicData.cSize = *size_;\
+ RPATOMICPTANKPLUGINDATA(atm_)->instFlags |= rpPTANKIFLAGCNSSIZE;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetConstantSizeMacro(atm_)\
+ (&RPATOMICPTANKPLUGINDATA(atm_)->publicData.cSize)
+
+#define RpPTankAtomicSetConstantRotateMacro(atm_, rot_)\
+MACRO_START\
+{\
+ RPATOMICPTANKPLUGINDATA(atm_)->publicData.cRotate = rot_;\
+ RPATOMICPTANKPLUGINDATA(atm_)->instFlags |= rpPTANKIFLAGCNS2DROTATE;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetConstantRotateMacro(atm_)\
+ (RPATOMICPTANKPLUGINDATA(atm_)->publicData.cRotate)
+
+#define RpPTankAtomicSetConstantMatrixMacro(atm_, mtx_)\
+MACRO_START\
+{\
+ RwMatrixCopy(&(RPATOMICPTANKPLUGINDATA(atm_)->publicData.cMatrix),mtx_);\
+ RPATOMICPTANKPLUGINDATA(atm_)->instFlags |= rpPTANKIFLAGCNSMATRIX;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetConstantMatrixMacro(atm_)\
+ (&(RPATOMICPTANKPLUGINDATA(atm_)->publicData.cMatrix))
+
+#define RpPTankAtomicSetConstantColorMacro(atm_, col_)\
+MACRO_START\
+{\
+ RPATOMICPTANKPLUGINDATA(atm_)->publicData.cColor = *col_;\
+ if( RpGeometryGetMaterial(RpAtomicGetGeometry(atm_),0) )\
+ {\
+ RpMaterialSetColor(\
+ RpGeometryGetMaterial(RpAtomicGetGeometry(atm_),0),\
+ &RPATOMICPTANKPLUGINDATA(atm_)->publicData.cColor);\
+ }\
+ RPATOMICPTANKPLUGINDATA(atm_)->instFlags |= rpPTANKIFLAGCNSCOLOR;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetConstantColorMacro(atm_)\
+ (&(RPATOMICPTANKPLUGINDATA(atm_)->publicData.cColor))
+
+#define RpPTankAtomicSetConstantVtxColorMacro(atm_, col_)\
+MACRO_START\
+{\
+ memcpy(RPATOMICPTANKPLUGINDATA(atm_)->publicData.cVtxColor,\
+ col_,\
+ sizeof(RwRGBA)*4);\
+ RPATOMICPTANKPLUGINDATA(atm_)->instFlags |= rpPTANKIFLAGCNSVTXCOLOR;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetConstantVtxColorMacro(atm_)\
+ (RPATOMICPTANKPLUGINDATA(atm_)->publicData.cVtxColor)
+
+#define RpPTankAtomicSetConstantVtx2TexCoordsMacro(atm_, uv_)\
+MACRO_START\
+{\
+ memcpy(RPATOMICPTANKPLUGINDATA(atm_)->publicData.cUV,\
+ uv_,\
+ sizeof(RwTexCoords)*2);\
+ RPATOMICPTANKPLUGINDATA(atm_)->instFlags |= rpPTANKIFLAGCNSVTX2TEXCOORDS;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetConstantVtx2TexCoordsMacro(atm_)\
+ (RPATOMICPTANKPLUGINDATA(atm_)->publicData.cUV)
+
+#define RpPTankAtomicSetConstantVtx4TexCoordsMacro(atm_, uv_)\
+MACRO_START\
+{\
+ memcpy(RPATOMICPTANKPLUGINDATA(atm_)->publicData.cUV,\
+ uv_,\
+ sizeof(RwTexCoords)*4);\
+ RPATOMICPTANKPLUGINDATA(atm_)->instFlags |= rpPTANKIFLAGCNSVTX4TEXCOORDS;\
+}\
+MACRO_STOP
+
+#define RpPTankAtomicGetConstantVtx4TexCoordsMacro(atm_)\
+ (RPATOMICPTANKPLUGINDATA(atm_)->publicData.cUV)
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+extern RwInt32
+RpPTankAtomicGetActiveParticlesCount(RpAtomic *atomic);
+
+extern RwInt32
+RpPTankAtomicGetMaximumParticlesCount(RpAtomic *atomic);
+
+extern void
+RpPTankAtomicSetActiveParticlesCount(RpAtomic *atomic, RwInt32 count);
+
+extern void
+RpPTankAtomicSetTexture(RpAtomic *atomic, RwTexture *texture);
+
+extern RwTexture *
+RpPTankAtomicGetTexture(RpAtomic *atomic);
+
+extern RpAtomic *
+RpPTankAtomicSetMaterial(RpAtomic *atomic, RpMaterial *material);
+
+extern RpMaterial *
+RpPTankAtomicGetMaterial(RpAtomic *atomic);
+
+extern void
+RpPTankAtomicSetBlendModes(RpAtomic *atomic,
+ RwBlendFunction srcBlendMode,
+ RwBlendFunction dstBlendMode );
+
+extern void
+RpPTankAtomicGetBlendModes(RpAtomic *atomic,
+ RwBlendFunction *srcBlendMode,
+ RwBlendFunction *dstBlendMode );
+
+extern void
+RpPTankAtomicSetVertexAlpha(RpAtomic *atomic, RwBool vtxAlphaState);
+
+extern RwBool
+RpPTankAtomicGetVertexAlpha(RpAtomic *atomic);
+
+extern void
+RpPTankAtomicSetConstantCenter(RpAtomic *atomic, RwV2d *center);
+
+const RwV2d *
+RpPTankAtomicGetConstantCenter(RpAtomic *atomic);
+
+extern void
+RpPTankAtomicSetConstantSize(RpAtomic *atomic, RwV2d *size);
+
+extern const RwV2d *
+RpPTankAtomicGetConstantSize(RpAtomic *atomic);
+
+extern void
+RpPTankAtomicSetConstantRotate(RpAtomic *atomic, RwReal rotate);
+
+extern RwReal
+RpPTankAtomicGetConstantRotate(RpAtomic *atomic);
+
+extern void
+RpPTankAtomicSetConstantMatrix(RpAtomic *atomic, RwMatrix *matrix);
+
+extern const RwMatrix *
+RpPTankAtomicGetConstantMatrix(RpAtomic *atomic);
+
+extern void
+RpPTankAtomicSetConstantColor(RpAtomic *atomic, RwRGBA *color);
+
+extern const RwRGBA *
+RpPTankAtomicGetConstantColor(RpAtomic *atomic);
+
+extern void
+RpPTankAtomicSetConstantVtxColor(RpAtomic *atomic, RwRGBA *color);
+
+extern const RwRGBA *
+RpPTankAtomicGetConstantVtxColor(RpAtomic *atomic);
+
+extern void
+RpPTankAtomicSetConstantVtx2TexCoords(RpAtomic *atomic, RwTexCoords *UVs);
+
+extern const RwTexCoords *
+RpPTankAtomicGetConstantVtx2TexCoords(RpAtomic *atomic);
+
+extern void
+RpPTankAtomicSetConstantVtx4TexCoords(RpAtomic *atomic, RwTexCoords *UVs);
+
+extern const RwTexCoords *
+RpPTankAtomicGetConstantVtx4TexCoords(RpAtomic *atomic);
+#else
+
+#define RpPTankAtomicGetActiveParticlesCount(atm_)\
+ RpPTankAtomicGetActiveParticlesCountMacro(atm_)
+
+#define RpPTankAtomicGetMaximumParticlesCount(atm_)\
+ RpPTankAtomicGetMaximumParticlesCountMacro(atm_)
+
+#define RpPTankAtomicSetActiveParticlesCount(atm_,cnt_)\
+ RpPTankAtomicSetActiveParticlesCountMacro(atm_,cnt_)
+
+
+#define RpPTankAtomicSetTexture(atm_,tex_)\
+ RpPTankAtomicSetTextureMacro(atm_,tex_)
+
+#define RpPTankAtomicGetTexture(atm_)\
+ RpPTankAtomicGetTextureMacro(atm_)
+
+extern RpAtomic *
+RpPTankAtomicSetMaterial(RpAtomic *atomic, RpMaterial *material);
+
+#define RpPTankAtomicGetMaterial(atm_)\
+ RpPTankAtomicGetMaterialMacro(atm_)
+
+#define RpPTankAtomicSetBlendModes(atm_,src_,dst_)\
+ RpPTankAtomicSetBlendModesMacro(atm_,src_,dst_)
+
+#define RpPTankAtomicGetBlendModes(atm_,src_,dst_)\
+ RpPTankAtomicGetBlendModesMacro(atm_,src_,dst_)
+
+#define RpPTankAtomicSetVertexAlpha(atm_, vas_)\
+ RpPTankAtomicSetVertexAlphaMacro(atm_, vas_)
+
+#define RpPTankAtomicGetVertexAlpha(atm_)\
+ RpPTankAtomicGetVertexAlphaMacro(atm_)
+
+#define RpPTankAtomicSetConstantCenter(atm_, ctr_)\
+ RpPTankAtomicSetConstantCenterMacro(atm_, ctr_)
+
+#define RpPTankAtomicGetConstantCenter(atm_)\
+ RpPTankAtomicGetConstantCenterMacro(atm_)
+
+#define RpPTankAtomicSetConstantSize(atm_, size_)\
+ RpPTankAtomicSetConstantSizeMacro(atm_, size_)
+
+#define RpPTankAtomicGetConstantSize(atm_)\
+ RpPTankAtomicGetConstantSizeMacro(atm_)
+
+#define RpPTankAtomicSetConstantRotate(atm_, rot_)\
+ RpPTankAtomicSetConstantRotateMacro(atm_, rot_)
+
+#define RpPTankAtomicGetConstantRotate(atm_)\
+ RpPTankAtomicGetConstantRotateMacro(atm_)
+
+#define RpPTankAtomicSetConstantMatrix(atm_, mtx_)\
+ RpPTankAtomicSetConstantMatrixMacro(atm_, mtx_)
+
+#define RpPTankAtomicGetConstantMatrix(atm_)\
+ RpPTankAtomicGetConstantMatrixMacro(atm_)
+
+#define RpPTankAtomicSetConstantColor(atm_, col_)\
+ RpPTankAtomicSetConstantColorMacro(atm_, col_)
+
+#define RpPTankAtomicGetConstantColor(atm_)\
+ RpPTankAtomicGetConstantColorMacro(atm_)
+
+#define RpPTankAtomicSetConstantVtxColor(atm_, _col)\
+ RpPTankAtomicSetConstantVtxColorMacro(atm_, _col)
+
+#define RpPTankAtomicGetConstantVtxColor(atm_)\
+ RpPTankAtomicGetConstantVtxColorMacro(atm_)
+
+#define RpPTankAtomicSetConstantVtx2TexCoords(atm_, uv_)\
+ RpPTankAtomicSetConstantVtx2TexCoordsMacro(atm_, uv_)
+
+#define RpPTankAtomicGetConstantVtx2TexCoords(atm_)\
+ RpPTankAtomicGetConstantVtx2TexCoordsMacro(atm_)\
+
+#define RpPTankAtomicSetConstantVtx4TexCoords(atm_, uv_)\
+ RpPTankAtomicSetConstantVtx4TexCoordsMacro(atm_, uv_)
+
+#define RpPTankAtomicGetConstantVtx4TexCoords(atm_)\
+ RpPTankAtomicGetConstantVtx4TexCoordsMacro(atm_)
+
+#endif
+
+/*
+ * Data access API ***********************************************************
+ */
+
+extern RwBool
+RpPTankAtomicLock(RpAtomic *atomic, RpPTankLockStruct *dst,
+ RwUInt32 dataFlags, RpPTankLockFlags lockFlag);
+
+extern void *
+RpPTankAtomicLockByIndex(RpAtomic *atomic, RwInt32 idx, RwUInt32 dataFlags, RpPTankLockFlags lockFlag);
+
+extern RpAtomic *
+RpPTankAtomicUnlock(RpAtomic *atomic);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*---- end: ./ptank.h----*/
+
+/*---- start: c:/daily/rwsdk/plugin/ptank/d3d8/ptankplatform.h----*/
+
+enum RpPTankD3D8Flags
+{
+ rpPTANKD3D8FLAGSUSEPOINTSPRITES = 0x00000001,
+
+ rpPTANKD3D8FLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+/*---- end: c:/daily/rwsdk/plugin/ptank/d3d8/ptankplatform.h----*/
+
+#endif /* RPPTANK_H */
+
+
diff --git a/rwsdk/include/d3d8/rpptank.rpe b/rwsdk/include/d3d8/rpptank.rpe
new file mode 100644
index 00000000..485b5dd8
--- /dev/null
+++ b/rwsdk/include/d3d8/rpptank.rpe
@@ -0,0 +1,643 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionPTank
+{
+
+
+
+ e_rwdb_CriterionPTankLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionPTank e_rwdb_CriterionPTank;
+
+
diff --git a/rwsdk/include/d3d8/rppvs.h b/rwsdk/include/d3d8/rppvs.h
new file mode 100644
index 00000000..29fc2343
--- /dev/null
+++ b/rwsdk/include/d3d8/rppvs.h
@@ -0,0 +1,395 @@
+/*
+ * Potentially Visible Set plug-in
+ */
+
+/**********************************************************************
+ *
+ * file : rppvs.h
+ *
+ * abstract : handle culling of worldsectors in RenderWare
+ *
+ **********************************************************************
+ *
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd. or
+ * Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. will not, under any
+ * circumstances, be liable for any lost revenue or other damages arising
+ * from the use of this file.
+ *
+ * Copyright (c) 2001 Criterion Software Ltd.
+ * All Rights Reserved.
+ *
+ * RenderWare is a trademark of Canon Inc.
+ *
+ ************************************************************************/
+
+#ifndef _RPPVS_H
+#define _RPPVS_H
+
+/**
+ * \defgroup rppvs RpPVS
+ * \ingroup rpplugin
+ *
+ * Geometric Potentially Visible Set Plugin for RenderWare Graphics.
+ */
+
+/****************************************************************************
+ Defines
+ */
+
+typedef RwUInt8 RpPVSVisMap;
+
+#define PVSFROMWORLDSECTOR(sector) \
+ ((RpPVS *)(((char *)(sector))+rpPVSGlobals.sectorOffset))
+
+#define WORLDSECTORFROMPVS(pvs) \
+ ((RpWorldSector *)(((char *)(pvs))-rpPVSGlobals.sectorOffset))
+
+#define PVSFROMCONSTWORLDSECTOR(sector) \
+ ((const RpPVS *)(((const char *)(sector))+rpPVSGlobals.sectorOffset))
+
+
+#define PVSCACHEFROMWORLD(world) \
+ ((RpPVSCache *)(((char *)(world))+rpPVSGlobals.worldOffset))
+#define PVSCACHEFROMCONSTWORLD(world) \
+ ((const RpPVSCache *)(((const char *)(world))+rpPVSGlobals.worldOffset))
+
+#define PVSVISMAPSETSECTOR(_vismap, _id) \
+ (_vismap)[(_id) >> 3] |= (1 << ((_id) & 7))
+
+#define PVSVISMAPUNSETSECTOR(_vismap, _id) \
+ (_vismap)[(_id) >> 3] ^= (1 << ((_id) & 7))
+
+#define PVSVISMAPGETSECTOR(_vismap, _id) \
+ ((_vismap)[(_id) >> 3] & (1 << ((_id) & 7)))
+
+#define PVSVISMAPLENGTH(_vismaplength, _nosectors) \
+ (_vismaplength) = ((_nosectors + 7) >> 3)
+
+
+/* Progress callback message types */
+#define rpPVSPROGRESSSTART 20
+#define rpPVSPROGRESSUPDATE 12
+#define rpPVSPROGRESSEND 22
+
+/**
+ * \ingroup rppvs
+ * \ref RpPVSProgressCallBack
+ * This typedef sets the callback function for sampling within a world sector.
+ *
+ * \param value A value between 0.0 and 100.0 to represent the percentage completion.
+ * \param msg The message may take one of the following:
+ *
+ * \li rpPVSPROGRESSSTART
+ * The PVS creation process is about to start. The argument value is equal to 0.0.
+ *
+ * \li rpPVSPROGRESSUPDATE
+ * The PVS creation process has finished processing a subsection of the world.
+ * The argument value is equal to the percentage of the world processed up to this point.
+ *
+ * \li rpPVSPROGRESSEND
+ * The PVS creation process has ended. All world sectors have been processed.
+ * The argument value is equal to 100.0.
+ *
+ * The progress callback may return FALSE to indicate that the generation of PVS data
+ * should terminate. Otherwise, return TRUE to continue.
+ *
+ * The PVS plugin must be attached before using this function.
+ *
+ *
+ */
+typedef RwBool(*RpPVSProgressCallBack) (RwInt32 msg,
+ RwReal value);
+
+
+/**
+ * \ingroup rppvs
+ * \ref RpPVSCallBack
+ * This typedef sets the callback function for sampling within a world sector.
+ *
+ * \param worldSector A pointer to the \ref RpWorldSector being sampled.
+ * \param box The bounding box of the region being sampled.
+ * \param pData A pointer to private data for the sampling function.
+ */
+typedef RpWorldSector *(*RpPVSCallBack) (RpWorldSector * worldSector,
+ const RwBBox * box,
+ void *pData);
+
+#define RpPVSCallback RpPVSCallBack
+
+typedef struct _RpPVSCallBack _RpPVSCallBack;
+struct _RpPVSCallBack
+{
+ RpPVSCallBack callback;
+ void *data;
+};
+
+enum _rpPVSPartitionId
+{
+ rpNAPVSPARTITIONID = 0,
+ rpPVSFRONT,
+ rpPVSBACK,
+ rpPVSSPLIT,
+ rpPVSCOPLANAR,
+ rpPVSPARTITIONIDFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum _rpPVSPartitionId _rpPVSPartitionId;
+
+typedef struct _rpPVSPolyList _rpPVSPolyList;
+typedef struct _rpPVSPolyList *_rpPVSPolyListPtr;
+
+typedef struct _rpPVSPoly _rpPVSPoly;
+typedef struct _rpPVSPoly *_rpPVSPolyPtr;
+
+typedef struct _rpPVSPlaneEq _rpPVSPlaneEq;
+struct _rpPVSPlaneEq
+{
+ RwReal x;
+ RwReal y;
+ RwReal z;
+ RwReal w;
+
+ RwReal l; /* recip of length of the normal */
+
+ _rpPVSPartitionId lastresult; /* temp: stores result of last polygon wrt this plane */
+};
+
+typedef struct
+{
+ RwInt32 x;
+ RwInt32 y;
+ RwInt32 z;
+}RwV3i;
+
+typedef struct _rpPVSPolyRecord _rpPVSPolyRecord;
+struct _rpPVSPolyRecord
+{
+ RwBool original; /* True if not a fragment */
+ RwReal priority; /* Used for sorting, lower values higher priority */
+ _rpPVSPolyListPtr parent; /* Unique pointer to original parent */
+ _rpPVSPolyPtr geom; /* corners of the poly */
+ _rpPVSPlaneEq plane; /* plane equation of the poly */
+ RwInt32 home; /* world sector id in range 0..numsectors */
+ RpWorldSector *homeaddr; /* world sector pointer */
+ RwBool translucent;
+
+ RwBool hasbeenclipper; /* Used during WA creation */
+
+ /* used by proximity culling, calculated once */
+ RwV3d centroid;
+ RwReal radius;
+ RwV3d extreme; /* the vertex furthest away from the centroid */
+
+ RwReal coneRadius; /* Used during clipping only */
+
+};
+
+struct _rpPVSPoly
+{
+ RwV3d v;
+ _rpPVSPoly *next;
+
+ RwInt32 pscalar; /* Used during clipping only */
+ RwReal scalar; /* Used during clipping only */
+ _rpPVSPlaneEq shadowPlane; /* Used during clipping only */
+};
+
+struct _rpPVSPolyList
+{
+ _rpPVSPolyRecord data;
+ _rpPVSPolyList *next;
+};
+
+typedef struct RpPVS RpPVS;
+struct RpPVS
+{
+ RwInt32 sectorID; /* Id of the sector */
+ RwInt32 vismaplength; /* Length of vismap */
+ RwInt32 sampleKey; /* Currently unused, for future use */
+
+ RpPVSVisMap *vismap;
+
+ _rpPVSPolyListPtr sectailpoly; /* Pointer to last polygon in polygons list that is in this sector */
+
+ _rpPVSPartitionId potential; /* temp: is sector in out or split from current shadow volume - for heirarchical clip */
+ RwUInt32 numpols;
+ RwBBox sbox; /* Bounding box of the sector */
+ RwBBox gbox; /* Bounding box of the geometry of the sector */
+ RwReal diagonal; /* Diagonal size of bounding box of the sector */
+ RwV3d centre; /* Centre of the sector */
+ RwInt32 axessig[3]; /* sampling significance of the axes of the gbox */
+};
+
+typedef struct RpPVSCache RpPVSCache;
+struct RpPVSCache
+{
+ RwBool processed; /* flag to indicate exisiting PVS data for the world */
+ RwBool formatted; /* flag to indicate exisiting intermediate polygonal data for PVS generation */
+
+ /* stats collection */
+ RwInt32 ptotal;
+ RwInt32 paccept;
+
+ /* pipeline hooking */
+ RwBool hooked;
+
+ /* used during vismap allocation */
+ RwUInt32 nextID;
+
+ RwInt32 viscount;
+
+ /* Used during construction */
+ RpPVSProgressCallBack progressCallBack;
+
+ _rpPVSPolyListPtr polygons; /* A copy of the input data set of all world polygons */
+
+ RpWorldSectorCallBackRender renderCallBack;
+};
+
+typedef struct RpPVSGlobalVars RpPVSGlobalVars;
+struct RpPVSGlobalVars
+{
+ RpWorld *World;
+
+ RwInt32 worldOffset; /* Offset into global data */
+ RwInt32 sectorOffset; /* Offset into global data */
+
+ RwBool collis; /* Collision detection */
+ RwBool bfc; /* Backface culling */
+
+ RwInt32 NumWorldSectors;
+
+ RwInt32 progress_count;
+ RwReal diagonal;
+
+ RwReal gran;
+
+ RwInt32 InSector; /* Current sector id */
+ RwV3d ViewPos; /* Current view pos */
+ RpPVS *CurrPVS; /* Current PVS sector */
+};
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RpPVSGlobalVars rpPVSGlobals;
+
+extern RpWorld *
+RpPVSSetProgressCallBack(RpWorld * wpWorld,
+ RpPVSProgressCallBack
+ callback);
+
+extern RpWorldSector *
+RpPVSSetViewPosition(RpWorld * wpWorld,
+ RwV3d * pos);
+
+extern RpWorldSector *
+RpPVSSetViewSector(RpWorld * wpWorld, RpWorldSector * spSect);
+
+extern RpWorldSector *
+RpPVSSetWorldSectorPairedVisibility(RpWorldSector * spSectA,
+ RpWorldSector * spSectB,
+ RwBool visible,
+ RwBool mutual);
+
+extern RpWorld *
+RpPVSDestroy(RpWorld * wpWorld);
+
+extern RwBool
+RpPVSWorldSectorVisible(RpWorldSector * spSect);
+
+extern RwBool
+RpPVSPluginAttach(void);
+
+extern RwBool
+RpPVSQuery(RpWorld * wpWorld);
+
+extern RwBool
+RpPVSAtomicVisible(RpAtomic * atom);
+
+extern RpWorld *
+RpPVSStatisticsGet(RpWorld * wpWorld,
+ RwInt32 * ptotal,
+ RwInt32 * paccept);
+
+extern RpPVSProgressCallBack
+RpPVSGetProgressCallBack(RpWorld *
+ wpWorld);
+
+extern RpWorld *
+RpPVSConstruct(RpWorld * wpWorld,
+ RpPVSCallBack callback,
+ void *pData);
+
+extern RpWorld*
+RpPVSConstructSector(RpWorld * wpWorld,
+ RpWorldSector * spSector,
+ RpPVSCallBack callback,
+ void *pData);
+
+
+extern RpWorldSector *
+RpPVSGeneric(RpWorldSector * spSect,
+ const RwBBox __RWUNUSED__ * box,
+ void *data);
+
+extern RwBool
+RpPVSSetCollisionDetection(RwBool collis);
+
+extern RwBool
+RpPVSSetBackFaceCulling(RwBool bfc);
+
+extern RpWorld *
+RpPVSUnhook(RpWorld * wpWorld);
+
+extern RpWorld *
+RpPVSHook(RpWorld * wpWorld);
+
+extern RpWorldSector *
+RpPVSSetWorldSectorVisibility(RpWorldSector * spSect,
+ RwBool visible);
+
+extern RwBool
+RpPVSSamplePOV(RwV3d * pos,
+ RwBool colltest);
+
+extern RxNodeDefinition *
+RxNodeDefinitionGetPVSWorldSectorCSL(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* These functions are added for backwards compatibility... */
+#define RpPVSCreate(_wpWorld, \
+ _raster, _zraster, _mindist, \
+ _maxdist, _maxdepth, _callback, _pData) \
+ RpPVSConstruct(_wpWorld, _callback, _pData)
+
+#define RpPVSAddPOV(_pos) \
+ RpPVSSamplePOV(_pos, FALSE)
+
+#define RpPVSAddWorldSector(_sector) \
+ RpPVSSetWorldSectorVisibility(_sector, TRUE)
+
+#define RpPVSAddExtraPOV(_world, _raster, _zraster, _mindist, _mazdist, _matrix) \
+MACRO_START \
+{ \
+ rpPVSGlobals.World = (_world); \
+ RpPVSSamplePOV(&((_matrix)->pos), TRUE); \
+} \
+MACRO_STOP
+
+
+#endif /* _RPPVS_H */
diff --git a/rwsdk/include/d3d8/rppvs.rpe b/rwsdk/include/d3d8/rppvs.rpe
new file mode 100644
index 00000000..dc060cff
--- /dev/null
+++ b/rwsdk/include/d3d8/rppvs.rpe
@@ -0,0 +1,640 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionGPVS
+{
+
+
+
+ e_rwdb_CriterionGPVSLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionGPVS e_rwdb_CriterionGPVS;
+
+
diff --git a/rwsdk/include/d3d8/rprandom.h b/rwsdk/include/d3d8/rprandom.h
new file mode 100644
index 00000000..8690c69a
--- /dev/null
+++ b/rwsdk/include/d3d8/rprandom.h
@@ -0,0 +1,65 @@
+/**********************************************************************
+ *
+ * File : rprandom.h
+ *
+ * Abstract : Random Number Generator
+ *
+ **********************************************************************
+ *
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd. or
+ * Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. will not, under any
+ * circumstances, be liable for any lost revenue or other damages arising
+ * from the use of this file.
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+ * All Rights Reserved.
+ *
+ * RenderWare is a trademark of Canon Inc.
+ *
+ ************************************************************************/
+
+#ifndef RPRANDOM_H
+#define RPRANDOM_H
+
+/**
+ * \defgroup rprandom RpRandom
+ * \ingroup rpplugin
+ *
+ * Random Number Generation Plugin for RenderWare Graphics.
+ */
+
+/*--- Include files ---*/
+#include "rwcore.h"
+
+#include "rprandom.rpe" /* automatically generated header file */
+
+/*--- Plugin API Functions ---*/
+
+#define RPRANDMAX (~((~0)<<31))
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+RwBool RpRandomPluginAttach(void);
+
+/* Getting values */
+
+extern RwUInt32 RpRandom(void);
+extern void RpRandomSeed(RwUInt32 seed);
+
+extern RwUInt32 RpRandomMT(void);
+extern void RpRandomSeedMT(RwUInt32 seed);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RPRANDOM_H */
+
diff --git a/rwsdk/include/d3d8/rprandom.rpe b/rwsdk/include/d3d8/rprandom.rpe
new file mode 100644
index 00000000..8e267eee
--- /dev/null
+++ b/rwsdk/include/d3d8/rprandom.rpe
@@ -0,0 +1,638 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionRandom
+{
+
+
+
+ e_rwdb_CriterionRandomLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionRandom e_rwdb_CriterionRandom;
+
+
diff --git a/rwsdk/include/d3d8/rpskin.h b/rwsdk/include/d3d8/rpskin.h
new file mode 100644
index 00000000..df446c1b
--- /dev/null
+++ b/rwsdk/include/d3d8/rpskin.h
@@ -0,0 +1,222 @@
+
+#ifndef RPSKIN_H
+#define RPSKIN_H
+
+/**
+ * \defgroup rpskin RpSkin
+ * \ingroup rpplugin
+ *
+ * Skin Plugin for RenderWare Graphics.
+ */
+
+/*===========================================================================*
+ *--- Include files ---------------------------------------------------------*
+ *===========================================================================*/
+#include "rwcore.h"
+#include "rpworld.h"
+
+#include "rpcriter.h"
+#include "rpskin.rpe"
+
+#include "rphanim.h"
+
+/*===========================================================================*
+ *--- Global Types ----------------------------------------------------------*
+ *===========================================================================*/
+typedef struct RwMatrixWeights RwMatrixWeights;
+
+/**
+ * \ingroup rpskin
+ * \struct RwMatrixWeights
+ * A structure for defining up to four matrix weights per vertex.
+ * Not all entries need to be used.
+ *
+ * \note
+ * Values should be sorted, such that any zero 0.0f entries appear
+ * after the valid weights. Any weights that appear after a zero
+ * entry will be ignored.
+ *
+ * \see RpSkinCreate
+ */
+struct RwMatrixWeights
+{
+ RwReal w0; /**< The first matrix weight. */
+ RwReal w1; /**< The second matrix weight. */
+ RwReal w2; /**< The third matrix weight. */
+ RwReal w3; /**< The fourth matrix weight. */
+};
+
+/**
+ * \ingroup rpskin
+ * \typedef RpSkin
+ *
+ * Skin object. This should be considered an opaque type.
+ * Use the RpSkin API functions to access.
+ *
+ * \see RpSkinCreate
+ * \see RpSkinDestroy
+ */
+typedef struct RpSkin RpSkin;
+
+/*===========================================================================*
+ *--- Plugin API Functions --------------------------------------------------*
+ *===========================================================================*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/*---------------------------------------------------------------------------*
+ *- Plugin functions -*
+ *---------------------------------------------------------------------------*/
+extern RwBool
+RpSkinPluginAttach(void);
+
+/*---------------------------------------------------------------------------*
+ *- Skin Atomic functions -*
+ *---------------------------------------------------------------------------*/
+extern RpAtomic *
+RpSkinAtomicSetHAnimHierarchy( RpAtomic *atomic,
+ RpHAnimHierarchy *hierarchy );
+
+extern RpHAnimHierarchy *
+RpSkinAtomicGetHAnimHierarchy( const RpAtomic *atomic );
+
+/*---------------------------------------------------------------------------*
+ *- Skin Geometry functions -*
+ *---------------------------------------------------------------------------*/
+extern RpGeometry *
+RpSkinGeometrySetSkin( RpGeometry *geometry,
+ RpSkin *skin );
+
+extern RpSkin *
+RpSkinGeometryGetSkin( RpGeometry *geometry );
+
+extern RpSkin *
+RpSkinCreate( RwUInt32 numVertices,
+ RwUInt32 numBones,
+ RwMatrixWeights *vertexWeights,
+ RwUInt32 *vertexIndices,
+ RwMatrix *inverseMatrices );
+
+extern RpSkin *
+RpSkinDestroy( RpSkin *skin );
+
+extern RwUInt32
+RpSkinGetNumBones( RpSkin *skin );
+
+extern const RwMatrixWeights *
+RpSkinGetVertexBoneWeights( RpSkin *skin );
+
+extern const RwUInt32 *
+RpSkinGetVertexBoneIndices( RpSkin *skin );
+
+extern const RwMatrix *
+RpSkinGetSkinToBoneMatrices( RpSkin *skin );
+
+/*---------------------------------------------------------------------------*
+ *- Skin pipeline -*
+ *---------------------------------------------------------------------------*/
+
+/**
+ * \ingroup rpskin
+ * \ref RpSkinType defines the different ways a skinned atomic can
+ * be rendered. Once a skinned \ref RpGeometry has been attached to
+ * an \ref RpAtomic the atomic must be setup with the correct skin
+ * rendering pipeline with \ref RpSkinAtomicSetType.
+ */
+enum RpSkinType
+{
+ rpNASKINTYPE = 0, /**<Invalid skin pipeline. */
+ rpSKINTYPEGENERIC = 1, /**<Generic skin rendering. */
+ rpSKINTYPEMATFX = 2, /**<Material effects skin rendering. */
+ rpSKINTYPETOON = 3, /**<Toon skin rendering. */
+ rpSKINTYPEMATFXTOON = 4, /**<Note Toon + MatFX on same object NOT currently supported */
+ rpSKINTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpSkinType RpSkinType;
+
+extern RpAtomic *
+RpSkinAtomicSetType( RpAtomic *atomic,
+ RpSkinType type );
+
+extern RpSkinType
+RpSkinAtomicGetType( RpAtomic *atomic );
+
+/*---------------------------------------------------------------------------*/
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*---------------------------------------------------------------------------*
+ *- Backwards macros -*
+ *---------------------------------------------------------------------------*/
+
+#define RpSkinAtomicGetSkin(_a) \
+ RpSkinGeometryGetSkin(RpAtomicGetGeometry(_a))
+
+/*---------------------------------------------------------------------------*/
+
+/*---- start: ./d3d8/skinplatform.h----*/
+
+/**
+ * \defgroup rpskind3d8 D3D8
+ * \ingroup rpskin
+ *
+ * D3D8 skin pipeline extension.
+ */
+
+
+/*===========================================================================*
+ *--- D3D8 Defines -----------------------------------------------------------*
+ *===========================================================================*/
+
+/*===========================================================================*
+ *--- D3D8 Global Types ------------------------------------------------------*
+ *===========================================================================*/
+
+/**
+ * \ingroup rpskind3d8
+ * \ref RpSkinD3D8Pipeline rendering pipelines available within
+ * the \ref RpSkin plugin. Use \ref RpSkinGetD3D8Pipeline to
+ * retrieve the \ref RxPipeline's.
+ */
+enum RpSkinD3D8Pipeline
+{
+ rpNASKIND3D8PIPELINE = 0,
+ rpSKIND3D8PIPELINEGENERIC = 1,
+ /**<D3D8 generic skin rendering pipeline. */
+ rpSKIND3D8PIPELINEMATFX = 2,
+ /**<D3D8 material effect skin rendering pipeline. */
+ rpSKIND3D8PIPELINETOON = 3,
+ /**<D3D8 toon skin rendering pipeline. */
+ rpSKIND3D8PIPELINEMATFXTOON = 4,
+ /**<D3D8 toon matfx skin rendering pipeline not supported */
+ rpSKIND3D8PIPELINEMAX,
+ rpSKIND3D8PIPELINEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpSkinD3D8Pipeline RpSkinD3D8Pipeline;
+
+/*===========================================================================*
+ *--- D3D8 Plugin API Functions ----------------------------------------------*
+ *===========================================================================*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+/*---------------------------------------------------------------------------*/
+
+extern RxPipeline *
+RpSkinGetD3D8Pipeline( RpSkinD3D8Pipeline D3D8Pipeline );
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*---- end: ./d3d8/skinplatform.h----*/
+
+#endif /* RPSKIN_H */
+
+
diff --git a/rwsdk/include/d3d8/rpskin.rpe b/rwsdk/include/d3d8/rpskin.rpe
new file mode 100644
index 00000000..57cecd5e
--- /dev/null
+++ b/rwsdk/include/d3d8/rpskin.rpe
@@ -0,0 +1,638 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionSKIN
+{
+
+
+
+ e_rwdb_CriterionSKINLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionSKIN e_rwdb_CriterionSKIN;
+
+
diff --git a/rwsdk/include/d3d8/rpspline.h b/rwsdk/include/d3d8/rpspline.h
new file mode 100644
index 00000000..53fd8484
--- /dev/null
+++ b/rwsdk/include/d3d8/rpspline.h
@@ -0,0 +1,141 @@
+/*
+ * Structure for splines
+ *
+ *
+ * Copyright (c) Criterion Software Limited
+ */
+
+/******************************************/
+/* */
+/* RenderWare(TM) Graphics Library */
+/* */
+/******************************************/
+
+/*
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd.
+ * or Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. and Canon Inc. will not, under any
+ * circumstances, be liable for any lost revenue or other damages
+ * arising from the use of this file.
+ *
+ * Copyright (c) 1998. Criterion Software Ltd.
+ * All Rights Reserved.
+ */
+
+/***************************************************************************
+ * *
+ * Module : rpspline.h *
+ * *
+ * Purpose : Spline operations *
+ * *
+ **************************************************************************/
+
+#ifndef RPSPLINE_H
+#define RPSPLINE_H
+
+/**
+ * \defgroup rpspline RpSpline
+ * \ingroup rpplugin
+ *
+ * Spline Plugin for RenderWare Graphics.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+/*--- Include files ---*/
+#include "rwcore.h"
+#include "rpworld.h"
+
+#include "rpspline.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Global Types
+ */
+
+#define rpSPLINENAMELENGTH (32)
+
+typedef struct RpSpline RpSpline;
+/**
+ * \ingroup rpspline
+ * \struct RpSpline
+ * Spline object. This should be considered an opaque type.
+ * Use the RpSpline API functions to access.
+ */
+struct RpSpline
+{
+ RwObject tType; /**< Internal Use */
+ RwInt32 numCtrlPoints; /**< Internal Use */
+ RwInt32 nSplineType; /**< Internal Use */
+ void *pUser; /**< Internal Use */
+ RwV3d *ctrlPoints; /**< Internal Use */
+ RwChar caName[rpSPLINENAMELENGTH]; /**< Internal Use */
+ /* Keep this at tail */
+ RwV3d vPts[1]; /**< Internal Use */
+};
+
+/* Spline types */
+#define rpSPLINETYPEOPENLOOPBSPLINE (1) /* Bezier spline, open loop */
+#define rpSPLINETYPECLOSEDLOOPBSPLINE (2) /* Bezier spline, closed loop */
+
+/* Spline path types */
+#define rpSPLINEPATHSMOOTH (10) /* Normal */
+#define rpSPLINEPATHNICEENDS (11) /* Slows down the path at the ends */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Opening the spline plugin */
+extern RwBool RpSplinePluginAttach(void);
+
+/* Creating and destroying splines */
+extern RpSpline *RpSplineCreate(RwInt32 numCtrlPoints, RwInt32 type, RwV3d *ctrlPoints);
+extern RwBool RpSplineDestroy(RpSpline *spline);
+
+/* Finding a point and its tangent vector on the spline */
+extern RwV3d *RpSplineFindPosition(RpSpline *spline, RwInt32 path, RwReal where, RwV3d *pos, RwV3d *tangent);
+
+/* Finding a frame on the spline */
+extern RwReal RpSplineFindMatrix(RpSpline *spline, RwInt32 path, RwReal where, RwV3d *up, RwMatrix *matrix);
+/* LEGACY-SUPPORT MACRO */
+#define RpSplineFindFrame RpSplineFindMatrix
+
+/* Getting and setting the control points */
+extern RwInt32 RpSplineGetNumControlPoints(const RpSpline *spline);
+extern RwV3d *RpSplineGetControlPoint(RpSpline *spline, RwInt32 control, RwV3d *point);
+extern RpSpline *RpSplineSetControlPoint(RpSpline *spline, RwInt32 control, RwV3d * point);
+
+/* Copy a spline */
+extern RpSpline *RpSplineClone(RpSpline *spline);
+
+/* Spline reading and writing helper functions */
+extern RpSpline *RpSplineRead(RwChar *name);
+extern RwBool RpSplineWrite(RpSpline *spline, RwChar *name);
+
+/* Binary format */
+extern RwUInt32 RpSplineStreamGetSize(const RpSpline *spline);
+extern RpSpline *RpSplineStreamRead(RwStream *stream);
+extern const RpSpline *RpSplineStreamWrite(const RpSpline *spline, RwStream *stream);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RPSPLINE_H */
+
+
+
+
+
+
diff --git a/rwsdk/include/d3d8/rpspline.rpe b/rwsdk/include/d3d8/rpspline.rpe
new file mode 100644
index 00000000..27670751
--- /dev/null
+++ b/rwsdk/include/d3d8/rpspline.rpe
@@ -0,0 +1,642 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionSpline
+{
+
+E_RP_SPLINE_INVNAME,
+E_RP_SPLINE_INVTYPE,
+E_RP_SPLINE_INVCONTROLS,
+E_RP_SPLINE_OPEN,
+E_RP_SPLINE_PLUGINNOTINIT,
+
+ e_rwdb_CriterionSplineLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionSpline e_rwdb_CriterionSpline;
+
+
diff --git a/rwsdk/include/d3d8/rpstereo.h b/rwsdk/include/d3d8/rpstereo.h
new file mode 100644
index 00000000..5a8db912
--- /dev/null
+++ b/rwsdk/include/d3d8/rpstereo.h
@@ -0,0 +1,141 @@
+/*
+ * Stereo camera plugin
+ */
+
+/**********************************************************************
+ *
+ * File : rpstereo.h
+ *
+ * Abstract : Add Stereo Camera support to RenderWare
+ *
+ **********************************************************************
+ *
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd. or
+ * Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. will not, under any
+ * circumstances, be liable for any lost revenue or other damages arising
+ * from the use of this file.
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+ * All Rights Reserved.
+ *
+ * RenderWare is a trademark of Canon Inc.
+ *
+ ************************************************************************/
+
+#ifndef RPSTEREO_H
+#define RPSTEREO_H
+
+/**
+ * \defgroup rpstereo RpStereo
+ * \ingroup rpplugin
+ *
+ * Stereo Camera Plugin for RenderWare Graphics.
+ */
+
+/*--- Include files ---*/
+#include <rwcore.h>
+#include <rpworld.h>
+
+#include "rpstereo.rpe" /* automatically generated header file */
+
+/*--- Global Structures ---*/
+
+/* Supported Stereo Modes */
+
+/**
+ * \ingroup rpstereo
+ * \ref RpStereoCameraMode
+ * Stereo camera mode enumeration.
+ */
+enum RpStereoCameraMode
+{
+ rpNASTEREOMODE = 0,
+ rpSTEREOMONO, /**< Render as Mono camera - single
+ * image
+ */
+ rpSTEREOLEFTRIGHT, /**< Vertical split screen. Left eye
+ * image on left of screen. Right eye
+ * image on right of screen.
+ */
+ rpSTEREORIGHTLEFT, /**< Vertical split screen. Right eye
+ * image on left of screen. Left eye image
+ * on right of screen.
+ */
+
+ rpSTEREOROTATE90, /**< As for rpSTEREOLEFTRIGHT - with
+ * the images rotated inwards by 90 degrees
+ */
+ rpSTEREOINTERLACEDLEFTRIGHT, /**< Left and right eye images on
+ * alternate scanlines. The left eye image
+ * on the topmost line of the display.
+ */
+
+ rpSTEREOINTERLACEDRIGHTLEFT, /**< Left and right eye images on
+ * alternate scanlines. The right eye
+ * image is on the topmost line of the
+ * display.
+ */
+ rpSTEREOLASTMODE,
+ rpSTEREOCAMERAMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+/*
+ * typedef for stereo camera mode enumeration.
+ */
+typedef enum RpStereoCameraMode RpStereoCameraMode;
+
+/*--- Constants ---*/
+
+/* These may be used to quickly adapt an existing application to a
+ * stereo version.
+ */
+
+#ifdef RPSTEREO_OVERLOAD
+#define RwCameraBeginUpdate RpStereoCameraBeginUpdate
+#define RwCameraEndUpdate RpStereoCameraEndUpdate
+#undef RpWorldRender
+#define RpWorldRender RpStereoWorldRender
+#undef RpClumpRender
+#define RpClumpRender RpStereoClumpRender
+#undef RpAtomicRender
+#define RpAtomicRender RpStereoAtomicRender
+#undef RpWorldSectorRender
+#define RpWorldSectorRender RpStereoWorldSectorRender
+#endif
+
+/*--- Plugin API Functions ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+RwBool RpStereoPluginAttach(void);
+
+RpWorld *RpStereoWorldRender(RpWorld *world);
+RpClump *RpStereoClumpRender(RpClump *clump);
+RpAtomic *RpStereoAtomicRender(RpAtomic *atomic);
+RpWorldSector *RpStereoWorldSectorRender(RpWorldSector *sector);
+
+RwCamera *RpStereoCameraBeginUpdate(RwCamera *camera);
+RwCamera *RpStereoCameraEndUpdate(RwCamera *stereoCam);
+
+RwReal RpStereoCameraGetSeparation(RwCamera *stereoCam);
+RwReal RpStereoCameraGetFocal(RwCamera *stereoCam);
+RpStereoCameraMode RpStereoCameraGetMode(RwCamera *stereoCam);
+
+RwCamera *RpStereoCameraSetSeparation(RwCamera *stereoCam, RwReal dist);
+RwCamera *RpStereoCameraSetFocal(RwCamera *stereoCam, RwReal focal);
+RwCamera *RpStereoCameraSetMode(RwCamera *stereoCam, RpStereoCameraMode newMode);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RPSTEREO_H */
+
diff --git a/rwsdk/include/d3d8/rpstereo.rpe b/rwsdk/include/d3d8/rpstereo.rpe
new file mode 100644
index 00000000..b89dde2e
--- /dev/null
+++ b/rwsdk/include/d3d8/rpstereo.rpe
@@ -0,0 +1,641 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionStereo
+{
+
+
+E_RP_STEREO_INVMODE,
+
+E_RP_STEREO_INVFOCAL,
+
+ e_rwdb_CriterionStereoLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionStereo e_rwdb_CriterionStereo;
+
+
diff --git a/rwsdk/include/d3d8/rpusrdat.h b/rwsdk/include/d3d8/rpusrdat.h
new file mode 100644
index 00000000..3665e064
--- /dev/null
+++ b/rwsdk/include/d3d8/rpusrdat.h
@@ -0,0 +1,124 @@
+#ifndef RPUSERDATAPLUGIN_H
+#define RPUSERDATAPLUGIN_H
+
+/**
+ * \defgroup rpuserdata RpUserData
+ * \ingroup rpplugin
+ *
+ * User Data Plugin for RenderWare Graphics.
+ */
+
+/*
+ * UserData plugin
+ */
+
+#include <rwcore.h>
+#include <rpworld.h>
+
+/**
+ * \ingroup rpuserdata
+ * User data formats
+ */
+enum RpUserDataFormat
+{
+ rpNAUSERDATAFORMAT = 0,
+ rpINTUSERDATA, /**< 32 bit int data */
+ rpREALUSERDATA, /**< 32 bit float data */
+ rpSTRINGUSERDATA, /**< unsigned byte pointer data */
+ rpUSERDATAFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpUserDataFormat RpUserDataFormat;
+
+typedef struct RpUserDataArray RpUserDataArray;
+
+/**
+ * \ingroup rpuserdata
+ * \struct RpUserDataArray
+ * A structure representing an array of user data values
+ */
+
+struct RpUserDataArray
+{
+ RwChar *name; /**< Identifier for this data array */
+ RpUserDataFormat format; /**< Data format of this array */
+ RwInt32 numElements; /**< Number of elements in this array */
+ void *data; /**< Pointer to the array data */
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* Plugin API */
+extern RwBool RpUserDataPluginAttach(void);
+
+/* Geometry API */
+extern RwInt32 RpGeometryAddUserDataArray(RpGeometry *geometry, RwChar *name,
+ RpUserDataFormat format, RwInt32 numElements);
+extern RpGeometry *RpGeometryRemoveUserDataArray(RpGeometry *geometry, RwInt32 index);
+extern RpUserDataArray *RpGeometryGetUserDataArray(const RpGeometry *geometry, RwInt32 data);
+extern RwInt32 RpGeometryGetUserDataArrayCount(const RpGeometry *geometry);
+
+/* World Sector API */
+extern RwInt32 RpWorldSectorAddUserDataArray(RpWorldSector *sector, RwChar *name,
+ RpUserDataFormat format, RwInt32 numElements);
+extern RpWorldSector *RpWorldSectorRemoveUserDataArray(RpWorldSector *sector, RwInt32 index);
+extern RpUserDataArray *RpWorldSectorGetUserDataArray(const RpWorldSector *sector, RwInt32 data);
+extern RwInt32 RpWorldSectorGetUserDataArrayCount(const RpWorldSector *sector);
+
+/* RwFrame API */
+extern RwInt32 RwFrameAddUserDataArray(RwFrame *frame, RwChar *name,
+ RpUserDataFormat format, RwInt32 numElements);
+extern RwFrame *RwFrameRemoveUserDataArray(RwFrame *frame, RwInt32 index);
+extern RpUserDataArray *RwFrameGetUserDataArray(const RwFrame *frame, RwInt32 data);
+extern RwInt32 RwFrameGetUserDataArrayCount(const RwFrame *frame);
+
+/* RwCamera API */
+extern RwInt32 RwCameraAddUserDataArray(RwCamera *camera, RwChar *name,
+ RpUserDataFormat format, RwInt32 numElements);
+extern RwCamera *RwCameraRemoveUserDataArray(RwCamera *camera, RwInt32 index);
+extern RpUserDataArray *RwCameraGetUserDataArray(const RwCamera *camera, RwInt32 data);
+extern RwInt32 RwCameraGetUserDataArrayCount(const RwCamera *camera);
+
+/* RpLight API */
+extern RwInt32 RpLightAddUserDataArray(RpLight *light, RwChar *name,
+ RpUserDataFormat format, RwInt32 numElements);
+extern RpLight *RpLightRemoveUserDataArray(RpLight *light, RwInt32 index);
+extern RpUserDataArray *RpLightGetUserDataArray(const RpLight *light, RwInt32 data);
+extern RwInt32 RpLightGetUserDataArrayCount(const RpLight *light);
+
+/* RpMaterial API */
+extern RwInt32 RpMaterialAddUserDataArray(RpMaterial *material, RwChar *name,
+ RpUserDataFormat format, RwInt32 numElements);
+extern RpMaterial *RpMaterialRemoveUserDataArray(RpMaterial *material, RwInt32 index);
+extern RpUserDataArray *RpMaterialGetUserDataArray(const RpMaterial *material, RwInt32 data);
+extern RwInt32 RpMaterialGetUserDataArrayCount(const RpMaterial *material);
+
+/* RwTexture API */
+extern RwInt32 RwTextureAddUserDataArray(RwTexture *texture, RwChar *name,
+ RpUserDataFormat format, RwInt32 numElements);
+extern RwTexture *RwTextureRemoveUserDataArray(RwTexture *texture, RwInt32 index);
+extern RpUserDataArray *RwTextureGetUserDataArray(const RwTexture *texture, RwInt32 data);
+extern RwInt32 RwTextureGetUserDataArrayCount(const RwTexture *texture);
+
+/* User Data Array API */
+extern RwChar *RpUserDataArrayGetName(RpUserDataArray *userData);
+extern RpUserDataFormat RpUserDataArrayGetFormat(RpUserDataArray *userData);
+extern RwInt32 RpUserDataArrayGetNumElements(RpUserDataArray *userData);
+
+extern RwInt32 RpUserDataArrayGetInt(RpUserDataArray *userData, RwInt32 index);
+extern RwReal RpUserDataArrayGetReal(RpUserDataArray *userData, RwInt32 index);
+extern RwChar *RpUserDataArrayGetString(RpUserDataArray *userData, RwInt32 index);
+
+extern void RpUserDataArraySetInt(RpUserDataArray *userData, RwInt32 index, RwInt32 value);
+extern void RpUserDataArraySetReal(RpUserDataArray *userData, RwInt32 index, RwReal value);
+extern void RpUserDataArraySetString(RpUserDataArray *userData, RwInt32 index, RwChar *value);
+
+extern RwInt32 RpUserDataGetFormatSize(RpUserDataFormat format);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RPUSERDATAPLUGIN_H */
diff --git a/rwsdk/include/d3d8/rpusrdat.rpe b/rwsdk/include/d3d8/rpusrdat.rpe
new file mode 100644
index 00000000..31c37fd1
--- /dev/null
+++ b/rwsdk/include/d3d8/rpusrdat.rpe
@@ -0,0 +1,639 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionUserData
+{
+
+
+
+ e_rwdb_CriterionUserDataLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionUserData e_rwdb_CriterionUserData;
+
+
diff --git a/rwsdk/include/d3d8/rpworld.h b/rwsdk/include/d3d8/rpworld.h
new file mode 100644
index 00000000..21fdc31b
--- /dev/null
+++ b/rwsdk/include/d3d8/rpworld.h
@@ -0,0 +1,3735 @@
+/******************************************/
+/* */
+/* RenderWare(TM) Graphics Library */
+/* */
+/******************************************/
+
+/*
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd.
+ * or Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. and Canon Inc. will not, under any
+ * circumstances, be liable for any lost revenue or other damages
+ * arising from the use of this file.
+ *
+ * Copyright (c) 1999. Criterion Software Ltd.
+ * All Rights Reserved.
+ */
+
+/*************************************************************************
+ *
+ * Filename: <C:/daily/rwsdk/include/d3d8/rpworld.h>
+ * Automatically Generated on: Wed Jul 10 10:45:01 2002
+ *
+ ************************************************************************/
+
+#ifndef RPWORLD_H
+#define RPWORLD_H
+
+/*--- Check For Previous Required Includes ---*/
+#ifndef RWCORE_H
+#error "Include RWCORE.H before including this file"
+#endif /* RWCORE_H */
+
+/*--- System Header Files ---*/
+#include <stdarg.h>
+#include <stdlib.h>
+
+/*--- Error enumerations ---*/
+#include "rpworld.rpe"
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/native.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/wrldpipe.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/nodeD3D8WorldSectorAllInOne.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetD3D8WorldSectorAllInOne(void);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/nodeD3D8AtomicAllInOne.h ---*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetD3D8AtomicAllInOne(void);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/D3D8VertexBufferManager.h ---*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeWorldSectorInstance.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetWorldSectorInstance(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeWorldSectorEnumerateLights.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetWorldSectorEnumerateLights(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodePreLight.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetPreLight(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodePostLight.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetPostLight(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeMaterialScatter.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetMaterialScatter(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeLight.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetLight(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeFastPathSplitter.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetFastPathSplitter(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeAtomicInstance.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetAtomicInstance(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeAtomicEnumerateLights.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetAtomicEnumerateLights(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/bamateri.h ---*/
+
+/*
+ * Handling surface materials
+ * Materials describe how things are to appear when rendered
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+ */
+
+/****************************************************************************
+ Global Types
+ */
+
+
+typedef struct RpMaterialChunkInfo RpMaterialChunkInfo;
+typedef struct RpMaterialChunkInfo _rpMaterial;
+
+struct RpMaterialChunkInfo
+{
+ RwInt32 flags; /**< Material flags - unused currently -
+ for future expansion */
+ RwRGBA color; /**< Colour of material. */
+ RwInt32 unused; /**< Not used */
+ RwBool textured; /**< Are we textured? */
+ RwSurfaceProperties surfaceProps; /**< Surface properties */
+};
+
+#if (!defined(RwMaterialAssign))
+#define RwMaterialAssign(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RwMaterialAssign)) */
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpMaterial
+ * Material object. This should be
+ * considered an opaque type. Use the RpMaterial API functions to access.
+ */
+typedef struct RpMaterial RpMaterial;
+
+#if (!defined(DOXYGEN))
+struct RpMaterial
+{
+ RwTexture *texture; /**< texture */
+ RwRGBA color; /**< color */
+ RxPipeline *pipeline; /**< pipeline */
+ RwSurfaceProperties surfaceProps; /**< surfaceProps */
+ RwInt16 refCount; /* C.f. rwsdk/world/bageomet.h:RpGeometry */
+ RwInt16 pad;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpMaterialCallBack
+ \ref RpMaterialCallBack
+ * represents the function called from \ref RpGeometryForAllMaterials and
+ * \ref RpWorldForAllMaterials for all materials referenced by polygons in a
+ * given geometry. This function should return a pointer to the current
+ * material to indicate success. The callback may return NULL to terminate
+ * further callbacks on the materials.
+ *
+ * \param material Pointer to the current material
+ * \param data Pointer to developer-defined data structure.
+ *
+ * \return Pointer to the current material.
+ */
+typedef RpMaterial *(*RpMaterialCallBack)(RpMaterial *material, void *data);
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RpMaterialAddRefMacro(_material) \
+ (((_material)->refCount++), (_material))
+
+#define RpMaterialAddRefVoidMacro(_material) \
+MACRO_START \
+{ \
+ (_material)->refCount++; \
+} \
+MACRO_STOP
+
+
+#define RpMaterialSetColorMacro(_material, _color) \
+ (RwRGBAAssign(&((_material)->color), (_color)), (_material))
+
+#define RpMaterialGetColorMacro(_material) \
+ (&((_material)->color))
+
+#define RpMaterialSetSurfacePropertiesMacro(_material, _surfProps) \
+ (RwSurfacePropertiesAssign(&((_material)->surfaceProps), \
+ (_surfProps)), (_material))
+
+#define RpMaterialSetSurfacePropertiesVoidMacro(_material, _surfProps) \
+MACRO_START \
+{ \
+ RwSurfacePropertiesAssign(&((_material)->surfaceProps), \
+ (_surfProps)); \
+} \
+MACRO_STOP
+
+#define RpMaterialGetSurfacePropertiesMacro(_material) \
+ (&((_material)->surfaceProps))
+
+#define RpMaterialGetTextureMacro(_material) \
+ ((_material)->texture)
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RpMaterialAddRef(_material) \
+ RpMaterialAddRefMacro(_material)
+
+#define RpMaterialSetColor(_material, _color) \
+ RpMaterialSetColorMacro(_material, _color)
+
+#define RpMaterialGetColor(_material) \
+ RpMaterialGetColorMacro(_material)
+
+#define RpMaterialSetSurfaceProperties(_material, _surfProps) \
+ RpMaterialSetSurfacePropertiesMacro(_material, _surfProps)
+
+#define RpMaterialGetSurfaceProperties(_material) \
+ RpMaterialGetSurfacePropertiesMacro(_material)
+
+#define RpMaterialGetTexture(_material) \
+ RpMaterialGetTextureMacro(_material)
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+/* Creating, destroying and referencing materials */
+extern RpMaterial *RpMaterialCreate(void);
+extern RwBool RpMaterialDestroy(RpMaterial *material);
+extern RpMaterial *RpMaterialClone(RpMaterial *material);
+
+/* Textures */
+extern RpMaterial *RpMaterialSetTexture(RpMaterial *material, RwTexture *texture);
+
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+extern RpMaterial *RpMaterialAddRef(RpMaterial *material);
+
+/* Textures */
+extern RwTexture *RpMaterialGetTexture(const RpMaterial *material);
+
+/* Setting and getting colors */
+extern RpMaterial *RpMaterialSetColor(RpMaterial *material, const RwRGBA *color);
+extern const RwRGBA *RpMaterialGetColor(const RpMaterial *material);
+
+/* Setting and getting surface properties */
+extern RpMaterial *
+RpMaterialSetSurfaceProperties(RpMaterial *material,
+ const RwSurfaceProperties *surfaceProperties);
+
+extern const RwSurfaceProperties *
+RpMaterialGetSurfaceProperties(const RpMaterial *material);
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+/* Attaching toolkits */
+extern RwInt32 RpMaterialRegisterPlugin(RwInt32 size, RwUInt32 pluginID,
+ RwPluginObjectConstructor constructCB,
+ RwPluginObjectDestructor destructCB,
+ RwPluginObjectCopy copyCB);
+extern RwInt32 RpMaterialRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack readCB,
+ RwPluginDataChunkWriteCallBack writeCB,
+ RwPluginDataChunkGetSizeCallBack getSizeCB);
+extern RwInt32 RpMaterialSetStreamAlwaysCallBack(
+ RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+extern RwInt32 RpMaterialGetPluginOffset(RwUInt32 pluginID);
+extern RwBool RpMaterialValidatePlugins(const RpMaterial *material);
+
+/* Binary format */
+extern RwUInt32 RpMaterialStreamGetSize(const RpMaterial *material);
+extern RpMaterial *RpMaterialStreamRead(RwStream *stream);
+extern const RpMaterial *RpMaterialStreamWrite(const RpMaterial *material, RwStream *stream);
+extern RpMaterialChunkInfo *
+_rpMaterialChunkInfoRead(RwStream *stream,
+ RpMaterialChunkInfo *materialChunkInfo,
+ RwInt32 *bytesRead);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define RpMaterialChunkInfoRead(stream, materialChunkInfo, bytesRead) \
+ _rpMaterialChunkInfoRead(stream, materialChunkInfo, bytesRead)
+
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/bamatlst.h ---*/
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct RpMaterialList RpMaterialList;
+struct RpMaterialList
+{
+ RpMaterial **materials;
+ RwInt32 numMaterials;
+ RwInt32 space;
+};
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+#define rpMaterialListGetNumMaterials(mlist) ((mlist)->numMaterials)
+
+/* Setting up and destroying material lists */
+extern RpMaterialList *_rpMaterialListInitialize(RpMaterialList *matList);
+extern RpMaterialList *_rpMaterialListDeinitialize(RpMaterialList *matList);
+
+/* Accessing material lists */
+extern RpMaterial ** _rpMaterialListAlloc(RwUInt32 count);
+extern RpMaterial *_rpMaterialListGetMaterial(const RpMaterialList *matList,
+ RwInt32 matIndex);
+extern RpMaterialList * _rpMaterialListSetSize(RpMaterialList * matList,
+ RwInt32 size);
+extern RpMaterialList *_rpMaterialListCopy(RpMaterialList *matListOut,
+ const RpMaterialList *matListIn);
+extern RwInt32 _rpMaterialListAppendMaterial(RpMaterialList *matList,
+ RpMaterial *material);
+extern RwInt32 _rpMaterialListFindMaterialIndex(const RpMaterialList *matList,
+ const RpMaterial *material);
+
+/* Binary format */
+extern RwUInt32 _rpMaterialListStreamGetSize(const RpMaterialList *matList);
+extern RpMaterialList *_rpMaterialListStreamRead(RwStream *stream,
+ RpMaterialList *matList);
+extern const RpMaterialList *_rpMaterialListStreamWrite(const RpMaterialList *matList,
+ RwStream *stream);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define rpMaterialListInitialize(_matList) \
+ _rpMaterialListInitialize(_matList)
+
+#define rpMaterialListDeinitialize(_matList) \
+ _rpMaterialListDeinitialize(_matList)
+
+#define rpMaterialListGetMaterial(_matList, _matIndex) \
+ _rpMaterialListGetMaterial(_matList, _matIndex)
+
+#define rpMaterialListCopy(_matListOut, _matListIn) \
+ _rpMaterialListCopy(_matListOut, _matListIn)
+
+#define rpMaterialListAppendMaterial(_matList, _material) \
+ _rpMaterialListAppendMaterial(_matList, _material)
+
+#define rpMaterialListStreamRead(_stream, _matList) \
+ _rpMaterialListStreamRead(_stream, _matList)
+
+#define rpMaterialListStreamWrite(_matList, _stream) \
+ _rpMaterialListStreamWrite(_matList, _stream)
+
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/bamesh.h ---*/
+
+/*
+ *
+ * Purpose: Provide construction and enumeration facilities for meshes.
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+ */
+
+#define RPMESHGLOBAL(var) \
+ (RWPLUGINOFFSET(rpMeshGlobals, \
+ RwEngineInstance, \
+ meshModule.globalsOffset)->var)
+
+#define rwPRIMTYPEOR \
+ (rwPRIMTYPELINELIST | \
+ rwPRIMTYPEPOLYLINE | \
+ rwPRIMTYPETRILIST | \
+ rwPRIMTYPETRISTRIP | \
+ rwPRIMTYPETRIFAN | \
+ rwPRIMTYPEPOINTLIST)
+
+#define rpMESHHEADERPRIMTYPEOR \
+ (0 /* rpMESHHEADERTRILIST*/ | \
+ rpMESHHEADERTRISTRIP | \
+ rpMESHHEADERTRIFAN | \
+ rpMESHHEADERLINELIST | \
+ rpMESHHEADERPOLYLINE | \
+ rpMESHHEADERPOINTLIST)
+
+/****************************************************************************
+ Global variables
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwModuleInfo meshModule;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/****************************************************************************
+ Global types
+ */
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpMeshHeader
+ * typedef for header structure listing all meshes
+ * constituting a single RpGeometry or RpWorldSector
+ */
+typedef struct RpMeshHeader RpMeshHeader;
+
+/**
+ * \ingroup rpworlddatatypes
+ * \ref RpMeshHeaderFlags
+ * represents the different types of mesh.
+ * \see RpMeshHeader
+ */
+enum RpMeshHeaderFlags
+{
+ /* NOTE: trilists are denoted by absence of any other
+ * primtype flags, so be careful that you test:
+ * (triListFlag == flags&triListFlag)
+ * or:
+ * (0 == flags&rpMESHHEADERPRIMMASK)
+ * and not:
+ * (flags&triListFlag)
+ */
+ rpMESHHEADERTRISTRIP = 0x0001, /**< Render as tristrips */
+ rpMESHHEADERTRIFAN = 0x0002, /**< On PS2 these will be converted to trilists */
+ rpMESHHEADERLINELIST = 0x0004, /**< Render as linelists */
+ rpMESHHEADERPOLYLINE = 0x0008, /**< On PS2 these will be converted to linelists */
+ rpMESHHEADERPOINTLIST = 0x0010, /**< Pointlists are supported only if rendered by
+ * custom pipelines; there is no default RenderWare
+ * way to render pointlists. */
+
+ rpMESHHEADERPRIMMASK = 0x00FF, /**< All bits reserved for specifying primitive type */
+ rpMESHHEADERUNINDEXED = 0x0100, /**< Topology is defined implicitly by vertex
+ * order, ergo the mesh contains no indices */
+ rpMESHHEADERFLAGSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+/*
+ * Typedef for RpMeshHeaderFlags enumeration
+ * representing the different types of mesh
+ */
+typedef enum RpMeshHeaderFlags RpMeshHeaderFlags;
+
+typedef struct rpMeshGlobals rpMeshGlobals;
+struct rpMeshGlobals
+{
+ RwInt16 nextSerialNum;
+ RwFreeList *triStripListEntryFreeList;
+ RwUInt8 meshFlagsToPrimType[rpMESHHEADERPRIMTYPEOR];
+ RwUInt8 primTypeToMeshFlags[rwPRIMTYPEOR];
+};
+
+typedef struct RpBuildMeshTriangle RpBuildMeshTriangle;
+
+/**
+ * \ingroup rpworlddatatypes
+ * \struct RpBuildMeshTriangle
+ * This type represents an array of indices into
+ * the object vertex array. Used during the construction
+ * of tristrips.
+ *
+ * See API functions
+ * \see RpBuildMeshGeneratePreprocessTriStrip
+ * \see RpBuildMeshGenerateExhaustiveTriStrip
+ * \see RpBuildMeshGenerateTrivialTriStrip
+ * \see RpBuildMeshGenerateDefaultTriStrip
+ * and
+ * \see RpMeshSetTriStripMethod
+ * \see RpMeshGetTriStripMethod
+ */
+struct RpBuildMeshTriangle
+{
+ RwUInt16 vertIndex[3]; /**< indices into object vertex
+ * array. */
+ RpMaterial *material; /**< pointer to material used to
+ * render the mesh. */
+};
+
+typedef struct RpBuildMesh RpBuildMesh;
+
+/**
+ * \ingroup rpworlddatatypes
+ * \struct RpBuildMesh
+ * This type represents a mesh ready for tri stripping.
+ *
+ * See API functions
+ * \see RpBuildMeshGeneratePreprocessTriStrip
+ * \see RpBuildMeshGenerateExhaustiveTriStrip
+ * \see RpBuildMeshGenerateTrivialTriStrip
+ * \see RpBuildMeshGenerateDefaultTriStrip
+ * and
+ * \see RpMeshSetTriStripMethod
+ * \see RpMeshGetTriStripMethod
+ */
+struct RpBuildMesh
+{
+ RwUInt32 triangleBufferSize; /**< number of triangles
+ * space has been allocated
+ * for. */
+ RwUInt32 numTriangles; /**< number of triangles to be
+ * tristripped. */
+ RpBuildMeshTriangle *meshTriangles; /**< pointer to build mesh
+ * triangles. */
+};
+
+typedef struct RpMesh RpMesh;
+
+/**
+ * \ingroup rpworlddatatypes
+ * \struct RpMesh
+ * This type represents a single polygon mesh.
+ * A mesh is defined as a collection of triangles derived from an RpGeometry
+ * or RpWorldSector which have a common material.
+ *
+ * See API functions \see RpGeometryForAllMeshes and
+ * \see RpWorldSectorForAllMeshes and
+ * the corresponding function callback types:
+ */
+struct RpMesh
+{
+ RxVertexIndex *indices; /**< vertex indices defining the mesh */
+ RwUInt32 numIndices; /**< number of vertices in mesh */
+ RpMaterial *material; /**< pointer to material used to
+ * render the mesh. */
+};
+
+/**
+ * \ingroup rpworlddatatypes
+ * \struct RpMeshHeader
+ * Header for all meshes that constitute a single RpGeometry or RpWorldSector
+ */
+struct RpMeshHeader
+{
+ RwUInt32 flags; /**< \see RpMeshHeaderFlags */
+ RwUInt16 numMeshes; /**< Number of meshes in object */
+ RwUInt16 serialNum; /**< Determine if mesh has changed
+ * since last instance */
+ RwUInt32 totalIndicesInMesh; /**< Total triangle index
+ * count in all meshes
+ */
+ RwUInt32 firstMeshOffset; /**< Offset in bytes from end this
+ * structure RpMeshHeader
+ * to the first mesh
+ */
+};
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpMeshCallBack
+ * \ref RpMeshCallBack is the callback
+ * function supplied to \ref RpGeometryForAllMeshes and
+ * \ref RpWorldSectorForAllMeshes for all meshes in a given geometry.
+ *
+ * This function should return a pointer to the current mesh to indicate
+ * success. The callback may return NULL to terminate further callbacks
+ * on the meshes.
+ *
+ * \param mesh Pointer to the current mesh, supplied by
+ * iterator.
+ * \param meshHeader Pointer to the meshes header
+ * \param data Pointer to developer-defined data structure.
+ *
+ * \return
+ * Returns a pointer to the current mesh if successful or NULL if an error
+ * occurred.
+ */
+typedef RpMesh *(*RpMeshCallBack) (RpMesh * mesh,
+ RpMeshHeader * meshHeader,
+ void *pData);
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RpMeshHeaderGetPrimType(_mshHdr) \
+ ( (RwPrimitiveType)RPMESHGLOBAL(meshFlagsToPrimType)[(_mshHdr)->flags & \
+ rpMESHHEADERPRIMMASK] )
+
+#define RpMeshHeaderSetPrimType(_mshHdr, _prmTyp) \
+ ( (_mshHdr)->flags = \
+ ((_mshHdr)->flags & ~rpMESHHEADERPRIMMASK) | \
+ (rpMESHHEADERPRIMMASK & \
+ RPMESHGLOBAL(primTypeToMeshFlags)[(_prmTyp) & \
+ rpMESHHEADERPRIMMASK]), \
+ (_mshHdr) )
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Opening and closing module */
+extern void *_rpMeshOpen(void *instance, RwInt32 offset,
+ RwInt32 size);
+extern void *_rpMeshClose(void *instance, RwInt32 offset,
+ RwInt32 size);
+
+extern RwInt16 _rpMeshGetNextSerialNumber(void);
+
+/* Create a build mesh with nothing in */
+extern RpBuildMesh *_rpBuildMeshCreate(RwUInt32 bufferSize);
+
+/* Destroy a build mesh */
+extern RwBool _rpBuildMeshDestroy(RpBuildMesh * mesh);
+
+/* Destroy a build mesh */
+extern RwBool _rpMeshDestroy(RpMeshHeader * mesh);
+
+/* Add a triangle to a mesh */
+extern RpBuildMesh *_rpBuildMeshAddTriangle(RpBuildMesh * mesh,
+ RpMaterial * material,
+ RwInt32 vert1,
+ RwInt32 vert2,
+ RwInt32 vert3);
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+/* Get primtype from a mesh header */
+extern RwPrimitiveType RpMeshHeaderGetPrimType(RpMeshHeader *
+ meshHeader);
+
+/* Set primtype for a mesh header */
+extern RpMeshHeader *RpMeshHeaderSetPrimType(RpMeshHeader *
+ meshHeader,
+ RwPrimitiveType
+ primType);
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+/* Enumerate meshes within a mesh header */
+extern RpMeshHeader *_rpMeshHeaderForAllMeshes(RpMeshHeader *
+ meshHeader,
+ RpMeshCallBack
+ fpCallBack,
+ void *pData);
+
+/* Mesh serialisation functions */
+extern RwStream *_rpMeshWrite(const RpMeshHeader * meshHeader,
+ const void *object,
+ RwStream * stream,
+ const RpMaterialList * matList);
+extern RpMeshHeader *_rpMeshRead(RwStream * stream,
+ const void *object,
+ const RpMaterialList * matList);
+extern RwInt32 _rpMeshSize(const RpMeshHeader *meshHeader,
+ const void *object);
+/* Mesh header create/destroy functions */
+extern void _rpMeshHeaderDestroy(RpMeshHeader * meshHeader);
+extern RpMeshHeader * _rpMeshHeaderCreate(RwUInt32 size);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/basector.h ---*/
+
+/*
+ * Handling atomic sectors
+ * Atomic sectors are use to divide up the world into manageable portions
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+*/
+
+/****************************************************************************
+ Defines
+ */
+
+/* Type ID */
+#define rpWorldSector 0xff /* Not a true 'type'! */
+
+#define rpMINDISTANCEBETWEENVERTICES (RwReal)(0.0001)
+
+#define RPV3DFROMVERTEXNORMAL(v, n) \
+ (v).x = (((RwReal)((n).x)) * ( (RwReal)(1.0/128))); \
+ (v).y = (((RwReal)((n).y)) * ( (RwReal)(1.0/128))); \
+ (v).z = (((RwReal)((n).z)) * ( (RwReal)(1.0/128)))
+
+#define RPVERTEXNORMALFROMRWV3D(n, v) \
+ { \
+ RwFixed naTmp[3]; \
+ \
+ naTmp[0] = RwRealToFixed((v).x); \
+ naTmp[1] = RwRealToFixed((v).y); \
+ naTmp[2] = RwRealToFixed((v).z); \
+ \
+ if (naTmp[0] >= RwFixedCast(1)) \
+ { \
+ naTmp[0] = RwFixedCast(1)-1; \
+ } \
+ if (naTmp[0] <= RwFixedCast(-1)) \
+ { \
+ naTmp[0] = RwFixedCast(-1)+1; \
+ } \
+ if (naTmp[1] >= RwFixedCast(1)) \
+ { \
+ naTmp[1] = RwFixedCast(1)-1; \
+ } \
+ if (naTmp[1] <= RwFixedCast(-1)) \
+ { \
+ naTmp[1] = RwFixedCast(-1)+1; \
+ } \
+ if (naTmp[2] >= RwFixedCast(1)) \
+ { \
+ naTmp[2] = RwFixedCast(1)-1; \
+ } \
+ if (naTmp[2] <= RwFixedCast(-1)) \
+ { \
+ naTmp[2] = RwFixedCast(-1)+1; \
+ } \
+ \
+ (n).x = (RwInt8)(naTmp[0]>>9); \
+ (n).y = (RwInt8)(naTmp[1]>>9); \
+ (n).z = (RwInt8)(naTmp[2]>>9); \
+ }
+
+/* RpCollSector access macros - for pre v304 data */
+#define RWCOLLSECTORGETTYPE(sect) \
+ ((sect).cType&0x80)
+
+#define RWCOLLSECTORGETPLANE(sect) \
+ ((((sect).cType)>>3)&0xc)
+
+#define RWCOLLSECTORGETON(sect) \
+ (((sect).cType)&0x1f)
+
+#define RWCOLLSECTORGETVERTEX(sect) \
+ (sect).vertex
+
+#define RWCOLLSECTORGETSTART(sect) \
+ (sect).start
+
+#define RWCOLLSECTORGETNOPOLYS(sect) \
+ (sect).cType
+
+#define RWCOLLSECTORSETPOLYGONS(sect,no,st) \
+ (sect).cType = (RwUInt8)(no); \
+ (sect).start = (RwUInt8)(st)
+
+#define rwMAXCOLLISIONCUTS 7
+
+/****************************************************************************
+ Global types
+ */
+
+typedef struct RpVertexNormal RpVertexNormal;
+
+struct RpVertexNormal
+{
+ RwInt8 x;
+ RwInt8 y;
+ RwInt8 z;
+ RwUInt8 pad; /* pad character to force alignment */
+};
+
+typedef struct RpPolygon RpPolygon;
+
+struct RpPolygon
+{
+ RwUInt16 matIndex;
+ RwUInt16 vertIndex[3];
+};
+
+/* RpCollSector - for pre v304 data */
+#define RWCOLLSECTORSETPLANE(sect,plane,vert,no,st) \
+ (sect).cType = (RwUInt8)(0x80|((plane)<<3)|(no)); \
+ (sect).vertex = (RwUInt8)(vert); \
+ (sect).start = (RwUInt8)(st)
+
+typedef struct RpCollSector RpCollSector;
+
+struct RpCollSector
+{
+ RwUInt8 cType; /* Bit 7 - 1 plane */
+ /* 0 polygons */
+ /* Bit 6-5 - plane */
+ /* Bit 4-0 - amount ON plane */
+ RwUInt8 vertex; /* Vertex index used for the split */
+ RwUInt8 start; /* Starting polygon */
+};
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpWorldSector
+ * World Sector object. This should be
+ * considered an opaque type. Use the RpWorldSector API functions to access.
+ */
+typedef struct RpWorldSector RpWorldSector;
+
+#if (!defined(DOXYGEN))
+struct RpWorldSector
+{
+ RwInt32 type;
+
+ RpPolygon *polygons; /* Polygons themselves */
+
+ RwV3d *vertices; /* Vertex positions */
+ RpVertexNormal *normals; /* Vertex normals */
+
+ RwTexCoords *texCoords[rwMAXTEXTURECOORDS]; /* Texture coordinates */
+
+ RwRGBA *preLitLum; /* Pre lit luminances */
+
+ /* Pointer to memory allocated for vertex and poly pointers */
+ RwResEntry *repEntry;
+
+ /* Atomics in this sectors */
+ /* The pointers are frigged so they look like they are pointing to
+ Atomics when they are pointing to here */
+ RwLinkList collAtomicsInWorldSector; /* Coll priority */
+ RwLinkList noCollAtomicsInWorldSector; /* No Coll priority */
+
+ /* Lights in an atomic sector */
+ RwLinkList lightsInWorldSector;
+
+ /* Outer bounding box of sector based on BSP planes */
+ RwBBox boundingBox;
+
+ /* Bounding box tightly enclosing geometry */
+ RwBBox tightBoundingBox;
+
+ /* The root of the bsp collision tree for pre v304 data */
+ RpCollSector *colSectorRoot;
+
+ /* The mesh which groups same material polygons together */
+ RpMeshHeader *mesh;
+
+ /* The WorldSector object pipeline for this WorldSector */
+ RxPipeline *pipeline;
+
+ /* Material list window base
+ * (triangles in a given sector can "see"
+ * the 256 materials from
+ * MatList[matListWindowBase] -> MatList[matListWindowBase + 255])
+ */
+ RwUInt16 matListWindowBase;
+
+ RwUInt16 numVertices; /* Num vertices */
+ RwUInt16 numPolygons; /* Num polygons */
+ RwUInt16 pad;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpWorldSectorCallBack
+ \ref RpWorldSectorCallBack
+ * represents the function called from \ref RpWorldForAllWorldSectors,
+ * \ref RpAtomicForAllWorldSectors and \ref RpLightForAllWorldSectors for all
+ * world sectors in a given world or world sectors a given atomic or light lies
+ * in. This function should return a pointer to the current world sector to
+ * indicate success. The callback may return NULL to terminate further
+ * callbacks on the atomic or light.
+ *
+ * \return Pointer to the current world sector.
+ *
+ * \param sector Pointer to the current world sector
+ * \param data Pointer to developer-defined data structure.
+ */
+typedef RpWorldSector *(*RpWorldSectorCallBack)(RpWorldSector *worldSector, void *data);
+
+typedef struct RpSector RpSector;
+
+struct RpSector
+{
+ RwInt32 type;
+};
+
+/* NOTE: The left and right pointers can point to an RpPlaneSector or
+ * an RpWorldSector
+ * This is determined what the type is via the type value
+ */
+
+typedef struct RpPlaneSector RpPlaneSector;
+
+struct RpPlaneSector
+{
+ RwInt32 type;
+
+ RwReal value;
+ RpSector *leftSubTree; /* Sector 'left' (less) of the plane */
+ RpSector *rightSubTree; /* Sector 'right' (more) of the plane */
+ RwReal leftValue;
+ RwReal rightValue;
+};
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwPluginRegistry sectorTKList;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define RpWorldSectorGetBBoxMacro(_sctr) (&((_sctr)->boundingBox))
+#define RpWorldSectorGetTightBBoxMacro(_sctr) (&((_sctr)->tightBoundingBox))
+
+#if ((!defined(RWDEBUG)) && (!defined(RWSUPPRESSINLINE)))
+
+#define RpWorldSectorGetBBox RpWorldSectorGetBBoxMacro
+#define RpWorldSectorGetTightBBox RpWorldSectorGetTightBBoxMacro
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+/* Get info from atomic sectors */
+extern RwInt32 RpWorldSectorGetNumPolygons(const RpWorldSector *Sector);
+extern RwInt32 RpWorldSectorGetNumVertices(const RpWorldSector *Sector);
+
+/* Instancing and deinstancing sectors */
+extern RpWorldSector * RpWorldSectorRender(RpWorldSector *worldSector);
+
+extern const RpWorldSector *RpWorldSectorForAllMeshes(const RpWorldSector *sector,
+ RpMeshCallBack fpCallBack,
+ void *pData);
+
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+extern const RwBBox *RpWorldSectorGetBBox(const RpWorldSector *sector);
+extern const RwBBox *RpWorldSectorGetTightBBox(const RpWorldSector *sector);
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+/* Plugins */
+extern RwInt32 RpWorldSectorRegisterPlugin(RwInt32 size, RwUInt32 pluginID,
+ RwPluginObjectConstructor constructCB,
+ RwPluginObjectDestructor destructCB,
+ RwPluginObjectCopy copyCB);
+extern RwInt32 RpWorldSectorRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack readCB,
+ RwPluginDataChunkWriteCallBack writeCB,
+ RwPluginDataChunkGetSizeCallBack getSizeCB);
+extern RwInt32 RpWorldSectorSetStreamAlwaysCallBack(
+ RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+extern RwInt32 RpWorldSectorSetStreamRightsCallBack(RwUInt32 pluginID,
+ RwPluginDataChunkRightsCallBack rightsCB);
+extern RwInt32 RpWorldSectorGetPluginOffset(RwUInt32 pluginID);
+extern RwBool RpWorldSectorValidatePlugins(const RpWorldSector *sector);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/bameshop.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpTriStripMeshCallBack
+ * \ref RpTriStripMeshCallBack is the callback to generate triangle strips
+ * when the triangle stripped geometries or world sectors are unlocked.
+ *
+ * \param buildMesh pointer to the mesh which the triangle strip will be
+ * generated from.
+ * \param data pointer to user-supplied data to pass to the callback
+ * function.
+ *
+ * \return a pointer to the constructed mesh header.
+ *
+ */
+typedef RpMeshHeader *
+(*RpTriStripMeshCallBack) (RpBuildMesh *buildMesh, void *data);
+
+
+/****************************************************************************
+ Global types
+ */
+
+
+/****************************************************************************
+ Global Variables
+ */
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+/* Callback mesh generating functions */
+extern RpMeshHeader *
+RpBuildMeshGenerateTrivialTriStrip(RpBuildMesh *buildMesh, void *data);
+
+extern RpMeshHeader *
+RpBuildMeshGenerateDefaultTriStrip(RpBuildMesh *buildmesh, void *data);
+
+extern RpMeshHeader *
+RpBuildMeshGeneratePreprocessTriStrip(RpBuildMesh *buildmesh, void *data);
+
+extern RpMeshHeader *
+RpBuildMeshGenerateExhaustiveTriStrip(RpBuildMesh *buildmesh, void *data);
+
+extern RpMeshHeader *
+RpBuildMeshGenerateDefaultIgnoreWindingTriStrip(RpBuildMesh *buildmesh,
+ void *data);
+
+extern RpMeshHeader *
+RpBuildMeshGeneratePreprocessIgnoreWindingTriStrip(RpBuildMesh *buildmesh,
+ void *data);
+
+extern RpMeshHeader *
+RpBuildMeshGenerateExhaustiveIgnoreWindingTriStrip(RpBuildMesh *buildmesh,
+ void *data);
+
+/* Functions to set and get the global mesh tristrip algorithm */
+extern RwBool
+RpMeshSetTriStripMethod(RpTriStripMeshCallBack callback, void *data);
+
+extern RwBool
+RpMeshGetTriStripMethod(RpTriStripMeshCallBack *callback, void **data);
+
+
+extern RpMeshHeader *
+_rpTriListMeshGenerate(RpBuildMesh *buildMesh, void *data);
+
+/*
+ * Optimise the mesh ordering
+ * (sort on material and place transparent materials last)
+ */
+extern RpMeshHeader *
+_rpMeshOptimise(RpBuildMesh *buildmesh, RwUInt32 flags);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#define _rpTriStripMeshTrivialGenerate(_buildMesh, _data) \
+ RpBuildMeshGenerateTrivialTriStrip(_buildMesh, _data)
+
+#define _rpTriStripMeshDefaultGenerate(_buildmesh, _data) \
+ RpBuildMeshGenerateDefaultTriStrip(_buildmesh, _data)
+
+#define _rpTriStripMeshPreprocessGenerate(_buildmesh, _data) \
+ RpBuildMeshGeneratePreprocessTriStrip(_buildmesh, _data)
+
+#define _rpTriStripMeshExhaustiveGenerate(_buildmesh, _data) \
+ RpBuildMeshGenerateExhaustiveTriStrip(_buildmesh, _data)
+
+#define _rpMeshSetTristripMethod(_callback, _data) \
+ RpMeshSetTriStripMethod(_callback, _data)
+
+#define _rpMeshGetTristripMethod(_callback, _data) \
+ RpMeshGetTriStripMethod(_callback, _data)
+
+
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/balight.h ---*/
+
+/*
+ * Lighting 3D objects.
+ * Lights are used to illuminate atomics and worlds
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+ */
+
+
+/****************************************************************************
+ Defines
+ */
+
+/* Binary Light */
+typedef struct RpLightChunkInfo RpLightChunkInfo;
+typedef struct RpLightChunkInfo _rpLight;
+
+struct RpLightChunkInfo
+{
+ RwReal radius; /**< radius */
+ RwReal red; /**< red */
+ RwReal green; /**< green */
+ RwReal blue; /**< blue */
+ RwReal minusCosAngle; /**< minusCosAngle */
+ RwUInt32 typeAndFlags; /**< typeAndFlags */
+};
+
+/* Type ID */
+#define rpLIGHT 3
+
+/* Beyond this the lights must be positioned */
+#define rpLIGHTPOSITIONINGSTART 0x80
+
+/**
+ * \ingroup rpworlddatatypes
+ * \ref RpLightType are
+ * light sub types. This type represents the different
+ * types of light source that can be created using the API function \ref RpLightCreate.
+ * Note that lights of types rpLIGHTPOINT, rpLIGHTSPOT and rpLIGHTSPOTSOFT have linear
+ * intensity fall-off with distance from the source, reducing to zero at the light's radius:*/
+enum RpLightType
+{
+ rpNALIGHTTYPE = 0,
+
+ /* These don't take part in the tie mechanism (no position) */
+ rpLIGHTDIRECTIONAL, /**<Directional Light */
+ rpLIGHTAMBIENT, /**<Ambient Light */
+
+ /* These do take part in the tie mechanism (do have position) */
+ rpLIGHTPOINT = rpLIGHTPOSITIONINGSTART, /**<Point Light */
+ rpLIGHTSPOT, /**<Spot Light */
+ rpLIGHTSPOTSOFT, /**<Soft Spot Light */
+ rpLIGHTTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpLightType RpLightType;
+
+#define rpLIGHTMINCONEANGLE ((RwReal)0.0f)
+#if ((defined(XBOX_DRVMODEL_H)) || (defined(OPENGL_DRVMODEL_H)) || (defined(GCN_DRVMODEL_H)))
+/* XBox has Micro$oft-penned drivers, no wonder it crashes... */
+/* OpenGL and GCN clamp to 90 internally, so we mirror that behaviour */
+#define rpLIGHTMAXCONEANGLE ((RwReal)89.9999f)
+#else
+#define rpLIGHTMAXCONEANGLE ((RwReal)180.0f)
+#endif
+
+/*************/
+
+/*** FLAGS ***/
+
+/*************/
+
+/**
+ * \ingroup rpworlddatatypes
+ * \ref RpLightFlag defines what geometry is influenced by the light.
+ * The bit-field RpLightFlag specifies the options available for controlling the scope
+ * of a light source (see API function \ref RpLightSetFlags):*/
+enum RpLightFlag
+{
+ rpLIGHTLIGHTATOMICS = 0x01, /**<The light source illuminates all atomics in a world */
+ rpLIGHTLIGHTWORLD = 0x02, /**<The light source illuminates all static geometry in a world */
+ rpLIGHTFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpLightFlag RpLightFlag;
+
+/* rpLIGHTPRIVATENOCHROMA - turns on optimisations to do with
+ * lights which are a shade of grey
+ */
+enum rpLightPrivateFlag
+{
+ rpLIGHTPRIVATENOCHROMA = 0x01,
+ rpLIGHTPRIVATEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum rpLightPrivateFlag rpLightPrivateFlag;
+
+/*********************/
+
+
+#define RWMINUSCOSFROMTAN(_minusCosAngle, _tanAngle) \
+MACRO_START \
+{ \
+ const RwReal TanAngle2 = (_tanAngle) * (_tanAngle); \
+ const RwReal CosAngle2 = ((RwReal)1) / ( ((RwReal)1) + TanAngle2); \
+ RwReal CosAngle; \
+ rwSqrtMacro(&CosAngle, CosAngle2); \
+ (_minusCosAngle) = - CosAngle; \
+} \
+MACRO_STOP
+
+#define RWTANFROMMINUSCOS(_tanAngle, _minusCosAngle) \
+MACRO_START \
+{ \
+ const RwReal CosAngle2 = (_minusCosAngle) * (_minusCosAngle); \
+ const RwReal TanAngle2 = (((RwReal)1) - (CosAngle2)) / (CosAngle2); \
+ rwSqrtMacro(&_tanAngle, TanAngle2); \
+} \
+MACRO_STOP
+
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpLight
+ * Light. This should be
+ * considered an opaque type. User the RpLight API functions to access.
+ */
+typedef struct RpLight RpLight;
+
+#if (!defined(DOXYGEN))
+struct RpLight
+{
+ RwObjectHasFrame object; /**< object */
+ RwReal radius; /**< radius */
+ RwRGBAReal color; /**< color */ /* Light color */
+ RwReal minusCosAngle; /**< minusCosAngle */
+ RwLinkList WorldSectorsInLight; /**< WorldSectorsInLight */
+ RwLLLink inWorld; /**< inWorld */
+ RwUInt16 lightFrame; /**< lightFrame */
+ RwUInt16 pad;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpLightCallBack
+ * \ref RpLightCallBack
+ * represents the function called from \ref RpWorldForAllLights and
+ * \ref RpWorld SectorForAllLights for all lights in a given world or world
+ * sector. This function should return a pointer to the current light to
+ * indicate success. The callback may return NULL to terminate further
+ * callbacks on the world sector.
+ *
+ * \return Pointer to the current light.
+ *
+ * \param light Pointer to the current light in the world
+ * sector.
+ * \param data Pointer to developer-defined data structure.
+ */
+typedef RpLight *(*RpLightCallBack) (RpLight * light, void *data);
+
+typedef struct RpLightTie RpLightTie;
+
+struct RpLightTie
+{
+ /* Information for an atomic sector */
+ RwLLLink lightInWorldSector; /* Lights IN this ATOMIC SECTOR */
+ RpLight *light;
+
+ /* Information for a atomic */
+ RwLLLink WorldSectorInLight; /* Atomic sectors HOLDING this Light */
+ RpWorldSector *sect;
+};
+
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RpLightGetRadiusMacro(_light) \
+ ((_light)->radius)
+
+#define RpLightGetColorMacro(_light) \
+ (&((_light)->color))
+
+#define RpLightSetFrameMacro(_light, _frame) \
+ (rwObjectHasFrameSetFrame((_light), (_frame)), (_light))
+
+#define RpLightGetFrameMacro(_light) \
+ ((RwFrame *)rwObjectGetParent((_light)))
+
+#define RpLightGetTypeMacro(_light) \
+ ((RpLightType)rwObjectGetSubType((_light)))
+
+#define RpLightSetFlagsMacro(_light, _flags) \
+ ((rwObjectSetFlags((_light), (_flags))), (_light))
+
+#define RpLightGetFlagsMacro(_light) \
+ (rwObjectGetFlags((_light)))
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RpLightGetRadius(_light) \
+ RpLightGetRadiusMacro(_light)
+
+#define RpLightGetColor(_light) \
+ RpLightGetColorMacro(_light)
+
+#define RpLightSetFrame(_light, _frame) \
+ RpLightSetFrameMacro(_light, _frame)
+
+#define RpLightGetFrame(_light) \
+ RpLightGetFrameMacro(_light)
+
+#define RpLightGetType(_light) \
+ RpLightGetTypeMacro(_light)
+
+#define RpLightSetFlags(_light, _flags) \
+ RpLightSetFlagsMacro(_light, _flags)
+
+#define RpLightGetFlags(_light) \
+ RpLightGetFlagsMacro(_light)
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+extern RwReal RpLightGetRadius(const RpLight *light);
+extern const RwRGBAReal *RpLightGetColor(const RpLight *light);
+extern RpLight *RpLightSetFrame(RpLight *light, RwFrame *frame);
+extern RwFrame *RpLightGetFrame(const RpLight *light);
+extern RpLightType RpLightGetType(const RpLight *light);
+extern RpLight *RpLightSetFlags(RpLight *light, RwUInt32 flags);
+extern RwUInt32 RpLightGetFlags(const RpLight *light);
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+/* API Functions */
+extern RpLight *RpLightCreate(RwInt32 type);
+extern RwBool RpLightDestroy(RpLight *light);
+extern RpLight *RpLightSetRadius(RpLight *light, RwReal radius);
+extern RpLight *RpLightSetColor(RpLight *light, const RwRGBAReal *color);
+extern RwReal RpLightGetConeAngle(const RpLight *light);
+extern RpLight *RpLightSetConeAngle(RpLight * ight, RwReal angle);
+extern RwUInt32 RpLightStreamGetSize(const RpLight *light);
+extern RpLight *RpLightStreamRead(RwStream *stream);
+extern const RpLight *RpLightStreamWrite(const RpLight *light,
+ RwStream *stream);
+extern RpLightChunkInfo *_rpLightChunkInfoRead(RwStream *stream,
+ RpLightChunkInfo *lightChunkInfo,
+ RwInt32 *bytesRead);
+
+/* Attaching toolkits */
+extern RwInt32 RpLightRegisterPlugin(RwInt32 size,
+ RwUInt32 pluginID,
+ RwPluginObjectConstructor constructCB,
+ RwPluginObjectDestructor destructCB,
+ RwPluginObjectCopy copyCB);
+extern RwInt32 RpLightRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack readCB,
+ RwPluginDataChunkWriteCallBack writeCB,
+ RwPluginDataChunkGetSizeCallBack getSizeCB);
+extern RwInt32 RpLightSetStreamAlwaysCallBack(RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+extern RwInt32 RpLightGetPluginOffset(RwUInt32 pluginID);
+extern RwBool RpLightValidatePlugins(const RpLight * light);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define RpLightChunkInfoRead(stream, lightChunkInfo, bytesRead) \
+ _rpLightChunkInfoRead(stream, lightChunkInfo, bytesRead)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/D3D8lights.h ---*/
+/**
+ * \ingroup rplightd3d8
+ * \typedef RpD3D8AttenuationParams
+ * typedef for struct RpD3D8AttenuationParams
+ */
+typedef struct RpD3D8AttenuationParams RpD3D8AttenuationParams;
+/**
+ * \ingroup rplightd3d8
+ * \struct RpD3D8AttenuationParams
+ * This type represents the attenuation model of a spot or point light.
+ */
+struct RpD3D8AttenuationParams
+{
+ RwReal constant; /**< Constant attenuation coefficient */
+ RwReal linear; /**< Linear attenuation coefficient */
+ RwReal quadratic; /**< Quadratic attenuation coefficient */
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern void
+RpD3D8LightSetAttenuationParams(RpLight *light,
+ const RpD3D8AttenuationParams *params);
+
+extern void
+RpD3D8LightGetAttenuationParams(const RpLight *light,
+ RpD3D8AttenuationParams *params);
+
+extern RwBool
+_rwD3D8LightsOpen(void);
+
+extern RwBool
+_rwD3D8LightsGlobalEnable(RpLightFlag flags);
+
+extern RwBool
+_rwD3D8LightDirectionalEnable(RpLight *light);
+
+extern RwBool
+_rwD3D8LightLocalEnable(RpLight *light);
+
+extern void
+_rwD3D8LightsEnable(RwBool enable, RwUInt32 type);
+
+extern void
+_rwD3D8LightsClose(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/p2stdclsw.h ---*/
+typedef RpLight *RxLight;
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxClusterDefinition RxClLights; /* Uses the RxLight type (see above) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/bageomet.h ---*/
+
+/*
+ * Handling atomic's geometry
+ * Geometry describe objects, and are the building blocks for atomics
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+*/
+
+
+/****************************************************************************
+ Defines
+ */
+
+/* Type ID */
+#define rpGEOMETRY 8
+
+/**
+ * \ingroup rpworlddatatypes
+ * RpGeometryFlag
+ * Geometry type flags
+ *
+ * When creating a geometry, these flags can be OR'ed together to
+ * specify the format along with the rpGEOMETRYTEXCOORDSETS(n) macro if more
+ * than two sets of texture coordinates are required. See \ref RpGeometryCreate
+ * for more details.
+ *
+ * \see RpGeometryCreate().
+ */
+enum RpGeometryFlag
+{
+ rpGEOMETRYTRISTRIP = 0x00000001, /**<This geometry's meshes can be
+ rendered as strips.
+ \ref RpMeshSetTriStripMethod is
+ used to change this method.*/
+ rpGEOMETRYPOSITIONS = 0x00000002, /**<This geometry has positions */
+ rpGEOMETRYTEXTURED = 0x00000004, /**<This geometry has only one set of
+ texture coordinates. Texture
+ coordinates are specified on a per
+ vertex basis */
+ rpGEOMETRYPRELIT = 0x00000008, /**<This geometry has pre-light colors */
+ rpGEOMETRYNORMALS = 0x00000010, /**<This geometry has vertex normals */
+ rpGEOMETRYLIGHT = 0x00000020, /**<This geometry will be lit */
+ rpGEOMETRYMODULATEMATERIALCOLOR = 0x00000040, /**<Modulate material color
+ with vertex colors
+ (pre-lit + lit) */
+
+ rpGEOMETRYTEXTURED2 = 0x00000080, /**<This geometry has at least 2 sets of
+ texture coordinates. */
+
+ /*
+ * These above flags were stored in the flags field in an RwObject, they
+ * are now stored in the flags file of the RpGeometry.
+ */
+
+ rpGEOMETRYNATIVE = 0x01000000,
+ rpGEOMETRYNATIVEINSTANCE = 0x02000000,
+
+ rpGEOMETRYFLAGSMASK = 0x000000FF,
+ rpGEOMETRYNATIVEFLAGSMASK = 0x0F000000,
+
+ rpGEOMETRYFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpGeometryFlag RpGeometryFlag;
+
+/* Multi texture coordinate format specifier for RpGeometryCreate() */
+#define rpGEOMETRYTEXCOORDSETS(_num) ((_num & 0xff) << 16)
+
+/**
+ * \ingroup rpworlddatatypes
+ * RpGeometryLockMode
+ * Geometry lock flags
+ */
+enum RpGeometryLockMode
+{
+ rpGEOMETRYLOCKPOLYGONS = 0x01, /**<Lock the polygons (triangle list) */
+ rpGEOMETRYLOCKVERTICES = 0x02, /**<Lock the vertex positional data */
+ rpGEOMETRYLOCKNORMALS = 0x04, /**<Lock the vertex normal data */
+ rpGEOMETRYLOCKPRELIGHT = 0x08, /**<Lock the pre-light values */
+ rpGEOMETRYLOCKTEXCOORDS = 0x10, /**<Lock the texture coordinates set 1*/
+ rpGEOMETRYLOCKTEXCOORDS1 = 0x10, /**<Lock the texture coordinates set 1*/
+ rpGEOMETRYLOCKTEXCOORDS2 = 0x20, /**<Lock the texture coordinates set 2*/
+ rpGEOMETRYLOCKTEXCOORDS3 = 0x40, /**<Lock the texture coordinates set 3*/
+ rpGEOMETRYLOCKTEXCOORDS4 = 0x80, /**<Lock the texture coordinates set 4*/
+ rpGEOMETRYLOCKTEXCOORDS5 = 0x0100, /**<Lock the texture coordinates set 5*/
+ rpGEOMETRYLOCKTEXCOORDS6 = 0x0200, /**<Lock the texture coordinates set 6*/
+ rpGEOMETRYLOCKTEXCOORDS7 = 0x0400, /**<Lock the texture coordinates set 7*/
+ rpGEOMETRYLOCKTEXCOORDS8 = 0x0800, /**<Lock the texture coordinates set 8*/
+ rpGEOMETRYLOCKTEXCOORDSALL = 0x0ff0, /**<Lock all texture coordinate sets*/
+ rpGEOMETRYLOCKALL = 0x0fff, /**<Combination of all the above */
+
+ rpGEOMETRYLOCKMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpGeometryLockMode RpGeometryLockMode;
+
+/* Convenience macro for generating a tex coord lock flag */
+#define rpGEOMETRYLOCKTEXCOORDSIDX(_idx) (rpGEOMETRYLOCKTEXCOORDS1 << (_idx))
+
+
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct rpGeometryGlobals rpGeometryGlobals;
+struct rpGeometryGlobals
+{
+ RwFreeList *geomFreeList;
+};
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpGeometry
+ * Geometry object. This should be considered an opaque type.
+ * Use the RpGeometry API functions to access.
+ */
+typedef struct RpGeometry RpGeometry;
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpMorphTarget
+ * Morph target -- vertex positions and normals.
+ * This should be considered an opaque type.
+ * Use RpMorphTarget API functions to access.
+ */
+typedef struct RpMorphTarget RpMorphTarget;
+
+#if (!defined(DOXYGEN))
+struct RpMorphTarget
+{
+ RpGeometry *parentGeom;
+ RwSphere boundingSphere;
+ RwV3d *verts;
+ RwV3d *normals;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+typedef struct RpTriangle RpTriangle;
+
+/**
+ * \ingroup rpworlddatatypes
+ * \struct RpTriangle
+ * This type represents a triangle in a geometry specified
+ * by three indices into the geometry's vertex list (vertIndex)
+ * together with an index in to the geometry's
+ * material list (matIndex) (see API function \ref RpGeometryGetTriangles)
+ */
+struct RpTriangle
+{
+ RwUInt16 vertIndex[3]; /**< vertex indices */
+ RwInt16 matIndex; /**< Index into material list */
+};
+
+#if (!defined(DOXYGEN))
+struct RpGeometry
+{
+ RwObject object; /* Generic type */
+
+ RwUInt32 flags; /* Geometry flags */
+
+ RwUInt16 lockedSinceLastInst; /* What has been locked since we last instanced - for re-instancing */
+ RwInt16 refCount; /* Reference count (for keeping track of atomics referencing geometry) */
+
+ RwInt32 numTriangles; /* Quantity of various things (polys, verts and morph targets) */
+ RwInt32 numVertices;
+ RwInt32 numMorphTargets;
+ RwInt32 numTexCoordSets;
+
+ RpMaterialList matList;
+
+ RpTriangle *triangles; /* The triangles */
+
+ RwRGBA *preLitLum; /* The pre-lighting values */
+
+ RwTexCoords *texCoords[rwMAXTEXTURECOORDS]; /* Texture coordinates */
+
+ RwSurfaceProperties ignoredSurfaceProps; /* Not used in pp rendering, but present
+ * so if pipe1 files are read and written these
+ * values are not lost
+ */
+
+ RpMeshHeader *mesh; /* The mesh - groups polys of the same material */
+
+ RwResEntry *repEntry; /* Information for an instance */
+
+ RpMorphTarget *morphTarget; /* The Morph Target */
+};
+#endif /* (!defined(DOXYGEN)) */
+
+typedef struct RpGeometryChunkInfo RpGeometryChunkInfo;
+typedef struct RpGeometryChunkInfo _rpGeometry;
+
+struct RpGeometryChunkInfo
+{
+ RwInt32 format; /* Compression flags and number of texture coord sets */
+
+ RwInt32 numTriangles;
+ RwInt32 numVertices;
+
+ RwInt32 numMorphTargets;
+
+ RwSurfaceProperties ignoredSurfaceProps;
+};
+
+/* Callbacks */
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpGeometryCallBack
+ * \ref RpGeometryCallBack represents the simple callback function for the \ref RpGeometry object.
+ * The callback may return NULL to terminate further callbacks on
+ * the geometry.
+ *
+ * \param geometry Pointer to the current geometry, supplied by iterator.
+ * \param data Pointer to developer-defined data structure.
+ */
+typedef RpGeometry *(*RpGeometryCallBack)(RpGeometry *geometry, void *data);
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpGeometrySortByMaterialCallBack
+ * \ref RpGeometrySortByMaterialCallBack is used by
+ * \ref RpGeometrySortByMaterial in order to preserve the validity of plugin
+ * data when the vertices in an \ref RpGeometry are sorted (and some possibly
+ * duplicated).
+ *
+ * A vertex map table is provided to the callback - this contains, for each
+ * vertex in the new geometry, the index of the corresponding vertex in the
+ * original geometry.
+ *
+ * \param oldGeom Pointer to the source geometry.
+ * \param newGeom Pointer to the new, sorted geometry.
+ * \param remapTable pointer to the vertex map table
+ * \param numberOfEntries Number of vertices in the new
+ * geometry (size of the map table)
+ */
+typedef void (*RpGeometrySortByMaterialCallBack)(const RpGeometry *oldGeom,
+ RpGeometry *newGeom,
+ RwUInt16 *remapTable,
+ RwUInt16 numberOfEntries);
+
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RpMorphTargetSetBoundingSphereMacro(_mt, _sphere) \
+ (RwSphereAssign(&((_mt)->boundingSphere), (_sphere)), (_mt))
+
+#define RpMorphTargetGetBoundingSphereMacro(_mt) \
+ (&((_mt)->boundingSphere))
+
+#define RpGeometryGetNumMorphTargetsMacro(_geometry) \
+ ((_geometry)->numMorphTargets)
+
+#define RpGeometryGetMorphTargetMacro(_geometry, _index) \
+ (&((_geometry)->morphTarget[(_index)]))
+
+#define RpGeometryGetPreLightColorsMacro(_geometry) \
+ ((_geometry)->preLitLum)
+
+#define RpGeometryGetVertexTexCoordsMacro(_geometry, _uvIndex) \
+ ((_geometry)->texCoords[(_uvIndex) - 1])
+
+#define RpGeometryGetNumTexCoordSetsMacro(_geometry) \
+ ((_geometry)->numTexCoordSets)
+
+#define RpGeometryGetNumVerticesMacro(_geometry) \
+ ((_geometry)->numVertices)
+
+#define RpMorphTargetGetVerticesMacro(_mt) \
+ ((_mt)->verts)
+
+#define RpMorphTargetGetVertexNormalsMacro(_mt) \
+ ((_mt)->normals)
+
+#define RpGeometryGetTrianglesMacro(_geometry) \
+ ((_geometry)->triangles)
+
+#define RpGeometryGetNumTrianglesMacro(_geometry) \
+ ((_geometry)->numTriangles)
+
+#define RpGeometryGetMaterialMacro(_geometry, _num) \
+ (((_geometry)->matList.materials)[(_num)])
+
+#define RpGeometryGetNumMaterialsMacro(_geometry) \
+ ((_geometry)->matList.numMaterials)
+
+#define RpGeometryGetFlagsMacro(_geometry) \
+ ((_geometry)->flags)
+
+#define RpGeometrySetFlagsMacro(_geometry, _flags) \
+ (((_geometry)->flags = (_flags)), (_geometry))
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RpMorphTargetSetBoundingSphere(_geometry, _sphere) \
+ RpMorphTargetSetBoundingSphereMacro(_geometry, _sphere)
+
+#define RpMorphTargetGetBoundingSphere(_geometry) \
+ RpMorphTargetGetBoundingSphereMacro(_geometry)
+
+#define RpGeometryGetNumMorphTargets(_geometry) \
+ RpGeometryGetNumMorphTargetsMacro(_geometry)
+
+#define RpGeometryGetMorphTarget(_geometry, _index) \
+ RpGeometryGetMorphTargetMacro(_geometry, _index)
+
+#define RpGeometryGetPreLightColors(_geometry) \
+ RpGeometryGetPreLightColorsMacro(_geometry)
+
+#define RpGeometryGetVertexTexCoords(_geometry, _uvIndex) \
+ RpGeometryGetVertexTexCoordsMacro(_geometry, _uvIndex)
+
+#define RpGeometryGetNumTexCoordSets(_geometry) \
+ RpGeometryGetNumTexCoordSetsMacro(_geometry)
+
+#define RpGeometryGetNumVertices(_geometry) \
+ RpGeometryGetNumVerticesMacro(_geometry)
+
+#define RpMorphTargetGetVertices(_mt) \
+ RpMorphTargetGetVerticesMacro(_mt)
+
+#define RpMorphTargetGetVertexNormals(_mt) \
+ RpMorphTargetGetVertexNormalsMacro(_mt)
+
+#define RpGeometryGetTriangles(_geometry) \
+ RpGeometryGetTrianglesMacro(_geometry)
+
+#define RpGeometryGetNumTriangles(_geometry) \
+ RpGeometryGetNumTrianglesMacro(_geometry)
+
+#define RpGeometryGetMaterial(_geometry, _num) \
+ RpGeometryGetMaterialMacro(_geometry, _num)
+
+#define RpGeometryGetNumMaterials(_geometry) \
+ RpGeometryGetNumMaterialsMacro(_geometry)
+
+#define RpGeometryGetFlags(_geometry) \
+ RpGeometryGetFlagsMacro(_geometry)
+
+#define RpGeometrySetFlags(_geometry, _flags) \
+ RpGeometrySetFlagsMacro(_geometry, _flags)
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+/* Transforms geometry morph target vertices */
+
+extern RpGeometry *
+RpGeometryTransform(RpGeometry *geometry,
+ const RwMatrix *matrix);
+
+/* Create geometry for a 'space' marker */
+
+extern RpGeometry *
+RpGeometryCreateSpace(RwReal radius);
+
+/* Morph targets - Accessing geometry contents */
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+extern RpMorphTarget *
+RpMorphTargetSetBoundingSphere(RpMorphTarget *morphTarget,
+ const RwSphere *boundingSphere);
+
+extern RwSphere *
+RpMorphTargetGetBoundingSphere(RpMorphTarget *morphTarget);
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+extern const RpMorphTarget *
+RpMorphTargetCalcBoundingSphere(const RpMorphTarget *morphTarget,
+ RwSphere *boundingSphere);
+
+extern RwInt32
+RpGeometryAddMorphTargets(RpGeometry *geometry,
+ RwInt32 mtcount);
+
+extern RwInt32
+RpGeometryAddMorphTarget(RpGeometry *geometry);
+
+extern RpGeometry *
+RpGeometryRemoveMorphTarget(RpGeometry *geometry,
+ RwInt32 morphTarget);
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+extern RwInt32
+RpGeometryGetNumMorphTargets(const RpGeometry *geometry);
+
+extern RpMorphTarget *
+RpGeometryGetMorphTarget(const RpGeometry *geometry,
+ RwInt32 morphTarget);
+
+extern RwRGBA *
+RpGeometryGetPreLightColors(const RpGeometry *geometry);
+
+extern RwTexCoords *
+RpGeometryGetVertexTexCoords(const RpGeometry *geometry,
+ RwTextureCoordinateIndex uvIndex);
+
+extern RwInt32
+RpGeometryGetNumTexCoordSets(const RpGeometry *geometry);
+
+extern RwInt32
+RpGeometryGetNumVertices (const RpGeometry *geometry);
+
+extern RwV3d *
+RpMorphTargetGetVertices(const RpMorphTarget *morphTarget);
+
+extern RwV3d *
+RpMorphTargetGetVertexNormals(const RpMorphTarget *morphTarget);
+
+extern RpTriangle *
+RpGeometryGetTriangles(const RpGeometry *geometry);
+
+extern RwInt32
+RpGeometryGetNumTriangles(const RpGeometry *geometry);
+
+extern RpMaterial *
+RpGeometryGetMaterial(const RpGeometry *geometry,
+ RwInt32 matNum);
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+extern const RpGeometry *
+RpGeometryTriangleSetVertexIndices(const RpGeometry *geometry,
+ RpTriangle *triangle,
+ RwUInt16 vert1,
+ RwUInt16 vert2,
+ RwUInt16 vert3);
+
+extern RpGeometry *
+RpGeometryTriangleSetMaterial(RpGeometry *geometry,
+ RpTriangle *triangle,
+ RpMaterial *material);
+
+extern const RpGeometry *
+RpGeometryTriangleGetVertexIndices(const RpGeometry *geometry,
+ const RpTriangle *triangle,
+ RwUInt16 *vert1,
+ RwUInt16 *vert2,
+ RwUInt16 *vert3);
+
+extern RpMaterial *
+RpGeometryTriangleGetMaterial(const RpGeometry *geometry,
+ const RpTriangle *triangle);
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+extern RwInt32
+RpGeometryGetNumMaterials(const RpGeometry *geometry);
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+extern RpGeometry *
+RpGeometryForAllMaterials(RpGeometry *geometry,
+ RpMaterialCallBack fpCallBack,
+ void *pData);
+
+/* Accessing the inards of geometry */
+extern RpGeometry *
+RpGeometryLock(RpGeometry *geometry,
+ RwInt32 lockMode);
+
+extern RpGeometry *
+RpGeometryUnlock(RpGeometry *geometry);
+
+extern const RpGeometry *
+RpGeometryForAllMeshes(const RpGeometry *geometry,
+ RpMeshCallBack fpCallBack,
+ void *pData);
+
+/* Creation and destruction */
+extern RpGeometry *
+RpGeometryCreate(RwInt32 numVert,
+ RwInt32 numTriangles,
+ RwUInt32 format);
+
+extern RwBool
+RpGeometryDestroy(RpGeometry *geometry);
+
+extern RpGeometry *
+_rpGeometryAddRef(RpGeometry *geometry);
+
+/* Attaching toolkits */
+extern RwInt32
+RpGeometryRegisterPlugin(RwInt32 size,
+ RwUInt32 pluginID,
+ RwPluginObjectConstructor constructCB,
+ RwPluginObjectDestructor destructCB,
+ RwPluginObjectCopy copyCB);
+
+extern RwInt32
+RpGeometryRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack readCB,
+ RwPluginDataChunkWriteCallBack writeCB,
+ RwPluginDataChunkGetSizeCallBack getSizeCB);
+
+extern RwInt32
+RpGeometrySetStreamAlwaysCallBack(RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+
+extern RwInt32
+RpGeometryGetPluginOffset(RwUInt32 pluginID);
+
+extern RwBool
+RpGeometryValidatePlugins(const RpGeometry *geometry);
+
+/* Binary format */
+extern RwUInt32
+RpGeometryStreamGetSize(const RpGeometry *geometry);
+
+extern const RpGeometry *
+RpGeometryStreamWrite(const RpGeometry *geometry,
+ RwStream *stream);
+
+extern RpGeometry *
+RpGeometryStreamRead(RwStream *stream);
+
+extern RpGeometryChunkInfo *
+_rpGeometryChunkInfoRead(RwStream *stream,
+ RpGeometryChunkInfo *geometryChunkInfo,
+ RwInt32 *bytesRead);
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+/* Flags */
+extern RwUInt32
+RpGeometryGetFlags(const RpGeometry *geometry);
+
+extern RpGeometry *
+RpGeometrySetFlags(RpGeometry *geometry,
+ RwUInt32 flags);
+
+#endif
+
+/* Lighting characteristics */
+
+extern const RwSurfaceProperties *
+_rpGeometryGetSurfaceProperties(const RpGeometry *geometry);
+
+extern RpGeometry *
+_rpGeometrySetSurfaceProperties(RpGeometry *geometry,
+ const RwSurfaceProperties *surfaceProperties);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define RpGeometryGetSurfaceProperties(_geometry) \
+ _rpGeometryGetSurfaceProperties(_geometry)
+
+#define RpGeometrySetSurfaceProperties(_geometry, _surfaceProperties) \
+ _rpGeometrySetSurfaceProperties(_geometry, _surfaceProperties)
+
+#define rpGeometryAddRef(_geometry) \
+ _rpGeometryAddRef(_geometry)
+
+#define RpGeometryChunkInfoRead(stream, geometryChunkInfo, bytesRead) \
+ _rpGeometryChunkInfoRead(stream, geometryChunkInfo, bytesRead)
+
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/baclump.h ---*/
+
+/*
+ * Clump and atomic handling.
+ * Clumps and atomics are the movable rendered objects in the world
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+ */
+
+
+/****************************************************************************
+ Defines
+ */
+
+/****************************** Object type ID ******************************/
+
+/* Type IDs */
+
+#define rpATOMIC 1
+#define rpCLUMP 2
+
+/* Interpolator flags */
+enum RpInterpolatorFlag
+{
+ rpINTERPOLATORDIRTYINSTANCE = 0x01,
+ rpINTERPOLATORDIRTYSPHERE = 0x02,
+ rpINTERPOLATORNOFRAMEDIRTY = 0x04,
+ rpINTERPOLATORFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpInterpolatorFlag rpInterpolatorFlag;
+
+/**
+ * \ingroup rpworlddatatypes
+ * The bit-field type RpAtomicFlag specifies the options available for
+ * controlling the behavior of atomics. See API function \ref RpAtomicSetFlags.
+ *
+ * \see RpAtomicSetFlags
+ * \see RpAtomicGetFlags
+ * \see RpWorldSectorForAllCollisionAtomics
+ */
+
+enum RpAtomicFlag
+{
+ rpATOMICCOLLISIONTEST = 0x01, /**<A generic collision flag to indicate
+ * that the atomic should be considered
+ * in collision tests.
+ */
+ rpATOMICRENDER = 0x04, /**<The atomic is rendered if it is
+ * in the view frustum.
+ */
+
+ rpATOMICFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpAtomicFlag RpAtomicFlag;
+
+/**
+ * \ingroup rpworlddatatypes
+ * \ref RpAtomicSetGeomFlag defines how an atomic references a new geometry
+ *
+ * \see RpAtomicSetGeometry
+ */
+enum RpAtomicSetGeomFlag
+{
+ rpATOMICSAMEBOUNDINGSPHERE = 0x01, /**<The bounding-sphere for the
+ * new geometry is assumed to be the
+ * same as the old one, if any, and
+ * should not be recalculated.
+ */
+
+ rpATOMICSETGEOMFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpAtomicSetGeomFlag RpAtomicSetGeomFlag;
+
+enum RpAtomicPrivateFlag
+{
+ rpATOMICPRIVATEWORLDBOUNDDIRTY = 0x01,
+ rpATOMICPRIVATEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpAtomicPrivateFlag rpAtomicPrivateFlag;
+
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpAtomic
+ * Atomic Geometry object. This should be
+ * considered an opaque type. Use the RpAtomic API functions to access.
+ */
+typedef struct RpAtomic RpAtomic;
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpInterpolator
+ * Morph Target Interpolator.
+ * This should be considered an opaque type.
+ * Use the RpInterpolator API functions to access.
+ */
+typedef struct RpInterpolator RpInterpolator;
+
+#if (!defined(DOXYGEN))
+struct RpInterpolator
+{
+ RwInt32 flags; /**< flags */
+ RwInt16 startMorphTarget; /**< startMorphTarget */
+ RwInt16 endMorphTarget; /**< endMorphTarget */
+ RwReal time; /**< time */
+ RwReal recipTime; /**< recipTime */
+ RwReal position; /**< position */
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/* More callbacks */
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpClump
+ * Clump Geometry object. This should be
+ * considered an opaque type. Use the RpClump API functions to access.
+ */
+typedef struct RpClump RpClump;
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpClumpCallBack
+ * \ref RpClumpCallBack represents the
+ * function called from \ref RwCameraForAllClumpsInFrustum and
+ * \ref RwCameraForAllClumpsNotInFrustum when a clump lies inside the current camera's
+ * view frustum. It is also called from \ref RpWorldForAllClumps. This function should
+ * return a pointer to the current clump to indicate success. The callback may return
+ * NULL to terminate further callbacks on the clumps.
+ *
+ * \param clump Pointer to the current clump, supplied by
+ * iterator.
+ * \param data Pointer to developer-defined data structure.
+ *
+ * \return Pointer to the current clump.
+ *
+ * \see RpWorldForAllClumps
+ * \see RpClumpGetCallBack
+ * \see RpClumpSetCallBack
+ * \see RwCameraForAllClumpsInFrustum
+ * \see RwCameraForAllClumpsNotInFrustum
+ */
+typedef RpClump *(*RpClumpCallBack) (RpClump * clump, void *data);
+
+#if (!defined(DOXYGEN))
+struct RpClump
+{
+ RwObject object;
+
+ /* Information about all the Atomics */
+ RwLinkList atomicList;
+
+ /* Lists of lights and cameras */
+ RwLinkList lightList;
+ RwLinkList cameraList;
+
+ /* The clump in the world */
+ RwLLLink inWorldLink;
+
+ /* Clump callback */
+ RpClumpCallBack callback;
+
+ /* Render frame - used to prevent multiple invocations
+ * of the clump frustum callback
+ */
+ RwUInt16 renderFrame;
+ RwUInt16 pad;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpAtomicCallBackRender
+ * \ref RpAtomicCallBackRender represents the function called from
+ * \ref RpAtomicRender when the specified atomic
+ * lies inside the current camera's view frustum. The default callback
+ * initiates execution of the atomic rendering pipeline. This function should
+ * return a pointer to the atomic to indicate success.
+ *
+ * \param atomic Pointer to the current atomic, supplied by
+ * iterator.
+ *
+ * \see RpAtomicRender
+ */
+typedef RpAtomic *(*RpAtomicCallBackRender) (RpAtomic * atomic);
+
+#if (!defined(DOXYGEN))
+struct RpAtomic
+{
+ RwObjectHasFrame object;
+
+ /* Information for an instance */
+ RwResEntry *repEntry;
+
+ /* Triangles making the object */
+ RpGeometry *geometry;
+
+ /* Interpolated bounding sphere (in object space and world space) */
+ RwSphere boundingSphere;
+ RwSphere worldBoundingSphere;
+
+ /* Connections to other atomics */
+ RpClump *clump;
+ RwLLLink inClumpLink;
+
+ /* callbacks */
+ RpAtomicCallBackRender renderCallBack;
+
+ /* Interpolation animation pointer */
+ RpInterpolator interpolator;
+
+ /* Counter for checks of "render has occurred already" */
+ RwUInt16 renderFrame;
+ RwUInt16 pad;
+
+ /* Connections to sectors */
+ RwLinkList llWorldSectorsInAtomic;
+
+ /* The Atomic object pipeline for this Atomic */
+ RxPipeline *pipeline;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpAtomicCallBack
+ * \ref RpAtomicCallBack represents the function called from \ref RpWorldSectorForAllAtomics and
+ * \ref RpClumpForAllAtomics for all atomics in a given world sector or clump.
+ * This function should return a pointer to the current atomic to indicate
+ * success. The callback may return NULL to terminate further callbacks on
+ * the world sector.
+ *
+ * \param atomic Pointer to the current atomic, supplied by
+ * iterator.
+ * \param data Pointer to developer-defined data structure.
+ */
+typedef RpAtomic *(*RpAtomicCallBack) (RpAtomic * atomic, void *data);
+
+typedef struct RpTie RpTie;
+
+struct RpTie
+{
+ /* Information for an atomic sector */
+ RwLLLink lAtomicInWorldSector; /* Atomics IN this ATOMIC SECTOR */
+ RpAtomic *apAtom;
+
+ /* Information for a atomic */
+ RwLLLink lWorldSectorInAtomic; /* Atomic sectors HOLDING this atomic */
+ RpWorldSector *worldSector;
+};
+
+typedef struct RpClumpChunkInfo RpClumpChunkInfo;
+typedef struct RpClumpChunkInfo _rpClump;
+typedef struct RpClumpChunkInfo33000 _rpClump33000;
+
+struct RpClumpChunkInfo
+{
+ RwInt32 numAtomics;
+ RwInt32 numLights;
+ RwInt32 numCameras;
+};
+
+struct RpClumpChunkInfo33000
+{
+ RwInt32 numAtomics;
+};
+
+/****************************************************************************
+ <macro/inline functionality
+
+ */
+
+/* NB "RpAtomicRender(atom++) will break it */
+#define RpAtomicRenderMacro(_atomic) \
+ ((_atomic)->renderCallBack(_atomic))
+
+#define RpAtomicGetGeometryMacro(_atomic) \
+ ((_atomic)->geometry)
+
+#if (!defined(RpAtomicSetRenderCallBackMacro))
+
+/* NB "RpAtomicSetRenderCallBack(atom++, callback)" will break it */
+#define RpAtomicSetRenderCallBackMacro(_atomic, _callback) \
+MACRO_START \
+{ \
+ (_atomic)->renderCallBack = (_callback); \
+ if (!(_atomic)->renderCallBack) \
+ { \
+ (_atomic)->renderCallBack = AtomicDefaultRenderCallBack; \
+ } \
+} \
+MACRO_STOP
+
+#endif /* (!defined(RpAtomicSetRenderCallBackMacro)) */
+
+#define RpAtomicGetRenderCallBackMacro(_atomic) \
+ ((_atomic)->renderCallBack)
+
+#define RpAtomicGetInterpolatorMacro(_atomic) \
+ (&((_atomic)->interpolator))
+
+#define RpInterpolatorGetStartMorphTargetMacro(_intrp) \
+ ((_intrp)->startMorphTarget)
+
+#define RpInterpolatorGetEndMorphTargetMacro(_intrp) \
+ ((_intrp)->endMorphTarget)
+
+#define RpInterpolatorGetValueMacro(_intrp) \
+ ((_intrp)->position)
+
+#define RpInterpolatorGetScaleMacro(_intrp) \
+ ((_intrp)->time)
+
+/* NB "RpInterpolatorSetStartMorphTarget(interp++, target)" will break it */
+#define RpInterpolatorSetStartMorphTargetMacro(_intrp, _target, _atomic)\
+ ((_intrp)->startMorphTarget = (RwInt16) (_target), \
+ (_intrp)->flags |= (RwInt32)(rpINTERPOLATORDIRTYINSTANCE | \
+ rpINTERPOLATORDIRTYSPHERE ), \
+ ((!((_intrp)->flags & rpINTERPOLATORNOFRAMEDIRTY))? \
+ ((RpAtomicGetFrame(_atomic))? \
+ (RwFrameUpdateObjects(RpAtomicGetFrame(_atomic))): \
+ (0)): \
+ (0)), \
+ (_intrp))
+
+/* NB "RpInterpolatorSetEndMorphTarget(interp++, target)" will break it */
+#define RpInterpolatorSetEndMorphTargetMacro(_intrp, _target, _atomic) \
+ ((_intrp)->endMorphTarget = (RwInt16) (_target), \
+ (_intrp)->flags |= (RwInt32)(rpINTERPOLATORDIRTYINSTANCE | \
+ rpINTERPOLATORDIRTYSPHERE ), \
+ ((!((_intrp)->flags & rpINTERPOLATORNOFRAMEDIRTY))? \
+ ((RpAtomicGetFrame(_atomic))? \
+ (RwFrameUpdateObjects(RpAtomicGetFrame(_atomic))): \
+ (0)): \
+ (0)), \
+ (_intrp))
+
+/* NB "RpInterpolatorSetValue(interp++, value)" will break it */
+#define RpInterpolatorSetValueMacro(_intrp, _value, _atomic) \
+ ((_intrp)->position = (_value), \
+ (_intrp)->flags |= (RwInt32)(rpINTERPOLATORDIRTYINSTANCE | \
+ rpINTERPOLATORDIRTYSPHERE ), \
+ ((!((_intrp)->flags & rpINTERPOLATORNOFRAMEDIRTY))? \
+ ((RpAtomicGetFrame(_atomic))? \
+ (RwFrameUpdateObjects(RpAtomicGetFrame(_atomic))): \
+ (0)): \
+ (0)), \
+ (_intrp))
+
+/* NB "RpInterpolatorSetScale(interp++, *(scale++))" will break it */
+#define RpInterpolatorSetScaleMacro(_intrp, _scale, _atomic) \
+ ((_intrp)->time = (_scale), \
+ (_intrp)->recipTime = (RwReal) (1.0) / (_scale), \
+ (_intrp)->flags |= (RwInt32)(rpINTERPOLATORDIRTYINSTANCE | \
+ rpINTERPOLATORDIRTYSPHERE ), \
+ ((!((_intrp)->flags & rpINTERPOLATORNOFRAMEDIRTY))? \
+ ((RpAtomicGetFrame(_atomic))? \
+ (RwFrameUpdateObjects(RpAtomicGetFrame(_atomic))): \
+ (0)): \
+ (0)), \
+ (_intrp))
+
+#define RpAtomicGetClumpMacro(_atomic) \
+ ((_atomic)->clump)
+
+/* NB "RpAtomicGetBoundingSphere(atomic++)" will break it */
+#define RpAtomicGetBoundingSphereMacro(_atomic) \
+ ((((_atomic)->interpolator.flags & rpINTERPOLATORDIRTYSPHERE)? \
+ _rpAtomicResyncInterpolatedSphere(_atomic), 0: 0), \
+ &((_atomic)->boundingSphere))
+#define RpAtomicGetFrameMacro(_atomic) \
+ ((RwFrame *) rwObjectGetParent(_atomic))
+
+/* NB "RpClumpSetFrame(clump++, frame)" will break it */
+#if (!defined(RpClumpSetFrameMacro))
+#define RpClumpSetFrameMacro(_clump, _frame) \
+ (rwObjectSetParent(_clump, _frame), \
+ (_clump))
+#endif /* (!defined(RpClumpSetFrameMacro)) */
+
+#if (!defined(RpClumpSetFrameVoidMacro))
+#define RpClumpSetFrameVoidMacro(_clump, _frame) \
+MACRO_START \
+{ \
+ rwObjectSetParent(_clump, _frame); \
+} \
+MACRO_STOP
+#endif /* (!defined(RpClumpSetFrameVoidMacro)) */
+
+#define RpClumpGetFrameMacro(_clump) \
+ ((RwFrame *) rwObjectGetParent(_clump))
+
+/* NB "RpAtomicSetFlags(atomic++, flags)" will break it */
+#if (!defined(RpAtomicSetFlagsMacro))
+#define RpAtomicSetFlagsMacro(_atomic, _flags) \
+ (rwObjectSetFlags(_atomic, _flags), \
+ (_atomic))
+#endif /* (!defined(RpAtomicSetFlagsMacro)) */
+
+#define RpAtomicGetFlagsMacro(_atomic) \
+ (rwObjectGetFlags(_atomic))
+
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+
+#define RpAtomicRender(_atomic) \
+ RpAtomicRenderMacro(_atomic)
+
+#define RpAtomicGetGeometry(_atomic) \
+ RpAtomicGetGeometryMacro(_atomic)
+
+#define RpAtomicSetRenderCallBack(_atomic, _callback) \
+ RpAtomicSetRenderCallBackMacro(_atomic, _callback)
+
+#define RpAtomicGetRenderCallBack(_atomic) \
+ RpAtomicGetRenderCallBackMacro(_atomic)
+
+#define RpAtomicGetInterpolator(_atomic) \
+ RpAtomicGetInterpolatorMacro(_atomic)
+
+#define RpInterpolatorGetStartMorphTarget(_intrp) \
+ RpInterpolatorGetStartMorphTargetMacro(_intrp)
+
+#define RpInterpolatorGetEndMorphTarget(_intrp) \
+ RpInterpolatorGetEndMorphTargetMacro(_intrp)
+
+#define RpInterpolatorGetValue(_intrp) \
+ RpInterpolatorGetValueMacro(_intrp)
+
+#define RpInterpolatorGetScale(_intrp) \
+ RpInterpolatorGetScaleMacro(_intrp)
+
+#define RpInterpolatorSetStartMorphTarget(_intrp, _target, _atomic) \
+ RpInterpolatorSetStartMorphTargetMacro(_intrp, _target, _atomic)
+
+#define RpInterpolatorSetEndMorphTarget(_intrp, _target, _atomic) \
+ RpInterpolatorSetEndMorphTargetMacro(_intrp, _target, _atomic)
+
+#define RpInterpolatorSetValue(_intrp, _value, _atomic) \
+ RpInterpolatorSetValueMacro(_intrp, _value, _atomic)
+
+#define RpInterpolatorSetScale(_intrp, _scale, _atomic) \
+ RpInterpolatorSetScaleMacro(_intrp, _scale, _atomic)
+
+#define RpAtomicGetClump(_atomic) \
+ RpAtomicGetClumpMacro(_atomic)
+
+#define RpAtomicGetBoundingSphere(_atomic) \
+ RpAtomicGetBoundingSphereMacro(_atomic)
+
+#define RpAtomicGetFrame(_atomic) \
+ RpAtomicGetFrameMacro(_atomic)
+
+#define RpClumpSetFrame(_clump, _frame) \
+ RpClumpSetFrameMacro(_clump, _frame)
+
+#define RpClumpGetFrame(_clump) \
+ RpClumpGetFrameMacro(_clump)
+
+#define RpAtomicSetFlags(_atomic, _flags) \
+ RpAtomicSetFlagsMacro(_atomic, _flags)
+
+#define RpAtomicGetFlags(_atomic) \
+ RpAtomicGetFlagsMacro(_atomic)
+
+#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+/* Macro version of RpAtomicSetRenderCallBack needs this */
+extern RpAtomic *
+AtomicDefaultRenderCallBack(RpAtomic * atomic);
+
+extern void
+_rpAtomicResyncInterpolatedSphere(RpAtomic * atomic);
+
+extern const RwSphere *
+RpAtomicGetWorldBoundingSphere(RpAtomic * atomic);
+
+/* Enumeration */
+extern RpClump *
+RpClumpForAllAtomics(RpClump * clump,
+ RpAtomicCallBack callback,
+ void *pData);
+
+extern RpClump *
+RpClumpForAllLights(RpClump * clump,
+ RpLightCallBack callback,
+ void *pData);
+
+extern RpClump *
+RpClumpForAllCameras(RpClump * clump,
+ RwCameraCallBack callback,
+ void *pData);
+
+/* Frames */
+extern RpAtomic *
+RpAtomicSetFrame(RpAtomic * atomic,
+ RwFrame * frame);
+
+/* Create a space marking clump */
+extern RpClump *
+RpClumpCreateSpace(const RwV3d * position,
+ RwReal radius);
+
+/* Instancing and rendering */
+extern RpClump *
+RpClumpRender(RpClump * clump);
+
+extern RpClump *
+RpClumpRemoveAtomic(RpClump * clump,
+ RpAtomic * atomic);
+
+extern RpClump *
+RpClumpAddAtomic(RpClump * clump,
+ RpAtomic * atomic);
+
+extern RpClump *
+RpClumpRemoveLight(RpClump * clump,
+ RpLight * light);
+
+extern RpClump *
+RpClumpAddLight(RpClump * clump,
+ RpLight * light);
+
+extern RpClump *
+RpClumpRemoveCamera(RpClump * clump,
+ RwCamera * camera);
+
+extern RpClump *
+RpClumpAddCamera(RpClump * clump,
+ RwCamera * camera);
+
+/* Creation and destruction of clumps */
+extern RwBool
+RpClumpDestroy(RpClump * clump);
+
+extern RpClump *
+RpClumpCreate(void);
+
+extern RpClump *
+RpClumpClone(RpClump * clump);
+
+/* Creation and destruction of atomics*/
+extern RwBool
+RpAtomicDestroy(RpAtomic * atomic);
+
+extern RpAtomic *
+RpAtomicClone(RpAtomic * atomic);
+
+extern RpAtomic *
+RpAtomicCreate(void);
+
+/* Setting and getting geometry for an atomic */
+extern RpAtomic *
+RpAtomicSetGeometry(RpAtomic * atomic,
+ RpGeometry * geometry,
+ RwUInt32 flags);
+
+/* Frustum callbacks */
+extern RpClump *
+RpClumpSetCallBack(RpClump * clump,
+ RpClumpCallBack callback);
+
+extern RpClumpCallBack
+RpClumpGetCallBack(const RpClump * clump);
+
+/* The number of atomics in a clump */
+extern RwInt32
+RpClumpGetNumAtomics(RpClump * clump);
+
+extern RwInt32
+RpClumpGetNumLights(RpClump * clump);
+
+extern RwInt32
+RpClumpGetNumCameras(RpClump * clump);
+
+/* Light and camera extensions */
+extern RpClump *
+RpLightGetClump(const RpLight *light);
+
+extern RpClump *
+RwCameraGetClump(const RwCamera *camera);
+
+/* Binary format */
+extern RwUInt32
+RpAtomicStreamGetSize(RpAtomic * atomic);
+
+extern RpAtomic *
+RpAtomicStreamRead(RwStream * stream);
+
+extern RpAtomic *
+RpAtomicStreamWrite(RpAtomic * atomic,
+ RwStream * stream);
+
+extern RwUInt32
+RpClumpStreamGetSize(RpClump * clump);
+
+extern RpClump *
+RpClumpStreamRead(RwStream * stream);
+
+extern RpClump *
+RpClumpStreamWrite(RpClump * clump,
+ RwStream * stream);
+
+extern RpClumpChunkInfo *
+_rpClumpChunkInfoRead(RwStream * stream,
+ RpClumpChunkInfo * clumpChunkInfo,
+ RwInt32 * bytesRead);
+
+/* Attaching toolkits */
+extern RwInt32
+RpAtomicRegisterPlugin(RwInt32 size,
+ RwUInt32 pluginID,
+ RwPluginObjectConstructor constructCB,
+ RwPluginObjectDestructor destructCB,
+ RwPluginObjectCopy copyCB);
+
+extern RwInt32
+RpClumpRegisterPlugin(RwInt32 size,
+ RwUInt32 pluginID,
+ RwPluginObjectConstructor constructCB,
+ RwPluginObjectDestructor destructCB,
+ RwPluginObjectCopy copyCB);
+
+extern RwInt32
+RpAtomicRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack
+ readCB,
+ RwPluginDataChunkWriteCallBack
+ writeCB,
+ RwPluginDataChunkGetSizeCallBack
+ getSizeCB);
+
+extern RwInt32
+RpAtomicSetStreamAlwaysCallBack(RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+
+extern RwInt32
+RpAtomicSetStreamRightsCallBack(RwUInt32 pluginID,
+ RwPluginDataChunkRightsCallBack rightsCB);
+
+extern RwInt32
+RpClumpRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack readCB,
+ RwPluginDataChunkWriteCallBack writeCB,
+ RwPluginDataChunkGetSizeCallBack getSizeCB);
+
+extern RwInt32
+RpClumpSetStreamAlwaysCallBack(RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+
+extern RwInt32
+RpAtomicGetPluginOffset(RwUInt32 pluginID);
+
+extern RwInt32
+RpClumpGetPluginOffset(RwUInt32 pluginID);
+
+extern RwBool
+RpAtomicValidatePlugins(const RpAtomic * atomic);
+
+extern RwBool
+RpClumpValidatePlugins(const RpClump * clump);
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+extern RwFrame *
+RpAtomicGetFrame(const RpAtomic * atomic);
+
+extern RwFrame *
+RpClumpGetFrame(const RpClump * clump);
+
+extern RpClump *
+RpClumpSetFrame(RpClump * clump,
+ RwFrame * frame);
+
+/* Flags */
+extern RpAtomic *
+RpAtomicSetFlags(RpAtomic * atomic,
+ RwUInt32 flags);
+
+extern RwUInt32
+RpAtomicGetFlags(const RpAtomic * atomic);
+
+extern RwSphere *
+RpAtomicGetBoundingSphere(RpAtomic * atomic);
+
+extern RwInt32
+RpInterpolatorGetEndMorphTarget(const RpInterpolator * interpolator);
+
+extern RwInt32
+RpInterpolatorGetStartMorphTarget(const RpInterpolator * interpolator);
+
+extern RwReal
+RpInterpolatorGetValue(const RpInterpolator * interpolator);
+
+extern RwReal
+RpInterpolatorGetScale(const RpInterpolator * interpolator);
+
+extern RpInterpolator *
+RpInterpolatorSetEndMorphTarget(RpInterpolator * interpolator,
+ RwInt32 morphTarget,
+ RpAtomic * atomic);
+
+extern RpInterpolator *
+RpInterpolatorSetStartMorphTarget(RpInterpolator * interpolator,
+ RwInt32 morphTarget,
+ RpAtomic * atomic);
+
+extern RpInterpolator *
+RpInterpolatorSetValue(RpInterpolator * interpolator,
+ RwReal value,
+ RpAtomic *atomic);
+
+extern RpInterpolator *
+RpInterpolatorSetScale(RpInterpolator * interpolator,
+ RwReal scale,
+ RpAtomic *atomic);
+
+extern RpAtomic *
+RpAtomicRender(RpAtomic * atomic);
+
+/* Building clumps */
+extern RpClump *
+RpAtomicGetClump(const RpAtomic * atomic);
+
+extern RpInterpolator *
+RpAtomicGetInterpolator(RpAtomic * atomic);
+
+extern RpGeometry *
+RpAtomicGetGeometry(const RpAtomic * atomic);
+
+extern void
+RpAtomicSetRenderCallBack(RpAtomic * atomic,
+ RpAtomicCallBackRender callback);
+
+extern RpAtomicCallBackRender
+RpAtomicGetRenderCallBack(const RpAtomic * atomic);
+
+#endif
+
+/* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */
+
+extern RwBool RpAtomicInstance(RpAtomic *atomic);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define RpClumpChunkInfoRead(stream, clumpChunkInfo, bytesRead) \
+ _rpClumpChunkInfoRead(stream, clumpChunkInfo, bytesRead)
+
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/baworld.h ---*/
+
+/*
+ * World handling.
+ * World give objects scope, and provide a mechanism for
+ * efficiency static object rendering.
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+ *
+ */
+
+/****************************************************************************
+ Defines
+ */
+
+/* Type ID */
+#define rpWORLD 7
+
+/* RpWorld private flags (in RwObject) */
+enum RpWorldPrivateFlag
+{
+ rpWORLDSINGLEMALLOC = 0x01,
+ rpWORLDPRIVATEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpWorldPrivateFlag RpWorldPrivateFlag;
+
+/**
+ * \ingroup rpworlddatatypes
+ * The bit-field type \ref RpWorldFlag specifies the options available
+ * for creating the static geometry component of a world (see API function \ref RpWorldSetFlags):
+ */
+enum RpWorldFlag
+{
+ rpWORLDTRISTRIP = 0x01, /**<This world's meshes can be rendered
+ as tri strips */
+ rpWORLDPOSITIONS = 0x02, /**<This world has positions */
+ rpWORLDTEXTURED = 0x04, /**<This world has only one set of texture coordinates */
+ rpWORLDPRELIT = 0x08, /**<This world has luminance values */
+ rpWORLDNORMALS = 0x10, /**<This world has normals */
+ rpWORLDLIGHT = 0x20, /**<This world will be lit */
+ rpWORLDMODULATEMATERIALCOLOR = 0x40,
+ /**<Modulate material color with vertex colors
+ (pre-lit + lit) */
+ rpWORLDTEXTURED2 = 0x80, /**<This world has 2 or more sets of texture coordinates */
+
+ /*
+ * These above flags were stored in the flags field in an RwObject, they
+ * are now stored in the flags file of the RpWorld.
+ */
+
+ rpWORLDNATIVE = 0x01000000,
+ rpWORLDNATIVEINSTANCE = 0x02000000,
+
+ rpWORLDFLAGSMASK = 0x000000FF,
+ rpWORLDNATIVEFLAGSMASK = 0x0F000000,
+
+ rpWORLDSECTORSOVERLAP = 0x40000000,
+
+ rpWORLDFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpWorldFlag RpWorldFlag;
+
+/* Multi texture coordinate format specifier */
+#define rpWORLDTEXCOORDSETS(_num) ((_num & 0xff) << 16)
+
+/* Maximum depth of BSP tree */
+#define rpWORLDMAXBSPDEPTH 64
+
+
+/* macro/inline functionality */
+#define RpWorldGetBBoxMacro(_world) \
+ (&((_world)->boundingBox))
+
+#define RpWorldGetOriginMacro(_world) \
+ (&((_world)->worldOrigin))
+
+#define RpWorldGetNumMaterialsMacro(_world) \
+ ((_world)->matList.numMaterials)
+
+#define RpWorldGetMaterialMacro(_world, _num) \
+ (((_world)->matList.materials)[(_num)])
+
+#define RpWorldGetNumClumpsMacro(_world) \
+ ((_world)->numClumpsInWorld)
+
+#define RpWorldSetRenderOrderMacro(_world, _renderOrder) \
+ (((_world)->renderOrder = _renderOrder), (_world))
+
+#define RpWorldGetRenderOrderMacro(_world) \
+ ((_world)->renderOrder)
+
+#define RpWorldSetFlagsMacro(_world, _flags) \
+ (((_world)->flags = (_flags)), (_world))
+
+#define RpWorldGetFlagsMacro(_world) \
+ ((_world)->flags)
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RpWorldGetBBox(_world) \
+ RpWorldGetBBoxMacro(_world)
+
+#define RpWorldGetOrigin(_world) \
+ RpWorldGetOriginMacro(_world)
+
+#define RpWorldGetNumMaterials(_world) \
+ RpWorldGetNumMaterialsMacro(_world)
+
+#define RpWorldGetMaterial(_world, _num) \
+ RpWorldGetMaterialMacro(_world, _num)
+
+#define RpWorldGetNumClumps(_world) \
+ RpWorldGetNumClumpsMacro(_world)
+
+#define RpWorldSetRenderOrder(_world, _renderOrder) \
+ RpWorldSetRenderOrderMacro(_world, _renderOrder)
+
+#define RpWorldGetRenderOrder(_world) \
+ RpWorldGetRenderOrderMacro(_world)
+
+#define RpWorldSetFlags(_world, _flags) \
+ RpWorldSetFlagsMacro(_world, _flags)
+
+#define RpWorldGetFlags(_world) \
+ RpWorldGetFlagsMacro(_world)
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+/****************************************************************************
+ Global types
+ */
+
+
+/**
+ * \ingroup rpworlddatatypes
+ * \ref RpWorldRenderOrder
+ * represents the options available for
+ * the rendering order of world sectors in the camera's view frustum (see
+ * API function \ref RpWorldSetRenderOrder).
+ */
+enum RpWorldRenderOrder
+{
+ rpWORLDRENDERNARENDERORDER = 0,
+ rpWORLDRENDERFRONT2BACK, /**<Renders nearest sectors first */
+ rpWORLDRENDERBACK2FRONT, /**<Renders furthest sectors first */
+ rpWORLDRENDERORDERFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RpWorldRenderOrder RpWorldRenderOrder;
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpWorldSectorCallBackRender
+ * \ref RpWorldSectorCallBackRender represents the function called from
+ * \ref RpWorldSectorRender when the specified world sector lies inside the
+ * current camera's view frustum. The default callback initiates execution of
+ * the world sector rendering pipeline. This function should return a pointer
+ * to the world sector to indicate success
+ *
+ * \return Pointer to the world sector.
+ *
+ * \param worldSector Pointer to the world sector to be
+ * rendered
+ */
+typedef RpWorldSector *(*RpWorldSectorCallBackRender) (RpWorldSector *
+ worldSector);
+
+/**
+ * \ingroup rpworlddatatypes
+ * \typedef RpWorld
+ * World object. This should be considered an opaque type.
+ * Use the RpWorld API functions to access.
+ */
+typedef struct RpWorld RpWorld;
+
+#if (!defined(DOXYGEN))
+struct RpWorld
+{
+ RwObject object;
+
+ RwUInt32 flags;
+
+ RpWorldRenderOrder renderOrder;
+
+ /* Materials */
+ RpMaterialList matList;
+
+ /* The world stored as a BSP tree */
+ RpSector *rootSector;
+
+ /* The number of texture coordinate sets in each sector */
+ RwInt32 numTexCoordSets;
+
+ /* Render frame used when last rendered */
+ RwInt32 numClumpsInWorld;
+ RwLLLink *currentClumpLink;
+
+ /* All the clumps in the world */
+ RwLinkList clumpList;
+
+ /* All of the lights in the world */
+ RwLinkList lightList;
+
+ /* Directional lights in the world */
+ RwLinkList directionalLightList;
+
+ /* The worlds origin offset */
+ RwV3d worldOrigin;
+
+ /* Bounding box around the whole world */
+ RwBBox boundingBox;
+
+ /* Surface properties */
+ RwSurfaceProperties surfaceProps;
+
+ /* The callbacks functions */
+ RpWorldSectorCallBackRender renderCallBack;
+
+ RxPipeline *pipeline;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/****************************************************************************
+ Global Variables
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwPluginRegistry worldTKList;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwBool _rpWorldFindBBox(RpWorld * world,
+ RwBBox * boundingBox);
+
+/* Generate sector bounding boxes from BSP planes (not tight boxes) */
+extern RpWorld *_rpWorldSetupSectorBoundingBoxes(RpWorld *world);
+
+
+/* These stealth-API */
+extern RwBool _rpWorldForAllGlobalLights(RpLightCallBack callBack,
+ void *pData);
+extern RpWorldSector *_rpWorldSectorForAllLocalLights(RpWorldSector *
+ sector,
+ RpLightCallBack
+ callBack,
+ void *pData);
+
+extern RpWorldSector *_rpSectorDefaultRenderCallBack(RpWorldSector *
+ sector);
+
+/* Accessing worlds geometry */
+extern RpWorld *RpWorldLock(RpWorld * world);
+extern RpWorld *RpWorldUnlock(RpWorld * world);
+
+/* Managing a list of the worlds */
+extern void _rpWorldRegisterWorld(RpWorld * world,
+ RwUInt32 memorySize);
+extern void _rpWorldUnregisterWorld(RpWorld * world);
+
+/* Hook into world management */
+extern RwBool RpWorldPluginAttach(void);
+
+/* Enumerating objects in the world */
+extern RpWorld *RpWorldForAllClumps(RpWorld * world,
+ RpClumpCallBack fpCallBack,
+ void *pData);
+extern RpWorld *RpWorldForAllMaterials(RpWorld * world,
+ RpMaterialCallBack fpCallBack,
+ void *pData);
+extern RpWorld *RpWorldForAllLights(RpWorld * world,
+ RpLightCallBack fpCallBack,
+ void *pData);
+extern RpWorld *RpWorldForAllWorldSectors(RpWorld * world,
+ RpWorldSectorCallBack
+ fpCallBack, void *pData);
+
+/* Rendering */
+extern RpWorld *RpWorldRender(RpWorld * world);
+
+/* Creation/destruction */
+extern RwBool RpWorldDestroy(RpWorld * world);
+extern RpWorld *RpWorldCreate(RwBBox * boundingBox);
+extern RwBool RpWorldInstance(RpWorld *world);
+
+/* Getting/setting */
+extern RpWorld *_rpWorldSetSurfaceProperties(RpWorld * world,
+ const RwSurfaceProperties
+ * surface);
+extern const RwSurfaceProperties *
+ _rpWorldGetSurfaceProperties(const RpWorld *world);
+
+/* Sector callbacks */
+extern RpWorld *RpWorldSetSectorRenderCallBack(RpWorld * world,
+ RpWorldSectorCallBackRender
+ fpCallBack);
+extern RpWorldSectorCallBackRender RpWorldGetSectorRenderCallBack(const
+ RpWorld
+ *
+ world);
+
+/* Getting world from sector */
+extern RpWorld *RpWorldSectorGetWorld(const RpWorldSector * sector);
+
+extern RwInt32 RpWorldRegisterPlugin(RwInt32 size, RwUInt32 pluginID,
+ RwPluginObjectConstructor
+ constructCB,
+ RwPluginObjectDestructor
+ destructCB,
+ RwPluginObjectCopy copyCB);
+extern RwInt32 RpWorldRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack
+ readCB,
+ RwPluginDataChunkWriteCallBack
+ writeCB,
+ RwPluginDataChunkGetSizeCallBack
+ getSizeCB);
+extern RwInt32 RpWorldSetStreamAlwaysCallBack(
+ RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+extern RwInt32 RpWorldSetStreamRightsCallBack(RwUInt32 pluginID,
+ RwPluginDataChunkRightsCallBack rightsCB);
+extern RwInt32 RpWorldGetPluginOffset(RwUInt32 pluginID);
+extern RwBool RpWorldValidatePlugins(RpWorld * world);
+
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+/* Getting/setting */
+extern const RwBBox *RpWorldGetBBox(const RpWorld *world);
+extern const RwV3d *RpWorldGetOrigin(const RpWorld *world);
+
+/* Accessing a worlds materials */
+extern RwInt32 RpWorldGetNumMaterials(const RpWorld *world);
+extern RpMaterial *RpWorldGetMaterial(const RpWorld *world, RwInt32 matNum);
+
+/* Clumps */
+extern RwInt32 RpWorldGetNumClumps(RpWorld *world);
+
+/* Render order */
+extern RpWorld *RpWorldSetRenderOrder(RpWorld *world,
+ RpWorldRenderOrder renderOrder);
+extern RpWorldRenderOrder RpWorldGetRenderOrder(const RpWorld *world);
+
+/* Flags */
+extern RpWorld *RpWorldSetFlags(RpWorld *world, RwUInt32 flags);
+extern RwUInt32 RpWorldGetFlags(const RpWorld *world);
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define RpWorldSetSurfaceProperties(_world, _surface) \
+ _rpWorldSetSurfaceProperties(_world, _surface)
+
+#define RpWorldGetSurfaceProperties(_world) \
+ _rpWorldGetSurfaceProperties(_world)
+
+#define rpWorldFindBBox(_world, _boundingBox) \
+ _rpWorldFindBBox(_world, _boundingBox)
+
+#define rpWorldForAllGlobalLights(_callBack, _pData) \
+ _rpWorldForAllGlobalLights(_callBack, _pData)
+
+#define rpWorldSectorForAllLocalLights(_sector, _callBack, _pData) \
+ _rpWorldSectorForAllLocalLights(_sector, _callBack, _pData)
+
+#define _rpWorldLock(_world) \
+ RpWorldLock(_world)
+
+#define _rpWorldUnlock(_world) \
+ RpWorldUnlock(_world)
+
+#define rpWorldLock(_world) \
+ RpWorldLock(_world)
+
+#define rpWorldUnlock(_world) \
+ RpWorldUnlock(_world)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/D3D8pipe.h ---*/
+
+typedef struct RxD3D8ResEntryHeader RxD3D8ResEntryHeader;
+/**
+ * \ingroup rpworldd3d8
+ * \struct RxD3D8ResEntryHeader
+ * This structure contains D3D8 resource specific components.
+ */
+struct RxD3D8ResEntryHeader
+{
+ RwUInt16 serialNumber; /**< The mesh headers serial number */
+ RwUInt16 numMeshes; /**< The number of meshes */
+};
+
+/* This is what I keep in memory as part of the instance data setup */
+typedef struct RxD3D8InstanceData RxD3D8InstanceData;
+/**
+ * \ingroup rpworldd3d8
+ * \struct RxD3D8InstanceData
+ * This structure contains D3D8 resource specific components.
+ */
+struct RxD3D8InstanceData
+{
+ RwUInt32 minVert; /**< The vertex index where the
+ meshes vertices begin. Needed for
+ reinstancing, not for rendering */
+
+ RwInt32 stride; /**< Stride of vertex */
+
+ RwInt32 numVertices; /**< Number of vertices in the vertex buffer */
+ RwInt32 numIndices; /**< Number of indices to render the primitive */
+
+ RpMaterial *material; /**< The material for this instanced data */
+
+ RwUInt32 vertexShader; /**< Vertex shader or FVF flags */
+
+ RwUInt32 primType; /**< Primitive type */
+
+ void *indexBuffer; /**< Index buffer */
+ void *vertexBuffer; /**< Vertex buffer */
+
+ RwUInt32 baseIndex; /**< Needed if we share the vertex buffer */
+
+ RwUInt8 vertexAlpha; /**< The prelight data contains alpha */
+ RwUInt8 managed; /**< Created by the Vertex Buffer Manager */
+ RwUInt8 remapped; /**< Vertices where remapped to save VB space */
+};
+
+/**
+ * \ingroup rpworldd3d8
+ * \ref RxD3D8AllInOneInstanceCallBack callback function.
+ *
+ * \param object Pointer to the object.
+ * \param instancedData Pointer to \ref RxD3D8InstanceData.
+ * \param reinstance Boolean whether to reinstance.
+ *
+ * \see RxD3D8AllInOneSetInstanceCallBack
+ * \see RxD3D8AllInOneGetInstanceCallBack
+ * \see RxNodeDefinitionGetD3D8AtomicAllInOne
+ * \see RxNodeDefinitionGetD3D8WorldSectorAllInOne
+ */
+typedef RwBool (*RxD3D8AllInOneInstanceCallBack)(void *object,
+ RxD3D8InstanceData *instancedData,
+ RwBool reinstance);
+
+/**
+ * \ingroup rpworldd3d8
+ * \ref RxD3D8AllInOneReinstanceCallBack callback function.
+ *
+ * \param object Pointer to the object.
+ * \param meshHeader Const pointer to \ref RpMeshHeader.
+ * \param resEntry Pointer to \ref RxD3D8ResEntryHeader.
+ * \param instanceCallback Pointer to \ref RxD3D8AllInOneInstanceCallBack.
+ *
+ * \see RxD3D8AllInOneSetReinstanceCallBack
+ * \see RxD3D8AllInOneGetReinstanceCallBack
+ * \see RxNodeDefinitionGetD3D8AtomicAllInOne
+ * \see RxNodeDefinitionGetD3D8WorldSectorAllInOne
+ */
+typedef RwBool (*RxD3D8AllInOneReinstanceCallBack)(void *object,
+ RwResEntry *resEntry,
+ const RpMeshHeader *meshHeader,
+ RxD3D8AllInOneInstanceCallBack instanceCallback);
+
+/**
+ * \ingroup rpworldd3d8
+ * \ref RxD3D8AllInOneLightingCallBack callback function.
+ *
+ * \param object Void pointer to the object.
+ *
+ * \see RxD3D8AllInOneSetLightingCallBack
+ * \see RxD3D8AllInOneGetLightingCallBack
+ * \see RxNodeDefinitionGetD3D8AtomicAllInOne
+ * \see RxNodeDefinitionGetD3D8WorldSectorAllInOne
+ */
+typedef void (*RxD3D8AllInOneLightingCallBack)(void *object);
+
+/**
+ * \ingroup rpworldd3d8
+ * \ref RxD3D8AllInOneRenderCallBack callback function.
+ *
+ * \param repEntry Pointer to a resource entry.
+ * \param object Pointer to a object that the resource entry belongs to.
+ * \param type rpATOMIC or rwSECTORATOMIC.
+ * \param flags \ref RpGeometryFlag's or \ref RpWorldFlag's.
+ *
+ * \see RxD3D8AllInOneSetRenderCallBack
+ * \see RxD3D8AllInOneGetRenderCallBack
+ * \see RxNodeDefinitionGetD3D8AtomicAllInOne
+ * \see RxNodeDefinitionGetD3D8WorldSectorAllInOne
+ */
+typedef void (*RxD3D8AllInOneRenderCallBack)(RwResEntry *repEntry,
+ void *object,
+ RwUInt8 type,
+ RwUInt32 flags);
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+extern void
+RxD3D8AllInOneSetInstanceCallBack(RxPipelineNode *node,
+ RxD3D8AllInOneInstanceCallBack callback);
+
+extern RxD3D8AllInOneInstanceCallBack
+RxD3D8AllInOneGetInstanceCallBack(RxPipelineNode *node);
+
+extern void
+RxD3D8AllInOneSetReinstanceCallBack(RxPipelineNode *node,
+ RxD3D8AllInOneReinstanceCallBack callback);
+
+extern RxD3D8AllInOneReinstanceCallBack
+RxD3D8AllInOneGetReinstanceCallBack(RxPipelineNode *node);
+
+extern void
+RxD3D8AllInOneSetLightingCallBack(RxPipelineNode *node,
+ RxD3D8AllInOneLightingCallBack callback);
+
+extern RxD3D8AllInOneLightingCallBack
+RxD3D8AllInOneGetLightingCallBack(RxPipelineNode *node);
+
+extern void
+RxD3D8AllInOneSetRenderCallBack(RxPipelineNode *node,
+ RxD3D8AllInOneRenderCallBack callback);
+
+extern RxD3D8AllInOneRenderCallBack
+RxD3D8AllInOneGetRenderCallBack(RxPipelineNode *node);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/bapipew.h ---*/
+
+#define RpWorldGetGenericSectorPipelineMacro() \
+ (RXPIPELINEGLOBAL(genericWorldSectorPipeline))
+
+#define RpWorldGetDefaultSectorPipelineMacro() \
+ (RXPIPELINEGLOBAL(currentWorldSectorPipeline))
+
+#define RpWorldSetSectorPipelineMacro(_world, _pipeline) \
+ ( ((_world)->pipeline = _pipeline), _world )
+
+#define RpWorldGetSectorPipelineMacro(_world, _pipeline) \
+ ( (*(_pipeline) = (_world)->pipeline), _world )
+
+#define RpWorldSectorSetPipelineMacro(_sector, _pipeline) \
+ ( ((_sector)->pipeline = _pipeline), _sector )
+
+#define RpWorldSectorGetPipelineMacro(_sector, _pipeline) \
+ ( (*(_pipeline) = (_sector)->pipeline), _sector )
+
+#define RpAtomicGetGenericPipelineMacro() \
+ (RXPIPELINEGLOBAL(genericAtomicPipeline))
+
+#define RpAtomicGetDefaultPipelineMacro() \
+ (RXPIPELINEGLOBAL(currentAtomicPipeline))
+
+#define RpAtomicSetPipelineMacro(_atomic, _pipeline) \
+ ( ((_atomic)->pipeline = _pipeline), _atomic )
+
+#define RpAtomicGetPipelineMacro(_atomic, _pipeline) \
+ ( (*(_pipeline) = (_atomic)->pipeline), _atomic )
+
+#define RpMaterialGetGenericPipelineMacro() \
+ (RXPIPELINEGLOBAL(genericMaterialPipeline))
+
+#define RpMaterialGetDefaultPipelineMacro() \
+ (RXPIPELINEGLOBAL(currentMaterialPipeline))
+
+#define RpMaterialSetPipelineMacro(_material, _pipeline) \
+ ( ((_material)->pipeline = _pipeline), _material )
+
+#define RpMaterialGetPipelineMacro(_material, _pipeline) \
+ ( (*(_pipeline) = (_material)->pipeline), _material )
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RpWorldGetGenericSectorPipeline RpWorldGetGenericSectorPipelineMacro
+#define RpWorldGetDefaultSectorPipeline RpWorldGetDefaultSectorPipelineMacro
+#define RpWorldSetSectorPipeline RpWorldSetSectorPipelineMacro
+#define RpWorldGetSectorPipeline RpWorldGetSectorPipelineMacro
+#define RpWorldSectorSetPipeline RpWorldSectorSetPipelineMacro
+#define RpWorldSectorGetPipeline RpWorldSectorGetPipelineMacro
+
+#define RpAtomicGetGenericPipeline RpAtomicGetGenericPipelineMacro
+#define RpAtomicGetDefaultPipeline RpAtomicGetDefaultPipelineMacro
+#define RpAtomicSetPipeline RpAtomicSetPipelineMacro
+#define RpAtomicGetPipeline RpAtomicGetPipelineMacro
+
+#define RpMaterialGetGenericPipeline RpMaterialGetGenericPipelineMacro
+#define RpMaterialGetDefaultPipeline RpMaterialGetDefaultPipelineMacro
+#define RpMaterialSetPipeline RpMaterialSetPipelineMacro
+#define RpMaterialGetPipeline RpMaterialGetPipelineMacro
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxPipeline *RpWorldSetDefaultSectorPipeline(RxPipeline *pipeline);
+extern RxPipeline *RpAtomicSetDefaultPipeline(RxPipeline *pipeline);
+extern RxPipeline *RpMaterialSetDefaultPipeline(RxPipeline *pipeline);
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+extern RxPipeline *RpWorldGetGenericSectorPipeline(void);
+extern RxPipeline *RpWorldGetDefaultSectorPipeline(void);
+extern RpWorld *RpWorldSetSectorPipeline(RpWorld *world,
+ RxPipeline *pipeline);
+extern RpWorld *RpWorldGetSectorPipeline(RpWorld *world,
+ RxPipeline **pipeline);
+extern RpWorldSector *RpWorldSectorSetPipeline(RpWorldSector *sector,
+ RxPipeline *pipeline);
+extern RpWorldSector *RpWorldSectorGetPipeline(RpWorldSector *sector,
+ RxPipeline **pipeline);
+
+extern RxPipeline *RpAtomicGetGenericPipeline(void);
+extern RxPipeline *RpAtomicGetDefaultPipeline(void);
+extern RpAtomic *RpAtomicSetPipeline(RpAtomic *atomic,
+ RxPipeline *pipeline);
+extern const RpAtomic *RpAtomicGetPipeline(const RpAtomic *const atomic,
+ RxPipeline **pipeline);
+
+extern RxPipeline *RpMaterialGetGenericPipeline(void);
+extern RxPipeline *RpMaterialGetDefaultPipeline(void);
+extern RpMaterial *RpMaterialSetPipeline(RpMaterial *material,
+ RxPipeline *pipeline);
+extern RpMaterial *RpMaterialGetPipeline(RpMaterial *material,
+ RxPipeline **pipeline);
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+extern const RpGeometry *RpGeometryIsCorrectlySorted(const RpGeometry * geometry,
+ RwBool * result);
+extern RpGeometry *RpGeometrySortByMaterial(const RpGeometry * geometry,
+ RpGeometrySortByMaterialCallBack callback);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* LEGACY-SUPPORT macros */
+#define RpWorldGetGenericSectorInstancePipeline RpWorldGetGenericSectorPipeline
+#define RpWorldSetDefaultSectorInstancePipeline RpWorldSetDefaultSectorPipeline
+#define RpWorldGetDefaultSectorInstancePipeline RpWorldGetDefaultSectorPipeline
+#define RpWorldSetSectorInstancePipeline RpWorldSetSectorPipeline
+#define RpWorldGetSectorInstancePipeline RpWorldGetSectorPipeline
+#define RpWorldSectorSetInstancePipeline RpWorldSectorSetPipeline
+#define RpWorldSectorGetInstancePipeline RpWorldSectorGetPipeline
+
+#define RpAtomicGetGenericInstancePipeline RpAtomicGetGenericPipeline
+#define RpAtomicGetDefaultInstancePipeline RpAtomicGetDefaultPipeline
+#define RpAtomicSetDefaultInstancePipeline RpAtomicSetDefaultPipeline
+#define RpAtomicSetInstancePipeline RpAtomicSetPipeline
+#define RpAtomicGetInstancePipeline RpAtomicGetPipeline
+
+#define RpMaterialGetGenericRenderPipeline RpMaterialGetGenericPipeline
+#define RpMaterialSetDefaultRenderPipeline RpMaterialSetDefaultPipeline
+#define RpMaterialGetDefaultRenderPipeline RpMaterialGetDefaultPipeline
+#define RpMaterialSetRenderPipeline RpMaterialSetPipeline
+#define RpMaterialGetRenderPipeline RpMaterialGetPipeline
+
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/baworobj.h ---*/
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Adding and removing cameras to/from the world */
+extern RpWorld *RpWorldRemoveCamera(RpWorld *world, RwCamera *camera);
+extern RpWorld *RpWorldAddCamera(RpWorld *world, RwCamera *camera);
+extern RpWorld *RwCameraGetWorld(const RwCamera *camera);
+
+/* Adding and removing atomics to/from the world */
+extern RpWorld *RpWorldRemoveAtomic(RpWorld *world, RpAtomic *atomic);
+extern RpWorld *RpWorldAddAtomic(RpWorld *world, RpAtomic *atomic);
+extern RpWorld *RpAtomicGetWorld(const RpAtomic *atomic);
+
+/* Adding and removing clumps to/from the world */
+extern RpWorld *RpWorldAddClump(RpWorld *world, RpClump *clump);
+extern RpWorld *RpWorldRemoveClump(RpWorld *world, RpClump *clump);
+extern RpWorld *RpClumpGetWorld(const RpClump *clump);
+
+/* Adding and removing lights to/from the world */
+extern RpWorld *RpWorldAddLight(RpWorld *world, RpLight *light);
+extern RpWorld *RpWorldRemoveLight(RpWorld *world, RpLight *light);
+extern RpWorld *RpLightGetWorld(const RpLight *light);
+
+/* Finding whats in the view frustum */
+extern RwCamera *RwCameraForAllClumpsInFrustum(RwCamera *camera, void *data);
+extern RwCamera *RwCameraForAllClumpsNotInFrustum(RwCamera *camera,
+ RwInt32 numClumps, void *data);
+extern RwCamera *RwCameraForAllSectorsInFrustum(RwCamera *camera,
+ RpWorldSectorCallBack callBack,
+ void *pData);
+
+/* Enumeration involving the world sectors */
+extern RpLight *RpLightForAllWorldSectors(RpLight *light,
+ RpWorldSectorCallBack callback,
+ void *data);
+extern RpAtomic *RpAtomicForAllWorldSectors(RpAtomic *atomic,
+ RpWorldSectorCallBack callback,
+ void *data);
+extern RpWorldSector *RpWorldSectorForAllAtomics(RpWorldSector *sector,
+ RpAtomicCallBack callback,
+ void *data);
+extern RpWorldSector *RpWorldSectorForAllCollisionAtomics(RpWorldSector *sector,
+ RpAtomicCallBack callback,
+ void *data);
+extern RpWorldSector *RpWorldSectorForAllLights(RpWorldSector *sector,
+ RpLightCallBack callback,
+ void *data);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: c:/daily/rwsdk/world/babinwor.h ---*/
+/****************************************************************************
+ Global types
+ */
+
+/* Binary Representation
+ *
+ */
+typedef struct RpWorldChunkInfoSector RpWorldSectorChunkInfo;
+typedef struct RpWorldChunkInfoSector _rpWorldSector;
+
+struct RpWorldChunkInfoSector
+{
+ RwInt32 matListWindowBase;
+ RwInt32 numPolygons;
+ RwInt32 numVertices;
+ RwV3d inf;
+ RwV3d sup;
+ RwBool collSectorPresent;
+ RwBool unused;
+};
+
+typedef struct RpPlaneSectorChunkInfo RpPlaneSectorChunkInfo;
+typedef struct RpPlaneSectorChunkInfo _rpPlaneSector;
+
+struct RpPlaneSectorChunkInfo
+{
+ RwInt32 type;
+ RwReal value;
+ RwBool leftIsWorldSector;
+ RwBool rightIsWorldSector;
+ RwReal leftValue;
+ RwReal rightValue;
+};
+
+typedef struct RpWorldChunkInfo RpWorldChunkInfo;
+typedef struct RpWorldChunkInfo _rpWorld;
+
+struct RpWorldChunkInfo
+{
+ RwBool rootIsWorldSector;
+
+ RwV3d invWorldOrigin;
+
+ RwSurfaceProperties surfaceProps;
+
+ RwInt32 numPolygons;
+ RwInt32 numVertices;
+ RwInt32 numPlaneSectors;
+ RwInt32 numWorldSectors;
+ RwInt32 colSectorSize;
+
+ RwInt32 format; /* Flags about the world */
+};
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Binary format */
+extern RwUInt32 RpWorldStreamGetSize(const RpWorld *world);
+extern RpWorld *RpWorldStreamRead(RwStream *stream);
+extern const RpWorld *RpWorldStreamWrite(const RpWorld *world,
+ RwStream *stream);
+extern RpWorldSectorChunkInfo *
+_rpWorldSectorChunkInfoRead(RwStream *stream,
+ RpWorldSectorChunkInfo *worldSectorChunkInfo,
+ RwInt32 *bytesRead);
+extern RpPlaneSectorChunkInfo *
+_rpPlaneSectorChunkInfoRead(RwStream *stream,
+ RpPlaneSectorChunkInfo *planeSectorChunkInfo,
+ RwInt32 *bytesRead);
+extern RpWorldChunkInfo *
+_rpWorldChunkInfoRead(RwStream *stream,
+ RpWorldChunkInfo *worldChunkInfo,
+ RwInt32 *bytesRead);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define RpWorldSectorChunkInfoRead(stream, worldSectorChunkInfo, bytesRead) \
+ _rpWorldSectorChunkInfoRead(stream, worldSectorChunkInfo, bytesRead)
+
+#define RpPlaneSectorChunkInfoRead(stream, planeSectorChunkInfo, bytesRead) \
+ _rpPlaneSectorChunkInfoRead(stream, planeSectorChunkInfo, bytesRead)
+
+#define RpWorldChunkInfoRead(stream, worldChunkInfo, bytesRead) \
+ _rpWorldChunkInfoRead(stream, worldChunkInfo, bytesRead)
+
+#endif /* RPWORLD_H */
diff --git a/rwsdk/include/d3d8/rpworld.rpe b/rwsdk/include/d3d8/rpworld.rpe
new file mode 100644
index 00000000..080eefa5
--- /dev/null
+++ b/rwsdk/include/d3d8/rpworld.rpe
@@ -0,0 +1,63 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionWorld
+{
+
+
+E_RP_WORLD_INVSPHERE,
+
+E_RP_WORLD_INVINTERSECTION,
+
+E_RP_WORLD_MATRANGE,
+
+E_RP_WORLD_CLUMPINWORLD,
+
+E_RP_WORLD_CLUMPNOTINWORLD,
+
+E_RP_WORLD_ATOMICNOFRAME,
+
+E_RP_WORLD_TOOMANYVERTICES,
+
+ e_rwdb_CriterionWorldLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionWorld e_rwdb_CriterionWorld;
+
+
diff --git a/rwsdk/include/d3d8/rt2d.h b/rwsdk/include/d3d8/rt2d.h
new file mode 100644
index 00000000..5bf1faea
--- /dev/null
+++ b/rwsdk/include/d3d8/rt2d.h
@@ -0,0 +1,911 @@
+/*
+ * Data structures for 2d toolkit
+ *
+ * Copyright (c) Criterion Software Limited
+ */
+
+/***************************************************************************
+ * *
+ * Module : rt2d.h *
+ * *
+ * Purpose : *
+ * *
+ **************************************************************************/
+
+#ifndef RT2D_H
+#define RT2D_H
+
+/**
+ * \defgroup rt2d Rt2d
+ * \ingroup rttool
+ *
+ * 2D Rendering Toolkit for RenderWare.
+ */
+
+/**
+ * \defgroup rt2ddatatypes Data Types
+ * \ingroup rt2d
+ *
+ * Basic Data Types
+ */
+
+/**
+ * \defgroup rt2dsub Rt2d
+ * \ingroup rt2d
+ *
+ * Rt2d functions
+ */
+
+/**
+ * \defgroup rt2dbrush Rt2dBrush
+ * \ingroup rt2d
+ *
+ * Brush functions
+ */
+
+/**
+ * \defgroup rt2dctm Rt2dCTM
+ * \ingroup rt2d
+ *
+ * Current Transformation Matrix (CTM)
+ */
+
+/**
+ * \defgroup rt2ddevice Rt2dDevice
+ * \ingroup rt2d
+ *
+ * Camera device functions
+ */
+
+/**
+ * \defgroup rt2dfont Rt2dFont
+ * \ingroup rt2d
+ *
+ * Font functions
+ */
+
+/**
+ * \defgroup rt2dobject Rt2dObject
+ * \ingroup rt2d
+ *
+ * Objects
+ */
+
+/**
+ * \defgroup rt2dobjectstring Rt2dObjectString
+ * \ingroup rt2d
+ *
+ * String functions
+ */
+
+/**
+ * \defgroup rt2dpath Rt2dPath
+ * \ingroup rt2d
+ *
+ * Path functions
+ */
+
+/**
+ * \defgroup rt2dpickregion Rt2dPickRegion
+ * \ingroup rt2d
+ *
+ * Pick regions
+ */
+
+/**
+ * \defgroup rt2dscene Rt2dScene
+ * \ingroup rt2d
+ *
+ * Scenes
+ */
+
+/**
+ * \defgroup rt2dshape Rt2dShape
+ * \ingroup rt2d
+ *
+ * Shapes
+ */
+
+/**
+ * \defgroup rt2drwv2d RwV2d
+ * \ingroup rt2d
+ *
+ * Rt2d plugin directly extends the Core Library's RwV2d API functions.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include "rt2d.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Defines
+ */
+
+#define Rt2dBrushSetWidthMacro(_brush, _width) \
+ ( ( (_brush)->halfwidth = ((_width) * 0.5f) ), (_brush) )
+
+#define Rt2dBrushGetWidthMacro(_brush) \
+ ( (_brush)->halfwidth * 2.0f )
+
+#define Rt2dCTMReadMacro(_result) \
+ (RwMatrixCopy((_result), _rt2dCTMGet()), (_result))
+
+/****************************************************************************
+ Global Types
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/*
+ * rt2dShadeParameters
+ * typedef for a structure describing Shade Parameters
+ */
+typedef struct rt2dShadeParameters rt2dShadeParameters;
+
+/*
+ *
+ * rt2dShadeParameters
+ * describes Shade Parameters
+ */
+struct rt2dShadeParameters
+{
+ RwRGBAReal col; /* col */
+ RwV2d uv; /* uv */
+};
+
+/**
+ * \ingroup rt2ddatatypes
+ * \typedef Rt2dBrush
+ * typedef for a structure describing a Brush (opaque)
+ */
+typedef struct Rt2dBrush Rt2dBrush;
+
+/*
+ * Rt2dBrush
+ * structure describing a Brush
+ */
+#if defined (GCN_DRVMODEL_H)
+ #define VERTEXCACHESIZE 64
+#else
+ #define VERTEXCACHESIZE 256
+#endif
+
+struct Rt2dBrush
+{
+ RWIM3DVERTEX vertex[VERTEXCACHESIZE];
+ rt2dShadeParameters top;
+ rt2dShadeParameters dtop;
+ rt2dShadeParameters bottom;
+ rt2dShadeParameters dbottom;
+ RwInt32 calcFields;
+ RwTexture *texture;
+ RwReal halfwidth;
+};
+
+/**
+ * \ingroup rt2ddatatypes
+ * \typedef Rt2dPath
+ * typedef for a structure describing a Path (opaque)
+ */
+typedef struct Rt2dPath Rt2dPath;
+
+/**
+ * \ingroup rt2ddatatypes
+ * \typedef Rt2dFont
+ * typedef for a structure describing a Font (opaque)
+ */
+typedef struct Rt2dFont Rt2dFont;
+
+/*
+ * typedef used for referencing a spot in a font dictionary
+ */
+typedef struct _rt2dFontDictionaryNode _rt2dFontDictionaryNode;
+
+/**
+ * \ingroup rt2ddatatypes
+ * \typedef Rt2dBBox
+ * typedef for a structure describing a Bounding Box
+ */
+
+typedef struct Rt2dBBox Rt2dBBox;
+/**
+* \ingroup rt2ddatatypes
+ * \struct Rt2dBBox
+ * structure describing a Bounding Box
+ */
+struct Rt2dBBox
+{
+ RwReal x; /**< x-coordinate of lower-left corner */
+ RwReal y; /**< y-coordinate of lower-left corner */
+ RwReal w; /**< Width */
+ RwReal h; /**< Height */
+};
+
+/**
+ * \ingroup rt2ddatatypes
+ * \typedef Rt2dObject
+ * typedef for a structure describing a 2d Object
+ * This should be considered an opaque type.
+ * Use Rt2dObject, Rt2dScene, Rt2dShape, Rt2dPickRegion or Rt2dObjectString
+ * API functions to access.
+ */
+typedef struct Rt2dObject Rt2dObject;
+
+/*
+ * typedef for a structure describing a scene of shapes (opaque)
+ */
+typedef struct _rt2dScene _rt2dScene;
+
+/*
+ * typedef for a structure describing the depth of an object
+ */
+typedef struct _rt2dDepthOfObject _rt2dDepthOfObject;
+
+/*
+ * typedef for a structure describing the depth of an object
+ */
+struct _rt2dDepthOfObject
+{
+ Rt2dObject *object;
+ RwInt32 depth;
+};
+
+/*
+ * structure describing a scene of shapes
+ */
+struct _rt2dScene
+{
+ RwSList *objects; /* collection of objects in scene */
+ RwInt32 objectCount; /* number of objects */
+ RwSList *depths; /* depths for depthsort */
+ RwBool isDirtyDepths; /* depthsort needs updating */
+};
+
+/*
+ * typedef for a structure describing a shape (opaque)
+ */
+typedef struct _rt2dShape _rt2dShape;
+
+struct _rt2dShape
+{
+ RwSList *nodes; /* individual stroked/filled regions of the shape */
+};
+
+/*
+ * typedef for a structure describing a pick region that can be tested for point inclusion (opaque)
+ */
+typedef struct _rt2dPickRegion _rt2dPickRegion;
+
+/*
+ * structure describing a pick region that can be tested for point inclusion
+ */
+struct _rt2dPickRegion
+{
+ Rt2dPath *path; /* path that defines region for testing */
+ Rt2dBBox bbox; /* bounding box of path */
+ RwMatrix transformation;
+ /* ivnert transformation used to place the pick region */
+};
+
+/*
+ * structure describing a renderable text string
+ */
+struct _rt2dObjectString
+{
+ RwChar *textString; /* Text string to be rendered */
+ Rt2dBrush *brush; /* Brush to be used to draw text */
+ RwInt32 maxLength; /* Maximum string length before reallocation, excluding null */
+ RwReal height; /* Font rendering Height */
+ _rt2dFontDictionaryNode *font; /* Dictionary node identifying font to be used */
+};
+
+/*
+ * typedef for a renderable string
+ */
+typedef struct _rt2dObjectString _rt2dObjectString;
+/**
+ * \ingroup rt2ddatatypes
+ * \ref Rt2dObjectTypeEnum
+ * enumeration describing types of Rt2dObject
+ */
+enum Rt2dObjectTypeEnum {
+ rt2DOBJECTTYPEOBJECT=0, /**<An untyped (yet) object */
+ rt2DOBJECTTYPESCENE, /**<Container of objects */
+ rt2DOBJECTTYPESHAPE, /**<Shape object */
+ rt2DOBJECTTYPEPICKREGION, /**<Pick region object */
+ rt2DOBJECTTYPEOBJECTSTRING, /**<Text string object */
+ rt2DOBJECTTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT /* Ensures sizeof(enum) == sizeof(RwInt32)) */
+};
+
+typedef union _rt2dObjectdata _rt2dObjectdata;
+
+union _rt2dObjectdata
+{
+ _rt2dShape shape;
+ _rt2dScene scene;
+ _rt2dPickRegion pickRegion;
+ _rt2dObjectString objectString;
+};
+
+/*
+ * A base structure for forming a hierarchy of 2D shapes
+ */
+#if (!defined(DOXYGEN))
+
+#define Rt2dObjectIsLocked 0x00000001
+#define Rt2dObjectDirtyLTM 0x00000002
+#define Rt2dObjectVisible 0x00000004
+
+struct Rt2dObject
+{
+ RwInt32 type; /* tag identifying type of object */
+ RwInt32 depth; /* z-order of object under parent */
+ RwInt32 flag; /* ... */
+ RwMatrix MTM; /* local transformation matrix for object */
+ RwMatrix LTM; /* global transformation matrix for object */
+ RwRGBAReal colorMult; /* color multiply applied to object */
+ RwRGBAReal colorOffs; /* color offset applied to object */
+ _rt2dObjectdata data;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+
+/**
+ * \ingroup rt2ddatatypes
+ * \typedef Rt2dObjectCallBack
+ * typedef for a callback on an object
+ */
+typedef Rt2dObject *(* Rt2dObjectCallBack)(Rt2dObject *object, Rt2dObject *parent, void *data);
+
+/**
+ * \ingroup rt2ddatatypes
+ * \ref Rt2dJustificationType
+ * enumeration describing Justification
+ */
+enum Rt2dJustificationType
+{
+ rt2dJUSTIFYLEFT, /**<Left-justification */
+ rt2dJUSTIFYCENTER, /**<Center-justification */
+ rt2dJUSTIFYRIGHT, /**<Right-justification */
+ rt2DJUSTIFICATIONTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT /* Ensures sizeof(enum) == sizeof(RwInt32)) */
+};
+
+/*
+ * Rt2dObjectEnum
+ * typedef for a enumeration describing an object type enclosed by Rt2dObject
+ */
+typedef enum Rt2dJustificationType Rt2dJustificationType;
+
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+
+#define Rt2dBrushSetWidth(_brush, _width) \
+ Rt2dBrushSetWidthMacro(_brush, _width)
+
+#define Rt2dBrushGetWidth(_brush) \
+ Rt2dBrushGetWidthMacro(_brush)
+
+#define Rt2dCTMRead(_result) \
+ Rt2dCTMReadMacro(_result)
+
+#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+
+/*
+ * INITIALIZE
+ */
+extern void
+Rt2dOpen(RwCamera *cam);
+
+extern void
+Rt2dClose(void);
+/*
+ * PATHS
+ */
+extern Rt2dPath *
+Rt2dPathCreate(void);
+
+extern RwBool
+Rt2dPathDestroy(Rt2dPath *path);
+
+extern Rt2dPath *
+Rt2dPathLock(Rt2dPath *path);
+
+extern Rt2dPath *
+Rt2dPathUnlock(Rt2dPath *path);
+
+extern RwBool
+Rt2dPathIsLocked(Rt2dPath *path);
+
+extern RwUInt32
+Rt2dPathStreamGetSize(Rt2dPath *path);
+
+extern Rt2dPath *
+Rt2dPathStreamWrite(Rt2dPath *path, RwStream *stream);
+
+extern Rt2dPath *
+Rt2dPathStreamRead(RwStream *stream);
+
+extern Rt2dPath *
+Rt2dPathEmpty(Rt2dPath *path);
+
+extern Rt2dPath *
+Rt2dPathCopy(Rt2dPath *dst, const Rt2dPath *src);
+
+extern Rt2dPath *
+Rt2dPathInset(Rt2dPath *path, RwReal inset);
+
+extern Rt2dPath *
+Rt2dPathMoveto(Rt2dPath *path, RwReal x, RwReal y);
+
+extern Rt2dPath *
+Rt2dPathLineto(Rt2dPath *path, RwReal x, RwReal y);
+
+extern Rt2dPath *
+Rt2dPathRLineto(Rt2dPath *path, RwReal x, RwReal y);
+
+extern Rt2dPath *
+Rt2dPathCurveto(Rt2dPath *path, RwReal x1, RwReal y1, RwReal x2, RwReal y2, RwReal x3, RwReal y3);
+
+extern Rt2dPath *
+Rt2dPathRCurveto(Rt2dPath *path, RwReal x1, RwReal y1, RwReal x2, RwReal y2, RwReal x3, RwReal y3);
+
+extern Rt2dPath *
+Rt2dPathClose(Rt2dPath *path);
+
+extern Rt2dPath *
+Rt2dPathRect(Rt2dPath *path, RwReal x, RwReal y, RwReal w, RwReal h);
+
+extern Rt2dPath *
+Rt2dPathRoundRect(Rt2dPath *path, RwReal x, RwReal y, RwReal w, RwReal h, RwReal radius);
+
+extern Rt2dPath *
+Rt2dPathOval(Rt2dPath *path, RwReal x, RwReal y, RwReal w, RwReal h);
+
+extern Rt2dPath *
+Rt2dPathFlatten(Rt2dPath *path);
+
+extern const Rt2dPath *
+Rt2dPathGetBBox(const Rt2dPath *path, Rt2dBBox *bbox);
+
+extern Rt2dPath *
+Rt2dPathCreateMorphResultPath(Rt2dPath *path);
+
+extern Rt2dPath *
+Rt2dPathMorph(Rt2dPath *result, Rt2dPath *source, Rt2dPath *destination, RwReal alpha);
+
+/*
+ * BRUSHES
+ */
+extern Rt2dBrush *
+Rt2dBrushCreate(void);
+
+extern RwBool
+Rt2dBrushDestroy(Rt2dBrush * brush);
+
+extern Rt2dBrush *
+Rt2dBrushSetRGBA(Rt2dBrush *brush, RwRGBA * col0, RwRGBA * col1, RwRGBA * col2, RwRGBA * col3);
+
+extern Rt2dBrush *
+Rt2dBrushSetUV(Rt2dBrush *brush, RwV2d *uv0, RwV2d *uv1, RwV2d *uv2, RwV2d *uv3);
+
+extern Rt2dBrush *
+Rt2dBrushSetTexture(Rt2dBrush* brush, RwTexture* texture);
+
+extern RwUInt32
+Rt2dBrushStreamGetSize(Rt2dBrush *brush);
+
+extern Rt2dBrush *
+Rt2dBrushStreamWrite(Rt2dBrush *brush, RwStream *stream);
+
+extern Rt2dBrush *
+Rt2dBrushStreamRead(RwStream *stream);
+
+/*
+ * FONTS
+ */
+extern const RwChar *
+Rt2dFontSetPath(const RwChar *path);
+
+extern Rt2dFont *
+Rt2dFontRead(const RwChar *name);
+
+extern RwUInt32
+_rt2dFontStreamGetSize(Rt2dFont *font);
+
+extern Rt2dFont *
+_rt2dFontStreamWrite(Rt2dFont *font, RwStream *stream);
+
+extern Rt2dFont *
+_rt2dFontStreamRead(RwStream *stream);
+
+extern RwBool
+Rt2dFontDestroy(Rt2dFont *font);
+
+extern RwReal
+Rt2dFontGetHeight(Rt2dFont *font);
+
+extern RwReal
+Rt2dFontGetStringWidth(Rt2dFont *font, const RwChar *string, RwReal height);
+
+extern Rt2dFont *
+Rt2dFontShow(Rt2dFont *font, const RwChar *string, RwReal height, RwV2d *anchor, Rt2dBrush *brush);
+
+extern Rt2dFont *
+Rt2dFontFlow(Rt2dFont* font, RwChar* string, RwReal height, Rt2dBBox* bbox, Rt2dJustificationType format, Rt2dBrush* brush);
+
+extern Rt2dFont *
+Rt2dFontSetIntergapSpacing(Rt2dFont *font, RwReal gap);
+
+
+extern RwBool
+Rt2dFontCacheFlush(void);
+
+
+/*
+ * FILLING
+ */
+extern Rt2dPath *
+Rt2dPathFill(Rt2dPath *path, Rt2dBrush *brush);
+/*
+ * STROKING
+ */
+extern Rt2dPath *
+Rt2dPathStroke(Rt2dPath *path, Rt2dBrush *brush);
+
+/*
+ * TRANSFORMS
+ */
+extern RwBool
+Rt2dCTMPush(void);
+
+extern RwBool
+Rt2dCTMPop(void);
+
+extern RwBool
+Rt2dCTMSetIdentity(void);
+
+extern RwBool
+Rt2dCTMScale(RwReal x, RwReal y);
+
+extern RwBool
+Rt2dCTMTranslate(RwReal x, RwReal y);
+
+extern RwBool
+Rt2dCTMRotate(RwReal theta);
+
+extern RwBool
+RwV2dIsInPath(RwV2d *point, Rt2dPath *path);
+
+extern RwV2d *
+RwV2dInvertTransform(RwV2d *pointOut, RwV2d *pointIn);
+
+
+/*
+ * DEVICE SETTINGS
+ */
+extern RwBool
+Rt2dDeviceSetCamera(RwCamera *cam);
+
+extern RwCamera *
+Rt2dDeviceGetCamera(void);
+
+extern RwBool
+Rt2dDeviceGetStep(RwV2d *xstep, RwV2d *ystep, RwV2d *origin);
+
+extern RwBool
+Rt2dDeviceSetMetric(RwReal x, RwReal y, RwReal w, RwReal h);
+
+extern RwBool
+Rt2dDeviceGetMetric(RwReal *x, RwReal *y, RwReal *w, RwReal *h);
+
+extern RwBool
+Rt2dDeviceSetFlat(RwReal r);
+
+extern RwBool
+Rt2dDeviceGetClippath(Rt2dPath *path);
+
+extern RwBool
+Rt2dVisible(RwReal x, RwReal y, RwReal w, RwReal h);
+
+extern RwBool
+Rt2dDeviceSetLayerDepth(RwReal depth);
+
+extern RwBool
+Rt2dSetPipelineFlags(RwUInt32 flags);
+
+/*
+ * HIERARCHICAL SCENE FUNCTIONS - OBJECT MANIPULATION
+ */
+
+extern Rt2dObject *
+Rt2dObjectSetVisible(Rt2dObject *object,RwBool visible);
+
+extern RwBool
+Rt2dObjectIsVisible(Rt2dObject *object);
+
+extern void
+Rt2dObjectMTMChanged(Rt2dObject *object);
+
+extern RwMatrix *
+Rt2dObjectGetLTM(Rt2dObject *object);
+
+extern RwMatrix *
+Rt2dObjectGetMTM(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dObjectSetMTM(Rt2dObject *object, RwMatrix *mtm);
+
+extern void
+Rt2dObjectApplyCTM(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dObjectMTMSetIdentity(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dObjectMTMScale(Rt2dObject *object, RwReal x, RwReal y);
+
+extern Rt2dObject *
+Rt2dObjectMTMTranslate(Rt2dObject *object, RwReal x, RwReal y);
+
+extern Rt2dObject *
+Rt2dObjectMTMRotate(Rt2dObject *object, RwReal theta);
+
+extern RwRGBAReal *
+Rt2dObjectGetColorMultiplier(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dObjectSetColorMultiplier(Rt2dObject *object, RwRGBAReal *multCol);
+
+extern RwRGBAReal *
+Rt2dObjectGetColorOffset(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dObjectSetColorOffset(Rt2dObject *object, RwRGBAReal *oofsCol);
+
+extern RwInt32
+Rt2dObjectGetObjectType(Rt2dObject *object);
+
+extern RwInt32
+Rt2dObjectGetDepth(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dObjectSetDepth(Rt2dObject *object, RwInt32 depth);
+
+extern RwBool
+Rt2dObjectIsScene(Rt2dObject *object);
+
+extern RwBool
+Rt2dObjectIsShape(Rt2dObject *object);
+
+extern RwBool
+Rt2dObjectIsPickRegion(Rt2dObject *object);
+
+extern RwBool
+Rt2dObjectIsObjectString(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dObjectCopy(Rt2dObject *dst, Rt2dObject *src);
+
+/*
+ * HIERARCHICAL SCENE FUNCTIONS - SCENE
+ */
+extern Rt2dObject *
+Rt2dSceneCreate(void);
+
+extern RwBool
+Rt2dSceneDestroy(Rt2dObject *scene);
+
+extern Rt2dObject *
+Rt2dSceneLock(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dSceneUnlock(Rt2dObject *object);
+
+extern RwInt32
+Rt2dSceneGetChildCount(Rt2dObject *scene);
+
+extern Rt2dObject *
+Rt2dSceneGetChildByIndex(Rt2dObject *scene, RwInt32 index);
+
+extern RwV2d
+Rt2dSceneGetCoordFromScreen(Rt2dObject *scene,RwV2d screenCoord );
+
+extern Rt2dObject *
+Rt2dSceneAddChild(Rt2dObject *scene, Rt2dObject *object);
+
+/* Those are keeped for compatiblity with the present code */
+extern Rt2dObject *
+Rt2dSceneGetNewChildScene(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dSceneGetNewChildShape(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dSceneGetNewChildPickRegion(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dSceneGetNewChildObjectString(Rt2dObject *object, const RwChar *text,
+ const RwChar *font);
+
+extern Rt2dObject *
+Rt2dSceneStreamWrite(Rt2dObject *shape, RwStream *stream);
+
+extern RwUInt32
+Rt2dSceneStreamGetSize(Rt2dObject *scene);
+
+extern Rt2dObject *
+Rt2dSceneStreamRead(RwStream *stream);
+
+extern Rt2dObject *
+Rt2dSceneRender(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dSceneForAllChildren(Rt2dObject *scene, Rt2dObjectCallBack callback, void *pData );
+
+extern Rt2dObject *
+Rt2dSceneSetDepthDirty(Rt2dObject *scene);
+
+extern Rt2dObject *
+Rt2dSceneUpdateLTM(Rt2dObject *scene);
+
+/*
+ * HIERARCHICAL SCENE FUNCTIONS - SHAPE
+ */
+extern Rt2dObject *
+Rt2dShapeCreate(void);
+
+extern RwBool
+Rt2dShapeDestroy(Rt2dObject * shape);
+
+extern Rt2dBrush *
+Rt2dShapeGetNewBrush(Rt2dObject *shape);
+
+extern Rt2dPath *
+Rt2dShapeGetNewPath(Rt2dObject *shape);
+
+extern Rt2dObject *
+Rt2dShapeAddNode(Rt2dObject *shape, Rt2dPath *path, Rt2dBrush *fill, Rt2dBrush *stroke );
+
+extern RwInt32
+Rt2dShapeGetNodeCount(Rt2dObject *shape);
+
+extern Rt2dObject *
+Rt2dShapeStreamWrite(Rt2dObject *shape, RwStream *stream);
+
+extern RwUInt32
+Rt2dShapeStreamGetSize(Rt2dObject *shape);
+
+extern Rt2dObject *
+Rt2dShapeStreamRead(RwStream *stream);
+
+extern Rt2dObject *
+Rt2dShapeRender(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dShapeMorph(Rt2dObject *result,
+ Rt2dObject *source,
+ Rt2dObject *destination,
+ RwReal alpha);
+
+/*
+ * HIERARCHICAL SCENE FUNCTIONS - PICK REGION
+ */
+extern Rt2dObject *
+Rt2dPickRegionCreate(void);
+
+extern RwBool
+Rt2dPickRegionDestroy(Rt2dObject *pickRegion);
+
+extern Rt2dPath *
+Rt2dPickRegionGetPath(Rt2dObject *pickRegion);
+
+extern RwBool
+Rt2dPickRegionIsPointIn(Rt2dObject *pickRegion, RwV2d *point);
+
+extern Rt2dObject *
+Rt2dPickRegionStreamWrite(Rt2dObject *pickRegion, RwStream *stream);
+
+extern RwUInt32
+Rt2dPickRegionStreamGetSize(Rt2dObject *pickRegion);
+
+extern Rt2dObject *
+Rt2dPickRegionStreamRead(RwStream *stream);
+
+/*
+ * HIERARCHICAL SCENE FUNCTIONS - TEXT STRINGS
+ */
+extern Rt2dObject *
+Rt2dObjectStringCreate(const RwChar *textString, const RwChar *font);
+
+extern RwBool
+Rt2dObjectStringDestroy(Rt2dObject *object);
+
+extern Rt2dBrush *
+Rt2dObjectStringGetBrush(Rt2dObject *object);
+
+extern RwChar *
+Rt2dObjectStringGetText(Rt2dObject *object);
+
+extern RwChar *
+Rt2dObjectStringGetFont(Rt2dObject *object);
+
+extern RwReal
+Rt2dObjectStringGetHeight(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dObjectStringSetBrush(Rt2dObject *object, Rt2dBrush *);
+
+extern Rt2dObject *
+Rt2dObjectStringSetText(Rt2dObject *object, const RwChar *text);
+
+extern Rt2dObject *
+Rt2dObjectStringSetFont(Rt2dObject *object, const RwChar *font);
+
+extern Rt2dObject *
+Rt2dObjectStringSetHeight(Rt2dObject *object, const RwReal height);
+
+extern Rt2dObject *
+Rt2dObjectStringStreamRead(RwStream *stream);
+
+extern Rt2dObject *
+Rt2dObjectStringStreamWrite(Rt2dObject *object, RwStream *stream);
+
+extern RwUInt32
+Rt2dObjectStringStreamGetSize(Rt2dObject *object);
+
+extern Rt2dObject *
+Rt2dObjectStringRender(Rt2dObject *object);
+
+
+/*
+ * SPI for macros
+ */
+
+extern RwBool
+_rt2dCTMPush(RwMatrix *matrix);
+
+extern RwBool
+_rt2dCTMSet(RwMatrix *matrix);
+
+extern RwMatrix *
+_rt2dCTMGet(void);
+
+extern RwMatrix *
+_rt2dCTMGetDirect(void);
+
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+
+extern Rt2dBrush *
+Rt2dBrushSetWidth(Rt2dBrush *brush, RwReal width);
+extern RwReal
+Rt2dBrushGetWidth(Rt2dBrush * brush);
+
+extern RwMatrix *
+Rt2dCTMRead(RwMatrix * result);
+
+#endif /* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define Rt2dFontStreamGetSize(_font) \
+ _rt2dFontStreamGetSize(_font)
+
+#define Rt2dFontStreamWrite(_font,_stream) \
+ _rt2dFontStreamWrite(_font,_stream)
+
+#define Rt2dFontStreamRead(_stream) \
+ _rt2dFontStreamRead(_stream)
+
+#endif /* RT2D_H */
diff --git a/rwsdk/include/d3d8/rt2d.rpe b/rwsdk/include/d3d8/rt2d.rpe
new file mode 100644
index 00000000..1f9f8881
--- /dev/null
+++ b/rwsdk/include/d3d8/rt2d.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_Criterion2D
+{
+
+
+
+ e_rwdb_Criterion2DLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_Criterion2D e_rwdb_Criterion2D;
+
+
diff --git a/rwsdk/include/d3d8/rt2danim.h b/rwsdk/include/d3d8/rt2danim.h
new file mode 100644
index 00000000..cd593a8e
--- /dev/null
+++ b/rwsdk/include/d3d8/rt2danim.h
@@ -0,0 +1,1056 @@
+/***************************************************************************
+ * *
+ * Module : rt2danim.h *
+ * *
+ * Purpose : . *
+ * *
+ **************************************************************************/
+
+#ifndef RT2DANIM_H
+#define RT2DANIM_H
+
+/**
+ * \defgroup rt2danim Rt2dAnim
+ * \ingroup rttool
+ *
+ * A toolkit to coordinate the display, storage and manipulation of 2D
+ * animations.
+ */
+
+/**
+ * \defgroup rt2danimsub Rt2dAnim
+ * \ingroup rt2danim
+ *
+ * Animation functions
+ */
+
+/**
+ * \defgroup rt2dmaestro Rt2dMaestro
+ * \ingroup rt2danim
+ *
+ * Maestro functions
+ */
+
+/**
+ * \defgroup rt2dstringlabel Rt2dStringLabel
+ * \ingroup rt2danim
+ *
+ * String labels
+ */
+
+/**
+ * \defgroup rt2dmessage Rt2dMessage
+ * \ingroup rt2danim
+ *
+ * Messages
+ */
+
+/**
+ * \defgroup rt2dbutton Rt2dButton
+ * \ingroup rt2danim
+ *
+ * Buttons
+ */
+
+/**
+ * \defgroup rt2dcel Rt2dCel
+ * \ingroup rt2danim
+ *
+ * Cels
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include <rwcore.h>
+#include "rt2danim.rpe" /* automatically generated header file */
+#include "rt2d.h"
+#include "rpcriter.h"
+/****************************************************************************
+ Defines
+ */
+
+/****************************************************************************
+ Global Types
+ */
+
+/* RWPUBLIC */
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+#define RT2D_BUTTON_MAX_STATES 4
+#define RT2D_BUTTON_MAX_STATE_TRANSITIONS 32
+
+/* Button state flags. */
+
+#define rt2dANIMBUTTONSTATEPICKREGION 0x0001
+#define rt2dANIMBUTTONSTATEUP 0x0002
+#define rt2dANIMBUTTONSTATEDOWN 0x0004
+#define rt2dANIMBUTTONSTATEOVER 0x0008
+
+#define rt2dANIMBUTTONSTATEIDLETOOVERUP 0x0010
+#define rt2dANIMBUTTONSTATEOVERUPTOIDLE 0x0020
+#define rt2dANIMBUTTONSTATEOVERUPTOOVERDOWN 0x0040
+#define rt2dANIMBUTTONSTATEOVERDOWNTOOVERUP 0x0080
+#define rt2dANIMBUTTONSTATEOVERDOWNTOOUTDOWN 0x0100
+#define rt2dANIMBUTTONSTATEOUTDOWNTOOVERDOWN 0x0200
+#define rt2dANIMBUTTONSTATEOUTDOWNTOIDLE 0x0400
+#define rt2dANIMBUTTONSTATEIDLETOOVERDOWN 0x0800
+#define rt2dANIMBUTTONSTATEOVERDOWNTOIDLE 0x1000
+
+
+/* Mask to separate trans state in state flag. */
+#define rt2dANIMBUTTONSTATEMASK \
+ (rt2dANIMBUTTONSTATEPICKREGION | \
+ rt2dANIMBUTTONSTATEPICKUP | \
+ rt2dANIMBUTTONSTATEPICKDOWN | \
+ rt2dANIMBUTTONSTATEPICKOVER)
+
+/* Basic enumerations */
+
+/**
+ * \ingroup rt2dmessage
+ * \ref Rt2dMessageType, this type represents the different types of
+ * messages that are available.
+ */
+
+enum Rt2dMessageType
+{
+ rt2dMESSAGETYPENULL = 0, /**< Empty message. */
+ rt2dMESSAGETYPEPLAY, /**< Play animation. */
+ rt2dMESSAGETYPESTOP, /**< Stop animation. */
+ rt2dMESSAGETYPENEXTFRAME, /**< Advance to next frame. */
+ rt2dMESSAGETYPEPREVFRAME, /**< Rewind to previouse frame. */
+ rt2dMESSAGETYPEGOTOFRAME, /**< Advance to frame by index. */
+ rt2dMESSAGETYPEGOTOLABEL, /**< Advance to frame by label. */
+ rt2dMESSAGETYPEGETURL, /**< Get URL */
+ rt2dMESSAGETYPEDOACTION, /* Perform action. */
+ rt2dMESSAGETYPEFOREIGN, /**< Application specific message. */
+ rt2dMESSAGETYPEMOUSEMOVETO, /**< Move mouse. */
+ rt2dMESSAGETYPEMOUSEBUTTONSTATE, /**< Mouse button up or down. */
+ rt2dMESSAGETYPESPECIALTELLTARGET, /* Change target while queueing */
+ rt2dMESSAGETYPEBUTTONBYLABEL, /**< Mouse button transition by label */
+ rt2dMESSAGETYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum Rt2dMessageType Rt2dMessageType;
+
+/**
+ * \ingroup rt2dstringlabel
+ * \ref Rt2dStringLabelType, this type represents the different types of
+ * object that can be labelled in the maestro's label table.
+ */
+
+enum Rt2dStringLabelType
+{
+ rt2dANIMLABELTYPENONE = 0,
+ rt2dANIMLABELTYPEANIM, /**< Animation label. */
+ rt2dANIMLABELTYPEFRAME, /**< Frame or cel label. */
+ rt2dANIMLABELTYPEBUTTON, /**< Button label. */
+ rt2dANIMLABELTYPEFOREIGN, /**< Application specific. */
+ rt2dANIMLABELTYPESHAPE, /**< Shape label. */
+ rt2dANIMLABELTYPEURL, /**< URL label. */
+ rt2dANIMLABELTYPEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum Rt2dStringLabelType Rt2dStringLabelType;
+
+/* Basic animation structures */
+
+/**
+ * \ingroup rt2danimsub
+ * \typedef Rt2dAnimProps
+ * typedef for a structure describing the current state of a scene (opaque)
+ */
+typedef struct Rt2dAnimProps Rt2dAnimProps;
+
+/**
+ * \ingroup rt2danimsub
+ * \typedef Rt2dKeyFrameList
+ * typedef for a structure describing a list of keyframes
+ */
+typedef struct Rt2dKeyFrameList Rt2dKeyFrameList;
+
+/**
+ * \ingroup rt2danimsub
+ * \typedef Rt2dAnimObjectUpdate
+ * typedef for a structure describing a set of changes to a 2d object (opaque)
+ */
+typedef struct Rt2dAnimObjectUpdate Rt2dAnimObjectUpdate;
+
+/**
+ * \ingroup rt2danimsub
+ * \typedef Rt2dKeyFrameTransform
+ * typedef for a structure describing a transform change to a 2d object (opaque)
+ */
+typedef struct Rt2dKeyFrameTransform Rt2dKeyFrameTransform;
+
+/**
+ * \ingroup rt2danimsub
+ * \typedef Rt2dKeyFrameColor
+ * typedef for a structure describing a color change to a 2d object (opaque)
+ */
+typedef struct Rt2dKeyFrameColor Rt2dKeyFrameColor;
+
+/**
+ * \ingroup rt2danimsub
+ * \typedef Rt2dKeyFrameShow
+ * typedef for a structure describing a displayable or depth change to a 2d object (opaque)
+ */
+typedef struct Rt2dKeyFrameShow Rt2dKeyFrameShow;
+
+/**
+ * \ingroup rt2danimsub
+ * \typedef Rt2dKeyFrameMorph
+ * typedef for a structure describing a morph change to a 2d object (opaque)
+ */
+typedef struct Rt2dKeyFrameMorph Rt2dKeyFrameMorph;
+
+/**
+ * \ingroup rt2danimsub
+ * \typedef Rt2dAnim
+ * typedef for a structure describing a 2d animation (opaque)
+ */
+typedef struct Rt2dAnim Rt2dAnim;
+
+/**
+ * \ingroup rt2dbutton
+ * \typedef Rt2dButton
+ * typedef for a structure describing a button (opaque)
+ */
+typedef struct Rt2dButton Rt2dButton;
+
+/**
+ * \ingroup rt2dcel
+ * \typedef Rt2dCel
+ * typedef for a structure describing a cel (opaque)
+ */
+typedef struct Rt2dCel Rt2dCel;
+
+/**
+ * \ingroup rt2dcel
+ * \typedef Rt2dCelList
+ * typedef for a structure describing a cel list (opaque)
+ */
+typedef struct Rt2dCelList Rt2dCelList;
+
+/**
+ * \ingroup rt2dmaestro
+ * \typedef Rt2dMaestro
+ * typedef for a structure describing a maestro (opaque)
+ */
+typedef struct Rt2dMaestro Rt2dMaestro;
+
+/**
+ * \ingroup rt2dmessage
+ * \typedef Rt2dMessage
+ * typedef for a structure describing a message (opaque)
+ */
+typedef struct Rt2dMessage Rt2dMessage;
+
+typedef struct Rt2dMessageList Rt2dMessageList;
+
+/**
+ * \ingroup rt2dstringlabel
+ * \typedef Rt2dStringLabel
+ * typedef for a structure describing a string label (opaque)
+ */
+typedef struct Rt2dStringLabel Rt2dStringLabel;
+
+/**
+ * \ingroup rt2danimsub
+ * \struct Rt2dKeyFrame
+ * structure describing a transforming action
+ */
+struct Rt2dKeyFrameTransform
+{
+ RwMatrix matrix; /**< Transform to be applied */ /*64*/
+};
+
+/**
+ * \ingroup rt2danimsub
+ * \struct Rt2dKeyFrameColor
+ * structure describing a color setting action
+ */
+struct Rt2dKeyFrameColor
+{
+ RwRGBAReal color; /**< Color value for a keyframe */ /*16*/
+};
+
+/**
+ * \ingroup rt2danimsub
+ * \struct Rt2dKeyFrameShow
+ * structure describing a show/hide action
+ */
+struct Rt2dKeyFrameShow
+{
+ RwBool show; /**< visibility flag */ /*4*/
+ RwInt32 depth; /**< Depth order (reverse-z) */ /*4*/
+ RwUInt8 pad1[8]; /**< Alignment padding */ /*8*/
+};
+
+/**
+ * \ingroup rt2danimsub
+ * \struct Rt2dKeyFrameMorph
+ * structure describing a morph action
+ */
+struct Rt2dKeyFrameMorph
+{
+ Rt2dObject *source; /**< start object */ /*4*/
+ Rt2dObject *destination; /**< end object */ /*4*/
+ RwReal alpha; /**< interpolation value (0.0f-1.0f) */ /*4*/
+ RwInt32 pad1; /**< Alignment padding */ /*4*/
+};
+
+/**
+ * \ingroup rt2dmessage
+ * \struct Rt2dMessage
+ * Structure describing a message. A message must have a valid message type, (\ref Rt2dMessageType)
+ * and animation index. The animation index identifies which animation the message applies to.
+ * A -1 indicates the currently active animation. A message can have none, one or two additional
+ * \ref RwInt32 parameters, depending on the message type.
+ */
+struct Rt2dMessage
+{
+ RwUInt32 messageType; /**< message identifier
+ (\ref Rt2dMessageType) */
+ RwInt32 index; /**< animation to apply any
+ actions to */
+ RwInt32 intParam1; /**< first param (message dependant) */
+ RwInt32 intParam2; /**< second param (message dependant) */
+};
+
+#define _rt2dMessageGetMessageTypeMacro(_message) \
+ ((_message)->messageType);
+
+#define _rt2dMessageSetMessageTypeMacro(_message, _messageType) \
+ ((_message)->messageType = (_messageType));
+
+#define _rt2dMessageGetIndexMacro(_message) \
+ ((_message)->index);
+
+#define _rt2dMessageSetIndexMacro(_message, _index) \
+ ((_message)->index = (_index));
+
+#define _rt2dMessageSetParamMacro(_message, _param1, _param2) \
+MACRO_START \
+{ \
+ ((_message)->intParam1 = (_param1)); \
+ ((_message)->intParam2 = (_param2)); \
+} \
+MACRO_STOP
+
+#define _rt2dMessageGetParamMacro(_message, _param1, _param2) \
+MACRO_START \
+{ \
+ (*(_param1) = (_message)->intParam1); \
+ (*(_param2) = (_message)->intParam2); \
+} \
+MACRO_STOP
+
+/**
+ * \ingroup rt2dstringlabel
+ * \struct Rt2dStringLabel
+ * structure containing label information. The enitityType identifies the type
+ * of the label. The label's name is stored as an index
+ * in common storage area. The entityType and name of the label are used as keys
+ * during a search. Additional internal and user data can be stored with the
+ * label.
+ */
+struct Rt2dStringLabel
+{
+ RwUInt32 entityType; /**< type of the label
+ (\ref Rt2dStringLabelType) */
+ RwInt32 nameIndex; /**< index of name in internal data
+ area */
+ void *internalData; /**< internal data */
+ void *userData; /**< customizable data */
+
+};
+
+#define _rt2dStringLabelGetStringLabelTypeMacro(_strLabel) \
+ ((_strLabel)->entityType);
+
+#define _rt2dStringLabelSetStringLabelTypeMacro(_strLabel, _entityType) \
+ ((_strLabel)->entityType = (_entityType));
+
+#define _rt2dStringLabelGetNameIndexMacro(_strLabel) \
+ ((_strLabel)->nameIndex);
+
+#define _rt2dStringLabelSetNameIndexMacro(_strLabel, _index) \
+ ((_strLabel)->nameIndex = (_index));
+
+#define _rt2dStringLabelGetInternalDataMacro(_strLabel) \
+ ((_strLabel)->internalData);
+
+#define _rt2dStringLabelSetInternalDataMacro(_strLabel, _internalData) \
+ ((_strLabel)->internalData = (_internalData));
+
+#define _rt2dStringLabelGetUserDataMacro(_strLabel) \
+ ((_strLabel)->userData);
+
+#define _rt2dStringLabelSetUserDataMacro(_strLabel, _userData) \
+ ((_strLabel)->userData = (_userData));
+
+/**
+ * \ingroup rt2dcel
+ * \struct Rt2dCel
+ * structure containing cel information. The name of the cel is stored as an
+ * index into a label table. The buttons in the cel are stored as indices. These
+ * reference a list of buttons held by the cel's parent maestro. Any messages
+ * to be process when the cel is active is stored as index into the parent's
+ * maestro's message storage area.
+ */
+struct Rt2dCel
+{
+ RwInt32 strLabelIndex; /**< Frame label */
+ RwInt32 celIndex; /**< Frame number */
+ RwSList *buttonIndices; /**< List of buttons active in
+ this frame */
+ RwInt32 messageListIndex; /**< Messages to be posted after
+ displaying this frame */
+};
+
+#define _rt2dCelGetStringLabelIndexMacro(_cel) \
+ ((_cel)->strLabelIndex);
+
+#define _rt2dCelSetStringLabelIndexMacro(_cel, _index) \
+ ((_cel)->strLabelIndex = (_index));
+
+#define _rt2dCelGetCelIndexMacro(_cel) \
+ ((_cel)->celIndex);
+
+#define _rt2dCelSetCelIndexMacro(_cel, _index) \
+ ((_cel)->celIndex = (_index));
+
+#define _rt2dCelGetMessageListIndexMacro(_cel) \
+ ((_cel)->messageListIndex);
+
+#define _rt2dCelSetMessageListIndexMacro(_cel, _index) \
+ ((_cel)->messageListIndex = (_index));
+
+/* Callback typedefs */
+
+typedef Rt2dAnim *(*Rt2dAnimCallBack)(Rt2dAnim *object,
+ Rt2dAnimProps *props,
+ void *data);
+/**
+ * \ingroup rt2danimsub
+ * \typedef Rt2dKeyFrameListCallBack
+ * This typedef defines a callback function to apply to a frame list.
+ *
+ * \param anim Pointer to the animation
+ * \param props Pointer to the props that the animation acts upon
+ * \param keyframeList The key frame list
+ * \param keyframeListTime The key frame list time
+ * \param data User defined data
+ */
+typedef Rt2dKeyFrameList *(Rt2dKeyFrameListCallBack)(
+ Rt2dAnim *anim,
+ Rt2dAnimProps *props,
+ Rt2dKeyFrameList *keyframeList,
+ RwReal keyframeListTime,
+ void *data);
+
+/**
+ * \ingroup rt2danimsub
+ * \typedef Rt2dAnimOnEndReachedCallBack
+ * This typedef defines a callback function called at the end of an animation.
+ *
+ * \param anim Pointer to the animation ending
+ * \param props Pointer to the props that the animation acts upon
+ * \param remainingDeltaTime Remaining time
+ */
+typedef Rt2dAnim *(*Rt2dAnimOnEndReachedCallBack)(Rt2dAnim *anim,
+ Rt2dAnimProps *props,
+ RwReal remainingDeltaTime);
+
+/**
+ * \ingroup rt2dmaestro
+ * \typedef Rt2dMaestroAnimationsCallBack
+ * \ref Rt2dMaestroAnimationsCallBack represents the function called from
+ * \ref Rt2dMaestroForAllAnimations for all animations in the maestro.
+ * This function
+ * should return the current maestro to indicate success. The callback may
+ * return NULL to terminate further callbacks on the maestro.
+ *
+ * \param maestro Pointer to parent maestro.
+ * \param anim Pointer to the animation.
+ * \param props Pointer to the anim's props.
+ * \param pData Pointer to private data.
+ *
+ * \return Pointer to the maestro.
+ */
+
+typedef Rt2dMaestro *(*Rt2dMaestroAnimationsCallBack)
+ (Rt2dMaestro *maestro, Rt2dAnim *anim, Rt2dAnimProps *props, void * pData);
+
+/**
+ * \ingroup rt2dmessage
+ * \typedef Rt2dMessageHandlerCallBack
+ * \ref Rt2dMessageHandlerCallBack represents the function called from
+ * \ref Rt2dMaestroProcessMessages for all messages in the maestro's
+ * process message queue. The maestro does not filter any messages. The
+ * handler may process or ignore any messages it is given.
+ *
+ * This function should return the current message to indicate success. The
+ * callback may return NULL to terminate further callbacks on the maestro.
+ *
+ * \param maestro Pointer to parent maestro.
+ * \param message Pointer to the message.
+ *
+ * \return Pointer to the message.
+ */
+
+typedef Rt2dMessage *(*Rt2dMessageHandlerCallBack)
+ (Rt2dMaestro *maestro, Rt2dMessage *message);
+
+/* Message streaming call backs. */
+
+typedef RwInt32
+(*Rt2dMessageStreamGetSizeCallBack)
+ (Rt2dMaestro *maestro, Rt2dMessage *message);
+
+typedef Rt2dMessage *
+(*Rt2dMessageStreamReadCallBack)
+ (Rt2dMaestro *maestro, Rt2dMessage *message, RwStream *stream);
+
+typedef Rt2dMessage *
+(*Rt2dMessageStreamWriteCallBack)
+ (Rt2dMaestro *maestro, Rt2dMessage *message, RwStream *stream);
+
+/*
+ * Data access macros.
+ */
+
+/*
+ * Rt2dAnim
+ */
+
+/* General */
+
+extern Rt2dAnimOnEndReachedCallBack
+Rt2dAnimSetOnEndReachedCallBack(Rt2dAnimOnEndReachedCallBack callback);
+
+extern Rt2dAnimOnEndReachedCallBack
+Rt2dAnimGetOnEndReachedCallBack(void);
+
+
+extern Rt2dAnim *
+Rt2dAnimOnEndReachedCallBackLoop(Rt2dAnim *anim, Rt2dAnimProps *props,
+ RwReal remainingDeltaTime);
+
+extern Rt2dAnim *
+Rt2dAnimOnEndReachedCallBackStop(Rt2dAnim *anim, Rt2dAnimProps *props,
+ RwReal remainingDeltaTime);
+
+/* Management */
+extern Rt2dAnim *
+Rt2dAnimCreate(void);
+
+extern RwBool
+Rt2dAnimDestroy(Rt2dAnim *anim, Rt2dAnimProps *props);
+
+extern Rt2dAnim *
+Rt2dAnimLock(Rt2dAnim *anim, Rt2dAnimProps *props);
+
+extern Rt2dAnim *
+Rt2dAnimUnlock(Rt2dAnim *anim, Rt2dAnimProps *props);
+
+extern Rt2dAnim *
+Rt2dAnimAddKeyFrameList(Rt2dAnim *anim,
+ Rt2dKeyFrameList *keyframeList,
+ RwReal time);
+
+
+extern Rt2dAnim *
+Rt2dAnimCopy(Rt2dAnim *srcAnim, Rt2dAnimProps *srcProps);
+
+/* Streaming */
+extern RwUInt32
+Rt2dAnimStreamGetSize( Rt2dAnim *anim,
+ Rt2dAnimProps *props);
+
+extern Rt2dAnim *
+Rt2dAnimStreamRead(RwStream *stream,
+ Rt2dAnimProps *props);
+
+extern Rt2dAnim *
+Rt2dAnimStreamReadTo(RwStream *dest,
+ RwStream *stream,
+ Rt2dAnimProps *props);
+
+extern Rt2dAnim *
+Rt2dAnimStreamWrite(Rt2dAnim *anim, RwStream *stream,
+ Rt2dAnimProps *data);
+
+/* Playback */
+extern RwBool
+Rt2dAnimIsInterpolated(Rt2dAnim *anim);
+
+extern Rt2dAnim *
+Rt2dAnimSetInterpolate(Rt2dAnim *anim, RwBool interpolate);
+
+extern Rt2dAnim *
+Rt2dAnimReset(Rt2dAnim *anim, Rt2dAnimProps *props);
+
+extern Rt2dAnim *
+Rt2dAnimSetDeltaTimeScale(Rt2dAnim *anim, RwReal timeScale);
+
+extern Rt2dAnim *
+Rt2dAnimAddDeltaTime(Rt2dAnim *anim, Rt2dAnimProps *props,
+ RwReal deltaTime);
+
+extern Rt2dAnim *
+Rt2dAnimAddDeltaFrameIndex(Rt2dAnim *anim, Rt2dAnimProps *props,
+ RwInt32 deltaFrame);
+
+extern Rt2dAnim *
+Rt2dAnimTimeUpdate(Rt2dAnim *anim, Rt2dAnimProps *props);
+
+extern Rt2dAnim *
+Rt2dAnimGotoKeyFrameListByTime(Rt2dAnim *anim, Rt2dAnimProps *props,
+ RwReal time);
+
+extern Rt2dAnim *
+Rt2dAnimGotoKeyFrameListByIndex(Rt2dAnim *anim, Rt2dAnimProps *props,
+ RwInt32 frameIndex);
+
+/* Utilities */
+extern Rt2dAnim *
+Rt2dAnimForAllKeyFrameLists(Rt2dAnim *anim, Rt2dKeyFrameListCallBack callBack,
+ Rt2dAnimProps *props, void *data);
+
+/* Interrogation */
+extern RwInt32
+Rt2dAnimGetNumberOfKeyFrames(Rt2dAnim *anim);
+
+extern Rt2dKeyFrameList *
+Rt2dAnimGetKeyFrameListByIndex(Rt2dAnim *anim, RwUInt32 frameIndex);
+
+extern RwReal
+Rt2dAnimGetCurrentTime(Rt2dAnim *anim);
+
+extern RwReal
+Rt2dAnimGetFinalKeyFrameListTime(Rt2dAnim *anim);
+
+extern RwInt32
+Rt2dAnimGetPrevFrameIndex(Rt2dAnim *anim);
+
+extern RwReal
+Rt2dAnimGetPrevFrameTime(Rt2dAnim *anim);
+
+extern RwInt32
+Rt2dAnimGetNextFrameIndex(Rt2dAnim *anim);
+
+extern RwReal
+Rt2dAnimGetNextFrameTime(Rt2dAnim *anim);
+
+/* KeyFrameList Management */
+extern Rt2dKeyFrameList *
+Rt2dKeyFrameListCreate(Rt2dAnimProps *props);
+
+extern RwBool
+Rt2dKeyFrameListDestroy(Rt2dKeyFrameList *keyframeList);
+
+extern Rt2dKeyFrameList *
+Rt2dKeyFrameListLock(Rt2dKeyFrameList *keyframeList, Rt2dAnimProps *props);
+
+extern Rt2dKeyFrameList *
+Rt2dKeyFrameListUnlock(Rt2dKeyFrameList *keyframeList,
+ Rt2dAnimProps *props);
+
+extern Rt2dKeyFrameList*
+Rt2dKeyFrameListAddUpdateObject(Rt2dKeyFrameList *keyframeList,
+ Rt2dAnimObjectUpdate *update);
+
+/* KeyFrameList Streaming */
+extern Rt2dKeyFrameList *
+Rt2dKeyFrameListStreamRead(RwStream *stream);
+
+extern RwUInt32
+Rt2dKeyFrameListStreamGetSize(Rt2dKeyFrameList *keyframeList);
+
+extern Rt2dKeyFrameList *
+Rt2dKeyFrameListStreamWrite(Rt2dKeyFrameList *keyframeList,
+ RwStream *stream);
+
+/* KeyFrameList Playback */
+extern Rt2dKeyFrameList *
+Rt2dKeyFrameListAdvance(Rt2dKeyFrameList *keyframeList,
+ Rt2dAnimProps *props);
+
+extern Rt2dKeyFrameList *
+Rt2dKeyFrameListApply(Rt2dKeyFrameList *keyframeList, Rt2dAnimProps *props,
+ RwReal alpha);
+
+/* KeyFrameList edition object */
+extern Rt2dAnimObjectUpdate *
+Rt2dAnimObjectUpdateCreate(Rt2dObject *object);
+
+extern RwBool
+Rt2dAnimObjectUpdateDestroy(Rt2dAnimObjectUpdate *update);
+
+extern Rt2dAnimObjectUpdate *
+Rt2dAnimObjectUpdateClear(Rt2dAnimObjectUpdate *update);
+
+extern Rt2dAnimObjectUpdate*
+Rt2dAnimObjectUpdateSetTransform(Rt2dAnimObjectUpdate *update,
+ Rt2dKeyFrameTransform *transform);
+
+extern Rt2dAnimObjectUpdate*
+Rt2dAnimObjectUpdateSetColorOffs(Rt2dAnimObjectUpdate *update,
+ Rt2dKeyFrameColor *colorOffs);
+
+extern Rt2dAnimObjectUpdate*
+Rt2dAnimObjectUpdateSetColorMult(Rt2dAnimObjectUpdate *update,
+ Rt2dKeyFrameColor *colorMult);
+
+extern Rt2dAnimObjectUpdate*
+Rt2dAnimObjectUpdateSetShow(Rt2dAnimObjectUpdate *update,
+ Rt2dKeyFrameShow *show);
+
+extern Rt2dAnimObjectUpdate*
+Rt2dAnimObjectUpdateSetMorph(Rt2dAnimObjectUpdate *update,
+ Rt2dKeyFrameMorph *morph);
+
+extern Rt2dAnimObjectUpdate *
+Rt2dAnimObjectUpdateSetObject(Rt2dAnimObjectUpdate *update,
+ Rt2dObject *object);
+
+/* Props management */
+extern Rt2dAnimProps *
+Rt2dAnimPropsCreate(Rt2dObject *scene);
+
+extern RwBool
+Rt2dAnimPropsDestroy(Rt2dAnimProps *props);
+
+/*
+ * Rt2dButton
+ */
+
+extern Rt2dMaestro *
+Rt2dMaestroAddButton(Rt2dMaestro *maestro, RwInt32 strLabelIdx, RwInt32 objectIdx,
+ RwUInt32 stateFlag, RwInt32 *actionListIdx,
+ RwInt32 *index);
+
+/*
+ * Rt2dCel & Rt2dCelList
+ */
+
+extern Rt2dCel *
+Rt2dCelCreate(Rt2dMaestro *maestro,
+ RwChar *name,
+ RwInt32 celIndex, RwInt32 messageListIndex);
+
+extern Rt2dCelList *
+Rt2dCelListCreate( void );
+
+extern RwBool
+Rt2dCelDestroy(Rt2dMaestro *maestro, Rt2dCel *cel);
+
+extern Rt2dCel *
+Rt2dCelAddButtonIndex(Rt2dCel * cel, RwInt32 buttonIndex, RwInt32 *index);
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define Rt2dCelGetStringLabelIndex(_cel) \
+ _rt2dCelGetStringLabelIndexMacro((_cel));
+
+#define Rt2dCelSetStringLabelIndex(_cel, _index) \
+ _rt2dCelSetStringLabelIndexMacro((_cel), (_index));
+
+#define Rt2dCelGetCelIndex(_cel) \
+ _rt2dCelGetCelIndexMacro((_cel));
+
+#define Rt2dCelSetCelIndex(_cel, _index) \
+ _rt2dCelSetCelIndexMacro((_cel), (_index));
+
+#define Rt2dCelGetMessageListIndex(_cel) \
+ _rt2dCelGetMessageListIndexMacro((_cel));
+
+#define Rt2dCelSetMessageListIndex(_cel, _index) \
+ _rt2dCelSetMessageListIndexMacro((_cel), (_index));
+
+#else /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+extern RwInt32
+Rt2dCelGetStringLabelIndex(Rt2dCel *cel);
+
+extern void
+Rt2dCelSetStringLabelIndex(Rt2dCel *cel, RwInt32 index);
+
+extern RwInt32
+Rt2dCelGetCelIndex(Rt2dCel *cel);
+
+extern void
+Rt2dCelSetCelIndex(Rt2dCel *cel, RwInt32 index);
+
+extern RwInt32
+Rt2dCelGetMessageListIndex(Rt2dCel *cel);
+
+extern void
+Rt2dCelSetMessageListIndex(Rt2dCel *cel, RwInt32 index);
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+extern RwBool
+Rt2dCelListDestroy(Rt2dCelList *celList);
+
+extern Rt2dCelList *
+Rt2dCelListLock(Rt2dCelList *celList);
+
+extern Rt2dCelList *
+Rt2dCelListUnlock(Rt2dCelList * celList);
+
+extern Rt2dCelList *
+Rt2dCelListCopy(Rt2dCelList *srcCelList);
+
+extern Rt2dCelList *
+Rt2dCelListAddCel(Rt2dCelList *celList, Rt2dCel *cel, RwInt32 *index);
+
+extern Rt2dCelList *
+Rt2dCelListCelGetStringLabelIndex(Rt2dCelList *celList, RwInt32 celIndex, RwInt32 *index);
+
+extern Rt2dCelList *
+Rt2dCelListCelButtonGetDisplayVersion(Rt2dMaestro *maestro, Rt2dCelList * celList,
+ RwInt32 celIndex, RwInt32 celButtonIndex, RwInt32 *index);
+
+/*
+ * Rt2dMaestro
+ */
+extern Rt2dMaestro *
+Rt2dMaestroCreate(void);
+
+extern RwBool
+Rt2dMaestroDestroy(Rt2dMaestro *maestro);
+
+extern RwUInt32
+Rt2dMaestroStreamGetSize(Rt2dMaestro *maestro);
+
+extern Rt2dMaestro *
+Rt2dMaestroStreamRead(Rt2dMaestro *maestro, RwStream *stream);
+
+extern Rt2dMaestro *
+Rt2dMaestroStreamWrite(Rt2dMaestro *maestro, RwStream *stream);
+
+
+extern Rt2dMaestro *
+Rt2dMaestroForAllAnimations(Rt2dMaestro *maestro,
+ Rt2dMaestroAnimationsCallBack callback, void *data);
+
+extern Rt2dMaestro *
+Rt2dMaestroForAllVisibleAnimations(Rt2dMaestro *maestro,
+ Rt2dMaestroAnimationsCallBack callback, void *data);
+
+extern Rt2dMaestro *
+Rt2dMaestroAddAnimations(Rt2dMaestro *maestro,
+ RwInt32 parent, RwInt32 posInParentScene,
+ Rt2dAnim *anim, Rt2dAnimProps *animProps, Rt2dCelList *celList,
+ RwInt32 *index);
+
+extern Rt2dAnim *
+Rt2dMaestroGetAnimationsByIndex(Rt2dMaestro *maestro, RwInt32 index);
+
+extern Rt2dAnimProps *
+Rt2dMaestroGetAnimPropsByIndex(Rt2dMaestro *maestro, RwInt32 index);
+
+extern Rt2dMaestro *
+Rt2dMaestroUpdateAnimations(Rt2dMaestro *maestro);
+
+extern Rt2dMaestro *
+Rt2dMaestroAddDeltaTime(Rt2dMaestro *maestro, RwReal deltaTime);
+
+extern Rt2dMaestro *
+Rt2dMaestroLock(Rt2dMaestro * maestro);
+
+extern Rt2dMaestro *
+Rt2dMaestroUnlock(Rt2dMaestro *maestro);
+
+extern Rt2dObject *
+Rt2dMaestroGetScene(Rt2dMaestro *maestro);
+
+extern Rt2dMaestro *
+Rt2dMaestroSetScene(Rt2dMaestro *maestro, Rt2dObject *scene);
+
+extern Rt2dObject *
+Rt2dMaestroGetAnimSceneByIndex(Rt2dMaestro *maestro, RwInt32 index);
+
+extern Rt2dMaestro *
+Rt2dMaestroRender(Rt2dMaestro *maestro);
+
+extern Rt2dBBox *
+Rt2dMaestroGetBBox(Rt2dMaestro *maestro);
+
+extern Rt2dMaestro *
+Rt2dMaestroSetBBox(Rt2dMaestro *maestro, Rt2dBBox *bbox);
+
+
+/*
+ * Message & Message handlers.
+ */
+extern Rt2dMessageHandlerCallBack
+Rt2dMaestroGetMessageHandler(Rt2dMaestro *maestro);
+
+extern Rt2dMaestro *
+Rt2dMaestroSetMessageHandler(Rt2dMaestro *maestro, Rt2dMessageHandlerCallBack handler);
+
+extern Rt2dMaestro *
+Rt2dMaestroAddMessageList(Rt2dMaestro *maestro,
+ Rt2dMessage *message, RwInt32 num, RwInt32 *index);
+
+extern Rt2dMaestro *
+Rt2dMaestroPostMessages(Rt2dMaestro *maestro, Rt2dMessage *message, RwInt32 num);
+
+extern Rt2dMaestro *
+Rt2dMaestroProcessMessages(Rt2dMaestro *maestro);
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define Rt2dMessageGetMessageType(_message) \
+ _rt2dMessageGetMessageTypeMacro((_message));
+
+#define Rt2dMessageSetMessageTypeMacro(_message, _messageType) \
+ _rt2dMessageSetMessageTypeMacro((_message), (_messageType));
+
+#define Rt2dMessageGetIndex(_message) \
+ _rt2dMessageGetIndexMacro((_message));
+
+#define Rt2dMessageSetIndex(_message, _index) \
+ _rt2dMessageSetIndexMarco((_message), (_index));
+
+#define Rt2dMessageSetParam(_message, _param1, _param2) \
+ _rt2dMessageSetParamMacro((_message), (_param1), (_param2));
+
+#define Rt2dMessageGetParam(_message, _param1, _param2) \
+ _rt2dMessageGetParamMacro((_message), (_param1), (_param2));
+
+#else /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+extern Rt2dMessageType
+Rt2dMessageGetMessageType(Rt2dMessage *message);
+
+extern void
+Rt2dMessageSetMessageType(Rt2dMessage *message, Rt2dMessageType messageType);
+
+extern RwInt32
+Rt2dMessageGetIndex(Rt2dMessage *message);
+
+extern void
+Rt2dMessageSetIndex(Rt2dMessage *message, RwInt32 index);
+
+extern void
+Rt2dMessageGetParam(Rt2dMessage *message, RwInt32 *param1, RwInt32 *param2);
+
+extern void
+Rt2dMessageSetParam(Rt2dMessage *message, RwInt32 param1, RwInt32 param2);
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+/*
+ * Default message handler.
+ */
+extern Rt2dMessage *
+Rt2dMessageHandlerDefaultCallBack(Rt2dMaestro *maestro, Rt2dMessage *message);
+
+
+/*
+ * Labels.
+ */
+extern Rt2dStringLabel *
+Rt2dMaestroFindStringLabel(Rt2dMaestro *maestro,
+ Rt2dStringLabelType entityType, RwChar *lookupName,
+ RwInt32 *index);
+
+extern Rt2dStringLabel *
+Rt2dMaestroGetStringLabelByIndex(Rt2dMaestro *maestro, RwInt32 index);
+
+extern Rt2dMaestro *
+Rt2dMaestroAddStringLabel(Rt2dMaestro *maestro,
+ Rt2dStringLabelType entityType, RwChar *name,
+ void *internalData, RwInt32 *index);
+
+extern const RwChar *
+Rt2dMaestroGetStringLabelName(Rt2dMaestro *maestro,
+ Rt2dStringLabel *strLabel);
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define Rt2dStringLabelGetStringLabelType(_strLabel) \
+ _rt2dStringLabelGetStringLabelTypeMacro((_strLabel));
+
+#define Rt2dStringLabelSetStringLabelType(_strLabel, _entityType) \
+ _rt2dStringLabelSetStringLabelTypeMacro((_strLabel), (_entityType));
+
+#define Rt2dStringLabelGetNameIndex(_strLabel) \
+ _rt2dStringLabelGetNameIndexMacro((_strLabel));
+
+#define Rt2dStringLabelSetNameIndex(_strLabel, _index) \
+ _rt2dStringLabelSetNameIndexMacro((_strLabel), (_index));
+
+#define Rt2dStringLabelGetInternalData(_strLabel) \
+ _rt2dStringLabelGetInternalDataMacro((_strLabel));
+
+#define Rt2dStringLabelSetInternalData(_strLabel, _internalData) \
+ _rt2dStringLabelSetInternalDataMacro((_strLabel), (_internalData));
+
+#define Rt2dStringLabelGetUserData(_strLabel) \
+ _rt2dStringLabelGetUserDataMacro((_strLabel));
+
+#define Rt2dStringLabelSetUserData(_strLabel, _userData) \
+ _rt2dStringLabelSetUserDataMacro((_strLabel), (_userData));
+
+#else /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+extern Rt2dStringLabelType
+Rt2dStringLabelGetStringLabelType(Rt2dStringLabel *strLabel);
+
+extern void
+Rt2dStringLabelSetStringLabelType(Rt2dStringLabel *strLabel,
+ Rt2dStringLabelType entityType);
+
+extern RwInt32
+Rt2dStringLabelGetNameIndex(Rt2dStringLabel *strLabel);
+
+extern void
+Rt2dStringLabelSetNameIndex(Rt2dStringLabel *strLabel, RwInt32 index);
+
+extern void *
+Rt2dStringLabelGetInternalData(Rt2dStringLabel *strLabel);
+
+extern void
+Rt2dStringLabelSetInternalData(Rt2dStringLabel *strLabel, void *internalData);
+
+extern void *
+Rt2dStringLabelGetUserData(Rt2dStringLabel *strLabel);
+
+extern void
+Rt2dStringLabelSetUserData(Rt2dStringLabel *strLabel, void *userData);
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+
+
+/*
+ * Cels & Cel Lists
+ */
+extern Rt2dCelList *
+Rt2dMaestroGetCelListByIndex(Rt2dMaestro *maestro, RwInt32 index);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+#endif /* RT2DANIM_H*/
diff --git a/rwsdk/include/d3d8/rt2danim.rpe b/rwsdk/include/d3d8/rt2danim.rpe
new file mode 100644
index 00000000..82a9dac9
--- /dev/null
+++ b/rwsdk/include/d3d8/rt2danim.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum rwPLUGIN_ERRENUM
+{
+
+
+
+ rwPLUGIN_ERRENUMLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum rwPLUGIN_ERRENUM rwPLUGIN_ERRENUM;
+
+
diff --git a/rwsdk/include/d3d8/rtbary.h b/rwsdk/include/d3d8/rtbary.h
new file mode 100644
index 00000000..61c39b07
--- /dev/null
+++ b/rwsdk/include/d3d8/rtbary.h
@@ -0,0 +1,141 @@
+/***************************************************************************
+ * *
+ * Module : rtbary.h *
+ * *
+ * Purpose : Barycentric operations *
+ * *
+ **************************************************************************/
+
+#ifndef RTBARY_H
+#define RTBARY_H
+
+/**
+ * \defgroup rtbary RtBary
+ * \ingroup rttool
+ *
+ * Barycentric Toolkit for RenderWare.
+ */
+
+
+/****************************************************************************
+ Includes
+ */
+
+#include <rwcore.h>
+
+#include <rtbary.rpe> /* automatically generated header file */
+
+
+/****************************************************************************
+ Global types
+ */
+
+/**
+ * \ingroup rtbary
+ * \typedef RtBaryV4d
+ * typedef for the 4 element homogeneous row of a transform matrix mapping
+ * a point from Cartesian space to the barycentric space defined by a triangle.
+ */
+typedef RwReal RtBaryV4d[4];
+
+/**
+ * \ingroup rtbary
+ * \typedef RtBaryTransform
+ * typedef for the 4x4 homogeneous transform matrix mapping a point
+ * from Cartesian space to the barycentric space defined by a triangle.
+ */
+typedef RtBaryV4d RtBaryTransform[4];
+
+/****************************************************************************
+ Defines
+ */
+
+#define RtBaryV3dFromWeightsMacro(_out, _b, _v0, _v1, _v2) \
+MACRO_START \
+{ \
+ (_out)->x = (RwReal)( ((_v0)->x * (_b)[0]) + \
+ ((_v1)->x * (_b)[1]) + \
+ ((_v2)->x * (_b)[2]) ); \
+ (_out)->y = (RwReal)( ((_v0)->y * (_b)[0]) + \
+ ((_v1)->y * (_b)[1]) + \
+ ((_v2)->y * (_b)[2]) ); \
+ (_out)->z = (RwReal)( ((_v0)->z * (_b)[0]) + \
+ ((_v1)->z * (_b)[1]) + \
+ ((_v2)->z * (_b)[2]) ); \
+} \
+MACRO_STOP
+
+#define RtBaryWeightsFromV3dMacro(_out, _m, _in) \
+MACRO_START \
+{ \
+ (_out)[0] = ( (_m)[0][0] * (_in)->x + \
+ (_m)[1][0] * (_in)->y + \
+ (_m)[2][0] * (_in)->z + \
+ (_m)[3][0] ); \
+ (_out)[1] = ( (_m)[0][1] * (_in)->x + \
+ (_m)[1][1] * (_in)->y + \
+ (_m)[2][1] * (_in)->z + \
+ (_m)[3][1] ); \
+ (_out)[2] = ( (_m)[0][2] * (_in)->x + \
+ (_m)[1][2] * (_in)->y + \
+ (_m)[2][2] * (_in)->z + \
+ (_m)[3][2] ); \
+ (_out)[3] = ( (_m)[0][3] * (_in)->x + \
+ (_m)[1][3] * (_in)->y + \
+ (_m)[2][3] * (_in)->z + \
+ (_m)[3][3] ); \
+} \
+MACRO_STOP
+
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+
+#define RtBaryV3dFromWeights(_out, _b, _v0, _v1, _v2) \
+ RtBaryV3dFromWeightsMacro(_out, _b, _v0, _v1, _v2)
+
+#define RtBaryWeightsFromV3d(_out, _m, _in) \
+ RtBaryWeightsFromV3dMacro(_out, _m, _in)
+
+#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwBool
+RtBaryGetTransform(RtBaryTransform m,
+ RwReal * const area,
+ const RwV3d * const v0,
+ const RwV3d * const v1,
+ const RwV3d * const v2);
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+
+extern void
+RtBaryV3dFromWeights(RwV3d * const out,
+ const RtBaryV4d weights,
+ const RwV3d * const v0,
+ const RwV3d * const v1,
+ const RwV3d * const v2);
+
+extern void
+RtBaryWeightsFromV3d(RtBaryV4d out,
+ RtBaryTransform mat,
+ const RwV3d * const in);
+
+extern void
+_rtImportWorldBaryFromEdge(RtBaryV4d out,
+ RtBaryTransform mat,
+ const RwV3d * const in);
+
+#endif /* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RTBARY_H */
diff --git a/rwsdk/include/d3d8/rtbary.rpe b/rwsdk/include/d3d8/rtbary.rpe
new file mode 100644
index 00000000..fdfe3afe
--- /dev/null
+++ b/rwsdk/include/d3d8/rtbary.rpe
@@ -0,0 +1,645 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionBary
+{
+
+
+
+ e_rwdb_CriterionBaryLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionBary e_rwdb_CriterionBary;
+
+
diff --git a/rwsdk/include/d3d8/rtbezpat.h b/rwsdk/include/d3d8/rtbezpat.h
new file mode 100644
index 00000000..8a5960cb
--- /dev/null
+++ b/rwsdk/include/d3d8/rtbezpat.h
@@ -0,0 +1,401 @@
+/*
+ * Data structures for rtbezpat toolkit
+ * Copyright (c) Criterion Software Limited
+ */
+
+#if (!defined(RTBEZPAT_H))
+#define RTBEZPAT_H
+
+/**
+ * \defgroup rtbezpatch RtBezPat
+ * \ingroup rttool
+ *
+ * The Bezier Patch Toolkit is a group of functions that support the way
+ * RenderWare processes patches.
+ */
+
+/**
+ * \ingroup rtbezpatch
+ * \typedef RtBezierV4d
+ * typedef for struct RtBezierV4d.
+ */
+typedef struct RtBezierV4d RtBezierV4d;
+
+/**
+ * \ingroup rtbezpatch
+ * \struct RtBezierV4d
+ * This type represents 4d points and vectors specified by
+ * the (x, y, z, w) coordinates of a 4d point or
+ * the (x, y, z, w) components of a 4d vector.
+ */
+struct RtBezierV4d
+{
+ RwReal x;
+ /**< X value */
+ RwReal y;
+ /**< Y value */
+ RwReal z;
+ /**< Z value */
+ RwReal w;
+ /**< W value */
+};
+
+/**
+ * \ingroup rtbezpatch
+ * \typedef RtBezierRow
+ * typedef for a row of vectors.
+ * RtBezierRow is an array of 4 vectors
+ */
+typedef RtBezierV4d RtBezierRow[4];
+
+/**
+ * \ingroup rtbezpatch
+ * \typedef RtBezierMatrix
+ * typedef for a matrix of 4*4 vectors.
+ * RtBezierMatrix is an array of 4 rows.
+ */
+typedef RtBezierRow RtBezierMatrix[4];
+
+/*
+ * Bernstein polynomials;
+ */
+
+#define RtBern03(_u, _cu) ( (_cu) * (_cu) * (_cu) )
+#define RtBern13(_u, _cu) ( 3 * (_u) * (_cu) * (_cu) )
+#define RtBern23(_u, _cu) ( 3 * (_u) * (_u) * (_cu) )
+#define RtBern33(_u, _cu) ( (_u) * (_u) * (_u) )
+
+#define RtBezierQuadSample3dMacro(_out, _P, _u, _v) \
+MACRO_START \
+{ \
+ const RtBezierV4d * const P0 = &(_P)[0][0]; \
+ const RtBezierV4d * const P1 = &(_P)[1][0]; \
+ const RtBezierV4d * const P2 = &(_P)[2][0]; \
+ const RtBezierV4d * const P3 = &(_P)[3][0]; \
+ const RwReal _pu = (_u); \
+ const RwReal _cu = ((RwReal)1) - _pu; \
+ const RwReal B03u = RtBern03(_pu,_cu); \
+ const RwReal B13u = RtBern13(_pu,_cu); \
+ const RwReal B23u = RtBern23(_pu,_cu); \
+ const RwReal B33u = RtBern33(_pu,_cu); \
+ const RwReal _pv = (_v); \
+ const RwReal _cv = ((RwReal)1) - _pv; \
+ const RwReal B03v = RtBern03(_pv,_cv); \
+ const RwReal B13v = RtBern13(_pv,_cv); \
+ const RwReal B23v = RtBern23(_pv,_cv); \
+ const RwReal B33v = RtBern33(_pv,_cv); \
+ RtBezierRow A; \
+ \
+ A[0].x = B03u*P0[0].x + B13u*P1[0].x + B23u*P2[0].x + B33u*P3[0].x; \
+ A[0].y = B03u*P0[0].y + B13u*P1[0].y + B23u*P2[0].y + B33u*P3[0].y; \
+ A[0].z = B03u*P0[0].z + B13u*P1[0].z + B23u*P2[0].z + B33u*P3[0].z; \
+ A[1].x = B03u*P0[1].x + B13u*P1[1].x + B23u*P2[1].x + B33u*P3[1].x; \
+ A[1].y = B03u*P0[1].y + B13u*P1[1].y + B23u*P2[1].y + B33u*P3[1].y; \
+ A[1].z = B03u*P0[1].z + B13u*P1[1].z + B23u*P2[1].z + B33u*P3[1].z; \
+ A[2].x = B03u*P0[2].x + B13u*P1[2].x + B23u*P2[2].x + B33u*P3[2].x; \
+ A[2].y = B03u*P0[2].y + B13u*P1[2].y + B23u*P2[2].y + B33u*P3[2].y; \
+ A[2].z = B03u*P0[2].z + B13u*P1[2].z + B23u*P2[2].z + B33u*P3[2].z; \
+ A[3].x = B03u*P0[3].x + B13u*P1[3].x + B23u*P2[3].x + B33u*P3[3].x; \
+ A[3].y = B03u*P0[3].y + B13u*P1[3].y + B23u*P2[3].y + B33u*P3[3].y; \
+ A[3].z = B03u*P0[3].z + B13u*P1[3].z + B23u*P2[3].z + B33u*P3[3].z; \
+ \
+ (_out)->x = A[0].x*B03v + A[1].x*B13v + A[2].x*B23v + A[3].x*B33v; \
+ (_out)->y = A[0].y*B03v + A[1].y*B13v + A[2].y*B23v + A[3].y*B33v; \
+ (_out)->z = A[0].z*B03v + A[1].z*B13v + A[2].z*B23v + A[3].z*B33v; \
+} \
+MACRO_STOP
+
+#define RtBezierQuadDifferenceStepU3dMacro(_row) \
+MACRO_START \
+{ \
+ (_row)[0].x += (_row)[1].x; \
+ (_row)[0].y += (_row)[1].y; \
+ (_row)[0].z += (_row)[1].z; \
+ \
+ (_row)[1].x += (_row)[2].x; \
+ (_row)[1].y += (_row)[2].y; \
+ (_row)[1].z += (_row)[2].z; \
+ \
+ (_row)[2].x += (_row)[3].x; \
+ (_row)[2].y += (_row)[3].y; \
+ (_row)[2].z += (_row)[3].z; \
+ \
+} \
+MACRO_STOP
+
+#define RtBezierQuadDifferenceStepU4dMacro(_row) \
+MACRO_START \
+{ \
+ (_row)[0].x += (_row)[1].x; \
+ (_row)[0].y += (_row)[1].y; \
+ (_row)[0].z += (_row)[1].z; \
+ (_row)[0].w += (_row)[1].w; \
+ \
+ (_row)[1].x += (_row)[2].x; \
+ (_row)[1].y += (_row)[2].y; \
+ (_row)[1].z += (_row)[2].z; \
+ (_row)[1].w += (_row)[2].w; \
+ \
+ (_row)[2].x += (_row)[3].x; \
+ (_row)[2].y += (_row)[3].y; \
+ (_row)[2].z += (_row)[3].z; \
+ (_row)[2].w += (_row)[3].w; \
+ \
+} \
+MACRO_STOP
+
+#define RtBezierQuadDifferenceStepV3dMacro(_mat) \
+MACRO_START \
+{ \
+ RtBezierV4d * const m0 = &(_mat)[0][0]; \
+ RtBezierV4d * const m1 = &(_mat)[1][0]; \
+ RtBezierV4d * const m2 = &(_mat)[2][0]; \
+ RtBezierV4d * const m3 = &(_mat)[3][0]; \
+ \
+ /* (_row) 0 */ \
+ m0[0].x += m1[0].x; \
+ m0[0].y += m1[0].y; \
+ m0[0].z += m1[0].z; \
+ \
+ m0[1].x += m1[1].x; \
+ m0[1].y += m1[1].y; \
+ m0[1].z += m1[1].z; \
+ \
+ m0[2].x += m1[2].x; \
+ m0[2].y += m1[2].y; \
+ m0[2].z += m1[2].z; \
+ \
+ m0[3].x += m1[3].x; \
+ m0[3].y += m1[3].y; \
+ m0[3].z += m1[3].z; \
+ \
+ /* (_row) 1 */ \
+ m1[0].x += m2[0].x; \
+ m1[0].y += m2[0].y; \
+ m1[0].z += m2[0].z; \
+ \
+ m1[1].x += m2[1].x; \
+ m1[1].y += m2[1].y; \
+ m1[1].z += m2[1].z; \
+ \
+ m1[2].x += m2[2].x; \
+ m1[2].y += m2[2].y; \
+ m1[2].z += m2[2].z; \
+ \
+ m1[3].x += m2[3].x; \
+ m1[3].y += m2[3].y; \
+ m1[3].z += m2[3].z; \
+ \
+ /* (_row) 2 */ \
+ m2[0].x += m3[0].x; \
+ m2[0].y += m3[0].y; \
+ m2[0].z += m3[0].z; \
+ \
+ m2[1].x += m3[1].x; \
+ m2[1].y += m3[1].y; \
+ m2[1].z += m3[1].z; \
+ \
+ m2[2].x += m3[2].x; \
+ m2[2].y += m3[2].y; \
+ m2[2].z += m3[2].z; \
+ \
+ m2[3].x += m3[3].x; \
+ m2[3].y += m3[3].y; \
+ m2[3].z += m3[3].z; \
+} \
+MACRO_STOP
+
+#define RtBezierQuadDifferenceStepV4dMacro(_mat) \
+MACRO_START \
+{ \
+ RtBezierV4d * const m0 = &(_mat)[0][0]; \
+ RtBezierV4d * const m1 = &(_mat)[1][0]; \
+ RtBezierV4d * const m2 = &(_mat)[2][0]; \
+ RtBezierV4d * const m3 = &(_mat)[3][0]; \
+ \
+ /* (_row) 0 */ \
+ m0[0].x += m1[0].x; \
+ m0[0].y += m1[0].y; \
+ m0[0].z += m1[0].z; \
+ m0[0].w += m1[0].w; \
+ \
+ m0[1].x += m1[1].x; \
+ m0[1].y += m1[1].y; \
+ m0[1].z += m1[1].z; \
+ m0[1].w += m1[1].w; \
+ \
+ m0[2].x += m1[2].x; \
+ m0[2].y += m1[2].y; \
+ m0[2].z += m1[2].z; \
+ m0[2].w += m1[2].w; \
+ \
+ m0[3].x += m1[3].x; \
+ m0[3].y += m1[3].y; \
+ m0[3].z += m1[3].z; \
+ m0[3].w += m1[3].w; \
+ \
+ /* (_row) 1 */ \
+ m1[0].x += m2[0].x; \
+ m1[0].y += m2[0].y; \
+ m1[0].z += m2[0].z; \
+ m1[0].w += m2[0].w; \
+ \
+ m1[1].x += m2[1].x; \
+ m1[1].y += m2[1].y; \
+ m1[1].z += m2[1].z; \
+ m1[1].w += m2[1].w; \
+ \
+ m1[2].x += m2[2].x; \
+ m1[2].y += m2[2].y; \
+ m1[2].z += m2[2].z; \
+ m1[2].w += m2[2].w; \
+ \
+ m1[3].x += m2[3].x; \
+ m1[3].y += m2[3].y; \
+ m1[3].z += m2[3].z; \
+ m1[3].w += m2[3].w; \
+ \
+ /* (_row) 2 */ \
+ m2[0].x += m3[0].x; \
+ m2[0].y += m3[0].y; \
+ m2[0].z += m3[0].z; \
+ m2[0].w += m3[0].w; \
+ \
+ m2[1].x += m3[1].x; \
+ m2[1].y += m3[1].y; \
+ m2[1].z += m3[1].z; \
+ m2[1].w += m3[1].w; \
+ \
+ m2[2].x += m3[2].x; \
+ m2[2].y += m3[2].y; \
+ m2[2].z += m3[2].z; \
+ m2[2].w += m3[2].w; \
+ \
+ m2[3].x += m3[3].x; \
+ m2[3].y += m3[3].y; \
+ m2[3].z += m3[3].z; \
+ m2[3].w += m3[3].w; \
+} \
+MACRO_STOP
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+extern void
+RtBezierQuadControlFit3d(RtBezierMatrix B,
+ RtBezierMatrix P);
+
+extern void
+RtBezierQuadBernsteinWeight3d(RtBezierMatrix W,
+ RtBezierMatrix B);
+
+extern void
+RtBezierQuadBernsteinWeight4d(RtBezierMatrix W,
+ RtBezierMatrix B);
+
+extern void
+RtBezierQuadPointDifference3d(RtBezierMatrix D,
+ RtBezierMatrix W,
+ RwReal PointU,
+ RwReal PointV,
+ RwReal StepU,
+ RwReal stepV);
+
+extern void
+RtBezierQuadPointDifference4d(RtBezierMatrix D,
+ RtBezierMatrix W,
+ RwReal PointU,
+ RwReal PointV,
+ RwReal StepU,
+ RwReal stepV);
+
+extern void
+RtBezierQuadOriginDifference3d(RtBezierMatrix D,
+ RtBezierMatrix W,
+ RwReal stepU,
+ RwReal setpV);
+
+extern void
+RtBezierQuadOriginDifference4d(RtBezierMatrix D,
+ RtBezierMatrix W,
+ RwReal stepU,
+ RwReal setpV);
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+
+extern void
+RtBezierQuadSample3d(RwV3d * out,
+ RtBezierMatrix B,
+ RwReal u,
+ RwReal v);
+
+extern void RtBezierQuadDifferenceStepU3d(RtBezierRow row);
+extern void RtBezierQuadDifferenceStepU4d(RtBezierRow row);
+
+extern void RtBezierQuadDifferenceStepV3d(RtBezierMatrix mat);
+extern void RtBezierQuadDifferenceStepV4d(RtBezierMatrix mat);
+
+
+#else /* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */
+
+#define RtBezierQuadSample3d(_out, _P, _u, _v) \
+ RtBezierQuadSample3dMacro(_out, _P, _u, _v)
+
+#define RtBezierQuadDifferenceStepU3d(_row) \
+ RtBezierQuadDifferenceStepU3dMacro(_row)
+
+#define RtBezierQuadDifferenceStepU4d(_row) \
+ RtBezierQuadDifferenceStepU4dMacro(_row)
+
+#define RtBezierQuadDifferenceStepV3d(_mat) \
+ RtBezierQuadDifferenceStepV3dMacro(_mat)
+
+#define RtBezierQuadDifferenceStepV4d(_mat) \
+ RtBezierQuadDifferenceStepV4dMacro(_mat)
+
+#endif /* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */
+
+/*
+ *
+ */
+
+extern void
+RtBezierTriangleControlFit3d(RtBezierMatrix T, RtBezierMatrix P);
+
+extern void
+RtBezierQuadFromTriangle(RtBezierMatrix Q, RtBezierMatrix T);
+
+extern void
+RtBezierQuadTangent(RtBezierMatrix D,
+ RwReal theta,
+ RtBezierMatrix P);
+
+extern void
+RtBezierQuadTangentPair(RtBezierMatrix Dt,
+ RtBezierMatrix Dp,
+ RwReal theta,
+ RtBezierMatrix P);
+
+extern void
+RtBezierQuadGetNormals(RtBezierMatrix N,
+ RtBezierMatrix B);
+
+#if (defined(RWDEBUG) && defined(RWVERBOSE))
+
+extern void
+_rtBezierGnuPlot(RtBezierMatrix B,
+ RwChar * name,
+ RwChar * title);
+
+#else /* (defined(RWDEBUG) && defined(RWVERBOSE)) */
+
+#define _rtBezierGnuPlot(B, name, title) /* No-op */
+
+#endif /* (defined(RWDEBUG) && defined(RWVERBOSE)) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* (!defined(RTBEZPAT_H)) */
diff --git a/rwsdk/include/d3d8/rtbezpat.rpe b/rwsdk/include/d3d8/rtbezpat.rpe
new file mode 100644
index 00000000..e49b65b4
--- /dev/null
+++ b/rwsdk/include/d3d8/rtbezpat.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionBEZPATCH
+{
+
+
+
+ e_rwdb_CriterionBEZPATCHLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionBEZPATCH e_rwdb_CriterionBEZPATCH;
+
+
diff --git a/rwsdk/include/d3d8/rtbmp.h b/rwsdk/include/d3d8/rtbmp.h
new file mode 100644
index 00000000..37b5c97b
--- /dev/null
+++ b/rwsdk/include/d3d8/rtbmp.h
@@ -0,0 +1,51 @@
+
+/***************************************************************************
+ * *
+ * Module : rtBMP.h *
+ * *
+ * Purpose : Load BMP format files *
+ * *
+ **************************************************************************/
+
+#ifndef RTBMP_H
+#define RTBMP_H
+
+/**
+ * \defgroup rtbmp RtBMP
+ * \ingroup rttool
+ *
+ * BMP Image Format Toolkit for RenderWare.
+ *
+ * See also http://www.daubnet.com/formats/BMP.html
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+/*--- Include files ---*/
+#include "rwcore.h"
+
+#include "rtbmp.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwImage *RtBMPImageWrite(RwImage * image,
+ const RwChar * imageName);
+extern RwImage *RtBMPImageRead(const RwChar * imageName);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+#endif /* RTBMP_H */
diff --git a/rwsdk/include/d3d8/rtbmp.rpe b/rwsdk/include/d3d8/rtbmp.rpe
new file mode 100644
index 00000000..29dad089
--- /dev/null
+++ b/rwsdk/include/d3d8/rtbmp.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionBMP
+{
+
+
+
+ e_rwdb_CriterionBMPLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionBMP e_rwdb_CriterionBMP;
+
+
diff --git a/rwsdk/include/d3d8/rtcharse.h b/rwsdk/include/d3d8/rtcharse.h
new file mode 100644
index 00000000..4fdc2568
--- /dev/null
+++ b/rwsdk/include/d3d8/rtcharse.h
@@ -0,0 +1,111 @@
+/*
+ *
+ * Data structures for the charse toolkit
+ */
+
+/***************************************************************************
+ * *
+ * Module : rtcharse.h *
+ * *
+ * Purpose : Charset handling *
+ * *
+ **************************************************************************/
+
+#ifndef RTCHARSE_H
+#define RTCHARSE_H
+
+/**
+ * \defgroup rtcharset RtCharset
+ * \ingroup rttool
+ *
+ * Character Set/Foot Toolkit for RenderWare.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include <rwcore.h>
+
+/****************************************************************************
+ Global Types
+ */
+
+/* RWPUBLIC */
+
+typedef struct RtCharsetDesc RtCharsetDesc;
+
+/**
+ * \ingroup rtcharset
+ * \struct RtCharsetDesc
+ * Holds information about a character set.
+ */
+struct RtCharsetDesc
+{
+ RwInt32 width;
+ /**< Pixel-width of each character. */
+ RwInt32 height;
+ /**< Pixel-height of each character. */
+ RwInt32 width_internal;
+ /**< Pixel-width used internally, this is usually width+1 to add a border */
+ RwInt32 height_internal;
+ /**< Pixel-height used internally, this is usually height+1 to add a border */
+ RwInt32 count;
+ /**< Number of characters in the set. */
+ RwInt32 tilewidth;
+ /**< Width of raster in characters. */
+ RwInt32 tileheight;
+ /**< Height of raster in characters. */
+
+};
+
+/**
+ * \ingroup rtcharset
+ * \typedef RtCharset
+ * typedef for a structure defining a character set (opaque).
+ * \see RtCharsetCreate
+ */
+typedef RwRaster RtCharset;
+
+/* RWPUBLICEND */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+/* RWPUBLIC */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwBool RtCharsetOpen(void);
+extern void RtCharsetClose(void);
+
+extern RtCharset *RtCharsetPrint(RtCharset * charSet,
+ const RwChar * string,
+ RwInt32 x, RwInt32 y);
+extern RtCharset *RtCharsetPrintBuffered(RtCharset * charSet,
+ const RwChar * string,
+ RwInt32 x, RwInt32 y,
+ RwBool hideSpaces);
+extern RwBool RtCharsetBufferFlush(void);
+
+extern RtCharset *RtCharsetSetColors(RtCharset * charSet,
+ const RwRGBA * foreGround,
+ const RwRGBA * backGround);
+extern RtCharset *RtCharsetGetDesc(RtCharset * charset,
+ RtCharsetDesc * desc);
+
+extern RtCharset *RtCharsetCreate(const RwRGBA * foreGround,
+ const RwRGBA * backGround);
+extern RwBool RtCharsetDestroy(RtCharset * charSet);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+#endif /* RTCHARSE_H */
diff --git a/rwsdk/include/d3d8/rtcharse.rpe b/rwsdk/include/d3d8/rtcharse.rpe
new file mode 100644
index 00000000..39c37312
--- /dev/null
+++ b/rwsdk/include/d3d8/rtcharse.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionCharset
+{
+
+
+
+ e_rwdb_CriterionCharsetLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionCharset e_rwdb_CriterionCharset;
+
+
diff --git a/rwsdk/include/d3d8/rtimport.h b/rwsdk/include/d3d8/rtimport.h
new file mode 100644
index 00000000..cf4e6283
--- /dev/null
+++ b/rwsdk/include/d3d8/rtimport.h
@@ -0,0 +1,1278 @@
+/***************************************************************************
+ * *
+ * Module : rtimport.h *
+ * *
+ * Purpose : World handling functions. *
+ * *
+ **************************************************************************/
+
+#ifndef RTIMPORT_H
+#define RTIMPORT_H
+
+/**
+ * \defgroup rtimport RtWorldImport
+ * \ingroup rttool
+ *
+ * World Import Toolkit for Renderware.
+ */
+
+/**
+ * \defgroup selectors RtWorldImportPartitionSelectors
+ * \ingroup rtimport
+ *
+ * The set of provided RtWorldImportPartitionSelectors:
+ * Selects a good partition by calling one of the
+ * \ref iterators and then
+ * one of the \ref evaluators to
+ * see which is best.
+ */
+
+/**
+ * \defgroup iterators RtWorldImportPartitionIterators
+ * \ingroup rtimport
+ *
+ * The set of provided RtWorldImportPartitionIterators:
+ * Iterates through a set of candidate partitions, possibly
+ * using the geometric information in the build sector, or perhaps
+ * using some other criteria.
+ */
+
+/**
+ * \defgroup evaluators RtWorldImportPartitionEvaluators
+ * \ingroup rtimport
+ *
+ * The set of provided RtWorldImportPartitionEvaluators:
+ * Uses a combination of statistics, build sector, build status, and
+ * possibly other criteria to evaluate a partition. While the value
+ * returned can be any real value, all provided evaluators are return
+ * lower values for better partitioners, and are in the range [0..1]
+ * where appropriate
+ */
+
+/**
+ * \defgroup terminators RtWorldImportPartitionTerminators
+ * \ingroup rtimport
+ *
+ * The set of provided RtWorldImportPartitionTerminators:
+ * Checks given criteria about the statistics, build sector, build status, and
+ * possibly other criteria to see whether the building process should be
+ * allowed to terminate, or whether more parititoning is necessary.
+ */
+
+/**
+ * \defgroup kd RtWorldImportGuideKD
+ * \ingroup rtimport
+ *
+ * Tools to manipulate the \ref RtWorldImportGuideKDTree that is used to
+ * manually build the sectors of a world.
+ */
+
+/**
+ * \defgroup hints RtWorldImportHints
+ * \ingroup rtimport
+ *
+ * Tools to aid the build process by giving hints as to what geometry should
+ * not be split, and what geometry makes for a good partitioning guide.
+ */
+
+/****************************************************************************
+ Includes
+ */
+#include "rwcore.h"
+#include "rpworld.h"
+
+#include "rtimport.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Defines
+ */
+
+/* Progress callback message types */
+#define rtWORLDIMPORTPROGRESSBSPBUILDSTART 0
+#define rtWORLDIMPORTPROGRESSBSPBUILDUPDATE 1
+#define rtWORLDIMPORTPROGRESSBSPBUILDEND 2
+#define rtWORLDIMPORTPROGRESSBSPCOMPRESSSTART 3
+#define rtWORLDIMPORTPROGRESSBSPCOMPRESSUPDATE 4
+#define rtWORLDIMPORTPROGRESSBSPCOMPRESSEND 5
+
+/**
+ * \ingroup rtimport
+ * \def rtWORLDIMPORTINVALIDPARTITION
+ *
+ * This value means that no partition was found, or that the partition was
+ * invalid or impractical. The value represents infinity.
+ */
+#define rtWORLDIMPORTINVALIDPARTITION RwRealMAXVAL
+
+/****************************************************************************
+ Global types
+ */
+
+/**
+ * Internal use only
+ */
+typedef union RtWorldImportVertexState RtWorldImportVertexState;
+
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportVertex
+ *
+ * typedef for struct \ref RtWorldImportVertex
+ */
+typedef struct RtWorldImportVertex RtWorldImportVertex;
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportWeldVertex
+ *
+ * typedef for struct \ref RtWorldImportWeldVertex
+ */
+typedef struct RtWorldImportWeldVertex RtWorldImportWeldVertex;
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportBuildVertex
+ *
+ * typedef for struct \ref RtWorldImportBuildVertex
+ */
+typedef struct RtWorldImportBuildVertex RtWorldImportBuildVertex;
+
+
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportBuildPolyInfo
+ *
+ * typedef for struct \ref RtWorldImportBuildPolyInfo
+ */
+typedef struct RtWorldImportBuildPolyInfo RtWorldImportBuildPolyInfo;
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportBuildPolyInfo
+ *
+ * Information about a polygon
+ */
+struct RtWorldImportBuildPolyInfo
+{
+ RwInt16 matIndex;
+ /**< The material index */
+ RwUInt8 clipFlags;
+ /**< Clipping flags */
+ RwUInt8 hasAlpha;
+ /**< Alpha status */
+ void *pUserdata;
+ /**< Userdata */
+};
+
+typedef union RtWorldImportBuildVertexMode RtWorldImportBuildVertexMode;
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportBuildVertexMode
+ *
+ * Mode of the vertex.
+ *
+ */
+union RtWorldImportBuildVertexMode
+{
+ RtWorldImportVertex *vpVert;
+ /**< The vertex */
+ RwInt32 index;
+ /**< The index */
+};
+
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportBuildVertex
+ *
+ * A list of polygons as a list of vertices where the end of poly boundary
+ * is marked by mode.vpVert == NULL.
+ *
+ */
+struct RtWorldImportBuildVertex
+{
+ RtWorldImportBuildVertexMode mode;
+ /**< The mode of the element */
+
+ RtWorldImportBuildPolyInfo pinfo;
+ /**< we store some poly info in the end marker of a boundary */
+};
+
+
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportGuideKDTree
+ *
+ * typedef for struct \ref RtWorldImportGuideKDTree
+ */
+typedef struct RtWorldImportGuideKDTree RtWorldImportGuideKDTree;
+
+/* NB Merged RtWorldImportPartition with RtWorldImportBuildClipStatistics because
+ * there was a unique one-to-one relationship between them, and it made things easier
+ * just updating one stucture, without having to update both in sequence...
+ */
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportBuildClipStatistics
+ *
+ * typedef for struct \ref RtWorldImportBuildClipStatistics
+ */
+typedef struct RtWorldImportBuildClipStatistics RtWorldImportBuildClipStatistics;
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportBuildClipStatistics
+ *
+ * Holds statistics about a partition or candidate partition during
+ * the build process.
+ */
+struct RtWorldImportBuildClipStatistics
+{
+ RwInt32 numPotentialSplit;
+ /**< The number of polygons split by the partition,
+ * disgregarding overlaps */
+
+ RwInt32 numPotentialLeft;
+ /**< The number of potential polygons and fragments on the
+ * left of the partition, disgregarding overlaps */
+
+ RwInt32 numPotentialRight;
+ /**< The number of potential polygons and fragments on the
+ * right of the partition, disgregarding overlaps */
+
+
+ RwInt32 numActualSplit;
+ /**< The number of polygons split by the partition */
+
+ RwInt32 numActualLeft;
+ /**< The number of polygons and fragments on the
+ * left of the partition */
+
+ RwInt32 numActualRight;
+ /**< The number of polygons and fragments on the
+ * right of the partition */
+
+
+ RwInt32 numMaterialLeft;
+ /**< The number of materials on the left of the partition */
+
+ RwInt32 numMaterialRight;
+ /**< The number of materials on the right of the partition */
+
+ RwInt32 numMaterialSplits;
+ /**< The number of materials split by the partition */
+
+
+ RwInt32 numMaterialSector;
+ /**< The total number of materials in the sector containing
+ * the partition */
+
+
+ RwReal overlapLeft;
+ /**< The actual, relative size of the overlap on the left of the partition */
+
+ RwReal overlapRight;
+ /**< The actual, relative size of the overlap on the right of the partition */
+};
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportPartition
+ *
+ * typedef for struct \ref RtWorldImportPartition
+ */
+typedef struct RtWorldImportPartition RtWorldImportPartition;
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportPartition
+ *
+ * A partitioning plane.
+ */
+struct RtWorldImportPartition
+{
+ RwInt32 type;
+ /**< Plane type, i.e. 0,4,8 for being normal to the x,y,z axes respectively. */
+
+ RwReal value;
+ /**< The distance of the plane from the origin */
+
+ RwReal maxLeftValue;
+ /**< The maximum value of the left face of the overlap. This is derived
+ * from the maxOverlapPercent value in \ref RtWorldImportParameters
+ */
+
+ RwReal maxRightValue;
+ /**< The maximum value of the right face of the overlap. This is derived
+ * from the maxOverlapPercent value in \ref RtWorldImportParameters
+ */
+
+ RtWorldImportBuildClipStatistics buildStats;
+ /**< The statistics for the partition */
+};
+
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportGuideKDTree
+ * Represents the structure of a binary tree with
+ * no contents per se. It is used to build a BSP in a user specified
+ * manner instead of using any heuristic.
+ *
+ */
+struct RtWorldImportGuideKDTree
+{
+ RtWorldImportPartition partition;
+ /**< A partitioning plane */
+
+ RwBBox bbox;
+ /**< Bounding box of the sector or super-sector */
+
+ RtWorldImportGuideKDTree *parent;
+ /**< Pointer to its parent */
+
+ RwInt32 order;
+ /**< Relationship information - 0 for left child, 1 for right child */
+
+ RtWorldImportGuideKDTree *left;
+ /**< Left child */
+
+ RtWorldImportGuideKDTree *right;
+ /**< Right child */
+};
+
+typedef struct _rtWorldImportGuideKDStackElement _rtWorldImportGuideKDStackElement;
+
+struct _rtWorldImportGuideKDStackElement
+{
+ RwBool terminal;
+ RtWorldImportGuideKDTree *node;
+ _rtWorldImportGuideKDStackElement *next;
+};
+
+typedef struct _rtWorldImportGuideKDStack _rtWorldImportGuideKDStack;
+
+struct _rtWorldImportGuideKDStack
+{
+ _rtWorldImportGuideKDStackElement *top;
+ _rtWorldImportGuideKDStackElement *current;
+ _rtWorldImportGuideKDStackElement *bottom;
+};
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportBuildSector
+ *
+ * typedef for struct \ref RtWorldImportBuildSector
+ */
+typedef struct RtWorldImportBuildSector RtWorldImportBuildSector;
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportBuildSector
+ *
+ * Holds information about the sector that is being subdivided
+ */
+struct RtWorldImportBuildSector
+{
+ RwInt32 type;
+ /**< Sector type (so can handle in an RpWorld) */
+
+ RtWorldImportVertex *vertices;
+ /**< A pointer to the list of vertices */
+
+ RwInt32 numVertices;
+ /**< The number of vertices */
+
+ RtWorldImportBuildVertex *boundaries;
+ /**< A list of boundaries \see RtWorldImportBuildVertex */
+
+ RwInt32 numBoundaries;
+ /**< The number of boundaries */
+
+ RwInt32 numPolygons;
+ /**< The number of polygons (triangles) */
+
+ RwBBox boundingBox;
+ /**< Sector's bounding box */
+
+ RwReal overlap;
+ /**< The percentage that the sector overlaps with its neighbour */
+
+ RwUInt32 maxNumMaterials;
+ /**< Maximum number of materials in the in the world */
+};
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportBuildStatus
+ *
+ * typedef for struct \ref RtWorldImportBuildStatus
+ */
+typedef struct RtWorldImportBuildStatus RtWorldImportBuildStatus;
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportBuildStatus
+ * World Import Build Status Structure
+ * Used to store the current tree's build status
+ */
+struct RtWorldImportBuildStatus
+{
+ RwInt32 depth; /**< current depth in the tree */
+};
+
+/**
+ * Internal use only
+ */
+union RtWorldImportVertexState
+{
+ /* clipFlags, two types, first is based on partition only, 2nd is
+ * also based on partition, but takes overlaps into consideration. i.e.
+ * number splits is usually higher in clipFlags[0] than [1] */
+ RwInt32 clipFlags[2]; /**< Internal use only */
+ RwInt32 forwardingAddress; /**< Internal use only */
+ RtWorldImportVertex *vpVert; /**< Internal use only */
+ RtWorldImportWeldVertex *vpWeldVert; /**< Internal use only */
+ RtWorldImportBuildVertex *vpBuildVert; /**< Internal use only */
+ RwSList *slist; /**< Internal use only */
+};
+
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportVertex
+ * Holds data for each vertex in the import world.
+ *
+ */
+struct RtWorldImportVertex
+{
+ RwV3d OC; /**< World space vertex position */
+ RwV3d normal; /**< World space vertex normal */
+ RwRGBA preLitCol; /**< Vertex Prelight color */
+ RwTexCoords texCoords[rwMAXTEXTURECOORDS];
+ /**< Vertex texture coordinates */
+ RtWorldImportVertexState state; /**< Internal use only */
+ RwInt32 matIndex; /**< Vertex material index */
+ void *pUserdata; /**< Pointer to unspecified per vertex user data */
+};
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportTriangle
+ * Holds data for each triangle in the import world.
+ *
+ * \see RtWorldImportTriangle
+ */
+typedef struct RtWorldImportTriangle RtWorldImportTriangle;
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportTriangle
+ * Holds data for each triangle in the import world.
+ *
+ * \see RtWorldImportTriangle
+ */
+struct RtWorldImportTriangle
+{
+ RwInt32 matIndex; /**< Index into material list */
+ RwInt32 vertIndex[3]; /**< Indices into vertex list */
+ void *pUserdata; /**< Pointer to unspecified per triangle user data */
+};
+
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportHints
+ *
+ * typedef for struct \ref RtWorldImportHints
+ */
+typedef struct RtWorldImportHints RtWorldImportHints;
+
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportHints
+ * Bounding box hints used to control the world sectorization process.
+ * \see RtWorldImportHintsSet
+ */
+struct RtWorldImportHints
+{
+ /** The bounding box hints */
+ RwBBox *boundingBoxes;
+ /** The number of bounding box hints */
+ RwInt32 numBoundingBoxes;
+};
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportParameters
+ *
+ * typedef for struct \ref RtWorldImportParameters
+ */
+typedef struct RtWorldImportParameters RtWorldImportParameters;
+
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportParameters
+ * Parameters used with \ref RtWorldImportCreateWorld.
+ * They are initialized to default values using \ref RtWorldImportParametersInit.
+ *
+ */
+struct RtWorldImportParameters
+{
+ RwReal worldSectorMaxSize;
+ /**< The maximum world sector size. */
+ RwInt32 maxWorldSectorPolygons;
+ /**< The maximum number of polygons in a world sector. */
+ RwReal maxOverlapPercent;
+ /**< Total fraction of world sector overlap allowed. */
+ RwReal weldThreshold;
+ /**< Threshold for welding vertices. */
+ RwReal angularThreshold;
+ /**< Angular threshold for welding vertex normals */
+ RwBool calcNormals;
+ /**< If TRUE then importer creates normals. */
+ RwBool conditionGeometry;
+ /**< If TRUE perform vertex welding and degenerate triangle removal.*/
+ RwBool userSpecifiedBBox;
+ /**< If TRUE allows user to specify minimum bounding-box for the
+ * world using the userBBox parameter. */
+ RwBBox userBBox;
+ /**< User specified world bounding-box if userSpecifiedBBox is TRUE.*/
+ RwReal uvLimit;
+ /**< If conditionGeometry is TRUE limit texture coordinates to this
+ * value. */
+ RwBool retainCreases;
+ /**< If TRUE then duplicate vertices with differing normals will not
+ * be merged. */
+ RwBool fixTJunctions;
+ /**< If TRUE then T-junctions are fixed in the geometry (slow). */
+ RwBool weldPolygons;
+ /**< If TRUE then polygons are welded where possible to reduce the
+ * polygon count. */
+ RwInt32 flags;
+ /**< Conversion flags (see RpWorldFlag). */
+ RwTextureAddressMode mode;
+ /**< If \ref rwTEXTUREADDRESSWRAP than weld vertices according to
+ * mod(1) congruent texture coordinates */
+ RwBool sortPolygons;
+ /**< If TRUE then polygons are sorted by their centroid */
+ RwBool cullZeroAreaPolygons;
+ /**< If TRUE then zero-area polygons are culled */
+ RwInt32 numTexCoordSets;
+ /**< The number of texture coordinate sets to use. If set to zero, then
+ * the number is taken from the flags parameter which, for backward
+ * compatibility, can include the \ref rpWORLDTEXTURED or \ref rpWORLDTEXTURED2
+ * flags. These specify one or two sets respectively. */
+ RwBool terminatorCheck;
+ /**< If TRUE the world will be checked for validity during the build process. */
+};
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImport
+ *
+ * typedef for struct \ref RtWorldImport
+ */
+typedef struct RtWorldImport RtWorldImport;
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImport
+ * World Import State Structure
+ */
+struct RtWorldImport
+{
+ RpMaterialList matList; /**< Material list */
+ RtWorldImportVertex *vertices; /**< Vertex array */
+ RwInt32 numVertices; /**< Vertex count */
+
+ RtWorldImportTriangle *polygons; /**< Triangle array */
+ RwInt32 numPolygons; /**< Triangle count */
+
+
+ RwSurfaceProperties surfaceProps; /**< The world's surface
+ lighting properties */
+};
+
+/**
+ * \ingroup rtimport
+ * \ref RtWorldImportProgressCallBack is the type for the callback function supplied to
+ * \ref RtWorldImportSetProgressCallBack.
+ *
+ * \param msg Message type corresponding to one of the following:
+ * \li rtWORLDIMPORTPROGRESSBSPBUILDSTART -
+ * The BSP creation process is about to start.
+ * The argument value is equal to 0.0.
+ * \li rtWORLDIMPORTPROGRESSBSPBUILDUPDATE -
+ * The BSP creation process has finished processing a subsection of
+ * the world. The argument value is equal to the percentage of the
+ * world processed up to this point.
+ * \li rtWORLDIMPORTPROGRESSBSPBUILDEND -
+ * The BSP creation process has ended.
+ * The argument value is equal to 100.0.
+ * \li rtWORLDIMPORTPROGRESSBSPCOMPRESSSTART -
+ * The BSP compression process is about to start. The argument value
+ * is equal to 0.0.
+ * \li rtWORLDIMPORTPROGRESSBSPCOMPRESSUPDATE -
+ * The BSP compression has finished processing a subsection of the
+ * world. The argument value is equal to the percentage of the world
+ * processed up to this point.
+ * \li rtWORLDIMPORTPROGRESSBSPCOMPRESSEND -
+ * The BSP compression process has ended. The argument value is equal
+ * to 100.0.
+ *
+ * \param value The percentage of the progress made in either BSP
+ * building or BSP compression.
+ *
+ * \return TRUE to continue BSP processing, FALSE to abort.
+ *
+ * \see RtWorldImportSetProgressCallBack
+ */
+typedef RwBool (*RtWorldImportProgressCallBack)(RwInt32 msg, RwReal value);
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportDestroyVertexUserdataCallBack
+ *
+ * A pointer to the CallBack function that will be called during
+ * vertex destruction.
+ */
+typedef RwBool (*RtWorldImportDestroyVertexUserdataCallBack)(void **pUserdata);
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportCloneVertexUserdataCallBack
+ *
+ * A pointer to the CallBack function that will be called during
+ * vertex cloning.
+ */
+typedef RwBool (*RtWorldImportCloneVertexUserdataCallBack)(void **pUserdataDst, void **pUserdataSrc);
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportInterpVertexUserdataCallBack
+ *
+ * A pointer to the CallBack function that will be called during
+ * vertex interpolation.
+ */
+typedef RwBool (*RtWorldImportInterpVertexUserdataCallBack)(void **pUserdataDst, void **pUserdata1, void **pUserdata2, RwReal delta);
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportDestroyPolygonUserdataCallBack
+ *
+ * A pointer to the CallBack function that will be called during
+ * polygon destruction.
+ */
+typedef RwBool (*RtWorldImportDestroyPolygonUserdataCallBack)(void **pUserdata);
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportSplitPolygonUserdataCallBack
+ *
+ * A pointer to the CallBack function that will be called during
+ * polygon division.
+ */
+typedef RwBool (*RtWorldImportSplitPolygonUserdataCallBack)(void **pUserdataDst, void **pUserdataSrc);
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportSectorSetVertexUserdataCallBack
+ *
+ * A pointer to the CallBack function that will be called during
+ * the setting of the vertex user data.
+ */
+typedef RwBool (*RtWorldImportSectorSetVertexUserdataCallBack)(void **pUserdata, RpWorldSector *sector, RwInt32 index);
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportSectorSetPolygonUserdataCallBack
+ *
+ * A pointer to the CallBack function that will be called during
+ * the setting of the polygon user data.
+ */
+typedef RwBool (*RtWorldImportSectorSetPolygonUserdataCallBack)(void **pUserdata, RpWorldSector *sector, RwInt32 index);
+
+
+
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportTerminationBuildCallBack
+ *
+ * A pointer to the function that will be called during the
+ * build process to determine whether the current sector should
+ * be subdivided further, or terminated.
+ */
+typedef RwBool (*RtWorldImportTerminationBuildCallBack)
+ (RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ void *pData);
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportPartitionBuildCallBack
+ *
+ * A pointer to the function that will be called during the
+ * build process to select a suitable sector partition.
+ */
+typedef RwReal (*RtWorldImportPartitionBuildCallBack)
+ (RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *pData);
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportBuildCallBacks
+ *
+ * typedef for struct \ref RtWorldImportBuildCallBacks
+ */
+typedef struct RtWorldImportBuildCallBacks RtWorldImportBuildCallBacks; /* MAYBE: rename to SectorCallBacks ?*/
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportBuildCallBacks
+ * Sectorization callbacks
+ */
+struct RtWorldImportBuildCallBacks
+{
+ RtWorldImportPartitionBuildCallBack partitionBuild;
+ /**< Callback for choosing partition */
+ void *partitionUserData;
+ /**< Partition callback user data */
+ RtWorldImportTerminationBuildCallBack terminationBuild;
+ /**< Callback for termination of further partitioning */
+ void *terminationUserData;
+ /**< Termination callback user data */
+};
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportUserdataCallBacks
+ *
+ * typedef for struct \ref RtWorldImportUserdataCallBacks
+ */
+typedef struct RtWorldImportUserdataCallBacks RtWorldImportUserdataCallBacks;
+/**
+ * \ingroup rtimport
+ * \struct RtWorldImportUserdataCallBacks
+ * Bundle of callbacks
+ */
+struct RtWorldImportUserdataCallBacks
+{
+ RtWorldImportDestroyVertexUserdataCallBack destroyVertexUserdata;
+ /**< Callback on vertex destruction */
+ RtWorldImportCloneVertexUserdataCallBack cloneVertexUserdata;
+ /**< Callback on vertex cloning */
+ RtWorldImportInterpVertexUserdataCallBack interpVertexUserdata;
+ /**< Callback on vertex interpolation */
+ RtWorldImportDestroyPolygonUserdataCallBack destroyPolygonUserdata;
+ /**< Callback on polygon destruction */
+ RtWorldImportSplitPolygonUserdataCallBack splitPolygonUserdata;
+ /**< Callback on polygon division */
+ RtWorldImportSectorSetVertexUserdataCallBack sectorSetVertexUserdata;
+ /**< Callback on setting vertex user data */
+ RtWorldImportSectorSetPolygonUserdataCallBack sectorSetPolygonUserdata;
+ /**< Callback on setting polygon user data */
+};
+
+/**
+ * \ingroup rtimport
+ * \typedef RtWorldImportBuildPartitionSelector
+ *
+ * An enumeration that can be passed to
+ * \ref RtWorldImportSetStandardBuildPartitionSelector to determine
+ * whether partitioning will be achieved automatically, using the
+ * default partition selected, or manually using the \ref RtWorldImportGuideKDTree
+ */
+typedef enum
+{
+ rwBUILDPARTITIONSELECTOR_DEFAULT,
+ /**< Sets the default automated process */
+ rwBUILDPARTITIONSELECTOR_GUIDED
+ /**< Sets the guided manual process */
+}
+RtWorldImportBuildPartitionSelector;
+
+
+
+
+/* Builds overlaps from plane and conversion params */
+#define BuildSectorSetOverlapsMacro(_boundingBox, _partition, _conversionParams) \
+MACRO_START \
+{ \
+ RwReal sup = GETCOORD((_boundingBox).sup, (_partition).type); \
+ RwReal inf = GETCOORD((_boundingBox).inf, (_partition).type); \
+ \
+ (_partition).maxLeftValue = \
+ (_partition).value + \
+ ((sup - (_partition).value) * (_conversionParams).maxOverlapPercent); \
+ \
+ (_partition).maxRightValue = \
+ (_partition).value - \
+ ((((_partition).value) - inf) * (_conversionParams).maxOverlapPercent); \
+} \
+MACRO_STOP
+
+/*****************************************************************************
+ * Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwBool
+_rtImportBuildSectorFindBBox(RtWorldImportBuildSector *buildSector, RwBBox *bbpOut);
+
+/* TODO: decide where these scheme functions are going and which ones are public and
+ whether _rt or RT should be used */
+extern void
+ _rtWorldImportGuideKDCopy(RtWorldImportGuideKDTree *KD, RpSector *spSector, RwInt32 depth);
+extern void _rtWorldImportGuideKDStackDestroy(_rtWorldImportGuideKDStack *stack);
+extern void
+_rtWorldImportGuideKDEncodeAsStack(RtWorldImportGuideKDTree *tree, _rtWorldImportGuideKDStack *stack);
+
+extern RtWorldImportGuideKDTree *RtWorldImportGuideKDCreate(RwBBox *bbox);
+extern RtWorldImportGuideKDTree *RtWorldImportGuideKDAddPartition
+ (RtWorldImportGuideKDTree *KD, RwInt32 type, RwReal value);
+extern void RtWorldImportGuideKDDeletePartition(RtWorldImportGuideKDTree *KD);
+extern void RtWorldImportGuideKDDestroy(RtWorldImportGuideKDTree *KD);
+
+extern RtWorldImportGuideKDTree *RtWorldImportGuideKDWrite(
+ RtWorldImportGuideKDTree *guideKD, const RwChar *filename);
+extern RtWorldImportGuideKDTree * RtWorldImportGuideKDRead(
+ const RwChar *filename, const RwBBox *bbox);
+
+/*****************************************************************************
+ * PARTITION SELECTORS - These callbacks for used to select a partition
+ * from a sector.
+ */
+
+extern RwReal
+RtWorldImportBalancedCullPartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData);
+
+extern RwReal
+RtWorldImportMaterialCountPartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData);
+
+extern RwReal
+RtWorldImportMaterialSeparatePartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData);
+
+extern RwReal
+RtWorldImportMaximumOccluderPartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportDisjointOccluderPartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportLeastCutAndBalancedPartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportMaximumExtentPartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportCullMiddleSpacePartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData);
+
+extern RwReal
+RtWorldImportCullEndSpacePartitionSelector(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData);
+
+extern RwReal
+RtWorldImportCullSpacePartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData);
+
+extern RwReal
+RtWorldImportHintBBoxPartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData);
+
+extern RwReal
+RtWorldImportGeneralOccluderPartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportBalancedTreePartitionSelector(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+/*****************************************************************************
+ * PARTITION ITERATORS - These callbacks iterate though a set of partitions
+ */
+
+extern RwBool
+RtWorldImportOrthogonalAutoPartitionIterator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData,
+ RwInt32* loopCounter);
+
+
+extern RwBool
+RtWorldImportRegularIntervalPartitionIterator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData,
+ RwInt32* loopCounter);
+
+
+extern RwBool
+RtWorldImportMiddleAxisPartitionIterator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData,
+ RwInt32 * loopCounter);
+
+
+extern RwBool
+RtWorldImportMedianPercentagePartitionIterator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData,
+ RwInt32 *loopCounter);
+
+
+extern RwBool
+RtWorldImportHintBBoxPartitionIterator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData,
+ RwInt32* loopCounter);
+
+extern RwBool
+RtWorldImportHighestVertexAccommodatingPlanePartitionIterator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData,
+ RwInt32* loopCounter);
+
+extern RwBool
+RtWorldImportMaterialBoundsPartitionIterator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData,
+ RwInt32 *loopCounter);
+
+/*****************************************************************************
+ * PARTITION EVALUATORS - These callbacks iterate though a set of partitions
+ */
+
+extern RwReal
+RtWorldImportFuzzyBalancedPartitionEvaluator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData);
+
+
+extern RwReal
+RtWorldImportPotentialSplitPartitionEvaluator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+
+extern RwReal
+RtWorldImportBalancedPartitionEvaluator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+
+extern RwReal
+RtWorldImportExtentPartitionEvaluator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+
+extern RwReal
+RtWorldImportOccluderPartitionEvaluator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+
+extern RwReal
+RtWorldImportWeightedOccluderPartitionEvaluator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportHintBBoxPartitionEvaluator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void *userData);
+
+extern RwReal
+RtWorldImportVolumeBalancedPartitionEvaluator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportWeightedDisjointOccluderPartitionEvaluator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportMaterialCutsPartitionEvaluator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportMaterialBalancedPartitionEvaluator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus *buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportAspectPartitionEvaluator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+
+extern RwReal
+RtWorldImportMaterialSeparatorPartitionEvaluator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ RtWorldImportPartition *partition,
+ void * userData);
+/*****************************************************************************
+ * PARTITION TERMINATORS - These callbacks are used to decide when
+ * partitioning of a sector should stop
+ */
+extern RwBool
+RtWorldImportNeverPartitionTerminator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ void * userData);
+
+extern RwBool
+RtWorldImportMaximumLegalPartitionTerminator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus * __RWUNUSED__ buildStatus,
+ void * __RWUNUSED__ userData);
+
+extern RwBool
+RtWorldImportDefaultPartitionTerminator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ void * pData);
+
+
+extern RwBool
+RtWorldImportDepthPartitionTerminator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ void * userData);
+
+
+extern RwBool
+RtWorldImportSectorHeightPartitionTerminator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ void * userData);
+
+extern RwBool
+RtWorldImportSizePartitionTerminator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ void * userData);
+
+extern RwBool
+RtWorldImportSectorAspectSizePartitionTerminator(RtWorldImportBuildSector * buildSector,
+ RtWorldImportBuildStatus * buildStatus,
+ void * userData);
+
+
+
+/* END TODO */
+
+/* WorldImport hints */
+extern void
+RtWorldImportHintsSet(RtWorldImportHints *hints);
+
+extern RtWorldImportHints *
+RtWorldImportHintsGet(void);
+
+extern RtWorldImportHints *
+RtWorldImportHintsCreate(void);
+
+extern RwBool
+RtWorldImportHintsDestroy(RtWorldImportHints *hints);
+
+extern RtWorldImportHints *
+RtWorldImportHintsAddBoundingBoxes(RtWorldImportHints *hints, RwInt32 numBoundingBoxes);
+
+extern void
+RtWorldImportMaterialGroupHintGenerator(RtWorldImportBuildSector *buildSector,
+ RtWorldImportHints *materialGroupHints);
+
+/* Initializing the conversion structure */
+extern RtWorldImportParameters *RtWorldImportParametersInit(void);
+extern void RtWorldImportParametersSet(RtWorldImportParameters *params);
+extern RtWorldImportParameters *RtWorldImportParametersGet(void);
+
+
+extern RpWorld *RtWorldImportCreateWorld(RtWorldImport *
+ nohsworld,
+ RtWorldImportParameters
+ * conversionParams);
+
+extern RpGeometry *RtWorldImportCreateGeometry(RtWorldImport *
+ nohsworld,
+ RtWorldImportParameters
+ * conversionParams);
+
+extern RtWorldImport *RtWorldImportCreate(void);
+
+extern RwBool RtWorldImportDestroy(RtWorldImport * nohsworld);
+
+extern RtWorldImport *RtWorldImportAddNumVertices(RtWorldImport *
+ nohsworld,
+ RwInt32
+ numNewVertices);
+
+extern RtWorldImport *RtWorldImportAddNumTriangles(RtWorldImport *
+ nohsworld,
+ RwInt32
+ numNewTriangles);
+
+extern RpMaterial *RtWorldImportGetMaterial(RtWorldImport *
+ nohsworld,
+ RwInt32 matInd);
+
+extern RwInt32 RtWorldImportGetNumVertices(RtWorldImport * nohsworld);
+
+extern RtWorldImportVertex *RtWorldImportGetVertices(RtWorldImport *
+ nohsworld);
+
+extern RwInt32 RtWorldImportGetNumTriangles(RtWorldImport * nohsworld);
+
+extern RtWorldImportTriangle *
+RtWorldImportGetTriangles(RtWorldImport * nohsworld);
+
+/* Surface lighting characteristics */
+extern RtWorldImport *
+RtWorldImportSetSurfaceProperties(RtWorldImport * world,
+ RwSurfaceProperties *
+ surface);
+
+extern RwSurfaceProperties *
+RtWorldImportGetSurfaceProperties(RtWorldImport * world);
+
+/* Progress callbacks */
+extern void
+RtWorldImportSetProgressCallBack(RtWorldImportProgressCallBack CB);
+
+extern RpWorldSector * RtWorldImportGetNumMaterials(RpWorldSector *worldSector, void *data);
+
+extern void
+_rtImportWorldSendProgressMessage(RwInt32 msgtype, RwReal value);
+
+/* Reading and Writing */
+
+extern RtWorldImport *RtWorldImportWrite(RtWorldImport * world,
+ RwChar * filename);
+
+extern RtWorldImport *RtWorldImportRead(RwChar * filename);
+
+extern RwInt32 RtWorldImportAddMaterial(RtWorldImport * nohsworld,
+ RpMaterial * material);
+
+extern RwInt32 RtWorldImportGetMaterialIndex(RtWorldImport * nohsworld,
+ RpMaterial * material);
+
+extern RtWorldImport *RtWorldImportForAllMaterials(RtWorldImport *
+ nohsworld,
+ RpMaterialCallBack
+ fpCallBack,
+ void *pData);
+
+extern void
+RtWorldImportSetUserdataCallBacks(RtWorldImportDestroyVertexUserdataCallBack
+ destroyVertexUserdataCB,
+ RtWorldImportCloneVertexUserdataCallBack
+ cloneVertexUserdataCB,
+ RtWorldImportInterpVertexUserdataCallBack
+ interpVertexUserdataCB,
+ RtWorldImportSectorSetVertexUserdataCallBack
+ sectorSetVertexUserdata,
+ RtWorldImportDestroyPolygonUserdataCallBack
+ destroyPolygonUserdataCB,
+ RtWorldImportSplitPolygonUserdataCallBack
+ splitPolygonUserdataCB,
+ RtWorldImportSectorSetPolygonUserdataCallBack
+ sectorSetPolygonUserdata);
+
+extern void
+RtWorldImportSetBuildCallBacks(RtWorldImportPartitionBuildCallBack
+ partitionBuildCB,
+ RtWorldImportTerminationBuildCallBack
+ terminationBuildCB);
+
+extern void
+RtWorldImportSetPartitionStatistics(RtWorldImportBuildSector * buildSector,
+ RtWorldImportPartition * partition);
+
+extern void
+RtWorldImportSetBuildCallBacksUserData(void *partitionUserData,
+ void *terminateUserData);
+
+
+extern void
+RtWorldImportSetStandardBuildPartitionSelector(RtWorldImportBuildPartitionSelector partitionSelector, void* userData);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#define RtWorldImportParametersInitialize(_paramsPtr) \
+ *(_paramsPtr) = *RtWorldImportParametersInit();
+
+
+
+#endif /* RTIMPORT_H */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/rwsdk/include/d3d8/rtimport.rpe b/rwsdk/include/d3d8/rtimport.rpe
new file mode 100644
index 00000000..d4b7ad2b
--- /dev/null
+++ b/rwsdk/include/d3d8/rtimport.rpe
@@ -0,0 +1,640 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionNoHSWorld
+{
+
+
+E_RW_SECTORDEGENERATE,
+
+E_RW_SECTORINVNOPOLYGONS,
+
+E_RW_NOPLANE,
+
+E_RW_SECTORINVPOLY,
+
+E_RW_SECTORUSED,
+
+E_RW_MAXBSPDEPTHEXCEEDED,
+
+
+ e_rwdb_CriterionNoHSWorldLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionNoHSWorld e_rwdb_CriterionNoHSWorld;
+
+
diff --git a/rwsdk/include/d3d8/rtintel.h b/rwsdk/include/d3d8/rtintel.h
new file mode 100644
index 00000000..c11329df
--- /dev/null
+++ b/rwsdk/include/d3d8/rtintel.h
@@ -0,0 +1,1206 @@
+/**
+ * Intel specific support toolkit
+ */
+
+/**********************************************************************
+ *
+ * File : rtintel.h
+ *
+ * Abstract : Intel specific support/emulation
+ *
+ **********************************************************************
+ *
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd. or
+ * Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. will not, under any
+ * circumstances, be liable for any lost revenue or other damages arising
+ * from the use of this file.
+ *
+ * Copyright (c) 1998 Criterion Software Ltd.
+ * All Rights Reserved.
+ *
+ * RenderWare is a trademark of Canon Inc.
+ *
+ ************************************************************************/
+
+#ifndef RTINTEL_H
+#define RTINTEL_H
+
+/**
+ * \defgroup rtintel RtIntel
+ * \ingroup rttool
+ *
+ * Intel CPU Toolkit for RenderWare.
+ */
+
+/****************************************************************************
+ Include files
+ */
+
+/*
+ * Pick up
+ * typedef struct _rwResEntryTag RwResEntry;
+ * from baresour.h (internal) / rwcore.h (external)
+ */
+
+/****************************************************************************
+ Global Types
+ */
+
+#include "rtintel.rpe" /* automatically generated header file */
+
+#if (!defined(RW_FIXED_64))
+typedef struct RwFixed64 RwFixed64;
+struct RwFixed64
+{
+ RwInt32 msb;
+ RwUInt32 lsb;
+};
+
+#define RW_FIXED_64
+#endif /* (!defined(RW_FIXED_64)) */
+
+#define doubleFromRwFixed64(x) \
+ ( ((double)((x).msb))*((double)(1<<16))*((double)(1<<16)) \
+ + ((double)((x).lsb)) )
+
+#if (!defined(RPINTELTIMEFUNCTION))
+typedef RwBool(*RtIntelTimeFunction) (void *data);
+
+#define RPINTELTIMEFUNCTION
+#endif /* (!defined(RPINTELTIMEFUNCTION)) */
+
+typedef struct RtIntelOverload RtIntelOverload;
+
+typedef void (*RwTransformFunction) (RwResEntry * repEntry);
+
+struct RtIntelOverload
+{
+ rwMatrixMultFn MatrixMultiplyFunction;
+ rwVectorMultFn VectorMultPointFunction;
+ rwVectorMultFn VectorMultVectorFunction;
+ RwTransformFunction TransformFunction;
+};
+
+#if (defined(__ICL))
+#define DEFINED__ICL " __ICL"
+#define UNDEFINED__ICL ""
+#else /* (defined(__ICL)) */
+#define DEFINED__ICL ""
+#define UNDEFINED__ICL " __ICL"
+#endif /* (defined(__ICL)) */
+
+#if (defined(_MSC_VER))
+
+# pragma comment ( user, "comment:" __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) ") : " "DEFINED " DEFINED__ICL " ; UNDEFINED " UNDEFINED__ICL )
+/* # pragma message (__FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) ") : " "DEFINED " DEFINED__ICL " ; UNDEFINED " UNDEFINED__ICL ) */
+/* # pragma comment ( user, "comment:" __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) ") : " "DEFINED " DEFINED__ICL " ; UNDEFINED " UNDEFINED__ICL ) */
+#if (! (defined(__ICL) || defined(XBOX_DRVMODEL_H)) )
+#pragma message (__DATE__ " " __TIME__ " " __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) ") : No MMX intrinsics - defaulting to software emulation")
+#pragma message (__DATE__ " " __TIME__ " " __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) ") : No SSE intrinsics - defaulting to software emulation")
+#pragma comment ( user, "comment:" __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) ") : No MMX intrinsics - defaulting to software emulation")
+#endif /* (! (defined(__ICL) || defined(XBOX_DRVMODEL_H)) ) */
+#endif /* (defined(_MSC_VER)) */
+
+/*
+ * MMX
+ */
+
+#if (defined(__ICL))
+
+#if (!defined(MMINTRIN_H))
+#include "mmintrin.h"
+#define MMINTRIN_H
+#endif /* (!defined(MMINTRIN_H)) */
+
+#else /* (defined(__ICL)) */
+
+#if (defined(_MSC_VER))
+
+#if (!defined(__M64))
+typedef __int64 Rt_m64;
+
+#define __M64
+#endif /* (!defined(__M64)) */
+
+#else /* (defined(_MSC_VER)) -- e.g. __GNUC__ */
+
+#if (!defined(__M64))
+
+typedef RwInt64 Rt_m64;
+
+#define __M64
+
+#endif /* (!defined(__M64)) */
+
+#endif /* (defined(_MSC_VER)) */
+
+#endif /* (defined(__ICL)) */
+
+/*
+ * SSE
+ */
+
+/*
+ * From
+ * ccomp.pdf
+ * 12 Intel C/C++ Compiler User's Guide
+ * for Win32 Systems With Katmai New Instruction Support
+ * --------------------------------------------------------
+ * Functionality Intrinsics Usage
+ * You need only define one preprocessor symbol and include the header file
+ * xmmintrin.h in your application to use the following functionality
+ * intrinsics:
+ * #define _MM_FUNCTIONALITY
+ * #include "xmmintrin.h"
+ * To encourage the compiler to inline the functionality intrinsic functions for
+ * better performance, consider using the -Qip and -Qipo compiler switches.
+ */
+
+#if (defined(__ICL))
+
+/* #define _MM2_FUNCTIONALITY */
+
+/* #define _MM_FUNCTIONALITY */
+
+/* #define _MM_NO_ABORT */
+
+/* #define _MM_NO_ACCURACY */
+
+/* #define _MM_NO_ALIGN_CHECK */
+
+/* #define _MM_NO_INLINE */
+
+/*
+ * Undefine "or", since this is valid assembler; e.g. in
+ * SDK10/include/xmm_func.h
+ * _asm {
+ * push eax
+ * fld f
+ * fstcw saved_cw
+ * mov eax, saved_cw
+ * or eax, 3072
+ * mov new_cw, eax
+ * fldcw new_cw
+ * fistp ret
+ * fldcw saved_cw
+ * pop eax
+ * }
+ */
+
+#if (!defined(XMMINTRIN_H))
+#include "xmmintrin.h"
+#define XMMINTRIN_H
+#endif /* (!defined(XMMINTRIN_H)) */
+
+typedef __m64 Rt_m64;
+typedef __m128 Rt_m128;
+
+#if (450 <= __ICL)
+#if (!defined(EMMINTRIN_H))
+#include "emmintrin.h"
+#define EMMINTRIN_H
+typedef __m128d Rt_m128d;
+typedef __m128i Rt_m128i;
+#endif /* (!defined(EMMINTRIN_H)) */
+#else /* (450 <= __ICL) */
+typedef __m128 Rt_m128d;
+typedef __m128 Rt_m128i;
+#endif /* (450 <= __ICL) */
+
+/*
+ * Report SSE options as compiler messages and object file comments
+ */
+
+#ifdef _MM2_FUNCTIONALITY
+#define DEFINED__MM2_FUNCTIONALITY " _MM2_FUNCTIONALITY"
+#define UNDEFINED__MM2_FUNCTIONALITY ""
+#else /* _MM2_FUNCTIONALITY */
+#define DEFINED__MM2_FUNCTIONALITY ""
+#define UNDEFINED__MM2_FUNCTIONALITY " _MM2_FUNCTIONALITY"
+#endif /* _MM2_FUNCTIONALITY */
+
+#ifdef _MM_FUNCTIONALITY
+#define DEFINED__MM_FUNCTIONALITY DEFINED__MM2_FUNCTIONALITY ## " _MM_FUNCTIONALITY"
+#define UNDEFINED__MM_FUNCTIONALITY UNDEFINED__MM2_FUNCTIONALITY
+#else /* _MM_FUNCTIONALITY */
+#define DEFINED__MM_FUNCTIONALITY DEFINED__MM2_FUNCTIONALITY
+#define UNDEFINED__MM_FUNCTIONALITY UNDEFINED__MM2_FUNCTIONALITY ## " _MM_FUNCTIONALITY"
+#endif /* _MM_FUNCTIONALITY */
+
+#ifdef _MM_NO_ABORT
+#define DEFINED__MM_NO_ABORT DEFINED__MM_FUNCTIONALITY ## " _MM_NO_ABORT"
+#define UNDEFINED__MM_NO_ABORT UNDEFINED__MM_FUNCTIONALITY
+#else /* _MM_NO_ABORT */
+#define DEFINED__MM_NO_ABORT DEFINED__MM_FUNCTIONALITY
+#define UNDEFINED__MM_NO_ABORT UNDEFINED__MM_FUNCTIONALITY ## " _MM_NO_ABORT"
+#endif /* _MM_NO_ABORT */
+
+#ifdef _MM_NO_ACCURACY
+#define DEFINED__MM_NO_ACCURACY DEFINED__MM_NO_ABORT ## " _MM_NO_ACCURACY"
+#define UNDEFINED__MM_NO_ACCURACY UNDEFINED__MM_NO_ABORT
+#else /* _MM_NO_ACCURACY */
+#define DEFINED__MM_NO_ACCURACY DEFINED__MM_NO_ABORT
+#define UNDEFINED__MM_NO_ACCURACY UNDEFINED__MM_NO_ABORT ## " _MM_NO_ACCURACY"
+#endif /* _MM_NO_ACCURACY */
+
+#ifdef _MM_NO_ALIGN_CHECK
+#define DEFINED__MM_NO_ALIGN_CHECK DEFINED__MM_NO_ACCURACY ## " _MM_NO_ALIGN_CHECK"
+#define UNDEFINED__MM_NO_ALIGN_CHECK UNDEFINED__MM_NO_ACCURACY
+#else /* _MM_NO_ALIGN_CHECK */
+#define DEFINED__MM_NO_ALIGN_CHECK DEFINED__MM_NO_ACCURACY
+#define UNDEFINED__MM_NO_ALIGN_CHECK UNDEFINED__MM_NO_ACCURACY ## " _MM_NO_ALIGN_CHECK"
+#endif /* _MM_NO_ALIGN_CHECK */
+
+#ifdef _MM_NO_INLINE
+#define DEFINED__MM_NO_INLINE DEFINED__MM_NO_ALIGN_CHECK ## " _MM_NO_INLINE"
+#define UNDEFINED__MM_NO_INLINE UNDEFINED__MM_NO_ALIGN_CHECK
+#else /* _MM_NO_INLINE */
+#define DEFINED__MM_NO_INLINE DEFINED__MM_NO_ALIGN_CHECK
+#define UNDEFINED__MM_NO_INLINE UNDEFINED__MM_NO_ALIGN_CHECK ## " _MM_NO_INLINE"
+#endif /* _MM_NO_INLINE */
+
+#pragma comment ( user, "comment:" __DATE__" " __TIME__ " - " __FILE__ ":" RW_STRINGIFY_EXPANDED(__LINE__) )
+#pragma comment ( user, "comment:" "DEFINED :" DEFINED__MM_NO_INLINE )
+#pragma comment ( user, "comment:" "UNDEFINED:" UNDEFINED__MM_NO_INLINE )
+
+#pragma message (__DATE__" " __TIME__ " - " __FILE__ ":" RW_STRINGIFY_EXPANDED(__LINE__) )
+#pragma message ("DEFINED :" DEFINED__MM_NO_INLINE )
+#pragma message ("UNDEFINED:" UNDEFINED__MM_NO_INLINE )
+
+#else /* (defined(__ICL)) */
+
+#define _MM_HINT_T0 1
+#define _MM_HINT_T1 2
+#define _MM_HINT_T2 3
+#define _MM_HINT_NTA 0
+
+#if (defined(__R5900__))
+typedef RwInt128 Rt_m128;
+#else /* (defined(__R5900__)) */
+#if (!defined(_PAIR__M64))
+struct Rt_m128
+{
+ Rt_m64 lo;
+ Rt_m64 hi;
+};
+#define _PAIR__M64
+typedef struct Rt_m128 Rt_m128;
+#endif /* (!defined(_PAIR__M64)) */
+#endif /* (defined(__R5900__)) */
+
+typedef Rt_m128 Rt_m128d;
+typedef Rt_m128 Rt_m128i;
+#endif /* (defined(__ICL)) */
+
+typedef struct RtIntelV4d RtIntelV4d;
+struct RtIntelV4d
+{
+ RwReal w;
+ RwV3d v3d;
+};
+
+typedef union _RpSSEOverlayM128 RpSSEOverlayM128;
+
+union _RpSSEOverlayM128
+{
+ float _f[4];
+ RwInt32 _d[4];
+ RwUInt32 ud[4];
+ RwInt16 _w[8];
+ RwUInt16 uw[8];
+ RwInt8 _b[16];
+ RwUInt8 ub[16];
+ Rt_m64 m64[2];
+ Rt_m128 m128;
+ RtIntelV4d v4d;
+ RwSplitBits bits[4];
+};
+
+typedef RpSSEOverlayM128 RpWNIOverlayM128;
+
+typedef union _RpWNIOverlayM128d RpWNIOverlayM128d;
+
+union _RpWNIOverlayM128d
+{
+ double df[2];
+ float _f[4];
+ RwInt32 _d[4];
+ RwUInt32 ud[4];
+ RwInt16 _w[8];
+ RwUInt16 uw[8];
+ RwInt8 _b[16];
+ RwUInt8 ub[16];
+ Rt_m64 m64[2];
+ Rt_m128d m128d;
+ RtIntelV4d v4d;
+ RwSplitBits bits[4];
+};
+
+typedef union _RpWNIOverlayM128i RpWNIOverlayM128i;
+
+union _RpWNIOverlayM128i
+{
+ double df[2];
+ float _f[4];
+ RwInt32 _d[4];
+ RwUInt32 ud[4];
+ RwInt16 _w[8];
+ RwUInt16 uw[8];
+ RwInt8 _b[16];
+ RwUInt8 ub[16];
+ Rt_m64 m64[2];
+ Rt_m128i m128i;
+ RtIntelV4d v4d;
+ RwSplitBits bits[4];
+};
+
+#define RWUNALIGNED16BYTE(ptr) (0x0000000FUL & ((RwUInt32)(ptr)))
+
+/*--- Plugin API Functions ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/*
+ * MMX
+ */
+
+/* General support intrinsics */
+extern void Rt_m_empty(void);
+extern Rt_m64 Rt_m_from_int(int i);
+extern int Rt_m_to_int(Rt_m64 m);
+extern Rt_m64 Rt_m_packsswb(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_packssdw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_packuswb(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_punpckhbw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_punpckhwd(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_punpckhdq(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_punpcklbw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_punpcklwd(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_punpckldq(Rt_m64 m1, Rt_m64 m2);
+
+/* Packed arithmetic intrinsics */
+extern Rt_m64 Rt_m_paddb(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_paddw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_paddd(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_paddsb(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_paddsw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_paddusb(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_paddusw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_psubb(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_psubw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_psubd(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_psubsb(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_psubsw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_psubusb(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_psubusw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_pmaddwd(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_pmulhw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_pmullw(Rt_m64 m1, Rt_m64 m2);
+
+/* Shift intrinsics */
+extern Rt_m64 Rt_m_psllw(Rt_m64 m, Rt_m64 count);
+extern Rt_m64 Rt_m_psllwi(Rt_m64 m, int count);
+extern Rt_m64 Rt_m_pslld(Rt_m64 m, Rt_m64 count);
+extern Rt_m64 Rt_m_pslldi(Rt_m64 m, int count);
+extern Rt_m64 Rt_m_psllq(Rt_m64 m, Rt_m64 count);
+extern Rt_m64 Rt_m_psllqi(Rt_m64 m, int count);
+extern Rt_m64 Rt_m_psraw(Rt_m64 m, Rt_m64 count);
+extern Rt_m64 Rt_m_psrawi(Rt_m64 m, int count);
+extern Rt_m64 Rt_m_psrad(Rt_m64 m, Rt_m64 count);
+extern Rt_m64 Rt_m_psradi(Rt_m64 m, int count);
+extern Rt_m64 Rt_m_psrlw(Rt_m64 m, Rt_m64 count);
+extern Rt_m64 Rt_m_psrlwi(Rt_m64 m, int count);
+extern Rt_m64 Rt_m_psrld(Rt_m64 m, Rt_m64 count);
+extern Rt_m64 Rt_m_psrldi(Rt_m64 m, int count);
+extern Rt_m64 Rt_m_psrlq(Rt_m64 m, Rt_m64 count);
+extern Rt_m64 Rt_m_psrlqi(Rt_m64 m, int count);
+
+/* Logical intrinsics */
+extern Rt_m64 Rt_m_pand(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_pandn(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_por(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_pxor(Rt_m64 m1, Rt_m64 m2);
+
+/* Comparision intrinsics */
+extern Rt_m64 Rt_m_pcmpeqb(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_pcmpeqw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_pcmpeqd(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_pcmpgtb(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_pcmpgtw(Rt_m64 m1, Rt_m64 m2);
+extern Rt_m64 Rt_m_pcmpgtd(Rt_m64 m1, Rt_m64 m2);
+
+/*
+ * SSE
+ */
+
+/*
+ * Arithmetic Operations
+ */
+
+extern Rt_m128 Rt_mm_add_ss(Rt_m128 a, Rt_m128 b) /* ADDSS */ ;
+extern Rt_m128 Rt_mm_add_ps(Rt_m128 a, Rt_m128 b) /* ADDPS */ ;
+extern Rt_m128 Rt_mm_sub_ss(Rt_m128 a, Rt_m128 b) /* SUBSS */ ;
+extern Rt_m128 Rt_mm_sub_ps(Rt_m128 a, Rt_m128 b) /* SUBPS */ ;
+extern Rt_m128 Rt_mm_mul_ss(Rt_m128 a, Rt_m128 b) /* MULSS */ ;
+extern Rt_m128 Rt_mm_mul_ps(Rt_m128 a, Rt_m128 b) /* MULPS */ ;
+extern Rt_m128 Rt_mm_div_ss(Rt_m128 a, Rt_m128 b) /* DIVSS */ ;
+extern Rt_m128 Rt_mm_div_ps(Rt_m128 a, Rt_m128 b) /* DIVPS */ ;
+extern Rt_m128 Rt_mm_sqrt_ss(Rt_m128 a) /* SQRTSS */ ;
+extern Rt_m128 Rt_mm_sqrt_ps(Rt_m128 a) /* SQRTPS */ ;
+extern Rt_m128 Rt_mm_rcp_ss(Rt_m128 a) /* RCPSS */ ;
+extern Rt_m128 Rt_mm_rcp_ps(Rt_m128 a) /* RCPPS */ ;
+extern Rt_m128 Rt_mm_rsqrt_ss(Rt_m128 a) /* RSQRTSS */ ;
+extern Rt_m128 Rt_mm_rsqrt_ps(Rt_m128 a) /* RSQRTPS */ ;
+extern Rt_m128 Rt_mm_min_ss(Rt_m128 a, Rt_m128 b) /* MINSS */ ;
+extern Rt_m128 Rt_mm_min_ps(Rt_m128 a, Rt_m128 b) /* MINPS */ ;
+extern Rt_m128 Rt_mm_max_ss(Rt_m128 a, Rt_m128 b) /* MAXSS */ ;
+extern Rt_m128 Rt_mm_max_ps(Rt_m128 a, Rt_m128 b) /* MAXPS */ ;
+
+/*
+ * Logical Operations
+ */
+
+extern Rt_m128 Rt_mm_and_ps(Rt_m128 a, Rt_m128 b) /* ANDPS */ ;
+extern Rt_m128 Rt_mm_andnot_ps(Rt_m128 a,
+ Rt_m128 b) /* ANDNPS */ ;
+extern Rt_m128 Rt_mm_or_ps(Rt_m128 a, Rt_m128 b) /* ORPS */ ;
+extern Rt_m128 Rt_mm_xor_ps(Rt_m128 a, Rt_m128 b) /* XORPS */ ;
+
+/*
+ * Comparisons
+ */
+
+extern Rt_m128 Rt_mm_cmpeq_ss(Rt_m128 a,
+ Rt_m128 b) /* CMPEQSS */ ;
+extern Rt_m128 Rt_mm_cmpeq_ps(Rt_m128 a,
+ Rt_m128 b) /* CMPEQPS */ ;
+extern Rt_m128 Rt_mm_cmplt_ss(Rt_m128 a,
+ Rt_m128 b) /* CMPLTSS */ ;
+extern Rt_m128 Rt_mm_cmplt_ps(Rt_m128 a,
+ Rt_m128 b) /* CMPLTPS */ ;
+extern Rt_m128 Rt_mm_cmple_ss(Rt_m128 a,
+ Rt_m128 b) /* CMPLESS */ ;
+extern Rt_m128 Rt_mm_cmple_ps(Rt_m128 a,
+ Rt_m128 b) /* CMPLEPS */ ;
+extern Rt_m128 Rt_mm_cmpgt_ss(Rt_m128 a, Rt_m128 b) /* CMPLTSS r */
+ ;
+extern Rt_m128 Rt_mm_cmpgt_ps(Rt_m128 a, Rt_m128 b) /* CMPLTPS r */
+ ;
+extern Rt_m128 Rt_mm_cmpge_ss(Rt_m128 a, Rt_m128 b) /* CMPLESS r */
+ ;
+extern Rt_m128 Rt_mm_cmpge_ps(Rt_m128 a, Rt_m128 b) /* CMPLEPS r */
+ ;
+extern Rt_m128 Rt_mm_cmpneq_ss(Rt_m128 a,
+ Rt_m128 b) /* CMPNEQSS */ ;
+extern Rt_m128 Rt_mm_cmpneq_ps(Rt_m128 a,
+ Rt_m128 b) /* CMPNEQPS */ ;
+extern Rt_m128 Rt_mm_cmpnlt_ss(Rt_m128 a,
+ Rt_m128 b) /* CMPNLTSS */ ;
+extern Rt_m128 Rt_mm_cmpnlt_ps(Rt_m128 a,
+ Rt_m128 b) /* CMPNLTPS */ ;
+extern Rt_m128 Rt_mm_cmpnle_ss(Rt_m128 a,
+ Rt_m128 b) /* CMPNLESS */ ;
+extern Rt_m128 Rt_mm_cmpnle_ps(Rt_m128 a,
+ Rt_m128 b) /* CMPNLEPS */ ;
+extern Rt_m128 Rt_mm_cmpngt_ss(Rt_m128 a, Rt_m128 b)
+ /* CMPNLTSS r */ ;
+extern Rt_m128 Rt_mm_cmpngt_ps(Rt_m128 a, Rt_m128 b)
+ /* CMPNLTPS r */ ;
+extern Rt_m128 Rt_mm_cmpnge_ss(Rt_m128 a, Rt_m128 b)
+ /* CMPNLESS r */ ;
+extern Rt_m128 Rt_mm_cmpnge_ps(Rt_m128 a, Rt_m128 b)
+ /* CMPNLEPS r */ ;
+extern Rt_m128 Rt_mm_cmpord_ss(Rt_m128 a,
+ Rt_m128 b) /* CMPORDSS */ ;
+extern Rt_m128 Rt_mm_cmpord_ps(Rt_m128 a,
+ Rt_m128 b) /* CMPORDPS */ ;
+extern Rt_m128 Rt_mm_cmpunord_ss(Rt_m128 a,
+ Rt_m128 b) /* CMPUNORDSS */ ;
+extern Rt_m128 Rt_mm_cmpunord_ps(Rt_m128 a,
+ Rt_m128 b) /* CMPUNORDPS */ ;
+extern int Rt_mm_comieq_ss(Rt_m128 a,
+ Rt_m128 b) /* COMISS */ ;
+extern int Rt_mm_comilt_ss(Rt_m128 a,
+ Rt_m128 b) /* COMISS */ ;
+extern int Rt_mm_comile_ss(Rt_m128 a,
+ Rt_m128 b) /* COMISS */ ;
+extern int Rt_mm_comigt_ss(Rt_m128 a,
+ Rt_m128 b) /* COMISS */ ;
+extern int Rt_mm_comige_ss(Rt_m128 a,
+ Rt_m128 b) /* COMISS */ ;
+extern int Rt_mm_comineq_ss(Rt_m128 a,
+ Rt_m128 b) /* COMISS */ ;
+extern int Rt_mm_ucomieq_ss(Rt_m128 a,
+ Rt_m128 b) /* UCOMISS */ ;
+extern int Rt_mm_ucomilt_ss(Rt_m128 a,
+ Rt_m128 b) /* UCOMISS */ ;
+extern int Rt_mm_ucomile_ss(Rt_m128 a,
+ Rt_m128 b) /* UCOMISS */ ;
+extern int Rt_mm_ucomigt_ss(Rt_m128 a,
+ Rt_m128 b) /* UCOMISS */ ;
+extern int Rt_mm_ucomige_ss(Rt_m128 a,
+ Rt_m128 b) /* UCOMISS */ ;
+extern int Rt_mm_ucomineq_ss(Rt_m128 a,
+ Rt_m128 b) /* UCOMISS */ ;
+
+/*
+ * Conversion Operations
+ */
+
+extern int Rt_mm_cvt_ss2si(Rt_m128 a) /* CVTSS2SI */ ;
+extern Rt_m64 Rt_mm_cvt_ps2pi(Rt_m128 a) /* CVTPS2PI */ ;
+extern int Rt_mm_cvtt_ss2si(Rt_m128 a) /* CVTTSS2SI */ ;
+extern Rt_m64 Rt_mm_cvtt_ps2pi(Rt_m128 a) /* CVTTPS2PI */ ;
+extern Rt_m128 Rt_mm_cvt_si2ss(Rt_m128 a,
+ int b) /* CVTSI2SS */ ;
+extern Rt_m128 Rt_mm_cvt_pi2ps(Rt_m128 a,
+ Rt_m64 b) /* CVTPI2PS */ ;
+
+/*
+ * Miscellaneous
+ */
+
+extern Rt_m128 Rt_mm_shuffle_ps(Rt_m128 a, Rt_m128 b,
+ int i) /* SHUFPS */ ;
+extern Rt_m128 Rt_mm_unpackhi_ps(Rt_m128 a,
+ Rt_m128 b) /* UNPCKHPS */ ;
+extern Rt_m128 Rt_mm_unpacklo_ps(Rt_m128 a,
+ Rt_m128 b) /* UNPCKLPS */ ;
+extern Rt_m128 Rt_mm_loadh_pi(Rt_m128 a, Rt_m64 * p) /* MOVHPS reg, mem */
+ ;
+extern void Rt_mm_storeh_pi(Rt_m64 * p, Rt_m128 a) /* MOVHPS mem, reg */
+ ;
+extern Rt_m128 Rt_mm_movehl_ps(Rt_m128 a,
+ Rt_m128 b) /* MOVHLPS */ ;
+extern Rt_m128 Rt_mm_movelh_ps(Rt_m128 a,
+ Rt_m128 b) /* MOVLHPS */ ;
+extern Rt_m128 Rt_mm_loadl_pi(Rt_m128 a, Rt_m64 * p)
+ /* MOVLPS reg, mem */ ;
+extern void Rt_mm_storel_pi(Rt_m64 * p, Rt_m128 a) /* MOVLPS mem, reg */
+ ;
+extern int Rt_mm_movemask_ps(Rt_m128 a) /* MOVMSKPS */ ;
+extern unsigned int Rt_mm_getcsr(void) /* STMXCSR */ ;
+extern void Rt_mm_setcsr(unsigned int i) /* LDMXCSR */ ;
+
+/*
+ * Load Operations
+ */
+
+extern Rt_m128 Rt_mm_load_ss(float *p) /* MOVSS */ ;
+extern Rt_m128 Rt_mm_load_ps1(float *p) /* MOVSS + shuffling */
+ ;
+extern Rt_m128 Rt_mm_load_ps(float *p) /* MOVAPS */ ;
+extern Rt_m128 Rt_mm_loadu_ps(float *p) /* MOVUPS */ ;
+extern Rt_m128 Rt_mm_loadr_ps(float *p)
+ /* MOVAPS + shuffling */ ;
+
+/*
+ * Set Operations
+ */
+
+extern Rt_m128 Rt_mm_set_ss(float w) /* (composite) */ ;
+extern Rt_m128 Rt_mm_set_ps1(float w) /* (composite) */ ;
+extern Rt_m128 Rt_mm_set_ps(float z, float y, float x,
+ float w) /* (composite) */ ;
+extern Rt_m128 Rt_mm_setr_ps(float z, float y, float x,
+ float w) /* (composite) */ ;
+extern Rt_m128 Rt_mm_setzero_ps(void) /* (composite) */ ;
+
+/*
+ * Store Operations
+ */
+
+extern void Rt_mm_store_ss(float *p,
+ Rt_m128 a) /* MOVSS */ ;
+extern void Rt_mm_store_ps1(float *p, Rt_m128 a)
+ /* MOVSS + shuffling */ ;
+extern void Rt_mm_store_ps(float *p,
+ Rt_m128 a) /* MOVAPS */ ;
+extern void Rt_mm_storeu_ps(float *p,
+ Rt_m128 a) /* MOVUPS */ ;
+extern void Rt_mm_storer_ps(float *p, Rt_m128 a)
+ /* MOVAPS + shuffling */ ;
+extern Rt_m128 Rt_mm_move_ss(Rt_m128 a,
+ Rt_m128 b) /* MOVSS */ ;
+
+/*
+ * Integer Intrinsics
+ */
+
+extern int Rt_m_pextrw(Rt_m64 a, int n) /* PEXTRW */ ;
+extern Rt_m64 Rt_m_pinsrw(Rt_m64 a, int d,
+ int n) /* PINSRW */ ;
+extern Rt_m64 Rt_m_pmaxsw(Rt_m64 a, Rt_m64 b) /* PMAXSW */ ;
+extern Rt_m64 Rt_m_pmaxub(Rt_m64 a, Rt_m64 b) /* PMAXUB */ ;
+extern Rt_m64 Rt_m_pminsw(Rt_m64 a, Rt_m64 b) /* PMINSW */ ;
+extern Rt_m64 Rt_m_pminub(Rt_m64 a, Rt_m64 b) /* PMINUB */ ;
+extern int Rt_m_pmovmskb(Rt_m64 a) /* PMOVMSKB */ ;
+extern Rt_m64 Rt_m_pmulhuw(Rt_m64 a, Rt_m64 b) /* PMULHUW */ ;
+extern Rt_m64 Rt_m_pshufw(Rt_m64 a, int n) /* PSHUFW */ ;
+extern void Rt_m_lwmaskmovq(Rt_m64 d, Rt_m64 n,
+ char *p) /* MASKMOVQ */ ;
+
+/*
+ * Cacheability Support
+ */
+
+extern void Rt_mm_prefetch(char *p, int i) /* PREFETCH */ ;
+extern void Rt_mm_stream_pi(Rt_m64 * p,
+ Rt_m64 a) /* MOVNTQ */ ;
+extern void Rt_mm_stream_ps(float *p,
+ Rt_m128 a) /* MOVNTPS */ ;
+extern void Rt_mm_sfence(void) /* SFENCE */ ;
+
+/*
+ * WNI
+ */
+
+/* Arithmetic Operations */
+
+extern Rt_m128d Rt_mm_add_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_add_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_div_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_div_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_max_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_max_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_min_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_min_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_mul_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_mul_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_sqrt_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_sqrt_pd(Rt_m128d a);
+extern Rt_m128d Rt_mm_sub_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_sub_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_andnot_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_and_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_or_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_xor_pd(Rt_m128d a, Rt_m128d b);
+
+/* Comparisons */
+
+extern Rt_m128d Rt_mm_cmpeq_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmplt_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmple_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpgt_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpge_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpord_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpunord_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpneq_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpnlt_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpnle_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpngt_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpnge_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpeq_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmplt_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmple_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpgt_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpge_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpord_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpunord_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpneq_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpnlt_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpnle_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpngt_sd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cmpnge_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_comieq_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_comilt_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_comile_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_comigt_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_comige_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_comineq_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_ucomieq_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_ucomilt_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_ucomile_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_ucomigt_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_ucomige_sd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_ucomineq_sd(Rt_m128d a, Rt_m128d b);
+
+/* Conversion Operations */
+
+extern Rt_m128 Rt_mm_cvtpd_ps(Rt_m128d a);
+extern Rt_m128d Rt_mm_cvtps_pd(Rt_m128 a);
+extern Rt_m128d Rt_mm_cvtepi32_pd(Rt_m128i a);
+extern Rt_m128i Rt_mm_cvtpd_epi32(Rt_m128d a);
+extern int Rt_mm_cvtsd_si32(Rt_m128d a);
+extern Rt_m128 Rt_mm_cvtsd_ss(Rt_m128 a, Rt_m128d b);
+extern Rt_m128d Rt_mm_cvtsi32_sd(Rt_m128d a, int b);
+extern Rt_m128d Rt_mm_cvtss_sd(Rt_m128d a, Rt_m128 b);
+extern Rt_m128i Rt_mm_cvttpd_epi32(Rt_m128d a);
+extern int Rt_mm_cvttsd_si32(Rt_m128d a);
+extern Rt_m128 Rt_mm_cvtepi32_ps(Rt_m128i a);
+extern Rt_m128i Rt_mm_cvtps_epi32(Rt_m128 a);
+extern Rt_m128i Rt_mm_cvttps_epi32(Rt_m128 a);
+extern Rt_m64 Rt_mm_cvtpd_pi32(Rt_m128d a);
+extern Rt_m64 Rt_mm_cvttpd_pi32(Rt_m128d a);
+extern Rt_m128d Rt_mm_cvtpi32_pd(Rt_m64 a);
+
+/* Miscellaneous Operations */
+
+extern Rt_m128d Rt_mm_unpackhi_pd(Rt_m128d a, Rt_m128d b);
+extern Rt_m128d Rt_mm_unpacklo_pd(Rt_m128d a, Rt_m128d b);
+extern int Rt_mm_movemask_pd(Rt_m128d a);
+extern Rt_m128d Rt_mm_shuffle_pd(Rt_m128d a, Rt_m128d b, int i);
+extern Rt_m128d Rt_mm_load_pd(const double *p);
+extern Rt_m128d Rt_mm_load1_pd(const double *p);
+extern Rt_m128d Rt_mm_loadr_pd(const double *p);
+extern Rt_m128d Rt_mm_loadu_pd(const double *p);
+extern Rt_m128d Rt_mm_load_sd(const double *p);
+extern Rt_m128d Rt_mm_loadh_pd(Rt_m128d a, const double *p);
+extern Rt_m128d Rt_mm_loadl_pd(Rt_m128d a, const double *p);
+extern Rt_m128d Rt_mm_set_sd(double w);
+extern Rt_m128d Rt_mm_set1_pd(double w);
+extern Rt_m128d Rt_mm_set_pd(double w, double x);
+extern Rt_m128d Rt_mm_setr_pd(double w, double x);
+extern Rt_m128d Rt_mm_setzero_pd(void);
+extern Rt_m128d Rt_mm_move_sd(Rt_m128d a, Rt_m128d b);
+extern void Rt_mm_stream_pd(double *p, Rt_m128d a);
+extern void Rt_mm_store_sd(double *p, Rt_m128d a);
+extern void Rt_mm_store1_pd(double *p, Rt_m128d a);
+extern void Rt_mm_store_pd(double *p, Rt_m128d a);
+extern void Rt_mm_storeu_pd(double *p, Rt_m128d a);
+extern void Rt_mm_storer_pd(double *p, Rt_m128d a);
+extern void Rt_mm_storeh_pd(double *p, Rt_m128d a);
+extern void Rt_mm_storel_pd(double *p, Rt_m128d a);
+extern Rt_m128i Rt_mm_add_epi8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_add_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_add_epi32(Rt_m128i a, Rt_m128i b);
+extern Rt_m64 Rt_mm_add_si64(Rt_m64 a, Rt_m64 b);
+extern Rt_m128i Rt_mm_add_epi64(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_adds_epi8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_adds_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_adds_epu8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_adds_epu16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_avg_epu8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_avg_epu16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_madd_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_max_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_max_epu8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_min_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_min_epu8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_mulhi_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_mulhi_epu16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_mullo_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m64 Rt_mm_mul_su32(Rt_m64 a, Rt_m64 b);
+extern Rt_m128i Rt_mm_mul_epu32(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_sad_epu8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_sub_epi8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_sub_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_sub_epi32(Rt_m128i a, Rt_m128i b);
+extern Rt_m64 Rt_mm_sub_si64(Rt_m64 a, Rt_m64 b);
+extern Rt_m128i Rt_mm_sub_epi64(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_subs_epi8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_subs_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_subs_epu8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_subs_epu16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_and_si128(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_andnot_si128(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_or_si128(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_xor_si128(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_slli_si128(Rt_m128i a, int imm);
+extern Rt_m128i Rt_mm_slli_epi16(Rt_m128i a, int count);
+extern Rt_m128i Rt_mm_sll_epi16(Rt_m128i a, Rt_m128i count);
+extern Rt_m128i Rt_mm_slli_epi32(Rt_m128i a, int count);
+extern Rt_m128i Rt_mm_sll_epi32(Rt_m128i a, Rt_m128i count);
+extern Rt_m128i Rt_mm_slli_epi64(Rt_m128i a, int count);
+extern Rt_m128i Rt_mm_sll_epi64(Rt_m128i a, Rt_m128i count);
+extern Rt_m128i Rt_mm_srai_epi16(Rt_m128i a, int count);
+extern Rt_m128i Rt_mm_sra_epi16(Rt_m128i a, Rt_m128i count);
+extern Rt_m128i Rt_mm_srai_epi32(Rt_m128i a, int count);
+extern Rt_m128i Rt_mm_sra_epi32(Rt_m128i a, Rt_m128i count);
+extern Rt_m128i Rt_mm_srli_si128(Rt_m128i a, int imm);
+extern Rt_m128i Rt_mm_srli_epi16(Rt_m128i a, int count);
+extern Rt_m128i Rt_mm_srl_epi16(Rt_m128i a, Rt_m128i count);
+extern Rt_m128i Rt_mm_srli_epi32(Rt_m128i a, int count);
+extern Rt_m128i Rt_mm_srl_epi32(Rt_m128i a, Rt_m128i count);
+extern Rt_m128i Rt_mm_srli_epi64(Rt_m128i a, int count);
+extern Rt_m128i Rt_mm_srl_epi64(Rt_m128i a, Rt_m128i count);
+extern Rt_m128i Rt_mm_cmpeq_epi8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_cmpeq_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_cmpeq_epi32(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_cmpgt_epi8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_cmpgt_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_cmpgt_epi32(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_cmplt_epi8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_cmplt_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_cmplt_epi32(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_cvtsi32_si128(int a);
+extern int Rt_mm_cvtsi128_si32(Rt_m128i a);
+
+/* Miscellaneous Operations */
+
+extern Rt_m64 Rt_mm_movepi64_pi64(Rt_m128i a);
+extern Rt_m128i Rt_mm_movpi64_epi64(Rt_m64 a);
+extern Rt_m128i Rt_mm_move_epi64(Rt_m128i a);
+extern Rt_m128i Rt_mm_packs_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_packs_epi32(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_packus_epi16(Rt_m128i a, Rt_m128i b);
+extern int Rt_mm_extract_epi16(Rt_m128i a, int imm);
+extern Rt_m128i Rt_mm_insert_epi16(Rt_m128i a, int b, int imm);
+extern int Rt_mm_movemask_epi8(Rt_m128i a);
+extern Rt_m128i Rt_mm_shuffle_epi32(Rt_m128i a, int imm);
+extern Rt_m128i Rt_mm_shufflehi_epi16(Rt_m128i a, int imm);
+extern Rt_m128i Rt_mm_shufflelo_epi16(Rt_m128i a, int imm);
+extern Rt_m128i Rt_mm_unpackhi_epi8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_unpackhi_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_unpackhi_epi32(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_unpackhi_epi64(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_unpacklo_epi8(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_unpacklo_epi16(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_unpacklo_epi32(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_unpacklo_epi64(Rt_m128i a, Rt_m128i b);
+extern Rt_m128i Rt_mm_loadl_epi64(Rt_m128i const *p);
+extern Rt_m128i Rt_mm_load_si128(const Rt_m128i * p);
+extern Rt_m128i Rt_mm_loadu_si128(const Rt_m128i * p);
+extern Rt_m128i Rt_mm_set_epi64(Rt_m64 q1, Rt_m64 q0);
+extern Rt_m128i Rt_mm_set_epi32(int i3, int i2, int i1, int i0);
+extern Rt_m128i
+ Rt_mm_set_epi16(short w7, short w6,
+ short w5, short w4, short w3, short w2,
+ short w1, short w0);
+extern Rt_m128i Rt_mm_set_epi8(char b15, char b14,
+ char b13, char b12,
+ char b11, char b10,
+ char b9, char b8,
+ char b7, char b6,
+ char b5, char b4,
+ char b3, char b2,
+ char b1, char b0);
+extern Rt_m128i Rt_mm_set1_epi64(Rt_m64 q);
+extern Rt_m128i Rt_mm_set1_epi32(int i);
+extern Rt_m128i Rt_mm_set1_epi16(short w);
+extern Rt_m128i Rt_mm_set1_epi8(char b);
+extern Rt_m128i Rt_mm_setr_epi64(Rt_m64 q0, Rt_m64 q1);
+extern Rt_m128i Rt_mm_setr_epi32(int i0, int i1, int i2,
+ int i3);
+extern Rt_m128i Rt_mm_setr_epi16(short w0, short w1,
+ short w2, short w3,
+ short w4, short w5,
+ short w6, short w7);
+extern Rt_m128i Rt_mm_setr_epi8(char b0, char b1,
+ char b2, char b3,
+ char b4, char b5,
+ char b6, char b7,
+ char b8, char b9,
+ char b10, char b11,
+ char b12, char b13,
+ char b14, char b15);
+extern Rt_m128i Rt_mm_setzero_si128(void);
+
+/* Store Operations */
+
+extern void Rt_mm_store_si128(Rt_m128i * p, Rt_m128i a);
+extern void Rt_mm_storeu_si128(Rt_m128i * p, Rt_m128i a);
+extern void Rt_mm_maskmoveu_si128(Rt_m128i s, Rt_m128i n,
+ char *p);
+extern void Rt_mm_storel_epi64(Rt_m128i * p, Rt_m128i a);
+extern void Rt_mm_stream_si128(Rt_m128i * p, Rt_m128i a);
+extern void Rt_mm_stream_si32(int *p, int a);
+extern void Rt_mm_clflush(void const *p);
+extern void Rt_mm_lfence(void);
+extern void Rt_mm_mfence(void);
+
+/*
+ * API
+ */
+extern RwUInt32 RtIntelRDTSC(void);
+extern RwUInt32 RtIntelToggleEFLAGS(int mask);
+extern RwUInt32 RtIntelCPUID(RwUInt32 level,
+ void *pb, void *pc, void *pd);
+extern RwUInt32 RtIntelHaveCPUID(void);
+extern RwUInt32 RtIntelHaveRDTSC(void);
+extern RwUInt32 RtIntelHaveMMX(void);
+extern RwUInt32 RtIntelHaveSSE(void);
+extern RwUInt32 RtIntelHaveWNI(void);
+extern RwUInt32 RtIntelCpuType(void);
+
+extern RwBool RtIntelStartTiming(void * data);
+extern RwBool RtIntelStopTiming(void *data);
+extern RwBool RtIntelTime(RwFixed64 * result,
+ RtIntelTimeFunction func,
+ void *data);
+
+extern RwBool RtIntelPluginAttach(void);
+
+extern RtIntelOverload *_rtIntelOverloadGetHandle(void);
+
+extern RxNodeDefinition *RxNodeDefinitionGetSSETransformCSL(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*
+ * LEGACY-SUPPORT -- e.g.
+ * rwsdk/driver/d3d/baintd3d.c
+ * is locked at time of writing
+ */
+
+#define RpIntelRDTSC() RtIntelRDTSC()
+#define RpIntelToggleEFLAGS(_mask) RtIntelToggleEFLAGS(_mask)
+#define RpIntelCPUID(_level, _pb, _pc, _pd) \
+ RtIntelCPUID(_level, _pb, _pc, _pd)
+#define RpIntelHaveCPUID() RtIntelHaveCPUID()
+#define RpIntelHaveRDTSC() RtIntelHaveRDTSC()
+#define RpIntelHaveMMX() RtIntelHaveMMX()
+#define RpIntelHaveSSE() RtIntelHaveSSE()
+#define RpIntelHaveWNI() RtIntelHaveWNI()
+#define RpIntelCpuType() RtIntelCpuType()
+#define RpIntelStartTiming(_data) RtIntelStartTiming(_data)
+#define RpIntelStopTiming(_data) RtIntelStopTiming(_data)
+#define RpIntelTime(_result, _func, _data) \
+ RtIntelTime(_result, _func, _data)
+#define RpIntelPluginAttach() RtIntelPluginAttach()
+#define RpNodeDefinitionGetSSETransformCSL() \
+ RxNodeDefinitionGetSSETransformCSL()
+
+typedef RtIntelOverload RwIntelOverload;
+typedef RtIntelOverload RpIntelOverload;
+
+#define _rwIntelOverloadGetHandle() _rtIntelOverloadGetHandle()
+#define _rpIntelOverloadGetHandle() _rtIntelOverloadGetHandle()
+#define RwIntelHaveSSE() RtIntelHaveSSE()
+#define RpIntelHaveSSE() RtIntelHaveSSE()
+
+#if (defined(RWEMULATEINTELSIMD) || !defined(__ICL))
+
+/*
+ * MMX
+ */
+
+/* General support intrinsics */
+#define _m_empty() Rt_m_empty()
+#define _m_from_int(i) Rt_m_from_int(i)
+#define _m_to_int(m) Rt_m_to_int(m)
+#define _m_packsswb(m1, m2) Rt_m_packsswb(m1, m2)
+#define _m_packssdw(m1, m2) Rt_m_packssdw(m1, m2)
+#define _m_packuswb(m1, m2) Rt_m_packuswb(m1, m2)
+#define _m_punpckhbw(m1, m2) Rt_m_punpckhbw(m1, m2)
+#define _m_punpckhwd(m1, m2) Rt_m_punpckhwd(m1, m2)
+#define _m_punpckhdq(m1, m2) Rt_m_punpckhdq(m1, m2)
+#define _m_punpcklbw(m1, m2) Rt_m_punpcklbw(m1, m2)
+#define _m_punpcklwd(m1, m2) Rt_m_punpcklwd(m1, m2)
+#define _m_punpckldq(m1, m2) Rt_m_punpckldq(m1, m2)
+
+/* Packed arithmetic intrinsics */
+#define _m_paddb(m1, m2) Rt_m_paddb(m1, m2)
+#define _m_paddw(m1, m2) Rt_m_paddw(m1, m2)
+#define _m_paddd(m1, m2) Rt_m_paddd(m1, m2)
+#define _m_paddsb(m1, m2) Rt_m_paddsb(m1, m2)
+#define _m_paddsw(m1, m2) Rt_m_paddsw(m1, m2)
+#define _m_paddusb(m1, m2) Rt_m_paddusb(m1, m2)
+#define _m_paddusw(m1, m2) Rt_m_paddusw(m1, m2)
+#define _m_psubb(m1, m2) Rt_m_psubb(m1, m2)
+#define _m_psubw(m1, m2) Rt_m_psubw(m1, m2)
+#define _m_psubd(m1, m2) Rt_m_psubd(m1, m2)
+#define _m_psubsb(m1, m2) Rt_m_psubsb(m1, m2)
+#define _m_psubsw(m1, m2) Rt_m_psubsw(m1, m2)
+#define _m_psubusb(m1, m2) Rt_m_psubusb(m1, m2)
+#define _m_psubusw(m1, m2) Rt_m_psubusw(m1, m2)
+#define _m_pmaddwd(m1, m2) Rt_m_pmaddwd(m1, m2)
+#define _m_pmulhw(m1, m2) Rt_m_pmulhw(m1, m2)
+#define _m_pmullw(m1, m2) Rt_m_pmullw(m1, m2)
+
+/* Shift intrinsics */
+#define _m_psllw(m, count) Rt_m_psllw(m, count)
+#define _m_psllwi(m, count) Rt_m_psllwi(m, count)
+#define _m_pslld(m, count) Rt_m_pslld(m, count)
+#define _m_pslldi(m, count) Rt_m_pslldi(m, count)
+#define _m_psllq(m, count) Rt_m_psllq(m, count)
+#define _m_psllqi(m, count) Rt_m_psllqi(m, count)
+#define _m_psraw(m, count) Rt_m_psraw(m, count)
+#define _m_psrawi(m, count) Rt_m_psrawi(m, count)
+#define _m_psrad(m, count) Rt_m_psrad(m, count)
+#define _m_psradi(m, count) Rt_m_psradi(m, count)
+#define _m_psrlw(m, count) Rt_m_psrlw(m, count)
+#define _m_psrlwi(m, count) Rt_m_psrlwi(m, count)
+#define _m_psrld(m, count) Rt_m_psrld(m, count)
+#define _m_psrldi(m, count) Rt_m_psrldi(m, count)
+#define _m_psrlq(m, count) Rt_m_psrlq(m, count)
+#define _m_psrlqi(m, count) Rt_m_psrlqi(m, count)
+
+/* Logical intrinsics */
+#define _m_pand(m1, m2) Rt_m_pand(m1, m2)
+#define _m_pandn(m1, m2) Rt_m_pandn(m1, m2)
+#define _m_por(m1, m2) Rt_m_por(m1, m2)
+#define _m_pxor(m1, m2) Rt_m_pxor(m1, m2)
+
+/* Comparison intrinsics */
+#define _m_pcmpeqb(m1, m2) Rt_m_pcmpeqb(m1, m2)
+#define _m_pcmpeqw(m1, m2) Rt_m_pcmpeqw(m1, m2)
+#define _m_pcmpeqd(m1, m2) Rt_m_pcmpeqd(m1, m2)
+#define _m_pcmpgtb(m1, m2) Rt_m_pcmpgtb(m1, m2)
+#define _m_pcmpgtw(m1, m2) Rt_m_pcmpgtw(m1, m2)
+#define _m_pcmpgtd(m1, m2) Rt_m_pcmpgtd(m1, m2)
+
+/*
+ * SSE
+ */
+
+/*
+ * Arithmetic Operations
+ */
+
+#define _mm_add_ss(a, b) Rt_mm_add_ss(a, b)
+#define _mm_add_ps(a, b) Rt_mm_add_ps(a, b)
+#define _mm_sub_ss(a, b) Rt_mm_sub_ss(a, b)
+#define _mm_sub_ps(a, b) Rt_mm_sub_ps(a, b)
+#define _mm_mul_ss(a, b) Rt_mm_mul_ss(a, b)
+#define _mm_mul_ps(a, b) Rt_mm_mul_ps(a, b)
+#define _mm_div_ss(a, b) Rt_mm_div_ss(a, b)
+#define _mm_div_ps(a, b) Rt_mm_div_ps(a, b)
+#define _mm_sqrt_ss(a) Rt_mm_sqrt_ss(a)
+#define _mm_sqrt_ps(a) Rt_mm_sqrt_ps(a)
+#define _mm_rcp_ss(a) Rt_mm_rcp_ss(a)
+#define _mm_rcp_ps(a) Rt_mm_rcp_ps(a)
+#define _mm_rsqrt_ss(a) Rt_mm_rsqrt_ss(a)
+#define _mm_rsqrt_ps(a) Rt_mm_rsqrt_ps(a)
+#define _mm_min_ss(a, b) Rt_mm_min_ss(a, b)
+#define _mm_min_ps(a, b) Rt_mm_min_ps(a, b)
+#define _mm_max_ss(a, b) Rt_mm_max_ss(a, b)
+#define _mm_max_ps(a, b) Rt_mm_max_ps(a, b)
+
+/*
+ * Logical Operations
+ */
+
+#define _mm_and_ps(a, b) Rt_mm_and_ps(a, b)
+#define _mm_andnot_ps(a, b) Rt_mm_andnot_ps(a, b)
+#define _mm_or_ps(a, b) Rt_mm_or_ps(a, b)
+#define _mm_xor_ps(a, b) Rt_mm_xor_ps(a, b)
+
+/*
+ * Comparisons
+ */
+
+#define _mm_cmpeq_ss(a, b) Rt_mm_cmpeq_ss(a, b)
+#define _mm_cmpeq_ps(a, b) Rt_mm_cmpeq_ps(a, b)
+#define _mm_cmplt_ss(a, b) Rt_mm_cmplt_ss(a, b)
+#define _mm_cmplt_ps(a, b) Rt_mm_cmplt_ps(a, b)
+#define _mm_cmple_ss(a, b) Rt_mm_cmple_ss(a, b)
+#define _mm_cmple_ps(a, b) Rt_mm_cmple_ps(a, b)
+#define _mm_cmpgt_ss(a, b) Rt_mm_cmpgt_ss(a, b)
+#define _mm_cmpgt_ps(a, b) Rt_mm_cmpgt_ps(a, b)
+#define _mm_cmpge_ss(a, b) Rt_mm_cmpge_ss(a, b)
+#define _mm_cmpge_ps(a, b) Rt_mm_cmpge_ps(a, b)
+#define _mm_cmpneq_ss(a, b) Rt_mm_cmpneq_ss(a, b)
+#define _mm_cmpneq_ps(a, b) Rt_mm_cmpneq_ps(a, b)
+#define _mm_cmpnlt_ss(a, b) Rt_mm_cmpnlt_ss(a, b)
+#define _mm_cmpnlt_ps(a, b) Rt_mm_cmpnlt_ps(a, b)
+#define _mm_cmpnle_ss(a, b) Rt_mm_cmpnle_ss(a, b)
+#define _mm_cmpnle_ps(a, b) Rt_mm_cmpnle_ps(a, b)
+#define _mm_cmpngt_ss(a, b) Rt_mm_cmpngt_ss(a, b)
+#define _mm_cmpngt_ps(a, b) Rt_mm_cmpngt_ps(a, b)
+#define _mm_cmpnge_ss(a, b) Rt_mm_cmpnge_ss(a, b)
+#define _mm_cmpnge_ps(a, b) Rt_mm_cmpnge_ps(a, b)
+#define _mm_cmpord_ss(a, b) Rt_mm_cmpord_ss(a, b)
+#define _mm_cmpord_ps(a, b) Rt_mm_cmpord_ps(a, b)
+#define _mm_cmpunord_ss(a, b) Rt_mm_cmpunord_ss(a, b)
+#define _mm_cmpunord_ps(a, b) Rt_mm_cmpunord_ps(a, b)
+#define _mm_comieq_ss(a, b) Rt_mm_comieq_ss(a, b)
+#define _mm_comilt_ss(a, b) Rt_mm_comilt_ss(a, b)
+#define _mm_comile_ss(a, b) Rt_mm_comile_ss(a, b)
+#define _mm_comigt_ss(a, b) Rt_mm_comigt_ss(a, b)
+#define _mm_comige_ss(a, b) Rt_mm_comige_ss(a, b)
+#define _mm_comineq_ss(a, b) Rt_mm_comineq_ss(a, b)
+#define _mm_ucomieq_ss(a, b) Rt_mm_ucomieq_ss(a, b)
+#define _mm_ucomilt_ss(a, b) Rt_mm_ucomilt_ss(a, b)
+#define _mm_ucomile_ss(a, b) Rt_mm_ucomile_ss(a, b)
+#define _mm_ucomigt_ss(a, b) Rt_mm_ucomigt_ss(a, b)
+#define _mm_ucomige_ss(a, b) Rt_mm_ucomige_ss(a, b)
+#define _mm_ucomineq_ss(a, b) Rt_mm_ucomineq_ss(a, b)
+
+/*
+ * Conversion Operations
+ */
+
+#define _mm_cvt_ss2si(a) Rt_mm_cvt_ss2si(a)
+#define _mm_cvt_ps2pi(a) Rt_mm_cvt_ps2pi(a)
+#define _mm_cvtt_ss2si(a) Rt_mm_cvtt_ss2si(a)
+#define _mm_cvtt_ps2pi(a) Rt_mm_cvtt_ps2pi(a)
+#define _mm_cvt_si2ss(a, b) Rt_mm_cvt_si2ss(a, b)
+#define _mm_cvt_pi2ps(a, b) Rt_mm_cvt_pi2ps(a, b)
+
+/*
+ * Miscellaneous
+ */
+
+#define _mm_shuffle_ps(a, b, i) Rt_mm_shuffle_ps(a, b, i)
+#define _mm_unpackhi_ps(a, b) Rt_mm_unpackhi_ps(a, b)
+#define _mm_unpacklo_ps(a, b) Rt_mm_unpacklo_ps(a, b)
+#define _mm_loadh_pi(a, p) Rt_mm_loadh_pi(a, p)
+#define _mm_storeh_pi(p, a) Rt_mm_storeh_pi(p, a)
+#define _mm_movehl_ps(a, b) Rt_mm_movehl_ps(a, b)
+#define _mm_movelh_ps(a, b) Rt_mm_movelh_ps(a, b)
+#define _mm_loadl_pi(a, p) Rt_mm_loadl_pi(a, p)
+#define _mm_storel_pi(p, a) Rt_mm_storel_pi(p, a)
+#define _mm_movemask_ps(a) Rt_mm_movemask_ps(a)
+#define _mm_getcsr() Rt_mm_getcsr()
+#define _mm_setcsr(i) Rt_mm_setcsr(i)
+
+/*
+ *Load Operations
+ */
+
+#define _mm_load_ss(p) Rt_mm_load_ss(p)
+#define _mm_load_ps1(p) Rt_mm_load_ps1(p)
+#define _mm_load_ps(p) Rt_mm_load_ps(p)
+#define _mm_loadu_ps(p) Rt_mm_loadu_ps(p)
+#define _mm_loadr_ps(p) Rt_mm_loadr_ps(p)
+
+/*
+ * Set Operations
+ */
+
+#define _mm_set_ss(w) Rt_mm_set_ss(w)
+#define _mm_set_ps1(w) Rt_mm_set_ps1(w)
+#define _mm_set_ps(z, y, x, w) Rt_mm_set_ps(z, y, x, w)
+#define _mm_setr_ps(z, y, x, w) Rt_mm_setr_ps(z, y, x, w)
+#define _mm_setzero_ps() Rt_mm_setzero_ps()
+
+/*
+ * Store Operations
+ */
+
+#define _mm_store_ss(p, a) Rt_mm_store_ss(p, a)
+#define _mm_store_ps1(p, a) Rt_mm_store_ps1(p, a)
+#define _mm_store_ps(p, a) Rt_mm_store_ps(p, a)
+#define _mm_storeu_ps(p, a) Rt_mm_storeu_ps(p, a)
+#define _mm_storer_ps(p, a) Rt_mm_storer_ps(p, a)
+#define _mm_move_ss(a, b) Rt_mm_move_ss(a, b)
+
+/*
+ * Integer Intrinsics
+ */
+
+#define _m_pextrw(a, n) Rt_m_pextrw(a, n)
+#define _m_pinsrw(a, d, n) Rt_m_pinsrw(a, d, n)
+#define _m_pmaxsw(a, b) Rt_m_pmaxsw(a, b)
+#define _m_pmaxub(a, b) Rt_m_pmaxub(a, b)
+#define _m_pminsw(a, b) Rt_m_pminsw(a, b)
+#define _m_pminub(a, b) Rt_m_pminub(a, b)
+#define _m_pmovmskb(a) Rt_m_pmovmskb(a)
+#define _m_pmulhuw(a, b) Rt_m_pmulhuw(a, b)
+#define _m_pshufw(a, n) Rt_m_pshufw(a, n)
+#define _m_lwmaskmovq(d, n, p) Rt_m_lwmaskmovq(d, n, p)
+
+/*
+ * Cacheability Support
+ */
+
+#define _mm_prefetch(p, i) Rt_mm_prefetch(p, i)
+#define _mm_stream_pi(p, a) Rt_mm_stream_pi(p, a)
+#define _mm_stream_ps(p, a) Rt_mm_stream_ps(p, a)
+#define _mm_sfence() Rt_mm_sfence()
+
+#endif /* (defined(RWEMULATEINTELSIMD) || !defined(__ICL)) */
+
+#endif /* RTINTEL_H */
diff --git a/rwsdk/include/d3d8/rtintel.rpe b/rwsdk/include/d3d8/rtintel.rpe
new file mode 100644
index 00000000..bf297ca0
--- /dev/null
+++ b/rwsdk/include/d3d8/rtintel.rpe
@@ -0,0 +1,645 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionIntel
+{
+
+
+
+ e_rwdb_CriterionIntelLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionIntel e_rwdb_CriterionIntel;
+
+
diff --git a/rwsdk/include/d3d8/rtintsec.h b/rwsdk/include/d3d8/rtintsec.h
new file mode 100644
index 00000000..cb482b17
--- /dev/null
+++ b/rwsdk/include/d3d8/rtintsec.h
@@ -0,0 +1,138 @@
+/***************************************************************************
+ * *
+ * Module : rtintsec.h *
+ * *
+ * Purpose : Intersection tests on geometry primitives. *
+ * *
+ **************************************************************************/
+
+#ifndef RTINTSEC_H
+#define RTINTSEC_H
+
+/**
+ * \defgroup rtintersect RtIntersection
+ * \ingroup rttool
+ *
+ * Object Intersection Toolkit for RenderWare.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include <rwcore.h>
+#include "rtintsec.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Defines
+ */
+
+#define RTINTSECEPSILON (RwReal)(1e-8)
+#define RTINTSECEDGEEPS (RwReal)(1e-5)
+
+#define RtIntersectionLineTriangleMacro(_result, \
+ _lineStart, _lineDelta, \
+ _v0, _v1, _v2, \
+ _distance) \
+MACRO_START \
+{ \
+ RwV3d edge1, edge2, tVec, pVec, qVec; \
+ RwReal det; \
+ \
+ /* Find vectors for two edges sharing vert0 */ \
+ RwV3dSubMacro(&edge1, (_v1), (_v0)); \
+ RwV3dSubMacro(&edge2, (_v2), (_v0)); \
+ \
+ /* Begin calculating determinant \
+ * - also used to calculate U parameter */ \
+ RwV3dCrossProductMacro(&pVec, (_lineDelta), &edge2); \
+ \
+ /* If determinant is \
+ * + near zero, ray lies in plane of \
+ * triangle \
+ * + negative, triangle is backfacing \
+ */ \
+ det = RwV3dDotProductMacro(&edge1, &pVec); \
+ (_result) = (det > RTINTSECEPSILON); \
+ \
+ if ((_result)) \
+ { \
+ RwReal lo, hi, u; \
+ \
+ /* Calculate bounds for parameters with tolerance */ \
+ lo = - det*RTINTSECEDGEEPS; \
+ hi = det - lo; \
+ \
+ /* Calculate U parameter and test bounds */ \
+ RwV3dSubMacro(&tVec, (_lineStart), (_v0)); \
+ u = RwV3dDotProductMacro(&tVec, &pVec); \
+ (_result) = (u >= lo && u <= hi); \
+ \
+ if ((_result)) \
+ { \
+ RwReal v; \
+ \
+ /* Calculate V parameter and test bounds */ \
+ RwV3dCrossProductMacro(&qVec, &tVec, &edge1); \
+ v = RwV3dDotProductMacro((_lineDelta), &qVec); \
+ (_result) = (v >= lo && (u + v) <= hi); \
+ \
+ if ((_result)) \
+ { \
+ /* Calculate t, \
+ * and make sure intersection is in bounds of line */ \
+ *(_distance) = RwV3dDotProductMacro(&edge2, &qVec); \
+ \
+ /* Within bounds of line? */ \
+ (_result) = (*(_distance) >= lo && *(_distance) <= hi); \
+ \
+ if ((_result)) \
+ { \
+ *(_distance) = ((*(_distance)) / (det)); \
+ } \
+ } \
+ } \
+ } \
+} \
+MACRO_STOP
+
+
+/****************************************************************************
+ Global Types
+ */
+
+
+/* RWPUBLIC */
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Line intersections */
+extern RwBool
+RtIntersectionLineTriangle(RwV3d *lineStart, RwV3d *lineDelta,
+ RwV3d *v0, RwV3d *v1, RwV3d *v2,
+ RwReal *distance);
+
+/* Sphere intersections */
+extern RwBool
+RtIntersectionSphereTriangle(RwSphere *sphere,
+ RwV3d *v0, RwV3d *v1, RwV3d *v2,
+ RwV3d *normal,
+ RwReal *distance);
+
+/* BBox intersections */
+extern RwBool
+RtIntersectionBBoxTriangle(RwBBox *bbox, RwV3d *v0, RwV3d *v1, RwV3d *v2);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+#endif /* RTINTSEC_H */
diff --git a/rwsdk/include/d3d8/rtintsec.rpe b/rwsdk/include/d3d8/rtintsec.rpe
new file mode 100644
index 00000000..7b2ce6e1
--- /dev/null
+++ b/rwsdk/include/d3d8/rtintsec.rpe
@@ -0,0 +1,628 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionIntsec
+{
+
+
+
+ e_rwdb_CriterionIntsecLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionIntsec e_rwdb_CriterionIntsec;
+
+
diff --git a/rwsdk/include/d3d8/rtltmap.h b/rwsdk/include/d3d8/rtltmap.h
new file mode 100644
index 00000000..1a53b185
--- /dev/null
+++ b/rwsdk/include/d3d8/rtltmap.h
@@ -0,0 +1,601 @@
+
+/**
+ * \defgroup rtltmap RtLtMap
+ * \ingroup rttool
+ *
+ * Lightmap Generation Toolkit for RenderWare.
+ */
+
+#ifndef RTLTMAP_H
+#define RTLTMAP_H
+
+/*===========================================================================*
+ *--- Includes --------------------------------------------------------------*
+ *===========================================================================*/
+
+#include "rwcore.h"
+#include "rpworld.h"
+
+#include "rpltmap.h"
+
+
+/**
+ * \ingroup rtltmap
+ * \typedef RtLtMapIlluminateSampleCallBack
+ * \ref RtLtMapIlluminateSampleCallBack is the callback to be called, from
+ * within \ref RtLtMapIlluminate, for groups of samples in the objects
+ * currently being illuminated.
+ *
+ * For lightmapped objects, samples are grouped on a per-polygon basis and
+ * for vertex-lit objects, samples are grouped on a per-object basis (see
+ * \ref RtLtMapObjectFlags).
+ *
+ * This callback will receive an array of color values to fill in, each
+ * representing one sample in the current object - this may correspond to
+ * a texel in the current object's lightmap or the prelight colour of a
+ * vertex, depending on whether the object is lightmapped and/or vertex-lit.
+ * It will receive positions (in world-space) for each sample and the normal
+ * vector (again, in world-space) of each sample (normals are interpolated
+ * across polygons for non-flat-shaded materials. See \ref RtLtMapMaterialFlags).
+ * For lightmap samples (not vertex-lighting samples), it will receive
+ * barycentric coordinates within the current polygon. It will also receive
+ * a list of RpLights affecting the current object.
+ *
+ * The barycentric coordinates may be used, for example, to allow a callback
+ * to easily import existing lighting data (e.g from previously generated
+ * lightmaps in a different format, or from an art package with lighting
+ * functionality).
+ *
+ * NOTE: The alpha channel of the RwRGBA results array must NOT be modified.
+ * These values are used internally and their modification may result in
+ * unwanted visual artifacts in the resulting lighting solution.
+ *
+ * The default RtLtMapIlluminateSampleCallBacks supplied with RtLtMap is
+ * \ref RtLtMapDefaultSampleCallBack. This callback performs point and area
+ * lighting (the area lights use are those passed to \ref RtLtMapIlluminate).
+ *
+ * \param results A pointer to an array of \ref RwRGBA sample color values
+ * \param samplePositions A pointer to an array of \ref RwV3d values specifying the
+ * world-space positions of each of the samples in the results array
+ * \param baryCoords A pointer to an array of \ref RwV3d values specifying the
+ * barycentric coordinates (within the current polygon) of
+ * each of the samples in the results array
+ * \param numSamples The length of the results, samplePositions, baryCoords and normals arrays
+ * \param lights An array of pointers to \ref RpLight's affecting the current object
+ * \param numLights The length of the lights array
+ * \param normals A pointer to an array of \ref RwV3d values specifying the
+ * world-space, unit normals of each of the samples in the results array
+ *
+ * \return A pointer to the results array on success, NULL otherwise
+ *
+ * \see RtLtMapIlluminate
+ * \see RtLtMapIlluminateVisCallBack
+ * \see RtLtMapIlluminateProgressCallBack
+ */
+typedef RwRGBA *(*RtLtMapIlluminateSampleCallBack)(RwRGBA *results,
+ RwV3d *samplePositions,
+ RwV3d *baryCoords,
+ RwUInt32 numSamples,
+ RpLight **lights,
+ RwUInt32 numLights,
+ RwV3d *normals);
+
+/**
+ * \ingroup rtltmap
+ * \typedef RtLtMapIlluminateVisCallBack
+ * \ref RtLtMapIlluminateVisCallBack is the callback to be called, from
+ * within \ref RtLtMapIlluminate, to determine the visibility between a
+ * sample and a light.
+ *
+ * This callback is called for all samples in the current
+ * \ref RtLtMapLightingSession and for each light source which may
+ * potentially affect each of those samples (this may not be all the
+ * lights in the scene, as some hierarchical culling is performed).
+ * Each sample may represent a texel in the current object's lightmap
+ * or the prelight color of a vertex, depending on whether the object
+ * is lightmapped and/or vertex-lit (see \ref RtLtMapObjectFlags).
+ *
+ * The callback will receive a pointer to the world of the current
+ * \ref RtLtMapLightingSession (this may be used to perform intersection
+ * tests), the world-space position of the sample, the world-space
+ * position of the light, a pointer to a light and a pointer to an
+ * \ref RwRGBAReal result value.
+ *
+ * If the light pointer is NULL, this means that the current light
+ * is an area light (as opposed to an \ref RpLight), of an internal
+ * format. The area lights use are those passed to \ref RtLtMapIlluminate.
+ *
+ * The callback should return FALSE to signify that the light is wholly
+ * occluded w.r.t the sample position, otherwise it should return TRUE.
+ * Partial degrees of (color-frequency-dependent) occlusion may be
+ * expressed by modifying the RwRGBAReal value. This defaults to bright
+ * white but may be reduced to signify that the light from the light
+ * source should be attenuated. This could be used to take into account
+ * light-filtering objects in the scene (such as coloured glass or fog).
+ *
+ * The default RtLtMapIlluminateVisCallBack supplied with RtLtMap is
+ * \ref RtLtMapDefaultVisCallBack. This callback performs visibility
+ * tests using the line-intersection tests from \ref rtintersect. It tests
+ * for occlusion by RpWorldSectors and RpAtomics and it respects the
+ * relevant \ref RtLtMapObjectFlags and \ref RtLtMapMaterialFlags but it
+ * does not filter light; visibility is determined to be either one or zero.
+ *
+ * \param world The world of the current RtLtMapLightingSession
+ * \param result An RwRGBAReal value to attentuate this light's
+ * contribution to the current sample
+ * \param samplePos The world-space positiuon of the sample
+ * \param lightPos The world-space positiuon of the light
+ * \param light A pointer to the light (NULL if it is an are light)
+ *
+ * \return TRUE if the light is visible from the sample, FALSE if it is occluded
+ *
+ * \see RtLtMapIlluminate
+ * \see RtLtMapIlluminateSampleCallBack
+ * \see RtLtMapIlluminateProgressCallBack
+ */
+typedef RwBool (*RtLtMapIlluminateVisCallBack)(RpWorld *world,
+ RwRGBAReal *result,
+ RwV3d *samplePos,
+ RwV3d *lightPos,
+ RpLight *light);
+
+/**
+ * \ingroup rtltmap
+ * \typedef RtLtMapIlluminateProgressCallBack
+ * \ref RtLtMapIlluminateProgressCallBack is the callback to be called, from
+ * within \ref RtLtMapIlluminate, to allow a user to track lighting progress.
+ *
+ * The progress callback will be called at several stages during lighting,
+ * with a different 'message' parameter value used at each stage (see
+ * \ref RtLtMapProgressMessage). It will be called at the very start of
+ * lighting (for a given \ref RtLtMapLightingSession), before any samples
+ * are lit. It will also be called at the very end of lighting, after all
+ * samples have been lit. It will be called before and after each lighting
+ * 'slice' (see \ref RtLtMapIlluminate) and also after each group of
+ * samples have been lit.
+ *
+ * For lightmapped objects, samples are grouped on a per-polygon basis and
+ * for vertex-lit objects, samples are grouped on a per-object basis (see
+ * \ref RtLtMapObjectFlags).
+ *
+ * The progress callback will receive a RwReal value specifying the percentage
+ * of samples already lit in the current \ref RtLtMapLightingSession (see
+ * \ref RtLtMapLightingSessionGetNumSamples).
+ *
+ * By returning FALSE, the progress callback may cause early termination of
+ * the current lighting 'slice' (this may be used, for example, to keep
+ * the time spent lighting each slice fairly constant).
+ *
+ * There is no default progress callback supplied with RtLtMap.
+ *
+ * \param message A \ref RtLtMapProgressMessage identifying the stage
+ * of the current call to the progress callback
+ * \param value The percentage of samples already lit in the
+ * current \ref RtLtMapLightingSession
+ *
+ * \return FALSE to immediately terminate lighting, otherwise TRUE
+ *
+ * \see RtLtMapIlluminate
+ * \see RtLtMapIlluminateSampleCallBack
+ * \see RtLtMapIlluminateVisCallBack
+ */
+typedef RwBool (*RtLtMapIlluminateProgressCallBack)(RwInt32 message,
+ RwReal value);
+
+
+/**
+ * \ingroup rtltmap
+ * \ref RtLtMapProgressMessage is an enumerated type identifying the different
+ * stages at which the \ref RtLtMapIlluminateProgressCallBack may be called
+ * from within \ref RtLtMapIlluminate.
+ *
+ * \see RtLtMapIlluminateProgressCallBack
+ * \see RtLtMapIlluminate
+ */
+enum RtLtMapProgressMessage
+{
+ rtLTMAPPROGRESSNAMESSAGE = 0,
+
+ rtLTMAPPROGRESSSTART = 1, /**< This is issued at the beginning of
+ * an incremental lighting session */
+ rtLTMAPPROGRESSSTARTSLICE = 2, /**< This is issued at the beginning of every
+ * slice in an incremental lighting session */
+ rtLTMAPPROGRESSUPDATE = 3, /**< This is issued after the lighting of each
+ * lightmapped triangle or vertex-lit object */
+ rtLTMAPPROGRESSENDSLICE = 4, /**< This is issued at the end of every slice
+ * in an incremental lighting session */
+ rtLTMAPPROGRESSEND = 5, /**< This is issued at the end of an
+ * incremental lighting session */
+
+ rtLTMAPPROGRESSFORCEENUMSIZEINT = 0x7FFFFFFF
+};
+typedef enum RtLtMapProgressMessage RtLtMapProgressMessage;
+
+typedef struct RtLtMapLightingSession RtLtMapLightingSession;
+/**
+ * \ingroup rtltmap
+ * \typedef RtLtMapLightingSession
+ * The \ref RtLtMapLightingSession structure holds information to be passed to
+ * \ref RtLtMapIlluminate. It is used to parameterize the lighting process.
+ *
+ * The \ref RtLtMapLightingSession structure encapsulates a set of objects and
+ * keeps track of the proportion of samples, within that set, that have already
+ * been lit by calls to \ref RtLtMapIlluminate. Each call performs lighting for
+ * one 'slice' of the whole 'session'. If the camera member is non-NULL, it is
+ * important that the camera is not moved between lighting slices.
+ *
+ * The \ref RtLtMapLightingSession is also passed to
+ * \ref RtLtMapLightMapsCreate, \ref RtLtMapLightMapsClear,
+ * \ref RtLtMapLightMapsDestroy and \ref RtLtMapAreaLightGroupCreate,
+ * though not all of the session structure's member will be used in
+ * each of these cases.
+ *
+ * \see RtLtMapIlluminate
+ * \see RtLtMapLightMapsCreate
+ * \see RtLtMapLightMapsClear
+ * \see RtLtMapLightMapsDestroy
+ * \see RtLtMapAreaLightGroupCreate
+ */
+struct RtLtMapLightingSession
+{
+ RpWorld *world; /**< This world is that in which collisions are performed
+ * during illumination (for the purposes of lighting
+ * visibility determination) */
+ RwCamera *camera; /**< An optional pointer to a camera. The camera's frustum
+ * may be used to cull objects and/or triangles from the
+ * set of those to be processed. */
+ RpWorldSector **sectorList; /**< An optional array of \ref RpWorldSector pointers,
+ * specifying which sectors in the world to light. If
+ * this is NULL, then all sectors in the world (or those
+ * inside the optional camera's frustum) will be lit. */
+ RwInt32 numSectors; /**< The length of the sectorList array. If this is set to
+ * '-1' then none of the sectors in the world will be lit. */
+ RpAtomic **atomicList; /**< An optional array of \ref RpAtomic pointers,
+ * specifying which atomics to light. If this is NULL
+ * then all atomics in the world (or those inside the
+ * optional camera's frustum) will be lit. */
+ RwInt32 numAtomics; /**< The length of the atomicList array. If this is set to
+ * '-1' then none of the atomics in the world will be lit. */
+ RwUInt32 startSample; /**< Lighting for the current 'slice' should begin with this
+ * sample. It is the user's responsibility to increment this
+ * value after each slice. Note that partial lighting is
+ * quantized to be per-polygon (for lightmapped objects).
+ * startSample will always be rounded down, not up. */
+ RwUInt32 numSamples; /**< This specifies how many lightmap samples should be lit.
+ * If it is left zero then all samples in the current set
+ * of objects will be lit. Note that partial lighting is
+ * quantized to be per-polygon (for lightmapped objects).
+ * numSamples will always be rounded up, not down. */
+ RwUInt32 totalSamples;/**< This specifies how many lightmap samples will be lit in
+ * total for the world specified (this is filled in by
+ * \ref RtLtMapIlluminate, not the calling function). */
+ RtLtMapIlluminateSampleCallBack sampleCallBack; /**< A \ref RtLtMapIlluminateSampleCallBack
+ * to use during lighting. If this is left
+ * NULL, the default callback will be used. */
+ RtLtMapIlluminateVisCallBack visCallBack; /**< A \ref RtLtMapIlluminateVisCallBack
+ * to use during lighting. If this is left
+ * NULL, the default callback will be used. */
+ RtLtMapIlluminateProgressCallBack progressCallBack; /**< A \ref RtLtMapIlluminateProgressCallBack
+ * to use during lighting. If this is left
+ * NULL, no progress callback will be used. */
+};
+
+/**
+ * \ingroup rtltmap
+ * \ref RtLtMapMaterialFlags is an enumerated type specifying the different
+ * lightmap-related flags which may be applied to materials. These values
+ * will be taken into consideration within \ref RtLtMapIlluminate.
+ *
+ * \see RtLtMapMaterialGetFlags
+ * \see RtLtMapMaterialSetFlags
+ * \see RtLtMapMaterialGetAreaLightColor
+ * \see RtLtMapMaterialSetAreaLightColor
+ * \see RtLtMapMaterialGetLightMapDensityModifier
+ * \see RtLtMapMaterialSetLightMapDensityModifier
+ * \see RtLtMapMaterialGetAreaLightDensityModifier
+ * \see RtLtMapMaterialSetAreaLightDensityModifier
+ * \see RtLtMapMaterialSetAreaLightRadiusModifier
+ * \see RtLtMapMaterialGetAreaLightRadiusModifier
+ * \see RtLtMapIlluminate
+ * \see RtLtMapAreaLightGroupCreate
+ * \see RtLtMapIlluminateVisCallBack
+ */
+enum RtLtMapMaterialFlags
+{
+ rtLTMAPMATERIALNAFLAG = 0,
+
+ rtLTMAPMATERIALLIGHTMAP = 1, /**< This material should be lightmapped
+ * [for non-lightmapped materials within lightmapped objects,
+ * texel values will be set to (0, 0, 0) (or (255, 255, 255) if
+ * the rtLTMAPMATERIALAREALIGHT flag is present, so that light-
+ * emitting textures appear as bright as the light which they are
+ * emittering) and the mesh may be 'shrunk' in UV-space so as not
+ * to waste lightmap texels] */
+ rtLTMAPMATERIALAREALIGHT = 2, /**< This material is an area light emitter
+ * (see \ref RtLtMapAreaLightGroupCreate) */
+ rtLTMAPMATERIALNOSHADOW = 4, /**< This material does not block light */
+ rtLTMAPMATERIALSKY = 8, /**< This material blocks everything but directional
+ * lights, to allow sky polygons to occlude geometry
+ * and yet emit directional light (sky or sun light,
+ * being as if cast from an infinite distance) */
+ rtLTMAPMATERIALFLATSHADE = 16, /**< This material will be lit as if flat-shaded
+ * (polygon normals will be used during illumination) */
+
+ rtLTMAPMATERIALFLAGFORCEENUMSIZEINT = 0x7FFFFFFF
+};
+typedef enum RtLtMapMaterialFlags RtLtMapMaterialFlags;
+
+/**
+ * \ingroup rtltmap
+ * \ref RtLtMapObjectFlags is an enumerated type specifying the different
+ * lightmap-related flags which may be applied to world sectors and
+ * atomics. These values will be taken into consideration within
+ * \ref RtLtMapLightMapsCreate and \ref RtLtMapIlluminate.
+ *
+ * \see RtLtMapAtomicGetFlags
+ * \see RtLtMapAtomicSetFlags
+ * \see RtLtMapWorldSectorGetFlags
+ * \see RtLtMapWorldSectorSetFlags
+ * \see RtLtMapLightMapsCreate
+ * \see RtLtMapIlluminate
+ * \see RtLtMapIlluminateVisCallBack
+ */
+enum RtLtMapObjectFlags
+{
+ rtLTMAPOBJECTNAFLAG = 0,
+
+ rtLTMAPOBJECTLIGHTMAP = 1, /**< This object is to be lightmapped */
+ rtLTMAPOBJECTVERTEXLIGHT = 2, /**< This object's vertex prelight colours should
+ * be lit within \ref RtLtMapIlluminate. */
+ rtLTMAPOBJECTNOSHADOW = 4, /**< This object does not cast shadows (useful, for
+ * example, for moving objects for which dynamic
+ * shadows are to be rendered - such as doors) */
+
+ rtLTMAPOBJECTFLAGFORCEENUMSIZEINT = 0x7FFFFFFF
+};
+typedef enum RtLtMapObjectFlags RtLtMapObjectFlags;
+
+/* Area-lighting stuff:*
+ ***********************/
+
+/**
+ * \ingroup rtltmap
+ * \typedef RtLtMapAreaLightGroup
+ * \ref RtLtMapAreaLightGroup is a structure which acts as a container
+ * for area lights created by a call to \ref RtLtMapAreaLightGroupCreate.
+ * The containers may be chained and passed to \ref RtLtMapIlluminate.
+ * Each container has an optional pointer to a RwFrame which is used to
+ * transform the contained area lights relative to the world of the current
+ * \ref RtLtMapLightingSession and relative to each other (such that, for
+ * example, lights from multiple worlds, which are connected by portals,
+ * or which are composed of atomics and not world sectors, may be used
+ * within a single call to \ref RtLtMapIlluminate).
+ *
+ * \see RtLtMapAreaLightGroupCreate
+ * \see RtLtMapAreaLightGroupDestroy
+ * \see RtLtMapIlluminate
+ * \see RtLtMapIlluminateVisCallBack
+ */
+typedef struct RtLtMapAreaLightGroup RtLtMapAreaLightGroup;
+struct RtLtMapAreaLightGroup
+{
+ RwSList *meshes; /**< A list of hierarchically-grouped area lights */
+ RwFrame *frame; /**< An (optional) pointer to a frame (owned by something else)
+ * whose LTM specifies the coordinate system of this container,
+ * relative to the world of the current \ref RtLtMapLightingSession. */
+ RtLtMapAreaLightGroup *next; /**< A pointer for chaining are light groups together */
+};
+
+/* Area light triangles are grouped by source mesh (this may change) */
+typedef struct LtMapAreaLightMesh LtMapAreaLightMesh;
+struct LtMapAreaLightMesh
+{
+ RwUInt32 flags; /* To hold hierarchical visibility culling flags,
+ * relevant to the object/triangle *currently* being lit. */
+ RpMaterial *material; /* The emitter material, containing colour, etc */
+ RwSphere sphere; /* Each mesh has an associated center and radius */
+ RwReal ROI; /* Centred on the above sphere, the R.O.I. of the
+ * samples in this mesh (a conservative estimate) */
+ RwSList *triangles; /* A list of the area light triangles in this mesh */
+};
+
+/* Area light samples are grouped by source triangle */
+typedef struct LtMapAreaLight LtMapAreaLight;
+struct LtMapAreaLight
+{
+ RwUInt16 flags; /* To hold hierarchical visibility culling flags,
+ * relevant to the object/triangle *currently* being lit. */
+ RwUInt16 numSamples; /* Number of area light samples in this triangle */
+ RwReal areaPerSample; /* (triangleArea / numSamples) for this triangle */
+ RwPlane plane; /* This 'area light' is a triangle, this is its plane. */
+ RwSphere sphere; /* This bounds the triangle's points in world-space (it's
+ * not worth storing 3 points, coarse culling is fine) */
+ RwV3d *lights; /* Array of area light sample positions (in world-space) */
+};
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+/* Lightmap creation functionality: */
+extern RtLtMapLightingSession *
+RtLtMapLightMapsCreate(RtLtMapLightingSession *session,
+ RwReal density, RwRGBA *color);
+
+extern void
+RtLtMapLightMapsDestroy(RtLtMapLightingSession *session);
+extern RpAtomic *
+RtLtMapAtomicLightMapDestroy(RpAtomic *atomic);
+extern RpWorldSector *
+RtLtMapWorldSectorLightMapDestroy(RpWorldSector *sector);
+
+extern RwReal
+RtLtMapGetVertexWeldThreshold(void);
+extern RwBool
+RtLtMapSetVertexWeldThreshold(RwReal threshold);
+
+extern RwUInt32
+RtLtMapLightMapGetDefaultSize(void);
+extern RwBool
+RtLtMapLightMapSetDefaultSize(RwUInt32 size);
+
+extern RwUInt32
+RtLtMapAtomicGetLightMapSize(RpAtomic *atomic);
+extern RpAtomic *
+RtLtMapAtomicSetLightMapSize(RpAtomic *atomic, RwUInt32 size);
+extern RwUInt32
+RtLtMapWorldSectorGetLightMapSize(RpWorldSector *sector);
+extern RpWorldSector *
+RtLtMapWorldSectorSetLightMapSize(RpWorldSector *sector, RwUInt32 size);
+
+extern RwUInt32
+RtLtMapAtomicGetFlags(RpAtomic *atomic);
+extern RpAtomic *
+RtLtMapAtomicSetFlags(RpAtomic *atomic, RwUInt32 flags);
+extern RwUInt32
+RtLtMapWorldSectorGetFlags(RpWorldSector *sector);
+extern RpWorldSector *
+RtLtMapWorldSectorSetFlags(RpWorldSector *sector, RwUInt32 flags);
+
+
+/* Lightmap illumination functionality: */
+extern RwUInt32
+RtLtMapIlluminate(RtLtMapLightingSession *session,
+ RtLtMapAreaLightGroup *lights);
+
+extern RwReal
+RtLtMapGetSliverAreaThreshold(void);
+extern RwBool
+RtLtMapSetSliverAreaThreshold(RwReal threshold);
+
+extern RwRGBA *
+RtLtMapDefaultSampleCallBack(RwRGBA *results,
+ RwV3d *samplePositions,
+ RwV3d * __RWUNUSED__ baryCoords,
+ RwUInt32 numSamples,
+ RpLight **lights,
+ RwUInt32 numLights,
+ RwV3d *normals);
+
+extern RwBool
+RtLtMapDefaultVisCallBack(RpWorld *world,
+ RwRGBAReal __RWUNUSED__ *result,
+ RwV3d *samplePos,
+ RwV3d *lightPos,
+ RpLight __RWUNUSED__ *light);
+
+extern RtLtMapLightingSession *
+RtLtMapLightingSessionInitialize(RtLtMapLightingSession *session,
+ RpWorld *world);
+
+extern RwInt32
+RtLtMapLightingSessionGetNumSamples(RtLtMapLightingSession *session);
+extern RwInt32
+RtLtMapWorldSectorGetNumSamples(RpWorldSector *sector);
+extern RwInt32
+RtLtMapAtomicGetNumSamples(RpAtomic *atomic);
+
+extern RtLtMapLightingSession *
+RtLtMapImagesPurge(RtLtMapLightingSession *session);
+extern RpAtomic *
+RtLtMapAtomicImagePurge(RpAtomic *atomic);
+extern RpWorldSector *
+RtLtMapWorldSectorImagePurge(RpWorldSector *sector);
+
+extern RtLtMapLightingSession *
+RtLtMapLightMapsClear(RtLtMapLightingSession *session, RwRGBA *color);
+extern RpAtomic *
+RtLtMapAtomicLightMapClear(RpAtomic *atomic, RwRGBA *color);
+extern RpWorldSector *
+RtLtMapWorldSectorLightMapClear(RpWorldSector *sector, RwRGBA *color);
+
+
+/* Material/area-lighting functionality: */
+extern RtLtMapAreaLightGroup *
+RtLtMapAreaLightGroupCreate(RtLtMapLightingSession *session, RwReal density);
+extern RwBool
+RtLtMapAreaLightGroupDestroy(RtLtMapAreaLightGroup *lights);
+
+extern RwUInt32
+RtLtMapMaterialGetFlags(RpMaterial *material);
+extern RpMaterial *
+RtLtMapMaterialSetFlags(RpMaterial *material, RwUInt32 flags);
+
+extern RwReal
+RtLtMapMaterialGetLightMapDensityModifier(RpMaterial *material);
+extern RpMaterial *
+RtLtMapMaterialSetLightMapDensityModifier(RpMaterial *material, RwReal modifier);
+
+extern RwRGBA
+RtLtMapMaterialGetAreaLightColor(RpMaterial *material);
+extern RpMaterial *
+RtLtMapMaterialSetAreaLightColor(RpMaterial *material, RwRGBA color);
+
+extern RwReal
+RtLtMapMaterialGetAreaLightDensityModifier(RpMaterial *material);
+extern RpMaterial *
+RtLtMapMaterialSetAreaLightDensityModifier(RpMaterial *material, RwReal modifier);
+
+extern RwReal
+RtLtMapMaterialGetAreaLightRadiusModifier(RpMaterial *material);
+extern RpMaterial *
+RtLtMapMaterialSetAreaLightRadiusModifier(RpMaterial *material, RwReal modifier);
+
+extern RwUInt32
+RtLtMapGetMaxAreaLightSamplesPerMesh(void);
+extern RwBool
+RtLtMapSetMaxAreaLightSamplesPerMesh(RwUInt32 maxSamples);
+extern RwReal
+RtLtMapGetAreaLightDensityModifier(void);
+extern RwBool
+RtLtMapSetAreaLightDensityModifier(RwReal modifier);
+extern RwReal
+RtLtMapGetAreaLightRadiusModifier(void);
+extern RwBool
+RtLtMapSetAreaLightRadiusModifier(RwReal modifier);
+extern RwReal
+RtLtMapGetAreaLightErrorCutoff(void);
+extern RwBool
+RtLtMapSetAreaLightErrorCutoff(RwReal tolerance);
+
+
+
+/* Texture-saving functionality: */
+extern RwTexDictionary *
+RtLtMapTexDictionaryCreate(RtLtMapLightingSession *session);
+
+extern const RwChar *
+RtLtMapGetDefaultPrefixString(void);
+extern RwBool
+RtLtMapSetDefaultPrefixString(RwChar *string);
+
+extern RwUInt32
+RtLtMapGetLightMapCounter(void);
+extern RwBool
+RtLtMapSetLightMapCounter(RwUInt32 value);
+
+
+#if (defined(SKY2_DRVMODEL_H) || defined(NULLSKY_DRVMODEL_H))
+
+/* PS2-specific functionality: */
+extern RwTexture *RtLtMapSkyLightMapMakeDarkMap(RwTexture *lightMap);
+
+extern RwTexture *RtLtMapSkyBaseTextureProcess(RwTexture *texture);
+extern RpAtomic *RtLtMapSkyAtomicBaseTexturesProcess(RpAtomic *atomic);
+extern RpWorldSector *
+RtLtMapSkyWorldSectorBaseTexturesProcess(RpWorldSector *sector);
+extern RtLtMapLightingSession *
+RtLtMapSkyBaseTexturesProcess(RtLtMapLightingSession *session);
+
+#endif /* (defined(SKY2_DRVMODEL_H) || defined(NULLSKY_DRVMODEL_H)) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RTLTMAP_H */
+
+
diff --git a/rwsdk/include/d3d8/rtltmap.rpe b/rwsdk/include/d3d8/rtltmap.rpe
new file mode 100644
index 00000000..e510d78b
--- /dev/null
+++ b/rwsdk/include/d3d8/rtltmap.rpe
@@ -0,0 +1,638 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionLTMAPTOOL
+{
+
+
+
+ e_rwdb_CriterionLTMAPTOOLLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionLTMAPTOOL e_rwdb_CriterionLTMAPTOOL;
+
+
diff --git a/rwsdk/include/d3d8/rtmipk.h b/rwsdk/include/d3d8/rtmipk.h
new file mode 100644
index 00000000..c06a3879
--- /dev/null
+++ b/rwsdk/include/d3d8/rtmipk.h
@@ -0,0 +1,58 @@
+/**
+ * Mipmap K toolkit
+ */
+
+/***************************************************************************
+ * *
+ * Module : rtmipk.h *
+ * *
+ * Purpose : To calculate mipmap K values for Sky *
+ * *
+ **************************************************************************/
+
+#ifndef RTMIPK_H
+#define RTMIPK_H
+
+/**
+ * \defgroup rtmipk RtMipmapK
+ * \ingroup rttool
+ *
+ * Ps2/Mipmap K Value Toolkit for RenderWare.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include "rwcore.h"
+#include "rpworld.h"
+
+/* RWPUBLIC */
+
+/****************************************************************************
+ Defines
+ */
+
+/****************************************************************************
+ Global Types
+ */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern void RtMipKWorldCalculateKValues(RpWorld *world, RwCamera *camera);
+extern void RtMipKClumpCalculateKValues(RpClump *clump, RwCamera *camera);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+#endif /* RTMIPK_H */
diff --git a/rwsdk/include/d3d8/rtmipk.rpe b/rwsdk/include/d3d8/rtmipk.rpe
new file mode 100644
index 00000000..24e1fd33
--- /dev/null
+++ b/rwsdk/include/d3d8/rtmipk.rpe
@@ -0,0 +1,628 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionMipmapK
+{
+
+
+
+ e_rwdb_CriterionMipmapKLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionMipmapK e_rwdb_CriterionMipmapK;
+
+
diff --git a/rwsdk/include/d3d8/rtpick.h b/rwsdk/include/d3d8/rtpick.h
new file mode 100644
index 00000000..5ea78058
--- /dev/null
+++ b/rwsdk/include/d3d8/rtpick.h
@@ -0,0 +1,59 @@
+/***************************************************************************
+ * *
+ * Module : rtpick.h *
+ * *
+ * Purpose : Utils for picking atomics. *
+ * *
+ **************************************************************************/
+
+#ifndef RTPICK_H
+#define RTPICK_H
+
+/**
+ * \defgroup rtpick RtPick
+ * \ingroup rttool
+ *
+ * Picking Toolkit for RenderWare.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include "rwcore.h"
+#include "rtpick.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Defines
+ */
+
+/****************************************************************************
+ Global Types
+ */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Camera pixel ray */
+extern const RwCamera *RwCameraCalcPixelRay(const RwCamera *camera,
+ RwLine *line,
+ const RwV2d *pixel);
+
+/* Picking atomics */
+extern RpAtomic *RpWorldPickAtomicOnLine(RpWorld *world,
+ const RwLine *line);
+extern RpAtomic *RwCameraPickAtomicOnPixel(const RwCamera *camera,
+ const RwV2d *pixel);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* RTPICK_H */
diff --git a/rwsdk/include/d3d8/rtpick.rpe b/rwsdk/include/d3d8/rtpick.rpe
new file mode 100644
index 00000000..055ea9ff
--- /dev/null
+++ b/rwsdk/include/d3d8/rtpick.rpe
@@ -0,0 +1,628 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionPick
+{
+
+
+
+ e_rwdb_CriterionPickLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionPick e_rwdb_CriterionPick;
+
+
diff --git a/rwsdk/include/d3d8/rtpitexd.h b/rwsdk/include/d3d8/rtpitexd.h
new file mode 100644
index 00000000..39287bcd
--- /dev/null
+++ b/rwsdk/include/d3d8/rtpitexd.h
@@ -0,0 +1,74 @@
+/***********************************************************************
+ *
+ * Module: rtpitexd.h
+ *
+ * Purpose: Platform Independent Texture Dictionaries
+ *
+ ***********************************************************************/
+
+#if !defined( RTPITEXD_H )
+#define RTPITEXD_H
+
+/**
+ * \defgroup rtpitexd RtPITexD
+ * \ingroup rttool
+ *
+ * Platform Independent Texture Dictionaries
+ *
+ */
+
+
+/* =====================================================================
+ * Includes
+ * ===================================================================== */
+#include <rwcore.h>
+#include <rtpitexd.rpe> /* automatically generated */
+
+
+/* =====================================================================
+ * Defines
+ * ===================================================================== */
+
+
+/* =====================================================================
+ * Module specific type definitions
+ * ===================================================================== */
+
+/* =====================================================================
+ * Extern variables
+ * ===================================================================== */
+
+
+/* =====================================================================
+ * Extern function prototypes
+ * ===================================================================== */
+
+#if defined( __cplusplus )
+extern "C"
+{
+#endif /* defined( __cplusplus ) */
+
+/* RWPUBLIC */
+
+extern RwUInt32
+RtPITexDictionaryStreamGetSize( const RwTexDictionary *texDict );
+
+extern RwTexDictionary *
+RtPITexDictionaryStreamRead( RwStream *stream );
+
+extern RwTexDictionary *
+RtPITexDictionaryStreamWrite( RwTexDictionary *texDict,
+ RwStream *stream );
+
+/* RWPUBLICEND */
+
+extern void
+_rwImageGammaUnCorrectArrayOfRGBA( RwRGBA * rgbaOut,
+ RwRGBA * rgbaIn,
+ RwInt32 numEls );
+
+#if defined( __cplusplus )
+}
+#endif /* defined( __cplusplus ) */
+
+#endif /* !defined( RTPITEXD_H ) */
diff --git a/rwsdk/include/d3d8/rtpitexd.rpe b/rwsdk/include/d3d8/rtpitexd.rpe
new file mode 100644
index 00000000..0650ea5c
--- /dev/null
+++ b/rwsdk/include/d3d8/rtpitexd.rpe
@@ -0,0 +1,682 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionPITexDict
+{
+
+
+
+ e_rwdb_CriterionPITexDictLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionPITexDict e_rwdb_CriterionPITexDict;
+
+
diff --git a/rwsdk/include/d3d8/rtpng.h b/rwsdk/include/d3d8/rtpng.h
new file mode 100644
index 00000000..694c8400
--- /dev/null
+++ b/rwsdk/include/d3d8/rtpng.h
@@ -0,0 +1,49 @@
+
+/***************************************************************************
+ * *
+ * Module : rtPng.h *
+ * *
+ * Purpose : Load PNG format files *
+ * *
+ **************************************************************************/
+
+#ifndef RTPNG_H
+#define RTPNG_H
+
+/**
+ * \defgroup rtpng RtPNG
+ * \ingroup rttool
+ *
+ * PNG/Portable Network Graphics Image Format Toolkit for RenderWare.
+ *
+ * See also http://www.libpng.org/pub/png/
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+/*--- Include files ---*/
+#include "rwcore.h"
+
+#include "rtpng.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwImage *RtPNGImageWrite(RwImage * image, const RwChar * imageName);
+extern RwImage *RtPNGImageRead(const RwChar * imageName);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+#endif /* RTPNG_H */
diff --git a/rwsdk/include/d3d8/rtpng.rpe b/rwsdk/include/d3d8/rtpng.rpe
new file mode 100644
index 00000000..7a6b6cc2
--- /dev/null
+++ b/rwsdk/include/d3d8/rtpng.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionPNG
+{
+
+
+
+ e_rwdb_CriterionPNGLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionPNG e_rwdb_CriterionPNG;
+
+
diff --git a/rwsdk/include/d3d8/rtquat.h b/rwsdk/include/d3d8/rtquat.h
new file mode 100644
index 00000000..05e971d0
--- /dev/null
+++ b/rwsdk/include/d3d8/rtquat.h
@@ -0,0 +1,646 @@
+/*
+ * Data structures for Quaternions
+ * See http://www-groups.dcs.st-and.ac.uk/~history/Mathematicians/Hamilton.html
+ *
+ * Copyright (c) Criterion Software Limited
+ */
+
+#ifndef RTQUAT_H
+#define RTQUAT_H
+
+/**
+ * \defgroup rtquat RtQuat
+ * \ingroup rttool
+ *
+ * Quaternion Toolkit for RenderWare.
+ *
+ * See also http://www.gamasutra.com/features/19980703/quaternions_01.htm
+ */
+
+/*
+ * See http://www-groups.dcs.st-and.ac.uk/~history/Mathematicians/Hamilton.html
+ * On 16 October 1843 (a Monday) Hamilton was walking in along the Royal
+ * Canal with his wife to preside at a Council meeting of the Royal Irish
+ * Academy.
+ *
+ * Although his wife talked to him now and again Hamilton hardly
+ * heard, for the discovery of the quaternions, the first noncommutative
+ * algebra to be studied, was taking shape in his mind:-
+ *
+ * "And here there dawned on me the notion that we must admit, in
+ * some sense, a fourth dimension of space for the purpose of calculating
+ * with triples ... An electric circuit seemed to close, and a spark
+ * flashed forth."
+ */
+
+
+/****************************************************************************
+ Includes
+ */
+
+#include <math.h>
+/* renderware */
+#include "rwcore.h"
+
+#include "rtquat.rpe" /* automatically generated header file */
+
+#define RW_TOL_ORTHONORMAL ((RwReal)0.01)
+
+/****************************************************************************
+ Global Types
+ */
+
+
+typedef struct RtQuat RtQuat;
+/**
+ * \ingroup rtquat
+ * \struct RtQuat
+ * A structure describing a Quaternion
+ *
+*/
+struct RtQuat
+{
+ RwV3d imag; /**< The imaginary part(s) */
+ RwReal real; /**< The real part */
+};
+
+
+/****************************************************************************
+ Defines
+ */
+
+#define RtQuatInitMacro( result, _x, _y, _z, _w) \
+MACRO_START \
+{ \
+ (result)->real = (_w); \
+ (result)->imag.x = (_x); \
+ (result)->imag.y = (_y); \
+ (result)->imag.z = (_z); \
+} \
+MACRO_STOP
+
+#if (!defined(RtQuatAssignMacro))
+#define RtQuatAssignMacro(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RtQuatAssignMacro)) */
+
+#define RtQuatAddMacro( result, q1, q2 ) \
+MACRO_START \
+{ \
+ (result)->real = (q1)->real + (q2)->real; \
+ RwV3dAddMacro(&(result)->imag, &(q1)->imag, &(q2)->imag); \
+} \
+MACRO_STOP
+
+#define RtQuatIncrementRealPartMacro(result, s, q) \
+MACRO_START \
+{ \
+ (result)->real = (q)->real + s; \
+ (result)->imag.x = (q)->imag.x; \
+ (result)->imag.y = (q)->imag.y; \
+ (result)->imag.z = (q)->imag.z; \
+} \
+MACRO_STOP
+
+#define RtQuatDecrementRealPartMacro(result, s, q) \
+MACRO_START \
+{ \
+ (result)->real = (q)->real - s; \
+ (result)->imag.x = (q)->imag.x; \
+ (result)->imag.y = (q)->imag.y; \
+ (result)->imag.z = (q)->imag.z; \
+} \
+MACRO_STOP
+
+#define RtQuatIncrementMacro( result, dq ) \
+MACRO_START \
+{ \
+ (result)->real = (result)->real + (dq)->real; \
+ RwV3dAddMacro(&(result)->imag, &(result)->imag, &(dq)->imag); \
+} \
+MACRO_STOP
+
+#define RtQuatSubMacro( result, q1, q2 ) \
+MACRO_START \
+{ \
+ (result)->real = (q1)->real - (q2)->real; \
+ RwV3dSubMacro(&(result)->imag, &(q1)->imag, &(q2)->imag); \
+} \
+MACRO_STOP
+
+#define RtQuatNegateMacro( result, q ) \
+MACRO_START \
+{ \
+ (result)->real = -(q)->real; \
+ (result)->imag.x = -(q)->imag.x; \
+ (result)->imag.y = -(q)->imag.y; \
+ (result)->imag.z = -(q)->imag.z; \
+} \
+MACRO_STOP
+
+#define RtQuatConjugateMacro( result, q) \
+MACRO_START \
+{ \
+ (result)->real = (q)->real; \
+ (result)->imag.x = -(q)->imag.x; \
+ (result)->imag.y = -(q)->imag.y; \
+ (result)->imag.z = -(q)->imag.z; \
+} \
+MACRO_STOP
+
+#define RtQuatScaleMacro(result, q, scale ) \
+MACRO_START \
+{ \
+ (result)->real = (q)->real * scale; \
+ RwV3dScaleMacro(&(result)->imag, &(q)->imag, scale); \
+} \
+MACRO_STOP
+
+#define RtQuatModulusSquaredMacro( q ) \
+ ((q)->real * (q)->real + \
+ RwV3dDotProductMacro(&(q)->imag, &(q)->imag))
+
+#define RtQuatModulusMacro( result, q ) \
+MACRO_START \
+{ \
+ (result) = RtQuatModulusSquaredMacro(q); \
+ rwSqrtMacro(&result, result); \
+} \
+MACRO_STOP
+
+#define RtQuatMultiplyMacro( result, q1, q2) \
+MACRO_START \
+{ \
+ /* \
+ * Assumes q1 != result != q2 \
+ */ \
+ (result)->real = \
+ (q1)->real * (q2)->real - \
+ RwV3dDotProductMacro(&(q1)->imag,&(q2)->imag); \
+ RwV3dCrossProductMacro(&(result)->imag, &(q1)->imag, &(q2)->imag); \
+ RwV3dIncrementScaledMacro(&(result)->imag, &(q2)->imag, (q1)->real); \
+ RwV3dIncrementScaledMacro(&(result)->imag, &(q1)->imag, (q2)->real); \
+} \
+MACRO_STOP
+
+#define RtQuatReciprocalMacro( result, q) \
+MACRO_START \
+{ \
+ /* \
+ * Assumes result != q \
+ */ \
+ RwReal val = RtQuatModulusSquaredMacro(q); \
+ \
+ if (val > (RwReal) 0) \
+ { \
+ val = ((RwReal)1) / val; \
+ (result)->real = (q)->real * val; \
+ val = -val; \
+ RwV3dScaleMacro(&(result)->imag, &(q)->imag, val); \
+ } \
+} \
+MACRO_STOP
+
+#define RtQuatSquareMacro( result, q ) \
+MACRO_START \
+{ \
+ /* \
+ * Assumes result != q \
+ */ \
+ RwReal val = ((RwReal)2) * (q)->real ; \
+ \
+ (result)->real = \
+ (q)->real * (q)->real - \
+ RwV3dDotProductMacro(&(q)->imag, &(q)->imag); \
+ RwV3dScaleMacro(&(result)->imag, &(q)->imag, val); \
+} \
+MACRO_STOP
+
+#define RtQuatSquareRootMacro( result, q ) \
+MACRO_START \
+{ \
+ /* \
+ * Assumes result != q \
+ * other root is of course -result \
+ */ \
+ RwReal val; \
+ \
+ RtQuatModulusMacro(val,q); \
+ val = ((q)->real + val) * ((RwReal) 0.5); \
+ \
+ if (val > ((RwReal)0)) \
+ { \
+ rwSqrtMacro(&val, val); \
+ (result)->real = val; \
+ val = ((RwReal)0.5) / val; \
+ RwV3dScale(&(result)->imag, &(q)->imag, val); \
+ } \
+ else \
+ { \
+ result->imag.x = -(q)->real; \
+ rwSqrtMacro(&(result->imag.x), result->imag.x); \
+ result->imag.y = ((RwReal)0); \
+ result->imag.x = ((RwReal)0); \
+ result->real = ((RwReal)0); \
+ } \
+} \
+MACRO_STOP
+
+#define RtQuatLogMacro(result, q) \
+MACRO_START \
+{ \
+ /* \
+ * Assumes result != q \
+ */ \
+ const RwReal mod2 = RtQuatModulusSquaredMacro(q); \
+ RwReal sin_b; \
+ RwReal radians; \
+ RwReal factor; \
+ \
+ sin_b = RwV3dDotProduct(&(q)->imag, &(q)->imag); \
+ rwSqrtMacro(&sin_b, sin_b); \
+ radians = (RwReal) RwATan2(sin_b, (q)->real); \
+ factor = (sin_b > (RwReal) 0) ? (((RwReal)radians) / sin_b) : 0 ; \
+ \
+ RwV3dScaleMacro(&(result)->imag, &(q)->imag, factor); \
+ (result)->real = ((RwReal) RwLog(mod2)) * ((RwReal) 0.5); \
+ \
+} \
+MACRO_STOP
+
+#define RtQuatExpMacro(result, q) \
+MACRO_START \
+{ \
+ /* \
+ * Assumes result != q \
+ */ \
+ const RwReal exp_a = (RwReal)RwExp((q)->real); \
+ RwReal mod_b; \
+ RwReal factor; \
+ \
+ mod_b = RwV3dDotProduct(&(q)->imag, &(q)->imag); \
+ rwSqrtMacro(&mod_b, mod_b); \
+ factor = ( (mod_b > (RwReal) 0) ? \
+ (exp_a * ((RwReal)RwSin(mod_b)) / mod_b) : \
+ 0 ) ; \
+ \
+ RwV3dScaleMacro(&(result)->imag, &(q)->imag, factor); \
+ (result)->real = exp_a * (RwReal)RwCos(mod_b); \
+} \
+MACRO_STOP
+
+#define RtQuatPowMacro( result, q, e) \
+MACRO_START \
+{ \
+ RtQuat qLog; \
+ \
+ RtQuatLogMacro(&qLog, q); \
+ RtQuatScaleMacro(&qLog, &qLog, e); \
+ RtQuatExpMacro(result, &qLog); \
+} \
+MACRO_STOP
+
+#define RtQuatUnitLogMacro(result, q) \
+MACRO_START \
+{ \
+ /* \
+ * Assumes result != q \
+ */ \
+ RwReal sin_b ; \
+ RwReal radians ; \
+ RwReal factor ; \
+ \
+ sin_b = RwV3dDotProduct(&(q)->imag, &(q)->imag); \
+ rwSqrtMacro(&sin_b, sin_b); \
+ radians = (RwReal)RwATan2(sin_b, (q)->real); \
+ factor = (sin_b > (RwReal) 0) ? (((RwReal)radians) / sin_b) : 0 ; \
+ \
+ RwV3dScaleMacro(&(result)->imag, &(q)->imag, factor); \
+ (result)->real = (RwReal)0; \
+ \
+} \
+MACRO_STOP
+
+#define RtQuatUnitExpMacro(result, q) \
+MACRO_START \
+{ \
+ /* \
+ * Assumes result != q \
+ */ \
+ RwReal mod_b; \
+ RwReal factor; \
+ \
+ mod_b = RwV3dDotProduct(&(q)->imag, &(q)->imag); \
+ rwSqrtMacro(&mod_b, mod_b); \
+ factor = (mod_b > (RwReal) 0) ? (((RwReal)RwSin(mod_b)) / mod_b) : 0 ; \
+ \
+ RwV3dScaleMacro(&(result)->imag, &(q)->imag, factor); \
+ (result)->real = (RwReal)RwCos(mod_b); \
+ \
+} \
+MACRO_STOP
+
+#define RtQuatUnitPowMacro( result, q, e) \
+MACRO_START \
+{ \
+ RtQuat qLog; \
+ \
+ RtQuatUnitLogMacro(&qLog, q); \
+ RwV3dScaleMacro(&qLog.imag, &qLog.imag, e); \
+ RtQuatUnitExpMacro(result, &qLog); \
+} \
+MACRO_STOP
+
+#define RtQuatConvertToMatrixMacro(qpQuat, mpMatrix) \
+MACRO_START \
+{ \
+ RwReal rS; \
+ RwV3d rV; \
+ RwV3d rW; \
+ RwV3d square; \
+ RwV3d cross; \
+ \
+ rS = ((RwReal) 2) / RtQuatModulusSquaredMacro((qpQuat)); \
+ \
+ RwV3dScale(&rV, &(qpQuat)->imag, rS); \
+ RwV3dScale(&rW, &rV, (qpQuat)->real); \
+ \
+ square.x = (qpQuat)->imag.x * rV.x; \
+ square.y = (qpQuat)->imag.y * rV.y; \
+ square.z = (qpQuat)->imag.z * rV.z; \
+ \
+ cross.x = (qpQuat)->imag.y * rV.z; \
+ cross.y = (qpQuat)->imag.z * rV.x; \
+ cross.z = (qpQuat)->imag.x * rV.y; \
+ \
+ (mpMatrix)->right.x = ((RwReal) 1) - (square.y + square.z); \
+ (mpMatrix)->right.y = cross.z + rW.z; \
+ (mpMatrix)->right.z = cross.y - rW.y; \
+ \
+ (mpMatrix)->up.x = cross.z - rW.z; \
+ (mpMatrix)->up.y = ((RwReal) 1) - (square.z + square.x); \
+ (mpMatrix)->up.z = cross.x + rW.x; \
+ \
+ (mpMatrix)->at.x = cross.y + rW.y; \
+ (mpMatrix)->at.y = cross.x - rW.x; \
+ (mpMatrix)->at.z = ((RwReal) 1) - (square.x + square.y); \
+ \
+ /* Set position */ \
+ (mpMatrix)->pos.x = ((RwReal) 0); \
+ (mpMatrix)->pos.y = ((RwReal) 0); \
+ (mpMatrix)->pos.z = ((RwReal) 0); \
+ \
+ /* Matrix is orthogonal */ \
+ rwMatrixSetFlags((mpMatrix), \
+ (rwMATRIXTYPEORTHOGANAL & \
+ ~rwMATRIXINTERNALIDENTITY) ); \
+ \
+} \
+MACRO_STOP
+
+#define RtQuatUnitConvertToMatrixMacro(qpQuat, mpMatrix) \
+MACRO_START \
+{ \
+ const RwReal x = (qpQuat)->imag.x; \
+ const RwReal y = (qpQuat)->imag.y; \
+ const RwReal z = (qpQuat)->imag.z; \
+ const RwReal w = (qpQuat)->real; \
+ RwV3d square; \
+ RwV3d cross; \
+ RwV3d wimag; \
+ \
+ square.x = x * x; \
+ square.y = y * y; \
+ square.z = z * z; \
+ \
+ cross.x = y * z; \
+ cross.y = z * x; \
+ cross.z = x * y; \
+ \
+ wimag.x = w * x; \
+ wimag.y = w * y; \
+ wimag.z = w * z; \
+ \
+ (mpMatrix)->right.x = 1 - 2 * (square.y + square.z); \
+ (mpMatrix)->right.y = 2 * (cross.z + wimag.z); \
+ (mpMatrix)->right.z = 2 * (cross.y - wimag.y); \
+ \
+ (mpMatrix)->up.x = 2 * (cross.z - wimag.z); \
+ (mpMatrix)->up.y = 1 - 2 * (square.x + square.z); \
+ (mpMatrix)->up.z = 2 * (cross.x + wimag.x); \
+ \
+ (mpMatrix)->at.x = 2 * (cross.y + wimag.y); \
+ (mpMatrix)->at.y = 2 * (cross.x - wimag.x); \
+ (mpMatrix)->at.z = (1 - 2 * (square.x + square.y)); \
+ \
+ /* Set position */ \
+ (mpMatrix)->pos.x = ((RwReal) 0); \
+ (mpMatrix)->pos.y = ((RwReal) 0); \
+ (mpMatrix)->pos.z = ((RwReal) 0); \
+ \
+ /* Matrix is orthonormal */ \
+ rwMatrixSetFlags((mpMatrix), \
+ (rwMATRIXTYPEORTHONORMAL & \
+ ~rwMATRIXINTERNALIDENTITY) ); \
+} \
+MACRO_STOP
+
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+
+#define RtQuatInit( result, _x, _y, _z, _w) \
+ RtQuatInitMacro( result, _x, _y, _z, _w)
+
+#define RtQuatAssign( to, from ) \
+ RtQuatAssignMacro( to, from )
+
+#define RtQuatAdd( result, q1, q2 ) \
+ RtQuatAddMacro( result, q1, q2 )
+
+#define RtQuatIncrementRealPart(result, s, q) \
+ RtQuatIncrementRealPartMacro(result, s, q)
+
+#define RtQuatDecrementRealPart(result, s, q) \
+ RtQuatDecrementRealPartMacro(result, s, q)
+
+#define RtQuatIncrement( result, dq ) \
+ RtQuatIncrementMacro( result, dq )
+
+#define RtQuatSub( result, q1, q2 ) \
+ RtQuatSubMacro( result, q1, q2 )
+
+#define RtQuatNegate( result, q ) \
+ RtQuatNegateMacro( result, q )
+
+#define RtQuatConjugate( result, q) \
+ RtQuatConjugateMacro( result, q)
+
+#define RtQuatScale(result, q, scale ) \
+ RtQuatScaleMacro(result, q, scale )
+
+#define RtQuatModulusSquared( q ) \
+ RtQuatModulusSquaredMacro( q )
+
+#define RtQuatMultiply( result, q1, q2) \
+ RtQuatMultiplyMacro( result, q1, q2)
+
+#define RtQuatReciprocal( result, q) \
+ RtQuatReciprocalMacro( result, q)
+
+#define RtQuatSquare( result, q ) \
+ RtQuatSquareMacro( result, q )
+
+#define RtQuatSquareRoot( result, q ) \
+ RtQuatSquareRootMacro( result, q )
+
+#define RtQuatLog( result, q ) \
+ RtQuatLogMacro( result, q )
+
+#define RtQuatExp( result, q ) \
+ RtQuatExpMacro( result, q )
+
+#define RtQuatPow( result, q, e ) \
+ RtQuatPowMacro( result, q, e )
+
+#define RtQuatUnitLog( result, q ) \
+ RtQuatUnitLogMacro( result, q )
+
+#define RtQuatUnitExp( result, q ) \
+ RtQuatUnitExpMacro( result, q )
+
+#define RtQuatUnitPow( result, q, e ) \
+ RtQuatUnitPowMacro( result, q, e )
+
+#define RtQuatConvertToMatrix(qpQuat, mpMatrix) \
+ RtQuatConvertToMatrixMacro(qpQuat, mpMatrix)
+
+#define RtQuatUnitConvertToMatrix(qpQuat, mpMatrix) \
+ RtQuatUnitConvertToMatrixMacro(qpQuat, mpMatrix)
+
+#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */
+
+/****************************************************************************
+ Function prototypes
+ */
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwBool
+RtQuatConvertFromMatrix(RtQuat * const qpQuat,
+ const RwMatrix * const mpMatrix);
+
+extern RtQuat *
+RtQuatRotate(RtQuat * quat,
+ const RwV3d * axis,
+ RwReal angle,
+ RwOpCombineType combineOp);
+
+extern const RtQuat *
+RtQuatQueryRotate(const RtQuat *quat,
+ RwV3d * unitAxis,
+ RwReal * angle);
+
+extern RwV3d *
+RtQuatTransformVectors(RwV3d * vectorsOut,
+ const RwV3d * vectorsIn,
+ const RwInt32 numPoints,
+ const RtQuat *quat);
+
+extern RwReal
+RtQuatModulus(RtQuat * q);
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+
+extern void
+RtQuatInit(RtQuat * result, RwReal x, RwReal y, RwReal z, RwReal w);
+
+extern void
+RtQuatAssign(RtQuat * to, RtQuat * from);
+
+extern void
+RtQuatAdd(RtQuat * result, RtQuat * q1, RtQuat * q2);
+
+extern void
+RtQuatIncrementRealPart(RtQuat * result, RwReal s, RtQuat * q);
+
+extern void
+RtQuatDecrementRealPart(RtQuat * result, RwReal s, RtQuat * q);
+
+extern void
+RtQuatIncrement(RtQuat * result, RtQuat * dq);
+
+extern void
+RtQuatSub(RtQuat * result, RtQuat * q1, RtQuat * q2);
+
+extern void
+RtQuatNegate(RtQuat * result, RtQuat * q);
+
+extern void
+RtQuatConjugate(RtQuat * result, RtQuat * q);
+
+extern void
+RtQuatScale(RtQuat * result, RtQuat * q, RwReal scale);
+
+extern RwReal
+RtQuatModulusSquared(RtQuat * q);
+
+extern void
+RtQuatMultiply(RtQuat * result, RtQuat * q1, RtQuat * q2);
+
+extern void
+RtQuatReciprocal(RtQuat * result, RtQuat * q);
+
+extern void
+RtQuatSquare(RtQuat * result, RtQuat * q);
+
+extern void
+RtQuatSquareRoot(RtQuat * result, RtQuat * q);
+
+extern void
+RtQuatLog(RtQuat * result, RtQuat * q);
+
+extern void
+RtQuatExp(RtQuat * result, RtQuat * q);
+
+extern void
+RtQuatPow(RtQuat * result, RtQuat * q, RwReal e);
+
+extern void
+RtQuatUnitLog(RtQuat * result, RtQuat * q);
+
+extern void
+RtQuatUnitExp(RtQuat * result, RtQuat * q);
+
+extern void
+RtQuatUnitPow(RtQuat * result, RtQuat * q, RwReal e);
+
+extern void
+RtQuatConvertToMatrix(const RtQuat * const qpQuat,
+ RwMatrix * const mpMatrix);
+
+extern void
+RtQuatUnitConvertToMatrix(const RtQuat * const qpQuat,
+ RwMatrix * const mpMatrix);
+
+#endif /* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*
+ * Backwards compatibility code
+ */
+
+typedef RtQuat RpQuat;
+
+#define RpAnimQuatConvertFromMatrix(qpQuat, mpMatrix) \
+ RtQuatConvertFromMatrix(qpQuat, mpMatrix)
+
+#define RpAnimQuatConvertToMatrix(qpQuat,mpMatrix) \
+ RtQuatUnitConvertToMatrix(qpQuat,mpMatrix)
+
+
+#endif /* RTQUAT_H */
+
diff --git a/rwsdk/include/d3d8/rtquat.rpe b/rwsdk/include/d3d8/rtquat.rpe
new file mode 100644
index 00000000..e43bb50c
--- /dev/null
+++ b/rwsdk/include/d3d8/rtquat.rpe
@@ -0,0 +1,645 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionQuat
+{
+
+
+
+ e_rwdb_CriterionQuatLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionQuat e_rwdb_CriterionQuat;
+
+
diff --git a/rwsdk/include/d3d8/rtras.h b/rwsdk/include/d3d8/rtras.h
new file mode 100644
index 00000000..0a9064a8
--- /dev/null
+++ b/rwsdk/include/d3d8/rtras.h
@@ -0,0 +1,54 @@
+/***************************************************************************
+ * *
+ * Module : rtRAS.h *
+ * *
+ * Purpose : Load RAS format files *
+ * *
+ **************************************************************************/
+
+#ifndef RTRAS_H
+#define RTRAS_H
+
+/**
+ * \defgroup rtras RtRAS
+ * \ingroup rttool
+ *
+ * RAS/Sun Raster Fule Format Image Format Toolkit for RenderWare.
+ *
+ * See also http://www.sworks.com/hollasch/cgindex/formats/sunraster.html
+ *
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+/*--- Include files ---*/
+#include "rwcore.h"
+
+#include "rtras.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwImage *RtRASImageWrite(RwImage * image,
+ const RwChar * imageName);
+extern RwImage *RtRASImageRead(const RwChar * imageName);
+
+extern void _rwImageGammaUnCorrectArrayOfRGBA(RwRGBA * rgbaOut,
+ RwRGBA * rgbaIn,
+ RwInt32 numEls);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+#endif /* RTRAS_H */
diff --git a/rwsdk/include/d3d8/rtras.rpe b/rwsdk/include/d3d8/rtras.rpe
new file mode 100644
index 00000000..3398c3cc
--- /dev/null
+++ b/rwsdk/include/d3d8/rtras.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionRAS
+{
+
+
+
+ e_rwdb_CriterionRASLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionRAS e_rwdb_CriterionRAS;
+
+
diff --git a/rwsdk/include/d3d8/rtray.h b/rwsdk/include/d3d8/rtray.h
new file mode 100644
index 00000000..4bf0a343
--- /dev/null
+++ b/rwsdk/include/d3d8/rtray.h
@@ -0,0 +1,61 @@
+/***************************************************************************
+ * *
+ * Module : rtray.h *
+ * *
+ * Purpose : Picking with rays *
+ * *
+ **************************************************************************/
+
+#ifndef RTRAY_H
+#define RTRAY_H
+
+/**
+ * \defgroup rtray RtRay
+ * \ingroup rttool
+ *
+ * Line Toolkit for RenderWare.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include "rwcore.h"
+#include "rtray.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Defines
+ */
+
+
+ /****************************************************************************
+ Global Types
+ */
+
+
+/* RWPUBLIC */
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Line intersections */
+extern RwReal RtLineTriangleIntersectionTest(RwLine *line, RwV3d *normal,
+ RwV3d *v0, RwV3d *v1, RwV3d *v2);
+extern RwReal RtLineSphereIntersectionTest(RwLine *line, RwSphere *sphere);
+
+/* Line clipping */
+extern RwLine *RtLineClipPlane(RwLine *line, RwPlane *plane);
+extern RwLine *RtLineClipBBox(RwLine *line, RwBBox *box);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+#endif /* RTRAY_H */
diff --git a/rwsdk/include/d3d8/rtray.rpe b/rwsdk/include/d3d8/rtray.rpe
new file mode 100644
index 00000000..27788d94
--- /dev/null
+++ b/rwsdk/include/d3d8/rtray.rpe
@@ -0,0 +1,628 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionRay
+{
+
+
+
+ e_rwdb_CriterionRayLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionRay e_rwdb_CriterionRay;
+
+
diff --git a/rwsdk/include/d3d8/rtslerp.h b/rwsdk/include/d3d8/rtslerp.h
new file mode 100644
index 00000000..ec41752c
--- /dev/null
+++ b/rwsdk/include/d3d8/rtslerp.h
@@ -0,0 +1,262 @@
+/*
+ * Data Structures for Slerps/Spherical Linear Interpolations
+ * See also GemsIII/quatspin.c in
+ * http://www.acm.org/pubs/tog/GraphicsGems/gemsiii.zip
+ * Copyright (c) Criterion Software Limited
+ */
+
+/***************************************************************************
+ * *
+ * Module : rtslerp.h *
+ * *
+ * Purpose : Slerp functionality *
+ * *
+ **************************************************************************/
+
+#ifndef RTSLERP_H
+#define RTSLERP_H
+
+/**
+ * \defgroup rtslerp RtSlerp
+ * \ingroup rttool
+ *
+ * Slerp/Spherical Linear Interpolations Toolkit for RenderWare.
+ *
+ * See also http://www.cis.ohio-state.edu/~parent/book/Full.html
+ */
+
+#include "rwcore.h"
+#include "rtquat.h"
+
+/****************************************************************************
+ Includes
+ */
+
+#include "rtslerp.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Defines
+ */
+
+/* Masks for specifying which matrices to store by reference */
+#define rtSLERPREFNONE 0x00
+#define rtSLERPREFSTARTMAT 0x01
+#define rtSLERPREFENDMAT 0x02
+#define rtSLERPREFALL (~rtSLERPREFNONE)
+
+/****************************************************************************
+ Global Types
+ */
+
+
+typedef struct RtSlerp RtSlerp;
+/**
+ * \ingroup rtslerp
+ * \struct RtSlerp
+ * structure describing a Slerps/Spherical Linear Interpolations.
+ * See also GemsIII/quatspin.c in
+ * http://www.acm.org/pubs/tog/GraphicsGems/gemsiii.zip
+ */
+struct RtSlerp
+{
+ RwInt32 matRefMask; /**< Which matrices do we NOT own */
+ RwMatrix *startMat; /**< The start matrix */
+ RwMatrix *endMat; /**< The end matrix */
+ RwV3d axis; /**< The axis of rotation for the slerp */
+ RwReal angle; /**< The angle (in degrees) between src & dest */
+
+ /* Though a slerp may be a bad idea and opting for a lerp is better */
+ RwBool useLerp; /**< Do we want to use lerps? */
+};
+
+/* static frame sequence animation - contains no state */
+
+
+typedef struct RtQuatSlerpCache RtQuatSlerpCache;
+/**
+ * \ingroup rtslerp
+ * \struct RtQuatSlerpCache
+ * structure describing a SlerpCache,
+ * which should be initialized with \ref RtQuatSetupSlerpCache.
+ */
+struct RtQuatSlerpCache
+{
+ RtQuat raFrom; /**< Scaled initial quaternion */
+ RtQuat raTo; /**< Scaled final quaternion */
+ RwReal omega; /**< Angular displacement in radians */
+ RwBool nearlyZeroOm; /**< Flags near-zero angular
+ displacement*/
+};
+
+
+typedef struct RtQuatSlerpArgandCache RtQuatSlerpArgandCache;
+/**
+ * \ingroup rtslerp
+ * \struct RtQuatSlerpArgandCache
+ * a structure describing
+ * an Argand SlerpCache which should be
+ * initialized with \ref RtQuatSetupSlerpArgandCache.
+ * See http://www-groups.dcs.st-and.ac.uk/~history/Mathematicians/Argand.html
+ * Jean Argand was an accountant and amateur mathematician.
+ * He is famed for his geometrical interpretation of the complex numbers
+ * where i is interpreted as a rotation through 90.
+ */
+struct RtQuatSlerpArgandCache
+{
+ RtQuat logTo; /**< field Logarithm of final quaternion */
+ RtQuat logBase; /**< Logarithm of initial relative to final quaternion */
+};
+
+#define RtQuatSlerpMacro(qpResult, qpFrom, qpTo, rT, sCache) \
+MACRO_START \
+{ \
+ if ((rT) <= ((RwReal) 0)) \
+ { \
+ /* t is before start */ \
+ *(qpResult) = *(qpFrom); \
+ } \
+ else if (((RwReal) 1) <= (rT)) \
+ { \
+ \
+ /* t is after end */ \
+ *(qpResult) = *(qpTo); \
+ } \
+ else \
+ { \
+ /* ... so t must be in the interior then */ \
+ /* Calc coefficients rSclFrom, rSclTo */ \
+ RwReal rSclFrom = ((RwReal) 1) - (rT); \
+ RwReal rSclTo = (rT); \
+ \
+ if (!((sCache)->nearlyZeroOm)) \
+ { \
+ /* Standard case: slerp */ \
+ /* SLERPMESSAGE(("Neither nearly ZERO nor nearly PI")); */ \
+ \
+ rSclFrom *= (sCache)->omega; \
+ RwSinMinusPiToPiMacro(rSclFrom, rSclFrom); \
+ rSclTo *= (sCache)->omega; \
+ RwSinMinusPiToPiMacro(rSclTo, rSclTo); \
+ } \
+ \
+ /* Calc final values */ \
+ RwV3dScaleMacro(&(qpResult)->imag, \
+ &(sCache)->raFrom.imag, rSclFrom); \
+ RwV3dIncrementScaledMacro(&(qpResult)->imag, \
+ &(sCache)->raTo.imag, rSclTo); \
+ (qpResult)->real = \
+ ((sCache)->raFrom.real * rSclFrom) + \
+ ((sCache)->raTo.real * rSclTo); \
+ } \
+} \
+MACRO_STOP
+
+#define RtQuatSlerpArgandMacro(qpResult, qpFrom, qpTo, rT, sArgandCache) \
+MACRO_START \
+{ \
+ if ((rT) <= ((RwReal) 0)) \
+ { \
+ /* t is before start */ \
+ *(qpResult) = *(qpFrom); \
+ } \
+ else if (((RwReal) 1) <= (rT)) \
+ { \
+ /* t is after end */ \
+ *(qpResult) = *(qpTo); \
+ } \
+ else \
+ { \
+ RtQuat logBlend; \
+ \
+ /* ... so t must be in the interior then */ \
+ \
+ logBlend.imag.x = \
+ (sArgandCache)->logBase.imag.x + \
+ (rT) * (sArgandCache)->logTo.imag.x; \
+ logBlend.imag.y = \
+ (sArgandCache)->logBase.imag.y + \
+ (rT) * (sArgandCache)->logTo.imag.y; \
+ logBlend.imag.z = \
+ (sArgandCache)->logBase.imag.z + \
+ (rT) * (sArgandCache)->logTo.imag.z; \
+ logBlend.real = 0; \
+ \
+ RtQuatUnitExpMacro((qpResult), &logBlend); \
+ \
+ } \
+} \
+MACRO_STOP
+
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+
+#define RtQuatSlerp(qpResult, qpFrom, qpTo, rT, sCache) \
+ RtQuatSlerpMacro(qpResult, qpFrom, qpTo, rT, sCache)
+
+#define RtQuatSlerpArgand(qpResult, qpFrom, qpTo, rT, sArgandCache) \
+ RtQuatSlerpArgandMacro(qpResult, qpFrom, qpTo, rT, sArgandCache)
+
+#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Creating and destroying slerps */
+
+extern RtSlerp *RtSlerpCreate(RwInt32 nMatRefMask);
+
+extern void RtSlerpDestroy(RtSlerp * spSlerp);
+
+/* setting up a slerp */
+extern RtSlerp *RtSlerpInitialize(RtSlerp * spSlerp,
+ RwMatrix * mpMat1,
+ RwMatrix * mpMat2);
+
+/* Get a matrix */
+extern RwMatrix *RtSlerpGetMatrix(RtSlerp * spSlerp,
+ RwMatrix * mpResultMat,
+ RwReal nDelta);
+
+/* Set if lerp or slerp */
+extern RtSlerp *RtSlerpSetLerp(RtSlerp * spSlerp,
+ RwBool bUseLerp);
+
+extern void
+RtQuatSetupSlerpCache(RtQuat * qpFrom,
+ RtQuat * qpTo,
+ RtQuatSlerpCache * sCache);
+
+extern void
+RtQuatSetupSlerpArgandCache(RtQuat * qpFrom,
+ RtQuat * qpTo,
+ RtQuatSlerpArgandCache * sArgandCache);
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+
+extern void
+RtQuatSlerp(RtQuat * qpResult,
+ RtQuat * qpFrom,
+ RtQuat * qpTo,
+ RwReal rT,
+ RtQuatSlerpCache * sCache);
+
+extern void
+RtQuatSlerpArgand(RtQuat * qpResult,
+ RtQuat * qpFrom,
+ RtQuat * qpTo,
+ RwReal rT,
+ RtQuatSlerpArgandCache * sArgandCache);
+
+#endif /* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RTSLERP_H */
+
diff --git a/rwsdk/include/d3d8/rtslerp.rpe b/rwsdk/include/d3d8/rtslerp.rpe
new file mode 100644
index 00000000..847ccb00
--- /dev/null
+++ b/rwsdk/include/d3d8/rtslerp.rpe
@@ -0,0 +1,646 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionSlerp
+{
+
+
+
+ e_rwdb_CriterionSlerpLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionSlerp e_rwdb_CriterionSlerp;
+
+
diff --git a/rwsdk/include/d3d8/rtsplpvs.h b/rwsdk/include/d3d8/rtsplpvs.h
new file mode 100644
index 00000000..38ae118f
--- /dev/null
+++ b/rwsdk/include/d3d8/rtsplpvs.h
@@ -0,0 +1,65 @@
+
+/***************************************************************************
+ * *
+ * Module : rtsplpvs.h *
+ * *
+ * Purpose : To generate pvs data for a world froma spline *
+ * *
+ **************************************************************************/
+
+#ifndef RTSPLINEPVS_H
+#define RTSPLINEPVS_H
+
+/**
+ * \defgroup rtsplinepvs RtSplinePVS
+ * \ingroup rttool
+ *
+ * Spline PVS Toolkit for RenderWare.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include "rwcore.h"
+#include "rpworld.h"
+#include "rpspline.h"
+
+/* RWPUBLIC */
+
+/****************************************************************************
+ Defines
+ */
+
+/****************************************************************************
+ Global Types
+ */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RpWorld *
+RtSplinePVSConstruct(RpWorld * world,
+ RpSpline *spline, RwInt32 samples);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+/* for back compatibility */
+#define RtSplinePVSCreate(_world, _raster, _zraster, \
+ _mindist, _maxdist, _spline, _samples) \
+ RtSplinePVSConstruct(_world, \
+ _spline, _samples)
+
+
+#endif /* RTSPLINEPVS_H */
diff --git a/rwsdk/include/d3d8/rtsplpvs.rpe b/rwsdk/include/d3d8/rtsplpvs.rpe
new file mode 100644
index 00000000..d436b610
--- /dev/null
+++ b/rwsdk/include/d3d8/rtsplpvs.rpe
@@ -0,0 +1,628 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionSplinePVS
+{
+
+
+
+ e_rwdb_CriterionSplinePVSLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionSplinePVS e_rwdb_CriterionSplinePVS;
+
+
diff --git a/rwsdk/include/d3d8/rttiff.h b/rwsdk/include/d3d8/rttiff.h
new file mode 100644
index 00000000..9dbf22c8
--- /dev/null
+++ b/rwsdk/include/d3d8/rttiff.h
@@ -0,0 +1,47 @@
+/***************************************************************************
+ * *
+ * Module : rttiff.h *
+ * *
+ * Purpose : Load TIFF format files *
+ * *
+ **************************************************************************/
+
+#ifndef RWTIFF_H
+#define RWTIFF_H
+
+/**
+ * \defgroup rttiff RtTIFF
+ * \ingroup rttool
+ *
+ * TIFF/Tag Image File Format Image Format Toolkit for RenderWare.
+ *
+ * See also http://www.libtiff.org
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+/*--- Include files ---*/
+#include "rwcore.h"
+
+#include "rttiff.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwImage *RtTIFFImageRead(const RwChar *imageName);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+#endif /* RWTIFF_H */
diff --git a/rwsdk/include/d3d8/rttiff.rpe b/rwsdk/include/d3d8/rttiff.rpe
new file mode 100644
index 00000000..f82c7d82
--- /dev/null
+++ b/rwsdk/include/d3d8/rttiff.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionTIFF
+{
+
+
+
+ e_rwdb_CriterionTIFFLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionTIFF e_rwdb_CriterionTIFF;
+
+
diff --git a/rwsdk/include/d3d8/rttilerd.h b/rwsdk/include/d3d8/rttilerd.h
new file mode 100644
index 00000000..f11b703b
--- /dev/null
+++ b/rwsdk/include/d3d8/rttilerd.h
@@ -0,0 +1,70 @@
+/***************************************************************************
+ * *
+ * Module : rttilerd.h *
+ * *
+ * Purpose : Tile renderer *
+ * *
+ **************************************************************************/
+
+#ifndef RTTILERD_H
+#define RTTILERD_H
+
+/**
+ * \defgroup rttilerender RtTileRender
+ * \ingroup rttool
+ *
+ * Tile renderer - e.g. grabbing screen shots - Toolkit for RenderWare.
+ */
+
+/****************************************************************************
+ Includes
+ */
+#include "rwcore.h"
+
+#include "rpcriter.h"
+
+/****************************************************************************
+ Defines
+ */
+
+/****************************************************************************
+ Global Types
+ */
+
+typedef RwCamera * (*RtTileRenderCallBack)(RwCamera *camera,
+ RwInt32 x, RwInt32 y,
+ void *pData);
+
+typedef RwImage * (*RtTileArchiveCallBack)(RwImage *image,
+ RwInt32 x, RwInt32 y,
+ void *pData);
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Tile renderer */
+
+extern RwCamera *
+RtTileRender(RwCamera *camera,
+ RwInt32 imageWidth, RwInt32 imageHeight,
+ RwInt32 tileWidth, RwInt32 tileHeight,
+ RtTileRenderCallBack renderCallBack,
+ RtTileArchiveCallBack archiveCallBack,
+ void *pData);
+
+extern RwImage *
+RtTileDefaultArchive(RwImage *image,
+ RwInt32 x, RwInt32 y, void *pData);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RTTILERD_H */
diff --git a/rwsdk/include/d3d8/rttilerd.rpe b/rwsdk/include/d3d8/rttilerd.rpe
new file mode 100644
index 00000000..78222d06
--- /dev/null
+++ b/rwsdk/include/d3d8/rttilerd.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionTileRend
+{
+
+
+
+ e_rwdb_CriterionTileRendLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionTileRend e_rwdb_CriterionTileRend;
+
+
diff --git a/rwsdk/include/d3d8/rttoc.h b/rwsdk/include/d3d8/rttoc.h
new file mode 100644
index 00000000..02893aa8
--- /dev/null
+++ b/rwsdk/include/d3d8/rttoc.h
@@ -0,0 +1,99 @@
+/***************************************************************************
+ * *
+ * Module : rttoc.h *
+ * *
+ * Purpose : Table Of Contents (TOC) *
+ * *
+ **************************************************************************/
+
+#ifndef RTTOC_H
+#define RTTOC_H
+
+/**
+ * \defgroup rttoc RtTOC
+ * \ingroup rttool
+ *
+ * Table Of Contents (TOC) - e.g. creating a TOC for a RwStream.
+ */
+
+/****************************************************************************
+ Includes
+ */
+#include "rwcore.h"
+
+#include "rpcriter.h"
+
+/****************************************************************************
+ Defines
+ */
+
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct _rtTOCGUID _rtTOCGUID;
+struct _rtTOCGUID
+{
+ RwUInt32 data1;
+ RwUInt16 data2;
+ RwUInt16 data3;
+ RwUInt8 data4[8];
+};
+
+typedef struct RtTOCEntry RtTOCEntry;
+/**
+ * \ingroup rttoc
+ * \struct RtTOCEntry
+ *
+ * BLAH
+ */
+struct RtTOCEntry
+{
+ RwCorePluginID id; /**< Chunk ID */
+ RwUInt32 offset;/**< Offset of chunk from the start of the file
+ * including TOC */
+ _rtTOCGUID guid; /**< GUID */
+};
+
+typedef struct RtTOC RtTOC;
+
+/**
+ * \ingroup rttoc
+ * \struct RtTOC
+ *
+ * BLAH
+ */
+struct RtTOC
+{
+ RwInt32 numEntries; /**< Number of entries*/
+ RtTOCEntry entry[1]; /**< Entry*/
+};
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Create/Destroy */
+extern RtTOC *RtTOCCreate(RwStream *stream);
+extern void RtTOCDestroy(RtTOC *toc);
+
+/* Access */
+extern RwInt32 RtTOCGetNumEntries(const RtTOC *toc);
+extern RtTOCEntry *RtTOCGetEntry(RtTOC *toc, RwInt32 entry);
+
+/* Serialization */
+extern RwUInt32 RtTOCStreamGetSize(const RtTOC *toc);
+extern const RtTOC *RtTOCStreamWrite(RtTOC *toc, RwStream *stream);
+extern RtTOC *RtTOCStreamRead(RwStream *stream);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RTTOC_H */
diff --git a/rwsdk/include/d3d8/rttoc.rpe b/rwsdk/include/d3d8/rttoc.rpe
new file mode 100644
index 00000000..796f8de5
--- /dev/null
+++ b/rwsdk/include/d3d8/rttoc.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionTOC
+{
+
+
+
+ e_rwdb_CriterionTOCLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionTOC e_rwdb_CriterionTOC;
+
+
diff --git a/rwsdk/include/d3d8/rtvcat.h b/rwsdk/include/d3d8/rtvcat.h
new file mode 100644
index 00000000..474095e1
--- /dev/null
+++ b/rwsdk/include/d3d8/rtvcat.h
@@ -0,0 +1,38 @@
+
+/***************************************************************************
+ * *
+ * Module : rtvcat.h *
+ * *
+ * Purpose : Tristripping callback for vertex cache aware strips *
+ * *
+ **************************************************************************/
+
+#ifndef RTVCAT_H
+#define RTVCAT_H
+
+/****************************************************************************
+ Includes
+ */
+
+/*--- Include files ---*/
+#include "rwcore.h"
+
+#include "rtvcat.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern RpMeshHeader *
+RpBuildMeshGenerateCacheAwareTriStrip(RpBuildMesh *buildMesh,
+ void *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RTVCAT_H */
diff --git a/rwsdk/include/d3d8/rtvcat.rpe b/rwsdk/include/d3d8/rtvcat.rpe
new file mode 100644
index 00000000..464ca886
--- /dev/null
+++ b/rwsdk/include/d3d8/rtvcat.rpe
@@ -0,0 +1,629 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionVextexCacheStrip
+{
+
+
+
+ e_rwdb_CriterionVextexCacheStripLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionVextexCacheStrip e_rwdb_CriterionVextexCacheStrip;
+
+
diff --git a/rwsdk/include/d3d8/rtworld.h b/rwsdk/include/d3d8/rtworld.h
new file mode 100644
index 00000000..fef3e17c
--- /dev/null
+++ b/rwsdk/include/d3d8/rtworld.h
@@ -0,0 +1,85 @@
+/*
+ * World toolkit.
+ */
+/***************************************************************************
+ * *
+ * Module : rtworld.h *
+ * *
+ * Purpose : World tool helper functions header *
+ * *
+ **************************************************************************/
+
+#ifndef RTWORLD_H
+#define RTWORLD_H
+
+/**
+ * \defgroup rtworld RtWorld
+ * \ingroup rttool
+ *
+ * World Import Toolkit for RenderWare.
+ */
+
+/****************************************************************************
+ Includes
+ */
+
+#include "rpworld.h"
+
+#include "rtworld.rpe" /* automatically generated header file */
+
+/****************************************************************************
+ Defines
+ */
+
+/* RWPUBLIC */
+/****************************************************************************
+ Global Types
+ */
+
+/* RWPUBLICEND */
+
+/****************************************************************************
+ Exported globals
+ */
+
+/* RWPUBLIC */
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Get the number of various things in the world */
+extern RwInt32 RtWorldGetNumWorldSectors(RpWorld *world);
+extern RwInt32 RtWorldGetNumVertices(RpWorld *world);
+extern RwInt32 RtWorldGetNumPolygons(RpWorld *world);
+
+/* Find things out about materials in the world */
+extern RwInt32 RtWorldFindMaterialNum(RpWorld *world, RpMaterial *material);
+extern RpMaterial *RtWorldFindMaterialWithTextureName(RpWorld *world, RwChar *name);
+
+/* Optimisation functions in optimise.c */
+extern RpClump *RtClumpOptimize(RpClump *clump, RwReal dist);
+extern RpAtomic *RtAtomicOptimize(RpAtomic *atomic, RwReal dist);
+
+/*
+ * This function has been removed, however it still exists as a stealth
+ * function, _rtGeometryOptimize.
+ */
+#define RtGeometryOptimize(geometry, dist) (geometry)
+
+extern RpGeometry *_rtGeometryOptimize(RpGeometry *geometry, RwReal dist);
+
+/* Import utility functions from imputil.c */
+extern RpGeometry *RtGeometryCalculateVertexNormals(RpGeometry *geometry);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* RWPUBLICEND */
+
+#endif /* RWTLWRLD_H */
diff --git a/rwsdk/include/d3d8/rtworld.rpe b/rwsdk/include/d3d8/rtworld.rpe
new file mode 100644
index 00000000..bc20947e
--- /dev/null
+++ b/rwsdk/include/d3d8/rtworld.rpe
@@ -0,0 +1,628 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+enum e_rwdb_CriterionTlWorld
+{
+
+
+
+ e_rwdb_CriterionTlWorldLAST = RWFORCEENUMSIZEINT
+};
+
+typedef enum e_rwdb_CriterionTlWorld e_rwdb_CriterionTlWorld;
+
+
diff --git a/rwsdk/include/d3d8/rwcore.h b/rwsdk/include/d3d8/rwcore.h
new file mode 100644
index 00000000..b9214c63
--- /dev/null
+++ b/rwsdk/include/d3d8/rwcore.h
@@ -0,0 +1,4791 @@
+/******************************************/
+/* */
+/* RenderWare(TM) Graphics Library */
+/* */
+/******************************************/
+
+/*
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd.
+ * or Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. and Canon Inc. will not, under any
+ * circumstances, be liable for any lost revenue or other damages
+ * arising from the use of this file.
+ *
+ * Copyright (c) 1999. Criterion Software Ltd.
+ * All Rights Reserved.
+ */
+
+/*************************************************************************
+ *
+ * Filename: <C:/daily/rwsdk/include/d3d8/rwcore.h>
+ * Automatically Generated on: Wed Jul 10 10:45:00 2002
+ *
+ ************************************************************************/
+
+#ifndef RWCORE_H
+#define RWCORE_H
+
+/*--- System Header Files ---*/
+#include <rwplcore.h>
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/barwasmm.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2resort.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2macros.h ---*/
+
+#define RxClusterDecCursorByStride(_cluster, _stride) \
+ ((_cluster)->currentData = \
+ (void *)(((RwUInt8 *)(_cluster)->currentData) - \
+ (_stride)))
+
+#define RxClusterDecCursor(_cluster) \
+ RxClusterDecCursorByStride(_cluster, (_cluster)->stride)
+
+#define RxClusterIncCursorByStride(_cluster, _stride) \
+ ((_cluster)->currentData = \
+ (void *)(((RwUInt8 *)(_cluster)->currentData) + \
+ (_stride)))
+
+#define RxClusterIncCursor(_cluster) \
+ RxClusterIncCursorByStride(_cluster, (_cluster)->stride)
+
+#define RxClusterResetCursor(_cluster) \
+ ((_cluster)->currentData = (_cluster)->data)
+
+#define RxClusterGetCursorData(_cluster, _type) \
+ ((_type *)(_cluster)->currentData)
+
+#define RxClusterGetIndexedData(_cluster, _type, _index) \
+ ((_type *)(((RwUInt8 *)(_cluster)->data) + (_cluster)->stride*(_index)))
+
+#define RxClusterGetFreeIndex(_cluster) ( (_cluster)->numUsed++ )
+
+#define RxPipelineClusterAssertAttributeSet(_cluster, _attributeSet) \
+ RWASSERT( (_cluster)->clusterRef->attributeSet != NULL && \
+ rwstrcmp((_cluster)->clusterRef->attributeSet, \
+ (_attributeSet)) == 0 )
+
+#define RxPipelineNodeParamGetData(_param) \
+ ( (_param)->dataParam )
+
+#define RxPipelineNodeParamGetHeap(_param) \
+ ( (_param)->heap )
+
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2heap.h ---*/
+
+#if (defined(RWDEBUG) && (defined(RWMEMDEBUG)))
+
+#if (!defined(DISABLERWHEAP))
+#define DISABLERWHEAP
+#endif /* (!defined(DISABLERWHEAP)) */
+
+#endif /* (defined(RWDEBUG) && (defined(RWMEMDEBUG))) */
+
+typedef struct rxHeapFreeBlock rxHeapFreeBlock;
+typedef struct rxHeapSuperBlockDescriptor rxHeapSuperBlockDescriptor;
+typedef struct RxHeap RxHeap;
+typedef struct rxHeapBlockHeader rxHeapBlockHeader;
+
+struct rxHeapFreeBlock
+{
+ RwUInt32 size;
+ rxHeapBlockHeader *ptr;
+};
+
+struct rxHeapSuperBlockDescriptor
+{
+ void *start;
+ RwUInt32 size;
+ rxHeapSuperBlockDescriptor *next;
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxHeap
+ * structure describing a pipeline execution heap
+ */
+struct RxHeap
+{
+ RwUInt32 superBlockSize; /**< Granularity of heap growth */
+ rxHeapSuperBlockDescriptor *head; /**< Internally used superblock pointer */
+ rxHeapBlockHeader *headBlock; /**< Internally used block pointer */
+ rxHeapFreeBlock *freeBlocks; /**< Internally used free blocks pointer */
+ RwUInt32 entriesAlloced; /**< Number of entries allocated */
+ RwUInt32 entriesUsed; /**< Number of entries used */
+ RwBool dirty; /**< Internally used boolean, flags whether
+ * the heap needs resetting or not. */
+};
+
+struct rxHeapBlockHeader
+{
+ /* present in all blocks (used & unused) */
+ rxHeapBlockHeader *prev, *next;
+ RwUInt32 size;
+ rxHeapFreeBlock *freeEntry; /* (or null) */
+ RwUInt32 pad[4]; /* alignment padding to 32 bytes */
+};
+
+/* This wrapper cheaply early-outs when a heap doesn't *need* resetting */
+#define RxHeapReset(heap) \
+ ((FALSE == (heap)->dirty) ? (TRUE) : (_rxHeapReset(heap)))
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxHeap *RxHeapCreate(RwUInt32 size);
+extern void RxHeapDestroy(RxHeap * heap);
+extern RwBool _rxHeapReset(RxHeap * heap);
+extern void *RxHeapAlloc(RxHeap * heap, RwUInt32 size);
+extern void RxHeapFree(RxHeap * heap, void *block);
+extern void *RxHeapRealloc(RxHeap * heap, void *block,
+ RwUInt32 newSize, RwBool allowCopy);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#if (defined(DISABLERWHEAP))
+
+typedef struct rxHeapMallocTrace rxHeapMallocTrace;
+struct rxHeapMallocTrace
+{
+ rxHeapMallocTrace *next;
+ rxHeapBlockHeader *block;
+};
+
+#endif /* (defined(DISABLERWHEAP)) */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2dep.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2core.h ---*/
+
+extern RwInt32 _rxPipelineMaxNodes;
+extern RwInt32 _rxHeapInitialSize;
+/* LEGACY-SUPPORT MACRO */
+#define _rwRxHeapInitialSize _rxHeapInitialSize
+
+/* Beneficial padding of PowerPipe types is still being worked out... */
+#define PADCLUSTERSx
+
+
+/*************************************************************
+ * Global Defines
+ */
+
+#define RWBOOLTOGGLE(bVar) ((bVar == FALSE)?(bVar = TRUE):(bVar = FALSE))
+
+/* Both these currently limited due to the use of RwUInt32 bit-fields */
+#define RXNODEMAXCLUSTERSOFINTEREST 32
+#define RXNODEMAXOUTPUTS 32
+
+/* Useful (for memory alloc) to limit this during pipeline construction */
+#define RXPIPELINEDEFAULTMAXNODES 64
+
+/*
+ * Cluster flags
+ */
+
+#define rxCLFLAGS_NULL ((RwUInt16) 0x0000U)
+#define rxCLFLAGS_CLUSTERVALID ((RwUInt16) 0x0001U)
+#define rxCLFLAGS_EXTERNAL ((RwUInt16) 0x0002U)
+#define rxCLFLAGS_EXTERNALMODIFIABLE ((RwUInt16) 0x0004U | 0x0002U)
+#define rxCLFLAGS_MODIFIED ((RwUInt16) 0x0008U)
+
+/*
+ * Packet flags
+ */
+
+#define rxPKFLAGS_NULL ((RwUInt16) 0x0000U)
+
+/*
+ * used in input specification
+ */
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RxClusterValidityReq
+ * Flags specifying the state requirements for
+ * a \ref RxCluster on entry to a node */
+enum RxClusterValidityReq
+{
+ rxCLREQ_DONTWANT = 0, /**<The cluster is required but any data within it is
+ * not wanted and will be overwritten */
+ rxCLREQ_REQUIRED = 1, /**<The cluster is required and it must contain
+ * valid data */
+ rxCLREQ_OPTIONAL = 2, /**<The cluster will be used if it is present and
+ * contains valid data, otherwise the node will
+ * make do without it. */
+ rxCLUSTERVALIDITYREQFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RxClusterValid
+ * Flags specifying the state requirements for
+ * a \ref RxCluster on exit from a node */
+enum RxClusterValid
+{
+ rxCLVALID_NOCHANGE = 0, /**<The cluster and its data will not change in
+ * validity on passing through this node */
+ rxCLVALID_VALID = 1, /**<The cluster and its data will be valid on
+ * exit from this node */
+ rxCLVALID_INVALID = 2, /**<The cluster's data will be invalid on
+ * exit from this node */
+ rxCLUSTERVALIDFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct RxClusterDefinition RxClusterDefinition;
+
+typedef struct rxReq rxReq;
+
+typedef enum RxClusterValidityReq RxClusterValidityReq;
+typedef enum RxClusterValid RxClusterValid;
+typedef struct RxOutputSpec RxOutputSpec;
+typedef struct RxClusterRef RxClusterRef;
+typedef struct RxIoSpec RxIoSpec;
+
+typedef struct RxNodeMethods RxNodeMethods;
+typedef struct RxNodeDefinition RxNodeDefinition;
+
+typedef struct RxCluster RxCluster;
+typedef struct RxPipelineCluster RxPipelineCluster;
+typedef struct RxPacket RxPacket;
+typedef struct RxPipelineNode RxPipelineNode;
+typedef struct RxPipelineNodeTopSortData RxPipelineNodeTopSortData;
+typedef struct RxPipelineNode RxPipelineNodeInstance;
+typedef struct RxPipelineNodeParam RxPipelineNodeParam;
+typedef struct RxExecutionContext RxExecutionContext;
+typedef struct RxPipelineRequiresCluster RxPipelineRequiresCluster;
+typedef struct RxPipeline RxPipeline;
+
+/***************************************************************************
+ *
+ * C L U S T E R D E F I N I T I O N
+ *
+ ***************************************************************************/
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxClusterDefinition
+ * Structure describing a cluster */
+struct RxClusterDefinition
+{
+ RwChar *name; /**< Name */
+ RwUInt32 defaultStride; /**< Default stride */
+ RwUInt32 defaultAttributes; /**< Default attributes */
+ const RwChar *attributeSet; /**< Attribute set */
+};
+
+
+/***************************************************************************
+ *
+ * N O D E D E F I N I T I O N S T R U C T S
+ *
+ ***************************************************************************/
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxOutputSpec
+ * Structure describing an output specification of a node */
+struct RxOutputSpec
+{
+ RwChar *name; /**< Name */
+ RxClusterValid *outputClusters; /**< States of clusters of interest on output */
+ RxClusterValid allOtherClusters; /**< States of clusters not of interest on output */
+};
+
+
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RxClusterForcePresent
+ * Flags specifying whether an \ref RxCluster
+ * should be forced to be present in an \ref RxPipelineNode */
+enum RxClusterForcePresent
+{
+ rxCLALLOWABSENT = FALSE, /**<The cluster is allowed to be absent if no prior
+ * nodes create it and no subsequent nodes require it */
+ rxCLFORCEPRESENT = TRUE, /**<The cluster must be present even if no prior
+ * nodes create it and no subsequent nodes require it */
+
+ rxCLUSTERFORCEPRESENTFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RxClusterForcePresent RxClusterForcePresent;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxClusterRef
+ * Structure describing a cluster reference */
+struct RxClusterRef
+{
+ RxClusterDefinition *clusterDef; /**< Cluster definition */
+ RxClusterForcePresent forcePresent; /**< Specifies whether the cluster should be forced present */
+ RwUInt32 reserved; /**< Omit or initialize to zero */
+};
+
+#define rxCLRESERVED ((RwUInt32)0)
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxIoSpec
+ * Structure describing an input/output specification of a node */
+struct RxIoSpec
+{
+ RwUInt32 numClustersOfInterest;/**< Number of Clusters of interest */
+ RxClusterRef *clustersOfInterest; /**< Clusters of interest array */
+ RxClusterValidityReq *inputRequirements; /**< Requirements of the clusters of interest on input to the node */
+ RwUInt32 numOutputs; /**< Number of outputs from the node */
+ RxOutputSpec *outputs; /**< Output specification array */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxNodeBodyFn
+ * is the callback to be
+ * called during pipeline execution -- and, typically, process
+ * \ref RxPacket's -- for the owning pipeline node.
+ *
+ * \param self A pointer to the pipeline node being executed
+ * \param params A pointer to a parameter structure
+ *
+ * \return TRUE on success, FALSE otherwise.
+ *
+ * \see RxNodeMethods
+ */
+typedef RwBool (*RxNodeBodyFn) (RxPipelineNode * self,
+ const RxPipelineNodeParam *params);
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxNodeInitFn
+ * is the callback to be called,
+ * for the owning node definition, the first time an \ref RxPipeline
+ * referencing that node definition is unlocked.
+ *
+ * \param self A pointer to the node definition
+ *
+ * \return TRUE on success, FALSE otherwise.
+ *
+ * \see RxNodeMethods
+ */
+typedef RwBool (*RxNodeInitFn) (RxNodeDefinition * self);
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxNodeTermFn
+ * is the callback to be called,
+ * for the owning node definition, the last time an \ref RxPipeline
+ * referencing that node definition is destroyed or locked.
+ *
+ * \param self A pointer to the node definition
+ *
+ * \return None
+ *
+ * \see RxNodeMethods
+ */
+typedef void (*RxNodeTermFn) (RxNodeDefinition * self);
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxPipelineNodeInitFn
+ * is the callback to be called, for the owning pipeline node, whenever a
+ * \ref RxPipeline containing that that pipeline node is unlocked.
+ *
+ * \param self A pointer to the pipeline node
+ *
+ * \return TRUE on success, FALSE otherwise.
+ *
+ * \see RxNodeMethods
+ */
+typedef RwBool (*RxPipelineNodeInitFn) (RxPipelineNode * self);
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxPipelineNodeTermFn
+ * is the callback to be called, for the owning pipeline node, whenever a
+ * \ref RxPipeline containing that that pipeline node is locked or
+ * destroyed.
+ *
+ * \param self A pointer to the pipeline node
+ *
+ * \return None
+ *
+ * \see RxNodeMethods
+ */
+typedef void (*RxPipelineNodeTermFn) (RxPipelineNode * self);
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxPipelineNodeConfigFn
+ * is the callback to be called, for the owning pipeline node, whenever a
+ * \ref RxPipeline containing that that pipeline node is unlocked,
+ * *after* all \ref RxPipelineNodeInitFn's have been called for the
+ * pipeline in question. This func is to be used as described in
+ * RxPipelineNodeSendConfigMsg.
+ *
+ * \param self A pointer to the pipeline node
+ * \param pipeline A pointer to the containing pipeline
+ *
+ * \return TRUE on success, FALSE otherwise.
+ *
+ * \see RxNodeMethods
+ */
+typedef RwBool (*RxPipelineNodeConfigFn) (RxPipelineNode * self,
+ RxPipeline * pipeline);
+
+/* - removed from the API Reference January 2002 -
+ typedef RxConfigMsgHandlerFn
+ is the callback to be called, for the owning pipeline node, whenever
+ a message is sent to it by the ref RxPipelineNodeConfigFn of another
+ pipeline node in the same pipeline. See ref RxPipelineNodeSendConfigMsg.
+
+ param self A pointer to the pipeline node
+ param msg Message ID
+ param intparam Meaning is message-specific
+ param ptrparam Meaning is message-specific
+
+ return A RwInt32 value, 0: unserviced; -ve: error; +ve: informative success
+
+ see RxNodeMethods
+ */
+typedef RwUInt32 (*RxConfigMsgHandlerFn) (RxPipelineNode * self,
+ RwUInt32 msg,
+ RwUInt32 intparam,
+ void *ptrparam);
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxNodeMethods
+ * A structure describing a set
+ * of node methods
+ *
+ * \see RxNodeBodyFn
+ * \see RxNodeInitFn
+ * \see RxNodeTermFn
+ * \see RxPipelineNodeInitFn
+ * \see RxPipelineNodeTermFn
+ * \see RxPipelineNodeConfigFn
+ * \see RxConfigMsgHandlerFn
+ */
+struct RxNodeMethods
+{
+ RxNodeBodyFn nodeBody; /**< Node body function */
+ RxNodeInitFn nodeInit; /**< Node initialization function */
+ RxNodeTermFn nodeTerm; /**< Node termination function */
+ RxPipelineNodeInitFn pipelineNodeInit; /**< Pipeline node initialization function */
+ RxPipelineNodeTermFn pipelineNodeTerm; /**< Pipeline node termination function */
+ RxPipelineNodeConfigFn pipelineNodeConfig; /**< Pipleline node configuation function */
+ RxConfigMsgHandlerFn configMsgHandler; /**< Configuaraton message handler function */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RxNodeDefEditable
+ * Flags specifying whether an \ref RxNodeDefinition
+ * is editable or not (\ref RxPipelineNodeCloneDefinition,
+ * \ref RxPipelineNodeReplaceCluster and \ref RxPipelineNodeRequestCluster
+ * create editable copies of node definitions as the originals may be
+ * static definitions). */
+enum RxNodeDefEditable
+{
+ /**<This node definition should not be freed */
+ rxNODEDEFCONST = FALSE,
+ /**< This node definition is a temporary,
+ * modified copy of another and can be freed */
+ rxNODEDEFEDITABLE = TRUE,
+ rxNODEDEFEDITABLEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RxNodeDefEditable RxNodeDefEditable;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxNodeDefinition
+ * A structure describing a node definition */
+struct RxNodeDefinition
+{
+ RwChar *name; /**< Name */
+ RxNodeMethods nodeMethods; /**< Node methods */
+ RxIoSpec io; /**< Input/output specification */
+ RwUInt32 pipelineNodePrivateDataSize; /**< Size in bytes of node's private data */
+ RxNodeDefEditable editable; /**< Flags whether a node is editable */
+ RwInt32 InputPipesCnt; /**< Count of the unlocked pipelines containing this node */
+};
+
+/***************************************************************************
+ *
+ * P I P E L I N E - E X E C U T I O N - T I M E S T R U C T S
+ *
+ ***************************************************************************/
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipelineCluster
+ * A structure describing a pipeline cluster;
+ * that is, an \ref RxClusterDefinition in the context of a specific \ref RxPipeline
+ * (in the same way as an \ref RxPipelineNode is an \ref RxNodeDefinition in the
+ * context of a specific \ref RxPipeline). The \ref RxCluster is the structure
+ * representing this and the \ref RxClusterDefinition within \ref RxPacket's at
+ * pipeline-execution-time */
+struct RxPipelineCluster
+{
+ RxClusterDefinition *clusterRef; /**< Cluster refererence */
+ RwUInt32 creationAttributes; /**< Creation Attributes */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxCluster
+ * A structure describing a cluster; this is
+ * the representative of an \ref RxClusterDefinition and \ref RxPipelineCluster
+ * within \ref RxPacket's at pipeline-execution-time. */
+struct RxCluster
+{
+ RwUInt16 flags; /**< Bitfield of flags e.g. modification permissions */
+ RwUInt16 stride; /**< Stride in bytes of the cluster's data */
+ void *data; /**< The Cluster's data */
+ void *currentData; /**< A 'cursor', referencing the current element in the data */
+ RwUInt32 numAlloced; /**< Allocated count */
+ RwUInt32 numUsed; /**< Used count */
+ RxPipelineCluster *clusterRef; /**< Valid after a cluster has been locked for writing,
+ * otherwise NULL. Analog of \ref RxPipelineNode and
+ * its 'nodeDef' member. */
+ RwUInt32 attributes; /**< Attributes */
+#ifdef PADCLUSTERS
+ RwUInt32 pad[1]; /**< Alignment padding */
+#endif
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPacket
+ * A structure describing a packet header */
+struct RxPacket
+{
+ RwUInt16 flags; /**< Flags to guide pipeline execution */
+ RwUInt16 numClusters; /**< Maximum number of clusters simultanesouly present in the current pipeline */
+ RxPipeline *pipeline; /**< The pipeline in which this packet is embedded (the current pipeline) */
+ RwUInt32 *inputToClusterSlot; /**< LUT to locate clusters of interest in the packet */
+ RwUInt32 *slotsContinue; /**< Bitfields specifying clusters persisting to output node */
+ RxPipelineCluster **slotClusterRefs; /**< Internal Use */
+#ifdef PADCLUSTERS
+ RwUInt32 pad[3]; /**< Alignment padding */
+#endif
+ RxCluster clusters[1]; /**< Cluster array large enough for widest part of the pipeline */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipelineNode
+ * Structure describing a pipeline Node;
+ * that is an \ref RxNodeDefinition in the context
+ * of a specific \ref RxPipeline.
+ */
+struct RxPipelineNode
+{
+ RxNodeDefinition *nodeDef; /**< Node definition reference */
+ RwUInt32 numOutputs; /**< Output count */
+ RwUInt32 *outputs; /**< Output array, indexing the pipeline's array of pipeline nodes */
+ RxPipelineCluster **slotClusterRefs; /**< For packets passing through this node, SlotClusterRefs[n]
+ * identifies the cluster to be found at index n in the packet's
+ * Clusters[] array. These assignments are determined at pipeline
+ * Unlock() time and are good for the life of the pipeline. */
+ RwUInt32 *slotsContinue; /**< Cluster persistence table for the node's outputs */
+ void *privateData; /**< Pointer to the pipeline Node's private data */
+ RwUInt32 *inputToClusterSlot; /**< LUT to locate clusters of interest in packets passing through this pipeline Node */
+ RxPipelineNodeTopSortData *topSortData; /**< Internal Use */
+ void *initializationData; /**< Used by the pipeline node initialisation
+ * function in setting up the Private data. */
+ RwUInt32 initializationDataSize; /**< Present so that if the node is cloned
+ * we can copy the initialisation data. */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipelineNodeTopSortData
+ * Structure describing data used during topological sorting
+ * during \ref RxLockedPipeUnlock ;
+ * RenderWare users do not need to understand this */
+struct RxPipelineNodeTopSortData
+{
+ RwUInt32 numIns; /**< Input count */
+ RwUInt32 numInsVisited; /**< Count of inputs visited during dependencies
+ * propagation/cluster slot allocation */
+ rxReq *req; /**< Req used in dependencies propagation/cluster
+ * slot allocation */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipelineNodeParam
+ * Structure holding parameters
+ * to pass to node body functions */
+struct RxPipelineNodeParam
+{
+ void *dataParam; /**< The data pointer passed in to \ref RxPipelineExecute */
+ RxHeap *heap; /**< The heap associated with the current pipeline exeuction */
+};
+
+enum rxEmbeddedPacketState
+{
+ rxPKST_PACKETLESS = 0, /* Packet not created */
+ rxPKST_UNUSED = 1, /* Packet created and then destroyed */
+ rxPKST_INUSE = 2, /* Packet created but not yet destroyed and fetched but not yet dispatched */
+ rxPKST_PENDING = 3, /* Packet created but not destroyed and dispatched but not yet fetched */
+ rxEMBEDDEDPACKETSTATEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum rxEmbeddedPacketState rxEmbeddedPacketState;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxExecutionContext
+ * Structure describing an execution context */
+struct RxExecutionContext
+{
+ RxPipeline *pipeline; /**< Currently executing pipeline */
+ RxPipelineNode *currentNode; /**< Currently executing node */
+ RwInt32 exitCode; /**< Used internally for nodes returning error codes on exit */
+ RwUInt32 pad; /**< Alignment padding */
+ RxPipelineNodeParam params; /**< The parameters passed to node bodies */
+ /*RwUInt32 pad[2];*/
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipelineRequiresCluster
+ * Structure describing a pipeline requirement of a cluster */
+struct RxPipelineRequiresCluster
+{
+ RxClusterDefinition *clusterDef; /**< Reference to a Cluster definition */
+ RxClusterValidityReq rqdOrOpt; /**< Cluster validity requirement (rxCLREQ_DONTWANT, rxCLREQ_REQUIRED or rxCLREQ_OPTIONAL) */
+ RwUInt32 slotIndex; /**< Index into the packet's cluster array within this pipeline */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipeline
+ * Structure describing a pipeline */
+struct RxPipeline
+{
+ RwBool locked; /**< Flags whether the pipeline is locked for editing */
+ RwUInt32 numNodes; /**< Node count */
+ RxPipelineNode *nodes; /**< Topologically sorted array of pipeline nodes */
+ RwUInt32 packetNumClusterSlots; /**< Number of slots allocated for clusters */
+ rxEmbeddedPacketState embeddedPacketState; /**< The state of this pipeline's embedded packet */
+ RxPacket *embeddedPacket; /**< This pipeline's embedded packet */
+
+ RwUInt32 numInputRequirements; /**< Input requirements count */
+ RxPipelineRequiresCluster *inputRequirements; /**< Input requirements array */
+
+ void *superBlock; /**< Internally used block of memory */
+ RwUInt32 superBlockSize; /**< Internally used block of memory */
+
+ RwUInt32 entryPoint; /**< The index of the node which is the entry point of this pipeline */
+ RwUInt32 pluginId; /**< If required, the Id of the plugin owning this pipeline, or 0 */
+ RwUInt32 pluginData; /**< Rights callback extra data */
+};
+
+/****************************************************************************
+ * Global Prototypes
+ */
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxPipelineNodeOutputCallBack
+ * is the callback function supplied
+ * to \ref RxPipelineNodeForAllConnectedOutputs.
+ *
+ * The callback will be passed a pointer to the \ref RxPipelineNode whose
+ * outputs are being traversed and a pointer to the current output
+ * \ref RxPipelineNode, as well as a pointer to an optional user-defined
+ * data structure (callbackdata). If no such structure was specified, this
+ * will be NULL.
+ *
+ * \param node A pointer to the pipeline node whose outputs
+ * are being traversed
+ * \param outputnode A pointer to the current output
+ * pipeline node
+ * \param callbackdata A pointer to optional user-supplied data
+ *
+ * \return Returns a pointer to the \ref RxPipelineNode whose outputs are being
+ * traversed, or NULL to terminate traversal
+ */
+typedef RxPipelineNode * (*RxPipelineNodeOutputCallBack) (RxPipelineNode * node,
+ RxPipelineNode * outputnode,
+ void *callbackdata);
+
+#ifdef RWDEBUG
+#define RXCHECKFORUSERTRAMPLING(_pipeline) \
+ ( _rwPipelineCheckForTramplingOfNodePrivateSpace(_pipeline) )
+#endif /* RWDEBUG */
+
+#if (!defined(RXCHECKFORUSERTRAMPLING))
+#define RXCHECKFORUSERTRAMPLING(_pipeline) /* No op */
+#endif /* (!defined(RXCHECKFORUSERTRAMPLING)) */
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwBool
+_rxPipelineOpen(void);
+
+extern RwBool
+_rxPipelineClose(void);
+
+extern RwBool
+rxPipelinePluginsAttach(void);
+
+extern RxPipeline *
+RxPipelineCreate(void);
+
+
+extern void
+_rxPipelineDestroy(RxPipeline * Pipeline);
+
+#define _RxPipelineDestroy(_ppln) _rxPipelineDestroy(_ppln)
+#define RxPipelineDestroy(_ppln) (_rxPipelineDestroy(_ppln), TRUE)
+
+extern RxHeap *
+RxHeapGetGlobalHeap(void);
+
+extern RxPipeline *
+RxPipelineExecute(RxPipeline * pipeline,
+ void * data,
+ RwBool heapReset);
+
+extern RxPacket *
+RxPacketCreate(RxPipelineNode * node);
+
+extern RxCluster *
+RxClusterSetStride(RxCluster * cluster,
+ RwInt32 stride);
+
+extern RxCluster *
+RxClusterSetExternalData(RxCluster * cluster,
+ void *data,
+ RwInt32 stride,
+ RwInt32 numElements);
+
+extern RxCluster *
+RxClusterSetData(RxCluster * cluster,
+ void *data,
+ RwInt32 stride,
+ RwInt32 numElements);
+
+/* underlying PacketDestroy function */
+extern void
+_rxPacketDestroy(RxPacket * Packet);
+
+/* more convenient parameterization */
+#define RxPacketDestroy(pk, self) \
+ ( _rxPacketDestroy(pk) )
+
+#if (defined(RWDEBUG))
+extern RxPacket *RxPacketFetch(RxPipelineNode * Node);
+extern void RxPacketDispatch(RxPacket * packet,
+ RwUInt32 output,
+ RxPipelineNode * self);
+extern void RxPacketDispatchToPipeline(RxPacket * packet,
+ RxPipeline * dest,
+ RxPipelineNode * self);
+#else /* (defined(RWDEBUG)) */
+#define RxPacketFetch(_self) \
+ rxPacketFetchMacro(_self)
+#define RxPacketDispatch( _packet, _output, _self) \
+ rxPacketDispatchMacro(_packet, _output, _self)
+#define RxPacketDispatchToPipeline( _packet, _pipeline, _self) \
+ rxPacketDispatchToPipelineMacro(_packet, _pipeline, _self)
+#endif /* (defined(RWDEBUG)) */
+
+#define RxClusterInitialiseData(_clstr, _nmlmnts, _strd) \
+ ( RxClusterInitializeData((_clstr), (_nmlmnts), (_strd)) )
+extern RxCluster *
+RxClusterInitializeData(RxCluster *cluster, RwUInt32 numElements, RwUInt16 stride);
+
+extern RxCluster *
+RxClusterResizeData(RxCluster *CurrentCluster, RwUInt32 NumElements);
+
+extern RxCluster *
+RxClusterDestroyData(RxCluster *CurrentCluster);
+
+#if (defined(RWDEBUG))
+
+extern RxCluster *RxClusterLockRead(RxPacket * packet, RwUInt32 clusterIndex);
+
+#else /* !RWDEBUG */
+
+#define RXCLSLOT(PKT, CLIND) \
+ ((PKT)->inputToClusterSlot[(CLIND)])
+
+#define RxClusterLockRead(PKT, CLIND) \
+ ( (((RwInt32)RXCLSLOT(PKT, CLIND)) == -1) ? \
+ ((RxCluster *)NULL) : \
+ (RxClusterResetCursor(&PKT->clusters[RXCLSLOT(PKT, CLIND)]), \
+ &PKT->clusters[RXCLSLOT(PKT, CLIND)]) )
+
+#endif /* !RWDEBUG */
+
+extern RxCluster *
+RxClusterLockWrite(RxPacket * packet,
+ RwUInt32 clusterIndex,
+ RxPipelineNode * node);
+
+extern void
+RxClusterUnlock(RxCluster * cluster);
+
+extern RwUInt32
+RxPipelineNodeSendConfigMsg(RxPipelineNode * dest,
+ RwUInt32 msg,
+ RwUInt32 intparam,
+ void *ptrparam);
+
+extern RxPipelineNode *
+RxPipelineNodeForAllConnectedOutputs(RxPipelineNode * node,
+ RxPipeline * pipeline,
+ RxPipelineNodeOutputCallBack callbackfn,
+ void *callbackdata);
+
+/* Cluster attributes api [pipeline construction time] */
+
+extern RxPipelineCluster *
+RxPipelineNodeGetPipelineCluster(RxPipelineNode *node,
+ RwUInt32 clustersOfInterestIndex);
+
+extern RwUInt32
+RxPipelineClusterGetCreationAttributes(RxPipelineCluster *cluster);
+
+extern RxPipelineCluster *
+RxPipelineClusterSetCreationAttributes(RxPipelineCluster *cluster,
+ RwUInt32 creationAttributes);
+
+/* Cluster attributes api [pipeline execution time] */
+
+extern RwUInt32
+RxClusterGetAttributes(RxCluster *cluster);
+
+extern RxCluster *
+RxClusterSetAttributes(RxCluster *cluster, RwUInt32 attributes);
+
+
+extern void
+_rxEmbeddedPacketBetweenPipelines(RxPipeline * fromPipeline,
+ RxPipeline * toPipeline);
+
+extern RxPipelineNode *
+_rxEmbeddedPacketBetweenNodes(RxPipeline *pipeline,
+ RxPipelineNode *nodeFrom,
+ RwUInt32 whichOutput);
+
+extern RxExecutionContext _rxExecCtxGlobal;
+
+/* Summary of dispatch rules:
+ * o nodes that never fetch are safe to dispatch NULL, whether
+ * nodes above pass them a packet or not
+ * o if you destroy the packet you can dispatch(NULL,,)
+ * o if you fetch/create and dispatch(NULL), it doesn't really
+ * matter - the packet'll get passed on anyway */
+
+/* TODO: there's currently no way to prematurely terminate the pipeline
+ * without doing so as an error condition. You should create an
+ * enum for the exit code, either RXNODEEXITCONTINUE, RXNODEEXITTERMINATE
+ * or RXNODEEXTTERMINATEERROR and then test for RXNODEEXITCONTINUE in
+ * the below macros rather than FALSE. */
+
+/* TODO: _packet redundant here... create a new macro and legacy wrapper */
+#define rxPacketDispatchMacro(_packet, _output, _self) \
+MACRO_START \
+{ \
+ RxPipeline *curPipeline = _rxExecCtxGlobal.pipeline; \
+ \
+ /* _packet is now an obsolete parameter */ \
+ \
+ if ( FALSE != _rxExecCtxGlobal.exitCode ) \
+ { \
+ RxPipelineNode *nextNode = \
+ _rxEmbeddedPacketBetweenNodes(curPipeline, \
+ _self, \
+ (_output)); \
+ if ( nextNode != NULL ) \
+ { \
+ RwUInt32 exitCode = \
+ nextNode->nodeDef->nodeMethods.nodeBody( \
+ nextNode, &(_rxExecCtxGlobal.params)); \
+ /* Don't overwrite 'error' with 'success' */ \
+ if (FALSE == exitCode) _rxExecCtxGlobal.exitCode = exitCode; \
+ } \
+ } \
+ if ( curPipeline->embeddedPacketState > rxPKST_UNUSED \
+ /* !UNUSED and !PACKETLESS */ ) \
+ { \
+ curPipeline->embeddedPacketState = rxPKST_INUSE; \
+ _rxPacketDestroy(curPipeline->embeddedPacket); \
+ } \
+} \
+MACRO_STOP
+
+/* TODO: _self redundant here... create a new macro and legacy wrapper */
+#define rxPacketDispatchToPipelineMacro(_packet, _pipeline, _self) \
+MACRO_START \
+{ \
+ RxPipeline *toPipeline = (_pipeline); \
+ \
+ /* _packet is now an obsolete parameter */ \
+ \
+ if ( FALSE != _rxExecCtxGlobal.exitCode ) \
+ { \
+ RwUInt32 exitCode; \
+ RxPipeline *fromPipeline = _rxExecCtxGlobal.pipeline; /* save */ \
+ _rxEmbeddedPacketBetweenPipelines(fromPipeline, \
+ toPipeline); \
+ _rxExecCtxGlobal.pipeline = toPipeline; /* modify */ \
+ exitCode = \
+ toPipeline->nodes[0].nodeDef->nodeMethods.nodeBody( \
+ &toPipeline->nodes[0], &(_rxExecCtxGlobal.params)); \
+ if ( FALSE == exitCode ) _rxExecCtxGlobal.exitCode = exitCode; \
+ _rxExecCtxGlobal.pipeline = fromPipeline; /* restore */ \
+ } \
+ if ( toPipeline->embeddedPacketState > rxPKST_UNUSED \
+ /* !UNUSED and !PACKETLESS */ ) \
+ { \
+ toPipeline->embeddedPacketState = rxPKST_INUSE; \
+ _rxPacketDestroy(toPipeline->embeddedPacket); \
+ } \
+} \
+MACRO_STOP
+
+#define rxPacketFetchMacro(_node) \
+ ( ((_rxExecCtxGlobal.pipeline)->embeddedPacketState == rxPKST_PENDING) ?\
+ ((_rxExecCtxGlobal.pipeline)->embeddedPacketState = rxPKST_INUSE, \
+ (_rxExecCtxGlobal.pipeline)->embeddedPacket) : \
+ (NULL) )
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/d3d8/nodeD3D8SubmitNoLight.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2define.h ---*/
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxNodeOutput
+ * typedef for a reference to an output of a pipeline node */
+typedef RwUInt32 *RxNodeOutput;
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxNodeInput
+ * typedef for a reference to the input of a pipeline node */
+typedef RxPipelineNode *RxNodeInput;
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxLockedPipe
+ * typedef for a reference to a locked pipeline
+ */
+typedef RxPipeline RxLockedPipe;
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+/* PIPELINENODE API */
+
+extern RxNodeOutput
+RxPipelineNodeFindOutputByName(RxPipelineNode *node,
+ const RwChar *outputname);
+
+extern RxNodeOutput
+RxPipelineNodeFindOutputByIndex(RxPipelineNode *node,
+ RwUInt32 outputindex);
+
+extern RxNodeInput
+RxPipelineNodeFindInput(RxPipelineNode *node);
+
+extern RxNodeDefinition *
+RxPipelineNodeCloneDefinition(RxPipelineNode *node,
+ RxClusterDefinition *cluster2add);
+
+extern RxPipeline *
+RxPipelineNodeRequestCluster(RxPipeline *pipeline,
+ RxPipelineNode *node,
+ RxClusterDefinition *clusterDef);
+
+extern RxPipeline *
+RxPipelineNodeReplaceCluster(RxPipeline *pipeline,
+ RxPipelineNode *node,
+ RxClusterDefinition *oldClusterDef,
+ RxClusterDefinition *newClusterDef);
+
+extern void *
+RxPipelineNodeGetInitData(RxPipelineNode *node);
+
+extern void *
+RxPipelineNodeCreateInitData(RxPipelineNode *node,
+ RwUInt32 size);
+
+/* PIPELINE MANIPULATION API */
+
+extern RxPipeline *
+RxPipelineClone(RxPipeline *pipeline);
+
+extern RxPipelineNode *
+RxPipelineFindNodeByName(RxPipeline *pipeline,
+ const RwChar *name,
+ RxPipelineNode *start,
+ RwInt32 *nodeIndex);
+
+extern RxPipelineNode *
+RxPipelineFindNodeByIndex(RxPipeline *pipeline,
+ RwUInt32 nodeindex);
+
+extern RxLockedPipe *
+RxPipelineLock(RxPipeline *pipeline);
+
+extern RxPipeline *
+RxLockedPipeUnlock(RxLockedPipe *pipeline);
+
+
+extern RxLockedPipe *
+RxLockedPipeAddFragment(RxLockedPipe *pipeline,
+ RwUInt32 *firstIndex,
+ RxNodeDefinition *nodeDef0,
+ ...);
+
+
+extern RxPipeline *
+RxLockedPipeReplaceNode(RxLockedPipe *pipeline,
+ RxPipelineNode *node,
+ RxNodeDefinition *nodeDef);
+
+extern RxPipeline *
+RxLockedPipeDeleteNode(RxLockedPipe *pipeline,
+ RxPipelineNode *node);
+
+
+extern RxPipeline *
+RxLockedPipeSetEntryPoint(RxLockedPipe *pipeline,
+ RxNodeInput in);
+
+
+extern RxPipelineNode *
+RxLockedPipeGetEntryPoint(RxLockedPipe *pipeline);
+
+
+extern RxPipeline *
+RxLockedPipeAddPath(RxLockedPipe *pipeline,
+ RxNodeOutput out,
+ RxNodeInput in);
+
+extern RxPipeline *
+RxLockedPipeDeletePath(RxLockedPipe *pipeline,
+ RxNodeOutput out,
+ RxNodeInput in);
+
+
+extern RxPipeline *
+RxPipelineInsertDebugNode(RxPipeline *pipeline,
+ RxPipelineNode *before,
+ RxPipelineNode *after,
+ RxNodeDefinition *debugNode);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2altmdl.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeTransform.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetTransform(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeSubmitTriangle.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetSubmitTriangle(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeSubmitLine.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetSubmitLine(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeScatter.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetScatter(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeClone.h ---*/
+
+typedef struct RxPacketCacheCluster RxPacketCacheCluster;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPacketCacheCluster
+ * structure containing a cache of an \ref RxCluster's
+ * within an \ref RxPacketCache
+ */
+struct RxPacketCacheCluster
+{
+ RwUInt32 slot; /**< A \ref RwUInt32 index into the \ref RxPacketCache's
+ * array of RxPacketCacheCluster's */
+ RwUInt16 flags; /**< A cache of the original cluster's flags */
+ RwUInt16 stride; /**< A cache of the original cluster's stride */
+ void *data; /**< A cache of the original cluster's data */
+ RwUInt32 numAlloced; /**< A cache of the original cluster's numAlloced */
+ RwUInt32 numUsed; /**< A cache of the original cluster's numUsed */
+ RxPipelineCluster *clusterRef; /**< A cache of the original cluster's \ref RxPipelineCluster */
+};
+typedef struct RxPacketCache RxPacketCache;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPacketCache
+ * structure containing a cache of a \ref RxPacket */
+struct RxPacketCache
+{
+ RwUInt16 packetFlags; /**< A cache of the original packet's flags */
+ RwUInt16 pad[1]; /**< Alignment padding */
+ RwUInt32 numClusters; /**< The number of present clusters in the
+ * original packet when it was cloned */
+ RwBool lastCloneDone;/**< Once the cache has been cloned by \ref RxPacketCacheClone
+ * with (lastClone == TRUE), it should not be used again! */
+ RwUInt32 pad2[1]; /**< Alignment padding */
+ RxPacketCacheCluster clusters[1]; /**< An array of \ref RxPacketCacheCluster's,
+ * extending beyond 1 element */
+};
+
+
+typedef struct RxNodeCloneInitData RxNodeCloneInitData;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxNodeCloneInitData
+ * structure with which to initialize
+ * clone a \ref RxNodeDefinition,
+ * through \ref RxNodeDefinitionCloneCreate and
+ * set up cloned \ref RxPipelineNode modes, through
+ * \ref RxPipelineNodeCloneDefineModes */
+struct RxNodeCloneInitData
+{
+ RwUInt32 numModes; /**< Specifies the number of modes in
+ which the node should operate */
+ RwUInt32 numOutputs; /**< Specifies the number of outputs of this
+ Clone node, which is also the maximum
+ number of outputs to which any one mode
+ may dispatch packets */
+ RwUInt32 *modeSizes; /**< Specifies the number of outputs to which
+ each mode dispatches packets */
+ RwUInt32 **modes; /**< An array of numModes pointers to arrays
+ (of length numOutputs) specifying the
+ outputs, in order, to which each mode
+ should dispatch packets (output zero is
+ the first output) */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxNodeCloneData
+ * structure which is the private
+ * data of Clone nodes \ref RxPipelineNode */
+typedef struct RxNodeCloneData RxNodeCloneData;
+struct RxNodeCloneData
+{
+ RwBool optimized; /**< \ref RwBool specifying whether \ref RxPipelineNodeCloneOptimize
+ * has been run on this \ref RxPipelineNode yet */
+ RwUInt32 currentMode; /**< \ref RwUInt32 The current mode of operation */
+ RxNodeCloneInitData *data;/**< A pointer to \ref RxNodeCloneInitData data
+ * specifying the modes of operation */
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionCloneCreate(RxNodeCloneInitData *data);
+extern RwBool RxPipelineNodeCloneDefineModes(
+ RxPipeline *pipeline,
+ RxPipelineNode *node,
+ RxNodeCloneInitData *data);
+extern RwBool RxNodeDefinitionCloneDestroy(RxNodeDefinition *def);
+extern RwBool RxPipelineNodeCloneOptimize(RxPipeline *pipeline,
+ RxPipelineNode *node);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeImmStash.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetImmStash(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeImmRenderSetup.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetImmRenderSetup(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeImmMangleTriangleIndices.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetImmMangleTriangleIndices(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeImmMangleLineIndices.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetImmMangleLineIndices(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeImmInstance.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetImmInstance(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeCullTriangle.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetCullTriangle(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeClipTriangle.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetClipTriangle(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeClipLine.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetClipLine(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8texdic.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8rendst.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8raster.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8device.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8convrt.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d82drend.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/ssematml.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/cpuext.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/palquant.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/datblkcb.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/baraster.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+/**
+ * \ingroup datatypes
+ * \ref RwRasterLockMode represents the options available for locking
+ * a raster so that it may be modified (see API function \ref RwRasterLock). An
+ * application may wish to write to the raster, read from the raster or
+ * simultaneously write and read a raster (rwRASTERLOCKWRITE | rwRASTERLOCKREAD).
+ */
+enum RwRasterLockMode
+{
+ rwRASTERLOCKWRITE = 0x01, /**<Lock for writing */
+ rwRASTERLOCKREAD = 0x02, /**<Lock for reading */
+ rwRASTERLOCKNOFETCH = 0x04, /**<When used in combination with
+ * rwRASTERLOCKWRITE, asks the driver not to
+ * fetch the pixel data. This is only useful
+ * if it is known that ALL the raster data is
+ * going to be overwritten before the raster
+ * is unlocked, i.e. from an
+ * \ref RwRasterSetFromImage call. This flag
+ * is not supported by all drivers. */
+ rwRASTERLOCKRAW = 0x08, /**<When used in combination with
+ rwRASTERLOCKWRITE or rwRASTERLOCKREAD
+ allows access to the raw platform specific
+ pixel format */
+ rwRASTERLOCKMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+#define rwRASTERLOCKREADWRITE (rwRASTERLOCKREAD|rwRASTERLOCKWRITE)
+
+typedef enum RwRasterLockMode RwRasterLockMode;
+
+/**
+ * \ingroup datatypes
+ * \ref RwRasterFlipMode represents
+ * raster flip modes */
+enum RwRasterFlipMode
+{
+ rwRASTERFLIPDONTWAIT = 0, /**<Don't wait for VSync */
+ rwRASTERFLIPWAITVSYNC = 1, /**<Flip on VSync */
+ rwRASTERFLIPMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwRasterFlipMode RwRasterFlipMode;
+
+/**
+ * \ingroup datatypes
+ * RwRasterType
+ * This type represents the options available for creating a new
+ * raster (se API function \ref RwRasterCreate)*/
+enum RwRasterType
+{
+ rwRASTERTYPENORMAL = 0x00, /**<Normal */
+ rwRASTERTYPEZBUFFER = 0x01, /**<Z Buffer */
+ rwRASTERTYPECAMERA = 0x02, /**<Camera */
+ rwRASTERTYPETEXTURE = 0x04, /**<Texture */
+ rwRASTERTYPECAMERATEXTURE = 0x05, /**<Camera texture */
+ rwRASTERTYPEMASK = 0x07, /**<Mask for finding type */
+
+ rwRASTERDONTALLOCATE = 0x80, /**<If set the raster is not allocated */
+ rwRASTERTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwRasterType RwRasterType;
+
+/**
+ * \ingroup datatypes
+ * \ref RwRasterFormat is a set of values and flags which may be combined to
+ * specify a raster format. The format chosen for a particular raster depends
+ * on the hardware device and the raster type specified at creation time
+ * (see API function \ref RwRasterCreate). The format may be retrieved using
+ * API function \ref RwRasterGetFormat.
+ *
+ * The raster format is a packed set of bits which contains the following
+ * four pieces of information (these may be combined with bitwise OR):-
+ *
+ * <ol>
+ * <li> The pixel color format corresponding to one of the following values:-
+ * <ul>
+ * <li> rwRASTERFORMAT1555
+ * <li> rwRASTERFORMAT565
+ * <li> rwRASTERFORMAT4444
+ * <li> rwRASTERFORMATLUM8
+ * <li> rwRASTERFORMAT8888
+ * <li> rwRASTERFORMAT888
+ * <li> rwRASTERFORMAT16
+ * <li> rwRASTERFORMAT24
+ * <li> rwRASTERFORMAT32
+ * <li> rwRASTERFORMAT555
+ * </ul>
+ * This value may be masked out of the raster format using
+ * rwRASTERFORMATPIXELFORMATMASK.
+ * <li> The palette depth if the raster is palettized:-
+ * <ul>
+ * <li> rwRASTERFORMATPAL4
+ * <li> rwRASTERFORMATPAL8
+ * </ul>
+ * In these cases, the color format refers to that of the palette.
+ * <li> Flag rwRASTERFORMATMIPMAP. Set if the raster contains mipmap levels.
+ * <li> Flag rwRASTERFORMATAUTOMIPMAP. Set if the mipmap levels were generated
+ * automatically by RenderWare.
+ * </ol>
+ */
+enum RwRasterFormat
+{
+ rwRASTERFORMATDEFAULT = 0x0000, /* Whatever the hardware likes best */
+
+ rwRASTERFORMAT1555 = 0x0100, /**<16 bits - 1 bit alpha, 5 bits red, green and blue */
+ rwRASTERFORMAT565 = 0x0200, /**<16 bits - 5 bits red and blue, 6 bits green */
+ rwRASTERFORMAT4444 = 0x0300, /**<16 bits - 4 bits per component */
+ rwRASTERFORMATLUM8 = 0x0400, /**<Gray scale */
+ rwRASTERFORMAT8888 = 0x0500, /**<32 bits - 8 bits per component */
+ rwRASTERFORMAT888 = 0x0600, /**<24 bits - 8 bits per component */
+ rwRASTERFORMAT16 = 0x0700, /**<16 bits - undefined: useful for things like Z buffers */
+ rwRASTERFORMAT24 = 0x0800, /**<24 bits - undefined: useful for things like Z buffers */
+ rwRASTERFORMAT32 = 0x0900, /**<32 bits - undefined: useful for things like Z buffers */
+ rwRASTERFORMAT555 = 0x0a00, /**<16 bits - 5 bits red, green and blue */
+
+ rwRASTERFORMATAUTOMIPMAP = 0x1000, /**<RenderWare generated the mip levels */
+
+ rwRASTERFORMATPAL8 = 0x2000, /**<8 bit palettised */
+ rwRASTERFORMATPAL4 = 0x4000, /**<4 bit palettised */
+
+ rwRASTERFORMATMIPMAP = 0x8000, /**<Mip mapping on */
+
+ rwRASTERFORMATPIXELFORMATMASK = 0x0f00, /**<The pixel color format
+ * (excluding palettised bits) */
+ rwRASTERFORMATMASK = 0xff00 /**<The whole format */ ,
+ rwRASTERFORMATFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwRasterFormat RwRasterFormat;
+
+enum RwRasterPrivateFlag
+{
+ rwRASTERGAMMACORRECTED = 0x01,
+ rwRASTERPIXELLOCKEDREAD = 0x02, /* pixels are locked for reading */
+ rwRASTERPIXELLOCKEDWRITE = 0x04, /* pixels are locked for writing */
+ rwRASTERPALETTELOCKEDREAD = 0x08, /* palette is locked for reading */
+ rwRASTERPALETTELOCKEDWRITE = 0x10, /* palette is locked for writing */
+ rwRASTERPIXELLOCKEDRAW = 0x20, /* the pixels are in platform specific
+ format, used in combination with
+ rwRASTERPIXELLOCKEDREAD &
+ rwRASTERPIXELLOCKEDWRITE */
+ rwRASTERPRIVATEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwRasterPrivateFlag RwRasterPrivateFlag;
+
+#define rwRASTERPIXELLOCKED (rwRASTERPIXELLOCKEDREAD | rwRASTERPIXELLOCKEDWRITE)
+#define rwRASTERPALETTELOCKED (rwRASTERPALETTELOCKEDREAD | rwRASTERPALETTELOCKEDWRITE)
+#define rwRASTERLOCKED (rwRASTERPIXELLOCKED|rwRASTERPALETTELOCKED)
+
+/* How big is my stack!!! */
+#define rwRASTERCONTEXTSTACKSIZE 10
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwRaster
+ * Raster containing device-dependent pixels.
+ * This should be considered an opaque type.
+ * Use the RwRaster API functions to access.
+ */
+typedef struct RwRaster RwRaster;
+
+#if (!defined(DOXYGEN))
+struct RwRaster
+{
+ RwRaster *parent; /* Top level raster if a sub raster */
+ RwUInt8 *cpPixels; /* Pixel pointer when locked */
+ RwUInt8 *palette; /* Raster palette */
+ RwInt32 width, height, depth; /* Dimensions of raster */
+ RwInt32 stride; /* Lines bytes of raster */
+ RwInt16 nOffsetX, nOffsetY; /* Sub raster offset */
+ RwUInt8 cType; /* Type of raster */
+ RwUInt8 cFlags; /* Raster flags */
+ RwUInt8 privateFlags; /* Raster private flags */
+ RwUInt8 cFormat; /* Raster format */
+
+ RwUInt8 *originalPixels;
+ RwInt32 originalWidth;
+ RwInt32 originalHeight;
+ RwInt32 originalStride;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RwRasterGetWidthMacro(_raster) \
+ ((_raster)->width)
+
+#define RwRasterGetHeightMacro(_raster) \
+ ((_raster)->height)
+
+#define RwRasterGetStrideMacro(_raster) \
+ ((_raster)->stride)
+
+#define RwRasterGetDepthMacro(_raster) \
+ ((_raster)->depth)
+
+#define RwRasterGetFormatMacro(_raster) \
+ ((((_raster)->cFormat) & (rwRASTERFORMATMASK >> 8)) << 8)
+
+#define RwRasterGetTypeMacro(_raster) \
+ (((_raster)->cType) & rwRASTERTYPEMASK)
+
+#define RwRasterGetParentMacro(_raster) \
+ ((_raster)->parent)
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RwRasterGetWidth(_raster) \
+ RwRasterGetWidthMacro(_raster)
+
+#define RwRasterGetHeight(_raster) \
+ RwRasterGetHeightMacro(_raster)
+
+#define RwRasterGetStride(_raster) \
+ RwRasterGetStrideMacro(_raster)
+
+#define RwRasterGetDepth(_raster) \
+ RwRasterGetDepthMacro(_raster)
+
+#define RwRasterGetFormat(_raster) \
+ RwRasterGetFormatMacro(_raster)
+
+#define RwRasterGetType(_raster) \
+ RwRasterGetTypeMacro(_raster)
+
+#define RwRasterGetParent(_raster) \
+ RwRasterGetParentMacro(_raster)
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Creating destroying rasters */
+extern RwRaster *RwRasterCreate(RwInt32 width, RwInt32 height,
+ RwInt32 depth, RwInt32 flags);
+extern RwBool RwRasterDestroy(RwRaster * raster);
+
+/* Pulling info out of raster structure */
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+extern RwInt32 RwRasterGetWidth(const RwRaster *raster);
+extern RwInt32 RwRasterGetHeight(const RwRaster *raster);
+extern RwInt32 RwRasterGetStride(const RwRaster *raster);
+extern RwInt32 RwRasterGetDepth(const RwRaster *raster);
+extern RwInt32 RwRasterGetFormat(const RwRaster *raster);
+extern RwInt32 RwRasterGetType(const RwRaster *raster);
+extern RwRaster *RwRasterGetParent(const RwRaster *raster);
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+extern RwRaster *RwRasterGetOffset(RwRaster *raster,
+ RwInt16 *xOffset, RwInt16 *yOffset);
+
+extern RwInt32 RwRasterGetNumLevels(RwRaster * raster);
+
+extern RwRaster *RwRasterSubRaster(RwRaster * subRaster,
+ RwRaster * raster, RwRect * rect);
+
+extern RwRaster *RwRasterRenderFast(RwRaster * raster, RwInt32 x,
+ RwInt32 y);
+extern RwRaster *RwRasterRender(RwRaster * raster, RwInt32 x,
+ RwInt32 y);
+extern RwRaster *RwRasterRenderScaled(RwRaster * raster,
+ RwRect * rect);
+
+/* Raster rendering context */
+extern RwRaster *RwRasterPushContext(RwRaster * raster);
+extern RwRaster *RwRasterPopContext(void);
+extern RwRaster *RwRasterGetCurrentContext(void);
+
+/* Clearing rasters */
+extern RwBool RwRasterClear(RwInt32 pixelValue);
+extern RwBool RwRasterClearRect(RwRect * rpRect,
+ RwInt32 pixelValue);
+
+/* Displaying rasters */
+extern RwRaster *RwRasterShowRaster(RwRaster * raster, void *dev,
+ RwUInt32 flags);
+
+/* Locking and releasing */
+extern RwUInt8 *RwRasterLock(RwRaster * raster, RwUInt8 level,
+ RwInt32 lockMode);
+extern RwRaster *RwRasterUnlock(RwRaster * raster);
+extern RwUInt8 *RwRasterLockPalette(RwRaster * raster,
+ RwInt32 lockMode);
+extern RwRaster *RwRasterUnlockPalette(RwRaster * raster);
+
+/* Attaching toolkits */
+extern RwInt32 RwRasterRegisterPlugin(RwInt32 size,
+ RwUInt32 pluginID,
+ RwPluginObjectConstructor
+ constructCB,
+ RwPluginObjectDestructor
+ destructCB,
+ RwPluginObjectCopy copyCB);
+extern RwInt32 RwRasterGetPluginOffset(RwUInt32 pluginID);
+extern RwBool RwRasterValidatePlugins(const RwRaster * raster);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/drvmodel.h ---*/
+#ifndef D3D8_DRVMODEL_H
+#define D3D8_DRVMODEL_H
+
+#if (defined(__ICL))
+/* Avoid voluminous
+ * 'warning #344: typedef name has already been declared (with same type)'
+ * warnings from MS include files
+ */
+#pragma warning( disable : 344 )
+#endif /* (defined(__ICL)) */
+
+
+#include <windows.h>
+
+#if (defined(RWDEBUG))
+#if (defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC))
+#define _CRTDBG_MAP_ALLOC
+#endif /* defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) */
+#include <crtdbg.h>
+#define ERR_WRAP(A) (_rwRePrintErrorDDD3D((A), __FILE__, __LINE__))
+#endif /* (defined(RWDEBUG)) */
+
+#if (!defined(ERR_WRAP))
+#define ERR_WRAP(A) (A)
+#endif /* (!defined(ERR_WRAP)) */
+
+/****************************************************************************
+ Defines
+ */
+
+/* Set true depth information (for fogging, eg) */
+#define RwIm2DVertexSetCameraX(vert, camx) /* Nothing */
+#define RwIm2DVertexSetCameraY(vert, camy) /* Nothing */
+#define RwIm2DVertexSetCameraZ(vert, camz) /* Nothing */
+
+#define RwIm2DVertexSetRecipCameraZ(vert, recipz) ((vert)->rhw = recipz)
+
+#define RwIm2DVertexGetCameraX(vert) (cause an error)
+#define RwIm2DVertexGetCameraY(vert) (cause an error)
+#define RwIm2DVertexGetCameraZ(vert) (cause an error)
+#define RwIm2DVertexGetRecipCameraZ(vert) ((vert)->rhw)
+
+/* Set screen space coordinates in a device vertex */
+#define RwIm2DVertexSetScreenX(vert, scrnx) ((vert)->x = (scrnx))
+#define RwIm2DVertexSetScreenY(vert, scrny) ((vert)->y = (scrny))
+#define RwIm2DVertexSetScreenZ(vert, scrnz) ((vert)->z = (scrnz))
+#define RwIm2DVertexGetScreenX(vert) ((vert)->x)
+#define RwIm2DVertexGetScreenY(vert) ((vert)->y)
+#define RwIm2DVertexGetScreenZ(vert) ((vert)->z)
+
+/* Set texture coordinates in a device vertex */
+#define RwIm2DVertexSetU(vert, texU, recipz) ((vert)->u = (texU))
+#define RwIm2DVertexSetV(vert, texV, recipz) ((vert)->v = (texV))
+#define RwIm2DVertexGetU(vert) ((vert)->u)
+#define RwIm2DVertexGetV(vert) ((vert)->v)
+
+/* Modify the luminance stuff */
+#define RwIm2DVertexSetRealRGBA(vert, red, green, blue, alpha) \
+ ((vert)->emissiveColor = \
+ (((RwFastRealToUInt32(alpha)) << 24) | \
+ ((RwFastRealToUInt32(red)) << 16) | \
+ ((RwFastRealToUInt32(green)) << 8) | \
+ ((RwFastRealToUInt32(blue)))))
+
+#define RwIm2DVertexSetIntRGBA(vert, red, green, blue, alpha) \
+ ((vert)->emissiveColor = \
+ ((((RwUInt32)(alpha)) << 24) | \
+ (((RwUInt32)(red)) << 16) | \
+ (((RwUInt32)(green)) << 8) | \
+ (((RwUInt32)(blue)))))
+
+#define RwIm2DVertexGetRed(vert) \
+ (((vert)->emissiveColor >> 16) & 0xFF)
+
+#define RwIm2DVertexGetGreen(vert) \
+ (((vert)->emissiveColor >> 8) & 0xFF)
+
+#define RwIm2DVertexGetBlue(vert) \
+ ((vert)->emissiveColor & 0xFF)
+
+#define RwIm2DVertexGetAlpha(vert) \
+ (((vert)->emissiveColor >> 24) & 0xFF)
+
+#define RwIm2DVertexCopyRGBA(dst, src) \
+ ((dst)->emissiveColor = (src)->emissiveColor)
+
+/* Clipper stuff */
+
+#define RwIm2DVertexClipRGBA(o, i, n, f) \
+MACRO_START \
+{ \
+ const RwInt32 _factor = \
+ (RwFastRealToUInt32(i * (RwReal)(255))) & 255; \
+ \
+ (o)->emissiveColor = \
+ (((((RwIm2DVertexGetAlpha(f) - RwIm2DVertexGetAlpha(n)) * \
+ _factor) >> 8) + RwIm2DVertexGetAlpha(n)) << 24) | \
+ (((((RwIm2DVertexGetRed(f) - RwIm2DVertexGetRed(n)) * \
+ _factor) >> 8) + RwIm2DVertexGetRed(n)) << 16) | \
+ (((((RwIm2DVertexGetGreen(f) - RwIm2DVertexGetGreen(n)) * \
+ _factor) >> 8) + RwIm2DVertexGetGreen(n)) << 8) | \
+ (((((RwIm2DVertexGetBlue(f) - RwIm2DVertexGetBlue(n)) * \
+ _factor) >> 8) + RwIm2DVertexGetBlue(n))); \
+} \
+MACRO_STOP
+
+/* LEGACY-SUPPORT macros */
+#define RWIM2DVERTEXSetCameraX(vert, camx) RwIm2DVertexSetCameraX(vert, camx)
+#define RWIM2DVERTEXSetCameraY(vert, camy) RwIm2DVertexSetCameraY(vert, camy)
+#define RWIM2DVERTEXSetCameraZ(vert, camz) RwIm2DVertexSetCameraZ(vert, camz)
+#define RWIM2DVERTEXSetRecipCameraZ(vert, recipz) \
+ RwIm2DVertexSetRecipCameraZ(vert, recipz)
+#define RWIM2DVERTEXGetCameraX(vert) RwIm2DVertexGetCameraX(vert)
+#define RWIM2DVERTEXGetCameraY(vert) RwIm2DVertexGetCameraY(vert)
+#define RWIM2DVERTEXGetCameraZ(vert) RwIm2DVertexGetCameraZ(vert)
+#define RWIM2DVERTEXGetRecipCameraZ(vert) RwIm2DVertexGetRecipCameraZ(vert)
+#define RWIM2DVERTEXSetScreenX(vert, scrnx) RwIm2DVertexSetScreenX(vert, scrnx)
+#define RWIM2DVERTEXSetScreenY(vert, scrny) RwIm2DVertexSetScreenY(vert, scrny)
+#define RWIM2DVERTEXSetScreenZ(vert, scrnz) RwIm2DVertexSetScreenZ(vert, scrnz)
+#define RWIM2DVERTEXGetScreenX(vert) RwIm2DVertexGetScreenX(vert)
+#define RWIM2DVERTEXGetScreenY(vert) RwIm2DVertexGetScreenY(vert)
+#define RWIM2DVERTEXGetScreenZ(vert) RwIm2DVertexGetScreenZ(vert)
+#define RWIM2DVERTEXSetU(vert, u, recipz) RwIm2DVertexSetU(vert, u, recipz)
+#define RWIM2DVERTEXSetV(vert, v, recipz) RwIm2DVertexSetV(vert, v, recipz)
+#define RWIM2DVERTEXGetU(vert) RwIm2DVertexGetU(vert)
+#define RWIM2DVERTEXGetV(vert) RwIm2DVertexGetV(vert)
+#define RWIM2DVERTEXSetRealRGBA(vert, red, green, blue, alpha) \
+ RwIm2DVertexSetRealRGBA(vert, red, green, blue, alpha)
+#define RWIM2DVERTEXSetIntRGBA(vert, red, green, blue, alpha) \
+ RwIm2DVertexSetIntRGBA(vert, red, green, blue, alpha)
+#define RWIM2DVERTEXGetRed(vert) RwIm2DVertexGetRed(vert)
+#define RWIM2DVERTEXGetGreen(vert) RwIm2DVertexGetGreen(vert)
+#define RWIM2DVERTEXGetBlue(vert) RwIm2DVertexGetBlue(vert)
+#define RWIM2DVERTEXGetAlpha(vert) RwIm2DVertexGetAlpha(vert)
+#define RWIM2DVERTEXCopyRGBA(dst, src) RwIm2DVertexCopyRGBA(dst, src)
+#define RWIM2DVERTEXClipRGBA(o, i, n, f) RwIm2DVertexClipRGBA(o, i, n, f)
+
+/****************************************************************************
+ Global Types
+ */
+
+/* We use RwD3D8Vertex to drive the hardware in 2D mode */
+
+/**
+ * \ingroup rwcoredriverd3d8
+ * \typedef RwD3D8Vertex
+ * D3D8 vertex structure definition for 2D geometry
+ */
+typedef struct RwD3D8Vertex RwD3D8Vertex;
+/**
+ * \ingroup rwcoredriverd3d8
+ * \struct RwD3D8Vertex
+ * D3D8 vertex structure definition for 2D geometry
+ */
+struct RwD3D8Vertex
+{
+ RwReal x; /**< Screen X */
+ RwReal y; /**< Screen Y */
+ RwReal z; /**< Screen Z */
+ RwReal rhw; /**< Reciprocal of homogeneous W */
+
+ RwUInt32 emissiveColor; /**< Vertex color */
+
+ RwReal u; /**< Texture coordinate U */
+ RwReal v; /**< Texture coordinate V */
+};
+
+/* Define types used */
+
+/**
+ * \ingroup rwcoredriverd3d8
+ * \typedef RwIm2DVertex
+ * Typedef for a RenderWare Graphics Immediate Mode 2D Vertex
+ */
+typedef RwD3D8Vertex RwIm2DVertex;
+
+/* LEGACY-SUPPORT macro */
+/**
+ * \ingroup rwcoredriverd3d8
+ * \def RWIM2DVERTEX
+ * RWIM2DVERTEX is a legacy macro for RwIm2DVertex
+ */
+#define RWIM2DVERTEX RwIm2DVertex
+
+/**
+ * \ingroup rwcoredriverd3d8
+ * \typedef RxVertexIndex
+ *
+ * Typedef for a RenderWare Graphics PowerPipe Immediate
+ * Mode Vertex
+ */
+typedef RwUInt16 RxVertexIndex;
+
+/**
+ * \ingroup rwcoredriverd3d8
+ * \typedef RwImVertexIndex
+ * Typedef for a RenderWare Graphics Immediate Mode Vertex.
+ */
+typedef RxVertexIndex RwImVertexIndex;
+
+/* LEGACY-SUPPORT macro */
+/**
+ * \ingroup rwcoredriverd3d8
+ * \def RWIMVERTEXINDEX
+ * RWIMVERTEXINDEX is a legacy macro for RwImVertexIndex
+ */
+#define RWIMVERTEXINDEX RwImVertexIndex
+
+/**
+ * \ingroup rwcoredriverd3d8
+ * \struct RwD3D8Metrics
+ * Structure containing metrics counters
+ */
+typedef struct
+{
+ RwUInt32 numRenderStateChanges; /**< Number of Render States changed */
+ RwUInt32 numTextureStageStateChanges; /**< Number of Texture Stage States changed */
+ RwUInt32 numMaterialChanges; /**< Number of Material changes */
+ RwUInt32 numLightsChanged; /**< Number of Lights changed */
+}
+RwD3D8Metrics;
+
+#endif /* D3D8_DRVMODEL_H */
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/d3d8/pip2model.h ---*/
+
+
+
+
+
+/****************************************************************************
+ Global Defines
+ */
+
+#define RXHEAPPLATFORMDEFAULTSIZE (1 << 12) /* 4k */
+
+/****************************************************************************
+ Global Types
+ */
+
+/* We use D3D8 formats for the instanced versions, to allow hardware T&L */
+
+/**
+ * \ingroup corep2d3d8
+ * \typedef RxObjSpace3DVertex
+ * Typedef for an RxObjSpace3DVertex.
+ */
+typedef struct RxObjSpace3DVertex RxObjSpace3DVertex;
+
+/**
+ * \ingroup corep2d3d8
+ * \struct RxObjSpace3DVertex
+ * Structure representing object space vertex.
+ */
+struct RxObjSpace3DVertex
+{
+ RwV3d objVertex; /**< position */
+ RwV3d objNormal; /**< normal */
+ RwUInt32 color; /**< emissive color*/
+ RwReal u; /**< u */
+ RwReal v; /**< v */
+};
+
+/* This vertex is non truncatable */
+#define RxObjSpace3DVertexNoUVsNoNormalsSize (sizeof(RxObjSpace3DVertex))
+#define RxObjSpace3DVertexNoUVsSize (sizeof(RxObjSpace3DVertex))
+#define RxObjSpace3DVertexFullSize (sizeof(RxObjSpace3DVertex))
+
+/**
+ * \ingroup corep2d3d8
+ * \typedef RxObjSpace3DLitVertex
+ * Typedef for an RxObjSpace3DLitVertex.
+ */
+typedef RxObjSpace3DVertex RxObjSpace3DLitVertex;
+
+/**
+ * \ingroup corep2d3d8
+ * \typedef RwIm3DVertex
+ * Typedef for an RwIm3DVertex.
+ */
+typedef RxObjSpace3DLitVertex RwIm3DVertex;
+
+/* LEGACY-SUPPORT macro */
+#define RWIM3DVERTEX RwIm3DVertex
+typedef RwIm2DVertex RxScrSpace2DVertex;
+
+/****************************************************************************
+ Object-space 3D unlit vertex macros
+ */
+
+/* Vertex positions */
+#define RxObjSpace3DVertexGetPos(_vert, _pos) \
+ (*(_pos) = (_vert)->objVertex)
+#define RxObjSpace3DVertexSetPos(_vert, _pos) \
+ ((_vert)->objVertex = *(_pos))
+
+/* Pre-lighting colours */
+#define RxObjSpace3DVertexGetPreLitColor(_vert, _col) \
+MACRO_START \
+{ \
+ (_col)->alpha = (RwUInt8)((_vert)->color >> 24) & 0xFF; \
+ (_col)->red = (RwUInt8)((_vert)->color >> 16) & 0xFF; \
+ (_col)->green = (RwUInt8)((_vert)->color >> 8) & 0xFF; \
+ (_col)->blue = (RwUInt8)((_vert)->color ) & 0xFF; \
+} \
+MACRO_STOP
+
+#define RxObjSpace3DVertexSetPreLitColor(_vert, _col) \
+ ((_vert)->color = (((RwUInt32)(_col)->alpha) << 24) | \
+ (((RwUInt32)(_col)->red) << 16) | \
+ (((RwUInt32)(_col)->green) << 8) | \
+ (((RwUInt32)(_col)->blue) ))
+
+/* This uses the same slot as color (they are mutually exclusive) */
+#define RxObjSpace3DVertexGetColor RxObjSpace3DVertexGetPreLitColor
+
+/* Normals */
+#define RxObjSpace3DVertexGetNormal(_vert, _normal) \
+ (*(_normal) = (_vert)->objNormal)
+#define RxObjSpace3DVertexSetNormal(_vert, _normal) \
+ ((_vert)->objNormal = *(_normal))
+
+/* Us and Vs */
+#define RxObjSpace3DVertexGetU(_vert) \
+ ((_vert)->u)
+#define RxObjSpace3DVertexGetV(_vert) \
+ ((_vert)->v)
+#define RxObjSpace3DVertexSetU(_vert, _imu) \
+ ((_vert)->u = (_imu))
+#define RxObjSpace3DVertexSetV(_vert, _imv) \
+ ((_vert)->v = (_imv))
+
+/****************************************************************************
+ Object-space 3D lit vertex macros
+ */
+
+/* Vertex positions */
+#define RxObjSpace3DLitVertexGetPos(_vert, _pos) \
+ (*(_pos) = (_vert)->objVertex)
+#define RxObjSpace3DLitVertexSetPos(_vert, _pos) \
+ ((_vert)->objVertex = *(_pos))
+
+/* Vertex colours */
+#define RxObjSpace3DLitVertexGetColor(_vert, _col) \
+MACRO_START \
+{ \
+ (_col)->red = ((_vert)->color >> 16) & 0xFF; \
+ (_col)->green = ((_vert)->color >> 8) & 0xFF; \
+ (_col)->blue = ((_vert)->color ) & 0xFF; \
+ (_col)->alpha = ((_vert)->color >> 24) & 0xFF; \
+} \
+MACRO_STOP
+#define RxObjSpace3DLitVertexSetColor(_vert, _col) \
+ ((_vert)->color = (((RwUInt32)(_col)->alpha) << 24) | \
+ (((RwUInt32)(_col)->red) << 16) | \
+ (((RwUInt32)(_col)->green) << 8) | \
+ (((RwUInt32)(_col)->blue) ))
+
+/* Us and Vs */
+#define RxObjSpace3DLitVertexGetU(_vert) \
+ ((_vert)->u)
+#define RxObjSpace3DLitVertexGetV(_vert) \
+ ((_vert)->v)
+#define RxObjSpace3DLitVertexSetU(_vert, _imu) \
+ ((_vert)->u = (_imu))
+#define RxObjSpace3DLitVertexSetV(_vert, _imv) \
+ ((_vert)->v = (_imv))
+
+/* LEGACY-SUPPORT for old objvert names - NB does NOT guarantee the
+ * app will work, because the old IM3DVERTEX macros are NOT correctly
+ * abstracted - 'Get' will return pointers to RwV3ds inside the
+ * ObjVert, but you can't assume there are any RwV3ds inside an
+ * opaque vertex type */
+
+#define RwIm3DVertexSetU RxObjSpace3DLitVertexSetU
+#define RwIm3DVertexSetV RxObjSpace3DLitVertexSetV
+#define RwIm3DVertexGetNext(_vert) ((_vert) + 1)
+
+#define RwIm2DCameraVertexSetU(_devvert, _camvert, _u, _recipz) \
+MACRO_START \
+{ \
+ RwReal _uTmp = _u; \
+ _camvert->u = _uTmp; \
+ RwIm2DVertexSetU(_devvert, _uTmp, _recipz); \
+} \
+MACRO_STOP
+#define RwIm2DCameraVertexSetV(_devvert, _camvert, _v, _recipz) \
+MACRO_START \
+{ \
+ RwReal _vTmp = _v; \
+ _camvert->v = _vTmp; \
+ RwIm2DVertexSetV(_devvert, _vTmp, _recipz); \
+} \
+MACRO_STOP
+
+#define RwIm3DVertexSetPos(_vert, _imx, _imy, _imz) \
+MACRO_START \
+{ \
+ (_vert)->objVertex.x = _imx; \
+ (_vert)->objVertex.y = _imy; \
+ (_vert)->objVertex.z = _imz; \
+} \
+MACRO_STOP
+
+#define RwIm3DVertexSetNormal(vert, imx, imy, imz) \
+MACRO_START \
+{ \
+ RwV3d packed; \
+ packed.x = imx; \
+ packed.y = imy; \
+ packed.z = imz; \
+ RxObjSpace3DVertexSetNormal(vert, &packed); \
+} \
+MACRO_STOP
+
+#define RwIm3DVertexSetRGBA(_vert, _r, _g, _b, _a) \
+MACRO_START \
+{ \
+ ((_vert)->color = ((_a) << 24) | \
+ ((_r) << 16) | \
+ ((_g) << 8) | \
+ ((_b))); \
+} \
+MACRO_STOP
+
+#define RwIm3DVertexGetPos(_vert) (&((_vert)->objVertex))
+#define RwIm3DVertexGetNormal(vert) (&((vert)->objNormal))
+
+#define RwIm3DVertexCopyRGBA(_dst, _src) (((_dst)->color) = ((_src)->color))
+
+/* LEGACY-SUPPORT macros */
+#define RWIM2DCAMERAVERTEXSetU(_devvert, _camvert, _u, _recipz) \
+ RwIm2DCameraVertexSetU(_devvert, _camvert, _u, _recipz)
+#define RWIM2DCAMERAVERTEXSetV(_devvert, _camvert, _v, _recipz) \
+ RwIm2DCameraVertexSetV(_devvert, _camvert, _v, _recipz)
+#define RWIM3DVERTEXGetNext(vert) RwIm3DVertexGetNext(vert)
+#define RWIM3DVERTEXSetPos(vert, imx, imy, imz) RwIm3DVertexSetPos(vert, imx, imy, imz)
+#define RWIM3DVERTEXGetPos(vert) RwIm3DVertexGetPos(vert)
+#define RWIM3DVERTEXSetU(vert, imu) RwIm3DVertexSetU(vert, imu)
+#define RWIM3DVERTEXSetV(vert, imv) RwIm3DVertexSetV(vert, imv)
+#define RWIM3DVERTEXSetRGBA(vert, r, g, b, a) RwIm3DVertexSetRGBA(vert, r, g, b, a)
+#define RWIM3DVERTEXSetNormal(vert, imx, imy, imz) RwIm3DVertexSetNormal(vert, imx, imy, imz)
+#define RWIM3DVERTEXCopyRGBA(dst,src) RwIm3DVertexCopyRGBA(dst,src)
+#define RXOBJSPACE3DVERTEXGetPos(_vert, _pos) \
+ RxObjSpace3DVertexGetPos(_vert, _pos)
+#define RXOBJSPACE3DVERTEXSetPos(_vert, _pos) \
+ RxObjSpace3DVertexSetPos(_vert, _pos)
+#define RXOBJSPACE3DVERTEXGetPreLitColor(_vert, _col) \
+ RxObjSpace3DVertexGetPreLitColor(_vert, _col)
+#define RXOBJSPACE3DVERTEXSetPreLitColor(_vert, _col) \
+ RxObjSpace3DVertexSetPreLitColor(_vert, _col)
+#define RXOBJSPACE3DVERTEXGetColor RxObjSpace3DVertexGetColor
+#define RXOBJSPACE3DVERTEXGetNormal(_vert, _normal) \
+ RxObjSpace3DVertexGetNormal(_vert, _normal)
+#define RXOBJSPACE3DVERTEXSetNormal(_vert, _normal) \
+ RxObjSpace3DVertexSetNormal(_vert, _normal)
+#define RXOBJSPACE3DVERTEXGetU(_vert) RxObjSpace3DVertexGetU(_vert)
+#define RXOBJSPACE3DVERTEXGetV(_vert) RxObjSpace3DVertexGetV(_vert)
+#define RXOBJSPACE3DVERTEXSetU(_vert, _imu) \
+ RxObjSpace3DVertexSetU(_vert, _imu)
+#define RXOBJSPACE3DVERTEXSetV(_vert, _imv) \
+ RxObjSpace3DVertexSetV(_vert, _imv)
+#define RXOBJSPACE3DLITVERTEXGetPos(vert, pos) \
+ RxObjSpace3DLitVertexGetPos(vert, pos)
+#define RXOBJSPACE3DLITVERTEXSetPos(vert, pos) \
+ RxObjSpace3DLitVertexSetPos(vert, pos)
+#define RXOBJSPACE3DLITVERTEXGetColor(vert, col) \
+ RxObjSpace3DLitVertexGetColor(vert, col)
+#define RXOBJSPACE3DLITVERTEXSetColor(vert, col) \
+ RxObjSpace3DLitVertexSetColor(vert, col)
+#define RXOBJSPACE3DLITVERTEXGetU(vert) \
+ RxObjSpace3DLitVertexGetU(vert)
+#define RXOBJSPACE3DLITVERTEXGetV(vert) \
+ RxObjSpace3DLitVertexGetV(vert)
+#define RXOBJSPACE3DLITVERTEXSetU(vert, imu) \
+ RxObjSpace3DLitVertexSetU(vert, imu)
+#define RXOBJSPACE3DLITVERTEXSetV(vert, imv) \
+ RxObjSpace3DLitVertexSetV(vert, imv)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2renderstate.h ---*/
+
+/**
+ * \ingroup rwcoregeneric
+ * RxRenderStateFlag
+ * Flags used in the \ref RxRenderStateVector structure */
+enum RxRenderStateFlag
+{
+ rxRENDERSTATEFLAG_TEXTUREPERSPECTIVE = 0x00000001, /**<Perspective texturing is to be enabled */
+ rxRENDERSTATEFLAG_ZTESTENABLE = 0x00000002, /**<Z-Buffer testing is to be performed */
+ rxRENDERSTATEFLAG_ZWRITEENABLE = 0x00000004, /**<Z-Buffer writing is to be enabled */
+ rxRENDERSTATEFLAG_VERTEXALPHAENABLE = 0x00000008, /**<Vertex alpha is to be enabled */
+ rxRENDERSTATEFLAG_FOGENABLE = 0x00000010, /**<Fog is to be enabled */
+ rxRENDERSTATEFLAG_ALPHAPRIMITIVEBUFFER = 0x00000020, /**<Alpha primitive buffering is to be enabled */
+ rxRENDERSTATEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RxRenderStateFlag RxRenderStateFlag;
+
+typedef struct RxRenderStateVector RxRenderStateVector;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxRenderStateVector
+ * Structure describing a render-state vector,
+ * used by the RxClRenderState cluster */
+struct RxRenderStateVector
+{
+ RwUInt32 Flags; /**< A load of the boolean renderstate options */
+ RwShadeMode ShadeMode; /**< Flat or Gouraud currently */
+ RwBlendFunction SrcBlend; /**< Src alpha, 1-src alpha, etc */
+ RwBlendFunction DestBlend; /**< Dest alpha, 1-dest alpha, etc */
+ RwRaster *TextureRaster; /**< texture raster */
+ RwTextureAddressMode AddressModeU; /**< U addressing mode - WRAP, MIRROR, CLAMP, BORDER */
+ RwTextureAddressMode AddressModeV; /**< V addressing mode - WRAP, MIRROR, CLAMP, BORDER */
+ RwTextureFilterMode FilterMode; /**< filtering mode - combos of NEAREST LINEAR MIP */
+ RwRGBA BorderColor; /**< Border color for texturing address mode border */
+ RwFogType FogType; /**< Select the type of fogging to use */
+ RwRGBA FogColor; /**< Color used for fogging */
+ RwUInt8 *FogTable; /**< A 256 entry fog table */
+};
+
+#if (!defined(RxRenderStateVectorAssign))
+#define RxRenderStateVectorAssign(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RxRenderStateVectorAssign)) */
+
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxRenderStateVector *RxRenderStateVectorSetDefaultRenderStateVector(RxRenderStateVector *rsvp);
+extern const RxRenderStateVector *RxRenderStateVectorGetDefaultRenderStateVector(void);
+extern RxRenderStateVector *RxRenderStateVectorCreate(RwBool current);
+extern void RxRenderStateVectorDestroy(RxRenderStateVector *rsvp);
+extern RxRenderStateVector *RxRenderStateVectorLoadDriverState(RxRenderStateVector *rsvp);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2clpcom.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeRGBAInterp.h ---*/
+
+struct NodeRGBAInterpData
+{
+ RwBool rgbaInterpOn;
+ RxRenderStateVector state;
+};
+typedef struct NodeRGBAInterpData NodeRGBAInterpData;
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetRGBAInterp(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeUVInterp.h ---*/
+
+typedef struct RxNodeUVInterpSettings RxNodeUVInterpSettings;
+struct RxNodeUVInterpSettings
+{
+ RwBool uvInterpOn;
+ RxRenderStateVector state;
+};
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetUVInterp(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/baimage.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+/* If this bit is set then the image has been allocated by the user */
+
+enum RwImageFlag
+{
+ rwNAIMAGEFLAG = 0x00,
+ rwIMAGEALLOCATED = 0x1,
+ rwIMAGEGAMMACORRECTED = 0x2,
+ rwIMAGEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwImageFlag RwImageFlag;
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwImage
+ * Image containing device-independent pixels.
+ * This should be considered an opaque type.
+ * Use the RwImage API functions to access.
+ */
+typedef struct RwImage RwImage;
+
+#if (!defined(DOXYGEN))
+struct RwImage
+{
+ RwInt32 flags;
+
+ RwInt32 width; /* Device may have different ideas */
+ RwInt32 height; /* internally !! */
+
+ RwInt32 depth; /* Of referenced image */
+ RwInt32 stride;
+
+ RwUInt8 *cpPixels;
+ RwRGBA *palette;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup datatypes
+ * \ref RwImageCallBackRead
+ * is the function registered with \ref RwImageRegisterImageFormat that is used,
+ * for example by \ref RwImageRead and \ref RwImageReadMaskedImage,
+ * to read images of a specific format from a disk file.
+ *
+ * \param imageName Pointer to a string containing the file name of the image.
+ *
+ * \see RwImageRegisterImageFormat
+ *
+ */
+typedef RwImage *(*RwImageCallBackRead)(const RwChar * imageName);
+
+/**
+ * \ingroup datatypes
+ * \ref RwImageCallBackWrite
+ * is the function registered with \ref RwImageRegisterImageFormat that is used,
+ * for example by \ref RwImageWrite,
+ * to write images of a specific format to a disk file.
+ *
+ * \param image Pointer to the image.
+ *
+ * \param imageName Pointer to a string containing the file name
+ * of the image.
+ *
+ *
+ * \return Pointer to the written image.
+ *
+ * \see RwImageRegisterImageFormat
+ *
+ */
+typedef RwImage *(*RwImageCallBackWrite)(RwImage *image, const RwChar *imageName);
+
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RwImageSetStrideMacro(_image, _stride) \
+ (((_image)->stride = (_stride)), (_image))
+
+#define RwImageSetPixelsMacro(_image, _pixels) \
+ (((_image)->cpPixels = (_pixels)), (_image))
+
+#define RwImageSetPaletteMacro(_image, _palette) \
+ (((_image)->palette = (_palette)), (_image))
+
+#define RwImageGetWidthMacro(_image) \
+ ((_image)->width)
+
+#define RwImageGetHeightMacro(_image) \
+ ((_image)->height)
+
+#define RwImageGetDepthMacro(_image) \
+ ((_image)->depth)
+
+#define RwImageGetStrideMacro(_image) \
+ ((_image)->stride)
+
+#define RwImageGetPixelsMacro(_image) \
+ ((_image)->cpPixels)
+
+#define RwImageGetPaletteMacro(_image) \
+ ((_image)->palette)
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RwImageSetStride(_image, _stride) \
+ RwImageSetStrideMacro(_image, _stride)
+
+#define RwImageSetPixels(_image, _pixels) \
+ RwImageSetPixelsMacro(_image, _pixels)
+
+#define RwImageSetPalette(_image, _palette) \
+ RwImageSetPaletteMacro(_image, _palette)
+
+#define RwImageGetWidth(_image) \
+ RwImageGetWidthMacro(_image)
+
+#define RwImageGetHeight(_image) \
+ RwImageGetHeightMacro(_image)
+
+#define RwImageGetDepth(_image) \
+ RwImageGetDepthMacro(_image)
+
+#define RwImageGetStride(_image) \
+ RwImageGetStrideMacro(_image)
+
+#define RwImageGetPixels(_image) \
+ RwImageGetPixelsMacro(_image)
+
+#define RwImageGetPalette(_image) \
+ RwImageGetPaletteMacro(_image)
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+ /* Creating and destroying */
+extern RwImage *RwImageCreate(RwInt32 width, RwInt32 height,
+ RwInt32 depth);
+extern RwBool RwImageDestroy(RwImage * image);
+
+ /* Allocating */
+extern RwImage *RwImageAllocatePixels(RwImage * image);
+extern RwImage *RwImageFreePixels(RwImage * image);
+
+ /* Converting images */
+extern RwImage *RwImageCopy(RwImage * destImage,
+ const RwImage * sourceImage);
+
+ /* Resizing images */
+extern RwImage *RwImageResize(RwImage * image, RwInt32 width,
+ RwInt32 height);
+
+ /* Producing masks ! */
+extern RwImage *RwImageApplyMask(RwImage * image,
+ const RwImage * mask);
+extern RwImage *RwImageMakeMask(RwImage * image);
+
+ /* Helper functions */
+extern RwImage *RwImageReadMaskedImage(const RwChar * imageName,
+ const RwChar * maskname);
+extern RwImage *RwImageRead(const RwChar * imageName);
+extern RwImage *RwImageWrite(RwImage * image,
+ const RwChar * imageName);
+
+ /* Setting and getting the default path for images */
+extern RwChar *RwImageGetPath(void);
+extern const RwChar *RwImageSetPath(const RwChar * path);
+
+ /* Setting */
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+extern RwImage *RwImageSetStride(RwImage * image, RwInt32 stride);
+extern RwImage *RwImageSetPixels(RwImage * image, RwUInt8 * pixels);
+extern RwImage *RwImageSetPalette(RwImage * image, RwRGBA * palette);
+
+ /* Getting */
+extern RwInt32 RwImageGetWidth(const RwImage * image);
+extern RwInt32 RwImageGetHeight(const RwImage * image);
+extern RwInt32 RwImageGetDepth(const RwImage * image);
+extern RwInt32 RwImageGetStride(const RwImage * image);
+extern RwUInt8 *RwImageGetPixels(const RwImage * image);
+extern RwRGBA *RwImageGetPalette(const RwImage * image);
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+ /* Get device dependent pixel value */
+extern RwUInt32 RwRGBAToPixel(RwRGBA * rgbIn, RwInt32 rasterFormat);
+extern RwRGBA *RwRGBASetFromPixel(RwRGBA * rgbOut,
+ RwUInt32 pixelValue,
+ RwInt32 rasterFormat);
+
+ /* Gamma correction */
+extern RwBool RwImageSetGamma(RwReal gammaValue);
+extern RwReal RwImageGetGamma(void);
+extern RwImage *RwImageGammaCorrect(RwImage * image);
+
+ /* Adding and removing gamma correction */
+extern RwRGBA *RwRGBAGammaCorrect(RwRGBA * rgb);
+
+ /* Attaching toolkits */
+extern RwInt32 RwImageRegisterPlugin(RwInt32 size, RwUInt32 pluginID,
+ RwPluginObjectConstructor
+ constructCB,
+ RwPluginObjectDestructor
+ destructCB,
+ RwPluginObjectCopy copyCB);
+extern RwInt32 RwImageGetPluginOffset(RwUInt32 pluginID);
+extern RwBool RwImageValidatePlugins(const RwImage * image);
+
+extern RwBool RwImageRegisterImageFormat(const RwChar * extension,
+ RwImageCallBackRead
+ imageRead,
+ RwImageCallBackWrite
+ imageWrite);
+
+ /* Finding an extension for an image to load */
+extern const RwChar *RwImageFindFileType(const RwChar * imageName);
+
+ /* Reading and writing images to streams */
+extern RwInt32 RwImageStreamGetSize(const RwImage * image);
+extern RwImage *RwImageStreamRead(RwStream * stream);
+extern const RwImage *RwImageStreamWrite(const RwImage * image,
+ RwStream * stream);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/batextur.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+/* Type ID */
+#define rwTEXDICTIONARY 6
+
+/* Mipmap Name generation - maximum number of RwChar characters which can
+ * be appended to the root name.
+ */
+#define rwTEXTUREMIPMAPNAMECHARS 16
+
+/* We define texture names to be a maximum of 16 ISO chars */
+#define rwTEXTUREBASENAMELENGTH 32
+
+#define rwTEXTUREFILTERMODEMASK 0x000000FF
+#define rwTEXTUREADDRESSINGUMASK 0x00000F00
+#define rwTEXTUREADDRESSINGVMASK 0x0000F000
+#define rwTEXTUREADDRESSINGMASK (rwTEXTUREADDRESSINGUMASK | \
+ rwTEXTUREADDRESSINGVMASK)
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwTexDictionary
+ * is a texture dictionary containing textures.
+ * This should be considered an opaque type.
+ * Use the RwTexDictionary API functions to access.
+ */
+typedef struct RwTexDictionary RwTexDictionary;
+
+#if (!defined(DOXYGEN))
+struct RwTexDictionary
+{
+ RwObject object; /* Homogeneous type */
+ RwLinkList texturesInDict; /* List of textures in dictionary */
+ RwLLLink lInInstance; /* Link list of all dicts in system */
+};
+/* Information is entirely device dependent */
+#endif /* (!defined(DOXYGEN)) */
+
+
+/* Parent is the dictionary */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwTexture
+ * is a texture object.
+ * This should be considered an opaque type.
+ * Use the RwTexture API functions to access.
+ */
+typedef struct RwTexture RwTexture;
+
+#if (!defined(DOXYGEN))
+struct RwTexture
+{
+ RwRaster *raster; /** pointer to RwRaster with data */
+ RwTexDictionary *dict; /* Dictionary this texture is in */
+ RwLLLink lInDictionary; /* List of textures in this dictionary */
+
+ RwChar name[rwTEXTUREBASENAMELENGTH]; /* Name of the texture */
+ RwChar mask[rwTEXTUREBASENAMELENGTH]; /* Name of the textures mask */
+
+ /* 31 [xxxxxxxx xxxxxxxx vvvvuuuu ffffffff] 0 */
+ RwUInt32 filterAddressing; /* Filtering & addressing mode flags */
+
+ RwInt32 refCount; /* Reference count, surprisingly enough */
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup datatypes
+ * \ref RwTextureCallBackRead
+ * represents the function used by \ref RwTextureRead to read the specified
+ * texture from a disk file. This function should return a pointer to the
+ * texture to indicate success.
+ *
+ * \param name Pointer to a string containing the name of
+ * the texture to read.
+ *
+ * \param maskName Pointer to a string containing the name
+ * of the mask to read and apply to the texture.
+ *
+ * \return Pointer to the texture
+ *
+ * \see RwTextureSetReadCallBack
+ * \see RwTextureGetReadCallBack
+ */
+typedef RwTexture *(*RwTextureCallBackRead)(const RwChar *name,
+ const RwChar *maskName);
+
+/**
+ * \ingroup datatypes
+ * \ref RwTextureCallBack
+ * represents the function called from \ref RwTexDictionaryForAllTextures
+ * for all textures in a given texture dictionary. This function should
+ * return the current texture to indicate success. The callback may return
+ * NULL to terminate further callbacks on the texture dictionary.
+ *
+ * \param texture Pointer to the current texture.
+ *
+ * \param pData User-defined data pointer.
+ *
+ * \return Pointer to the current texture
+ *
+ * \see RwTexDictionaryForAllTextures
+ */
+typedef RwTexture *(*RwTextureCallBack)(RwTexture *texture, void *pData);
+
+
+/**
+ * \ingroup datatypes
+ * \ref RwTexDictionaryCallBack
+ * represents the function called from \ref RwTexDictionaryForAllTexDictionaries
+ * for all texture dictionaries that currently exist. This function should
+ * return the current texture dictionary to indicate success. The callback may
+ * return NULL to terminate further callbacks on the texture dictionary. It may
+ * safely destroy the current texture dictionary without adversely affecting
+ * the iteration process.
+ *
+ * \param dict Pointer to the current texture dictionary.
+ *
+ * \param pData User-defined data pointer.
+ *
+ * \return Pointer to the current texture dictionary
+ *
+ * \see RwTexDictionaryForAllTexdictionaries
+ */
+typedef RwTexDictionary *(*RwTexDictionaryCallBack)(RwTexDictionary *dict, void *data);
+
+
+/**
+ * \ingroup datatypes
+ * \ref RwTextureCallBackMipmapGeneration
+ * is the callback function supplied to \ref RwTextureSetMipmapGenerationCallBack
+ * and returned from \ref RwTextureGetMipmapGenerationCallBack.
+ *
+ * The supplied function will be passed a pointer to a raster and an image.
+ * The raster is the target for the generated mipmap levels and the image
+ * provides the base for their generation.
+ *
+ * \param raster Pointer to raster, the target for generated mipmap levels
+ * \param image Pointer to image, used to generate mipmap levels.
+ *
+ * \return
+ * Returns a pointer to the raster if successful or NULL if an error occurred.
+ *
+ * \see RwTextureSetMipmapGenerationCallBack
+ * \see RwTextureGetMipmapGenerationCallBack
+ * \see RwTextureSetAutoMipmapping
+ * \see RwTextureGetAutoMipmapping
+ */
+typedef RwRaster *(*RwTextureCallBackMipmapGeneration)(RwRaster * raster,
+ RwImage * image);
+
+/**
+ * \ingroup datatypes
+ * \ref RwTextureCallBackMipmapName
+ * is the callback function supplied to \ref RwTextureSetMipmapNameCallBack and
+ * returned from \ref RwTextureGetMipmapNameCallBack.
+ *
+ * The supplied function will be passed a pointer to a root name, a maskName, a mipmap
+ * level and a format. The function returns TRUE if successful and the root name will have been
+ * modified to equal the mipmap name.
+ *
+ * \param name Pointer to a string containing the root name of the texture. The
+ * mipmap level name is put here.
+ * \param maskName Pointer to a string containing the root mask name of the texture or
+ * NULL if no mask name is required.
+ * \param mipLevel A value equal to the mipmap level for which the name is required.
+ * \param format A value describing the mipmapping mode. A combination of the bit
+ * flags rwRASTERFORMATMIPMAP and rwRASTERFORMATAUTOMIPMAP.
+ *
+ * \return
+ * Returns TRUE if the name is generated successfully or FALSE if an error occurred.
+ *
+ * \see RwTextureGenerateMipmapName
+ * \see RwTextureSetMipmapNameCallBack
+ * \see RwTextureGetMipmapNameCallBack
+ * \see RwTextureSetAutoMipmapping
+ * \see RwTextureGetAutoMipmapping
+ */
+typedef RwBool (*RwTextureCallBackMipmapName)(RwChar *name,
+ RwChar *maskName,
+ RwUInt8 mipLevel,
+ RwInt32 format);
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RwTextureGetRasterMacro(_tex) \
+ ((_tex)->raster)
+
+#define RwTextureAddRefMacro(_tex) \
+ (((_tex)->refCount++), (_tex))
+
+#define RwTextureAddRefVoidMacro(_tex) \
+MACRO_START \
+{ \
+ (_tex)->refCount++; \
+} \
+MACRO_STOP
+
+#define RwTextureGetNameMacro(_tex) \
+ ((_tex)->name)
+
+#define RwTextureGetMaskNameMacro(_tex) \
+ ((_tex)->mask)
+
+#define RwTextureGetDictionaryMacro(_tex) \
+ ((_tex)->dict)
+
+#define RwTextureSetFilterModeMacro(_tex, _filtering) \
+ (((_tex)->filterAddressing = \
+ ((_tex)->filterAddressing & ~rwTEXTUREFILTERMODEMASK) | \
+ (((RwUInt32)(_filtering)) & rwTEXTUREFILTERMODEMASK)), \
+ (_tex))
+
+#define RwTextureGetFilterModeMacro(_tex) \
+ ((RwTextureFilterMode)((_tex)->filterAddressing & \
+ rwTEXTUREFILTERMODEMASK))
+
+#define RwTextureSetAddressingMacro(_tex, _addressing) \
+ (((_tex)->filterAddressing = \
+ ((_tex)->filterAddressing & ~rwTEXTUREADDRESSINGMASK) | \
+ (((((RwUInt32)(_addressing)) << 8) & rwTEXTUREADDRESSINGUMASK) | \
+ ((((RwUInt32)(_addressing)) << 12) & rwTEXTUREADDRESSINGVMASK))), \
+ (_tex))
+
+#define RwTextureSetAddressingUMacro(_tex, _addressing) \
+ (((_tex)->filterAddressing = \
+ ((_tex)->filterAddressing & ~rwTEXTUREADDRESSINGUMASK) | \
+ (((RwUInt32)(_addressing) << 8) & rwTEXTUREADDRESSINGUMASK)), \
+ (_tex))
+
+#define RwTextureSetAddressingVMacro(_tex, _addressing) \
+ (((_tex)->filterAddressing = \
+ ((_tex)->filterAddressing & ~rwTEXTUREADDRESSINGVMASK) | \
+ (((RwUInt32)(_addressing) << 12) & rwTEXTUREADDRESSINGVMASK)), \
+ (_tex))
+
+#define RwTextureGetAddressingMacro(_tex) \
+ (((((_tex)->filterAddressing & rwTEXTUREADDRESSINGUMASK) >> 8) == \
+ (((_tex)->filterAddressing & rwTEXTUREADDRESSINGVMASK) >> 12)) ? \
+ ((RwTextureAddressMode)(((_tex)->filterAddressing & \
+ rwTEXTUREADDRESSINGVMASK) >> 12)) : \
+ rwTEXTUREADDRESSNATEXTUREADDRESS)
+
+#define RwTextureGetAddressingUMacro(_tex) \
+ ((RwTextureAddressMode)(((_tex)->filterAddressing & \
+ rwTEXTUREADDRESSINGUMASK) >> 8))
+
+#define RwTextureGetAddressingVMacro(_tex) \
+ ((RwTextureAddressMode)(((_tex)->filterAddressing & \
+ rwTEXTUREADDRESSINGVMASK) >> 12))
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RwTextureGetRaster(_tex) \
+ RwTextureGetRasterMacro(_tex)
+
+#define RwTextureAddRef(_tex) \
+ RwTextureAddRefMacro(_tex)
+
+#define RwTextureGetName(_tex) \
+ RwTextureGetNameMacro(_tex)
+
+#define RwTextureGetMaskName(_tex) \
+ RwTextureGetMaskNameMacro(_tex)
+
+#define RwTextureGetDictionary(_tex) \
+ RwTextureGetDictionaryMacro(_tex)
+
+#define RwTextureSetFilterMode(_tex, _filtering) \
+ RwTextureSetFilterModeMacro(_tex, _filtering)
+
+#define RwTextureGetFilterMode(_tex) \
+ RwTextureGetFilterModeMacro(_tex)
+
+#define RwTextureSetAddressing(_tex, _addressing) \
+ RwTextureSetAddressingMacro(_tex, _addressing)
+
+#define RwTextureSetAddressingU(_tex, _addressing) \
+ RwTextureSetAddressingUMacro(_tex, _addressing)
+
+#define RwTextureSetAddressingV(_tex, _addressing) \
+ RwTextureSetAddressingVMacro(_tex, _addressing)
+
+#define RwTextureGetAddressing(_tex) \
+ RwTextureGetAddressingMacro(_tex)
+
+#define RwTextureGetAddressingU(_tex) \
+ RwTextureGetAddressingUMacro(_tex)
+
+#define RwTextureGetAddressingV(_tex) \
+ RwTextureGetAddressingVMacro(_tex)
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+ /* Reading mip maps */
+
+ /* Setting mip mapping states */
+extern RwBool RwTextureSetMipmapping(RwBool enable);
+extern RwBool RwTextureGetMipmapping(void);
+extern RwBool RwTextureSetAutoMipmapping(RwBool enable);
+extern RwBool RwTextureGetAutoMipmapping(void);
+
+ /* Setting and getting the mipmap generation function */
+extern RwBool
+RwTextureSetMipmapGenerationCallBack(RwTextureCallBackMipmapGeneration
+ callback);
+extern RwTextureCallBackMipmapGeneration
+RwTextureGetMipmapGenerationCallBack(void);
+
+ /* Setting and getting the mipmap file name generation function */
+extern RwBool
+RwTextureSetMipmapNameCallBack(RwTextureCallBackMipmapName callback);
+extern RwTextureCallBackMipmapName RwTextureGetMipmapNameCallBack(void);
+
+ /* Generating mipmaps for a raster */
+extern RwBool RwTextureGenerateMipmapName(RwChar * name,
+ RwChar * maskName,
+ RwUInt8 mipLevel,
+ RwInt32 format);
+extern RwBool RwTextureRasterGenerateMipmaps(RwRaster * raster,
+ RwImage * image);
+
+ /* LEGACY-SUPPORT mip mapping */
+extern RwBool _rwTextureSetAutoMipMapState(RwBool enable);
+extern RwBool _rwTextureGetAutoMipMapState(void);
+
+ /* Setting and getting the callback function */
+extern RwTextureCallBackRead RwTextureGetReadCallBack(void);
+extern RwBool RwTextureSetReadCallBack(RwTextureCallBackRead
+ fpCallBack);
+
+ /* Texture and mask names */
+extern RwTexture *RwTextureSetName(RwTexture * texture,
+ const RwChar * name);
+extern RwTexture *RwTextureSetMaskName(RwTexture * texture,
+ const RwChar * maskName);
+
+ /* Creating/destroying dictionaries */
+extern RwTexDictionary *RwTexDictionaryCreate(void);
+extern RwBool RwTexDictionaryDestroy(RwTexDictionary * dict);
+
+ /* Textures */
+extern RwTexture *RwTextureCreate(RwRaster * raster);
+extern RwBool RwTextureDestroy(RwTexture * texture);
+
+ /* Setting and getting texture map rasters */
+extern RwTexture *RwTextureSetRaster(RwTexture * texture,
+ RwRaster * raster);
+
+ /* Dictionary access */
+extern RwTexture *RwTexDictionaryAddTexture(RwTexDictionary * dict,
+ RwTexture * texture);
+extern RwTexture *RwTexDictionaryRemoveTexture(RwTexture * texture);
+extern RwTexture *RwTexDictionaryFindNamedTexture(RwTexDictionary *
+ dict,
+ const RwChar * name);
+
+ /* Reading a texture */
+extern RwTexture *RwTextureRead(const RwChar * name,
+ const RwChar * maskName);
+
+ /* Setting the current dictionary */
+extern RwTexDictionary *RwTexDictionaryGetCurrent(void);
+extern RwTexDictionary *RwTexDictionarySetCurrent(RwTexDictionary * dict);
+
+ /* Enumerating textures */
+extern const RwTexDictionary *RwTexDictionaryForAllTextures(const
+ RwTexDictionary
+ * dict,
+ RwTextureCallBack
+ fpCallBack,
+ void *pData);
+
+ /* Enumerating the texture dictionaries currently in the system */
+extern RwBool RwTexDictionaryForAllTexDictionaries(
+ RwTexDictionaryCallBack fpCallBack, void *pData);
+
+
+ /* Attaching toolkits */
+extern RwInt32 RwTextureRegisterPlugin(RwInt32 size,
+ RwUInt32 pluginID,
+ RwPluginObjectConstructor
+ constructCB,
+ RwPluginObjectDestructor
+ destructCB,
+ RwPluginObjectCopy copyCB);
+extern RwInt32 RwTexDictionaryRegisterPlugin(RwInt32 size,
+ RwUInt32 pluginID,
+ RwPluginObjectConstructor
+ constructCB,
+ RwPluginObjectDestructor
+ destructCB,
+ RwPluginObjectCopy
+ copyCB);
+extern RwInt32 RwTextureGetPluginOffset(RwUInt32 pluginID);
+extern RwInt32 RwTexDictionaryGetPluginOffset(RwUInt32 pluginID);
+extern RwBool RwTextureValidatePlugins(const RwTexture * texture);
+extern RwBool RwTexDictionaryValidatePlugins(const RwTexDictionary *
+ dict);
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+/* Textures */
+extern RwRaster *RwTextureGetRaster(const RwTexture *texture);
+extern RwTexture *RwTextureAddRef(RwTexture *texture);
+
+/* Texture and mask names */
+extern RwChar *RwTextureGetName(RwTexture *texture);
+extern RwChar *RwTextureGetMaskName(RwTexture *texture);
+
+/* Get owner dictionary */
+extern RwTexDictionary *RwTextureGetDictionary(RwTexture *texture);
+
+/* Filtering */
+extern RwTexture *RwTextureSetFilterMode(RwTexture *texture,
+ RwTextureFilterMode filtering);
+
+extern RwTextureFilterMode RwTextureGetFilterMode(const RwTexture *texture);
+
+/* Addressing */
+extern RwTexture *RwTextureSetAddressing(RwTexture *texture,
+ RwTextureAddressMode addressing);
+extern RwTexture *RwTextureSetAddressingU(RwTexture *texture,
+ RwTextureAddressMode addressing);
+extern RwTexture *RwTextureSetAddressingV(RwTexture *texture,
+ RwTextureAddressMode addressing);
+
+extern RwTextureAddressMode RwTextureGetAddressing(const RwTexture *texture);
+extern RwTextureAddressMode RwTextureGetAddressingU(const RwTexture *texture);
+extern RwTextureAddressMode RwTextureGetAddressingV(const RwTexture *texture);
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define RwTextureSetAutoMipMapState(_enable) \
+ _rwTextureSetAutoMipMapState(_enable)
+
+#define RwTextureGetAutoMipMapState() \
+ _rwTextureGetAutoMipMapState()
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2stdcls.h ---*/
+
+/*
+ * Current:
+ *
+ * wait on Simon for instructions to do cluster renaming thing,
+ * or go thru and change all cluster type names and cluster
+ * names (add CSL?)
+ *
+ */
+
+/* CamVerts.csl */
+
+/* clip flags */
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RwClipFlag
+ * Flags specifying the clipping status of a vertex
+ */
+enum RwClipFlag
+{
+ rwXLOCLIP = 0x01, /**<The vertex is outside the low X clip-plane */
+ rwXHICLIP = 0x02, /**<The vertex is outside the high X clip-plane */
+ rwXCLIP = 0x03, /**<The vertex is outside an X clip-plane */
+
+ rwYLOCLIP = 0x04, /**<The vertex is outside the low Y clip-plane */
+ rwYHICLIP = 0x08, /**<The vertex is outside the high Z clip-plane */
+ rwYCLIP = 0x0C, /**<The vertex is outside a Y clip-plane */
+
+ rwZLOCLIP = 0x10, /**<The vertex is outside the low Z clip-plane */
+ rwZHICLIP = 0x20, /**<The vertex is outside the high Z clip-plane */
+ rwZCLIP = 0x30, /**<The vertex is outside a Z clip-plane */
+
+ rwCLIPMASK = 0x3F, /**<Mask covering all used bits in the clip flags
+ * in case a plugin wants free ones to use (e.g RpGloss) */
+
+ rwCLIPFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwClipFlag RwClipFlag;
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RwClipFlag
+ * Typedef for RwClipFlag enumeration specifying the clipping status of a vertex
+ */
+
+
+typedef struct RxCamSpace3DVertex RxCamSpace3DVertex;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxCamSpace3DVertex
+ * Structure describing a camera-space 3D vertex.
+ */
+struct RxCamSpace3DVertex
+{
+ /* Position in sheared camera-space (pre-projection) */
+ RwV3d cameraVertex; /**< \ref RwV3d camera-space position of the vertex */
+ /* Clip flags on this vertex */
+ RwUInt8 clipFlags; /**< Clip flags for the vertex generated during transformation into camera-space, see \ref RwClipFlag */
+ RwUInt8 pad[3]; /**< Alignment padding */
+ /* Lit colour */
+ RwRGBAReal col; /**< Accumulated \ref RwReal light values (initialized to zero or prelight colours) */
+ /* Only used by the clipper */
+ RwReal u; /**< Texture U coordinate */
+ RwReal v; /**< Texture V coordinate */
+};
+
+/* Supports pipeline1 apps: */
+/**
+ * \ingroup datatypes
+ * \typedef RwCameraVertex
+ * typedef for a structure describing a camera-space 3D vertex.
+ */
+typedef RxCamSpace3DVertex RwCameraVertex;
+
+/* (used during lighting) Doesn't use alpha yet, but it will */
+#define RxCamSpace3DVertexSetRGBA(camvert, r, g, b, a) \
+MACRO_START \
+{ \
+ ((camvert)->col.red = (r)); \
+ ((camvert)->col.green = (g)); \
+ ((camvert)->col.blue = (b)); \
+ ((camvert)->col.alpha = (a)); \
+} \
+MACRO_STOP
+
+#define RxCamSpace3DVertexAddRGBA(camvert, r, g, b, a) \
+MACRO_START \
+{ \
+ ((camvert)->col.red += (r)); \
+ ((camvert)->col.green += (g)); \
+ ((camvert)->col.blue += (b)); \
+ ((camvert)->col.alpha += (a)); \
+} \
+MACRO_STOP
+
+/* LEGACY-SUPPORT macros */
+#define RXCAMSPACE3DVERTEXSetRGBA(camvert, r, g, b, a) \
+ RxCamSpace3DVertexSetRGBA(camvert, r, g, b, a)
+#define RXCAMSPACE3DVERTEXAddRGBA(camvert, r, g, b, a) \
+ RxCamSpace3DVertexAddRGBA(camvert, r, g, b, a)
+
+/* MeshState.csl */
+
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RxGeometryFlag
+ * Flags describing geometry properties
+ */
+enum RxGeometryFlag
+{
+ rxGEOMETRY_TRISTRIP = 0x01, /**<This geometry's meshes can be rendered as tri-strips */
+ rxGEOMETRY_POSITIONS = 0x02, /**<This geometry has positions */
+ rxGEOMETRY_TEXTURED = 0x04, /**<This geometry has textures applied */
+ rxGEOMETRY_PRELIT = 0x08, /**<This geometry has luminance values */
+ rxGEOMETRY_NORMALS = 0x10, /**<This geometry has normals */
+ rxGEOMETRY_LIGHT = 0x20, /**<This geometry will be lit */
+ rxGEOMETRY_MODULATE = 0x40, /**<This geometry will modulate the material color with the vertex colors (prelit + lit) */
+ rxGEOMETRY_TEXTURED2 = 0x80, /**<This geometry has 2 set of texture coordinates */
+
+ rxGEOMETRY_COLORED = 0x100, /**<This mesh specifies per-vertex colors. NB: ONLY USED IN IM3D */
+
+ rxGEOMETRYFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxGeometryFlag
+ * Typedef for RxGeometryFlag enumeration describing geometry properties
+ */
+typedef enum RxGeometryFlag RxGeometryFlag;
+
+typedef struct RxMeshStateVector RxMeshStateVector;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxMeshStateVector
+ * Structure describing a mesh-state vector,
+ * used by the RxClMeshState cluster
+ */
+struct RxMeshStateVector
+{
+ RwInt32 Flags; /**< \ref RxGeometryFlag Flags from the source geometry */
+ void *SourceObject; /**< A void pointer. In immediate mode it points to an
+ * internal structure and in atomic/world-sector object
+ * or material pipelines it points to an \ref RpMaterial. */
+ RwMatrix Obj2World; /**< \ref RwMatrix to transform from object-space to world-space */
+ RwMatrix Obj2Cam; /**< \ref RwMatrix to transform from object-space to camera-space */
+ RwSurfaceProperties SurfaceProperties; /**< \ref RwSurfaceProperties */
+ /* We can't necessarily reference an RpMaterial in here (i.e with Im3D),
+ * because RpMaterials are defined in RpWorld not RwCore */
+ RwTexture *Texture; /**< A pointer to a \ref RwTexture */
+ RwRGBA MatCol; /**< \ref RwRGBA material colour */
+ RxPipeline *Pipeline; /**< A pointer to the material pipeline where appropriate */
+ /* rwPRIMTYPETRILIST/TRIFAN/TRISTRIP/LINELIST/POLYLINE */
+ RwPrimitiveType PrimType; /**< \ref RwPrimitiveType primitive type */
+ /* Interpretation based on PrimType */
+ RwUInt32 NumElements; /**< \ref RwUInt32 number of elements (triangles, lines...) */
+ RwUInt32 NumVertices; /**< \ref RwUInt32 number of vertices */
+ RwInt32 ClipFlagsOr; /**< Boolean OR of the \ref RwClipFlag clip flags of all vertices in the mesh */
+ RwInt32 ClipFlagsAnd; /**< Boolean AND of the \ref RwClipFlag clip flags of all vertices in the mesh */
+ void *SourceMesh; /**< A void pointer to the source \ref RpMesh */
+ void *DataObject; /**< Mirrors the void data pointer of \ref RxPipelineExecute */
+};
+
+/* RxScatter.csl */
+typedef struct RxScatter RxScatter;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxScatter
+ * Structure used by the RxClScatter cluster
+ */
+struct RxScatter
+{
+ RxPipeline *pipeline; /**< \ref RxPipeline pointer, causes Scatter.csl
+ * to spit the packet out to the specified pipeline */
+ RxPipelineNode *node; /**< \ref RxPipelineNode pointer, causes Scatter.csl
+ * to send the packet to the specified PipelineNode
+ * (as long as it is actually one of its outputs!) */
+};
+
+/* RxInterpolants.csl */
+typedef struct RxInterp RxInterp;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxInterp
+ * Structure used by the RxClInterp cluster
+ */
+struct RxInterp
+{
+ RxVertexIndex originalVert; /**< \ref RxVertexIndex index to the new vertex generated on the clipped edge */
+ RxVertexIndex parentVert1; /**< \ref RxVertexIndex index to the first vertex of the clipped edge */
+ RxVertexIndex parentVert2; /**< \ref RxVertexIndex index to the second vertex of the clipped edge */
+ RwReal interp; /**< \ref RwReal interpolant along the clipped edge */
+};
+
+/* RxUVs.csl */
+typedef struct RxUV RxUV;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxUV
+ * Structure used by the RxClUV cluster
+ */
+struct RxUV
+{
+ RwReal u; /**< \ref RwReal U texture coordinate */
+ RwReal v; /**< \ref RwReal V texture coordinate */
+};
+
+/* RxTriPlanes.csl */
+typedef struct RxTriPlane RxTriPlane;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxTriPlane
+ * for the packed plane structure used in RpWorlds and by the RxClTriPlane cluster
+ * NOTE: this is currently not used in any nodes that ship with the SDK
+ */
+struct RxTriPlane
+{
+ /* Packed plane format used in RpWorlds */
+ RwUInt32 N; /**< \ref RwUInt32 Packed normal */
+ RwReal w; /**< \ref RwReal distance from origin */
+};
+
+/* RxVSteps.csl */
+
+#if (defined(_MSC_VER))
+# if (_MSC_VER>=1000)
+# pragma pack(push, 1)
+# endif /* (_MSC_VER>=1000) */
+#endif /* (defined(_MSC_VER)) */
+
+typedef struct RxVStep RxVStep;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxVStep
+ * Structure used by the RxClVStep cluster.
+ * To use the step values in the RxClVStep cluster, start at the beginning
+ * of the RxVStep and vertex arrays and proceed as follows: (a) Process one
+ * vertex, (b) Skip 'step' vertices, (c) Increment the cursor of the RxClVStep
+ * cluster. Repeat (a)-(c) until the entire vertex array has been processed.
+ * If the RxVStep array contains valid data, you should not have to bounds-check
+ * its cursor.
+ */
+struct RxVStep
+{
+ RwUInt8 step; /**< \ref RwUInt8 The number of vertices after the current one
+ * which can be skipped in lighting and other calculations because,
+ * for example, they belong only to back-facing triangles */
+};
+
+#if (defined(_MSC_VER))
+# if (_MSC_VER>=1000)
+# pragma pack(pop)
+# endif /* (_MSC_VER>=1000) */
+#endif /* (defined(_MSC_VER)) */
+
+/* CamNorms.csl */
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxCamNorm
+ * typedef for \ref RwV3d used by the RxClVStep cluster */
+typedef RwV3d RxCamNorm;
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Uses the RxObjSpace3DVertex type (see pipmodel.h) */
+extern RxClusterDefinition RxClObjSpace3DVertices;
+/* Uses the RxCamSpace3DVertex type */
+extern RxClusterDefinition RxClCamSpace3DVertices;
+/* Uses the RxScrSpace2DVertex type (see pipmodel.h) */
+extern RxClusterDefinition RxClScrSpace2DVertices;
+/* Uses the RxInterp type */
+extern RxClusterDefinition RxClInterpolants;
+/* Uses the RxMeshStateVector type */
+extern RxClusterDefinition RxClMeshState;
+/* Uses the RxRenderStateVector type (p2renderstate.c/h) */
+extern RxClusterDefinition RxClRenderState;
+/* Uses the RxVertexIndex type */
+extern RxClusterDefinition RxClIndices;
+/* Uses the RxScatter type */
+extern RxClusterDefinition RxClScatter;
+/* Uses the RxUV type */
+extern RxClusterDefinition RxClUVs;
+/* Uses the RxVStep type */
+extern RxClusterDefinition RxClVSteps;
+/* Uses the RwRGBAReal type */
+extern RxClusterDefinition RxClRGBAs;
+/* Uses the RxCamNorm type */
+extern RxClusterDefinition RxClCamNorms;
+
+/* Uses the RxTriPlane type.
+ * NOTE: this is currently not used in any nodes that ship with the SDK */
+extern RxClusterDefinition RxClTriPlanes;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/baim3d.h ---*/
+
+/**
+ * \ingroup datatypes
+ * RwIm3DTransformFlags
+ * The bit-field type RwIm3DTransformFlags
+ * specifies options available for controlling execution of the 3D immediate
+ * mode pipeline (see API function \ref RwIm3DTransform):*/
+enum RwIm3DTransformFlags
+{
+ rwIM3D_VERTEXUV = 1, /**<Texture coordinates in source vertices should be used */
+ rwIM3D_ALLOPAQUE = 2, /**<All source vertices are opaque (alpha is 255) */
+ rwIM3D_NOCLIP = 4, /**<No clipping should be performed on the geometry (the
+ * app may know it is all onscreen or within the guard band clipping
+ * region for the current hardware, so clipping can be skipped) */
+ rwIM3D_VERTEXXYZ = 8, /**<Vertex positions */
+ rwIM3D_VERTEXRGBA = 16, /**<Vertex color */
+
+ rwIM3DTRANSFORMFLAGSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwIm3DTransformFlags RwIm3DTransformFlags;
+
+
+
+typedef struct rwIm3DPool rwIm3DPool;
+typedef struct rwImmediGlobals rwImmediGlobals;
+typedef struct rwIm3DRenderPipelines rwIm3DRenderPipelines;
+typedef struct _rwIm3DPoolStash _rwIm3DPoolStash;
+
+#if (0 && defined(SKY2))
+typedef struct rwIm3DVertexCache RwIm3DVertexCache;
+#endif /* (0&& defined(SKY2)) */
+
+/* complete information to reconstruct post-transform Im3D "mesh" packet */
+struct _rwIm3DPoolStash
+{
+ RwUInt32 flags; /* rwIM3D_VERTEXUV, rwIM3D_ALLOPAQUE, rwIM3D_NOCLIP etc */
+ RwMatrix *ltm; /* world-space frame of the vertices, if they have one */
+ RwUInt32 numVerts;
+ RxObjSpace3DVertex *objVerts;
+ RxCamSpace3DVertex *camVerts;
+ RxScrSpace2DVertex *devVerts;
+ RxMeshStateVector *meshState;
+ RxRenderStateVector *renderState;
+ RxPipeline *pipeline;
+ RwPrimitiveType primType;
+ RxVertexIndex *indices;
+ RwUInt32 numIndices;
+};
+
+/* Used as a cache of transformed vertices */
+struct rwIm3DPool
+{
+ RwUInt16 numElements; /* could become RwUInt32 nowadays */
+ RwUInt16 pad; /* alignment padding */
+ void *elements; /* the original array of verts (or whatever...) - referenced not copied */
+ RwInt32 stride; /* the stride of the element */
+ _rwIm3DPoolStash stash;
+};
+
+struct rwIm3DRenderPipelines
+{
+ /* One Im3D render pipeline pointer per rwPRIMTYPE
+ * (several pointers may point to the same pipeline though) */
+ RxPipeline *triList;
+ RxPipeline *triFan;
+ RxPipeline *triStrip;
+ RxPipeline *lineList;
+ RxPipeline *polyLine;
+ RxPipeline *pointList;
+};
+
+struct rwImmediGlobals
+{
+ RxPipeline *genericIm3DTransformPipeline;
+ rwIm3DRenderPipelines genericIm3DRenderPipelines;
+
+ RxPipeline *im3DTransformPipeline;
+ rwIm3DRenderPipelines im3DRenderPipelines;
+
+ /* Platforms that have their own non-generic pipelines
+ * (OPENGL, D3D7, SKY2, KAMUI2, DOLPHIN) put them here: */
+ RxPipeline *platformIm3DTransformPipeline;
+ rwIm3DRenderPipelines platformIm3DRenderPipelines;
+
+#if (defined(SKY2_DRVMODEL_H))
+ /* The triangle PS2All render pipe automatically
+ * calls this PS2AllMat pipeline: */
+ RxPipeline *ps2AllMatIm3DTrianglePipeline;
+ /* The line PS2All render pipe automatically
+ * calls this PS2AllMat pipeline: */
+ RxPipeline *ps2AllMatIm3DLinePipeline;
+ /* PS2Manager pipelines */
+ RxPipeline *ps2ManagerIm3DRenderPipeline;
+#endif /* (defined(SKY2_DRVMODEL_H)) */
+
+ rwIm3DPool curPool; /* The current cache of transformed vertices */
+};
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern rwIm3DPool *_rwIm3DGetPool( void );
+
+extern void *RwIm3DTransform(RwIm3DVertex *pVerts, RwUInt32 numVerts,
+ RwMatrix *ltm, RwUInt32 flags);
+extern RwBool RwIm3DEnd(void);
+
+extern RwBool RwIm3DRenderLine(RwInt32 vert1, RwInt32 vert2);
+extern RwBool RwIm3DRenderTriangle(RwInt32 vert1, RwInt32 vert2,
+ RwInt32 vert3);
+extern RwBool RwIm3DRenderIndexedPrimitive(RwPrimitiveType primType,
+ RwImVertexIndex *indices,
+ RwInt32 numIndices);
+extern RwBool RwIm3DRenderPrimitive(RwPrimitiveType primType);
+
+extern RxPipeline *RwIm3DGetGenericTransformPipeline(void);
+extern RxPipeline *RwIm3DGetGenericRenderPipeline(RwPrimitiveType primType);
+
+extern RxPipeline *RwIm3DGetTransformPipeline(void);
+extern RxPipeline *RwIm3DGetRenderPipeline( RwPrimitiveType primType);
+extern RxPipeline *RwIm3DSetTransformPipeline(RxPipeline *pipeline);
+extern RxPipeline *RwIm3DSetRenderPipeline( RxPipeline *pipeline,
+ RwPrimitiveType primType);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/d3d8/im3dpipe.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8dxttex.h ---*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwTexture *RwD3D8DDSTextureRead(const RwChar *name, const RwChar *maskname);
+
+extern RwBool RwD3D8RasterIsCompressed(const RwRaster *raster);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/drvfns.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+/*******/
+/* API */
+/*******/
+
+/* Reports on whether D3D8 can render S3TC textures */
+extern RwBool
+RwD3D8DeviceSupportsDXTTexture(void);
+
+/* Get handle to D3D8 device - useful for setting D3D8 renderstate*/
+extern void *
+RwD3D8GetCurrentD3DDevice(void);
+
+/* Get maximun number of multisampling levels */
+extern RwUInt32
+RwD3D8EngineGetMaxMultiSamplingLevels(void);
+
+/* Set number of multisampling levels */
+extern void
+RwD3D8EngineSetMultiSamplingLevels(RwUInt32 numLevels);
+
+/* Set maximun full screen refresh rate */
+extern void
+RwD3D8EngineSetRefreshRate(RwUInt32 refreshRate);
+
+/* Get handle to D3D8 rendering surface - useful for advanced blit ops */
+extern void *
+RwD3D8GetCurrentD3DRenderTarget(void);
+
+/* Atach a window to a camera */
+extern RwBool
+RwD3D8CameraAttachWindow(void *camera, void *hwnd);
+
+/* Immediate mode rendering */
+extern RwBool RwD3D8SetVertexShader(RwUInt32 handle);
+extern RwBool RwD3D8SetPixelShader(RwUInt32 handle);
+extern RwBool RwD3D8SetStreamSource(RwUInt32 streamNumber, void *streamData, RwUInt32 stride);
+extern RwBool RwD3D8SetIndices(void *indexData, RwUInt32 baseVertexIndex);
+
+extern RwBool RwD3D8DrawIndexedPrimitiveUP(RwUInt32 primitiveType,
+ RwUInt32 minIndex,
+ RwUInt32 numVertices,
+ RwUInt32 numIndices,
+ const void* indexData,
+ const void* vertexStreamZeroData,
+ RwUInt32 VertexStreamZeroStride);
+
+extern RwBool RwD3D8DrawPrimitiveUP(RwUInt32 primitiveType,
+ RwUInt32 numVertices,
+ const void* vertexStreamZeroData,
+ RwUInt32 VertexStreamZeroStride);
+
+extern RwBool RwD3D8DrawIndexedPrimitive(RwUInt32 primitiveType,
+ RwUInt32 minIndex,
+ RwUInt32 numVertices,
+ RwUInt32 startIndex,
+ RwUInt32 numIndices);
+
+extern RwBool RwD3D8DrawPrimitive(RwUInt32 primitiveType,
+ RwUInt32 startVertex,
+ RwUInt32 numVertices);
+
+extern RwBool RwD3D8SetTexture(RwTexture *texture, RwUInt32 stage);
+
+extern RwBool RwD3D8SetRenderState(RwUInt32 state, RwUInt32 value);
+extern RwBool RwD3D8SetTextureStageState(RwUInt32 stage, RwUInt32 type, RwUInt32 value);
+extern RwBool RwD3D8SetTransform(RwUInt32 state, const void *matrix);
+extern RwBool RwD3D8SetMaterial(const void *material);
+extern void RwD3D8SetStencilClear(RwUInt32 stencilClear);
+
+
+extern void RwD3D8GetRenderState(RwUInt32 state, void *value);
+extern void RwD3D8GetTextureStageState(RwUInt32 stage, RwUInt32 type, void *value);
+extern void RwD3D8GetTransform(RwUInt32 state, void *matrix);
+extern RwUInt32 RwD3D8GetStencilClear(void);
+
+/*
+ * To convert between RwMatrix to D3DMATRIX when setting the
+ * world matrix
+ */
+extern RwBool RwD3D8SetTransformWorld(const RwMatrix *matrix);
+
+/*
+ * To convert between RpMaterial to D3DMATERIAL8
+ */
+extern RwBool RwD3D8SetSurfaceProperties(const RwRGBA *color,
+ const RwSurfaceProperties *surfaceProps,
+ RwBool modulate);
+
+/*
+ * To set on that index the light from the descriptor
+ */
+extern RwBool RwD3D8SetLight(RwInt32 index, const void *light);
+extern void RwD3D8GetLight(RwInt32 index, void *light);
+
+extern RwBool RwD3D8EnableLight(RwInt32 index, RwBool enable);
+
+/*
+ * To get a pointer to a Dynamic vertex buffer
+ * Use both functions, Create and Destroy, not only Create
+ */
+extern RwBool RwD3D8DynamicVertexBufferCreate(RwUInt32 fvf, RwUInt32 size,
+ void **vertexBuffer);
+
+extern void RwD3D8DynamicVertexBufferDestroy(void *vertexBuffer);
+
+/*
+ * To get a temporary pointer to a Dynamic vertex buffer memory
+ * Don't use with the previous functions because
+ * it mantains an internal list of dinamic vertex buffers
+ */
+extern RwBool RwD3D8DynamicVertexBufferLock(RwUInt32 vertexSize,
+ RwUInt32 numVertex,
+ void **vertexBufferOut,
+ void **vertexDataOut,
+ RwUInt32 *baseIndexOut);
+
+extern RwBool RwD3D8DynamicVertexBufferUnlock(void *vertexBuffer);
+
+/*
+ * To get a pointer to an Index vertex buffer
+ * It's created as WRITEONLY, MANAGED and D3DFMT_INDEX16
+ */
+extern RwBool RwD3D8IndexBufferCreate(RwUInt32 numIndices,
+ void **indexBuffer);
+
+/*
+ * To create a vertex shader from the declaration, also the function
+ * for deleting it.
+ */
+extern RwBool RwD3D8CreateVertexShader(const RwUInt32 *declaration,
+ const RwUInt32 *function,
+ RwUInt32 *handle,
+ RwUInt32 usage);
+
+extern void RwD3D8DeleteVertexShader(RwUInt32 handle);
+
+extern RwBool RwD3D8SetVertexShaderConstant(RwUInt32 registerAddress,
+ const void *constantData,
+ RwUInt32 constantCount);
+
+/*
+ * To create a pixel shader from the function, also the function
+ * for deleting it.
+ */
+extern RwBool RwD3D8CreatePixelShader(const RwUInt32 *function, RwUInt32 *handle);
+
+extern void RwD3D8DeletePixelShader(RwUInt32 handle);
+
+extern RwBool RwD3D8SetPixelShaderConstant(RwUInt32 registerAddress,
+ const void *constantData,
+ RwUInt32 constantCount);
+
+/*
+ * Get a const pointer to the D3DCAPS8 struct, (you need to do the cast)
+ */
+extern const void *RwD3D8GetCaps(void);
+
+/*
+ * Check if the sphere is fully inside of the frustum
+ */
+extern RwBool RwD3D8CameraIsSphereFullyInsideFrustum(const void *camera, const void *sphere);
+
+/*
+ * Check if the Bounding Box is fully inside of the frustum
+ */
+extern RwBool RwD3D8CameraIsBBoxFullyInsideFrustum(const void *camera, const void *boundingBox);
+
+/*
+ * Cheking the CPU capabilities
+ */
+
+extern RwBool _rwIntelSSEsupported(void);
+extern RwBool _rwIntelMMXsupported(void);
+
+/*
+ * Enabling texture format conversions when loading textures from a texture
+ * dictionary. FALSE by default.
+ */
+extern void
+_rwD3D8TexDictionaryEnableRasterFormatConversion(RwBool enable);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/* LEGACY-MACRO */
+/**
+ * \ingroup rwcoredriverd3d8
+ * \ref RwD3DLoadNativeTexture is a legacy macro for compatability with
+ * RWD3D7 applications that can be used to read a compressed texture from
+ * the specified DDS file on disk.
+ *
+ * It is recommended that applications for RWD3D8 should use the RWD3D8
+ * function \ref RwD3D8DDSTextureRead instead.
+ *
+ * \param name Pointer to a string containing the name of the texture to be read.
+ * \param maskname Pointer to a string containing the name of the mask or
+ * NULL if not required.
+ *
+ * \return Returns pointer to the new texture if successful or NULL if there
+ * is an error.
+ *
+ * \see RwD3D8DDSTextureRead
+ * \see RwD3D8DeviceSupportsDXTTexture
+ * \see RwImageSetPath
+ * \see RwTextureSetReadCallBack
+ * \see RwTextureSetMipmapping
+ * \see RwTextureSetAutoMipmapping
+ * \see RwTextureDestroy
+ *
+ */
+#define RwD3DLoadNativeTexture RwD3D8DDSTextureRead
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/baresamp.h ---*/
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwImage *RwImageResample(RwImage *dstImage, const RwImage *srcImage);
+extern RwImage *RwImageCreateResample(const RwImage *srcImage, RwInt32 width,
+ RwInt32 height);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/baimras.h ---*/
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Images from rasters */
+extern RwImage *RwImageSetFromRaster(RwImage *image, RwRaster *raster);
+
+/* Rasters from images */
+extern RwRaster *RwRasterSetFromImage(RwRaster *raster, RwImage *image);
+
+/* Finding raster formats */
+extern RwRGBA *RwRGBAGetRasterPixel(RwRGBA *rgbOut, RwRaster *raster,
+ RwInt32 x, RwInt32 y);
+
+/* Read a raster */
+extern RwRaster *RwRasterRead(const RwChar *filename);
+extern RwRaster *RwRasterReadMaskedRaster(const RwChar *filename, const RwChar *maskname);
+
+/* Finding appropriate raster formats */
+extern RwImage *RwImageFindRasterFormat(RwImage *ipImage,RwInt32 nRasterType,
+ RwInt32 *npWidth,RwInt32 *npHeight,
+ RwInt32 *npDepth,RwInt32 *npFormat);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/baframe.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+#if (!defined(RWFRAMESTATICPLUGINSSIZE))
+#define RWFRAMESTATICPLUGINSSIZE 0
+#endif
+
+#define RWFRAMEALIGNMENT(_frame) \
+ (! (((rwFRAMEALIGNMENT)-1) & ((RwUInt32)(_frame))))
+
+/* Type ID */
+#define rwFRAME 0
+
+/* dirty flag bits */
+#define rwFRAMEPRIVATEHIERARCHYSYNCLTM 0x01
+#define rwFRAMEPRIVATEHIERARCHYSYNCOBJ 0x02
+#define rwFRAMEPRIVATESUBTREESYNCLTM 0x04
+#define rwFRAMEPRIVATESUBTREESYNCOBJ 0x08
+#define rwFRAMEPRIVATESTATIC 0x10
+
+/****************************************************************************
+ Global Types
+ */
+
+#if (!defined(DOXYGEN))
+struct RwFrame
+{
+ RwObject object;
+
+ RwLLLink inDirtyListLink;
+
+ /* Put embedded matrices here to ensure they remain 16-byte aligned */
+ RwMatrix modelling;
+ RwMatrix ltm;
+
+ RwLinkList objectList; /* List of objects connected to a frame */
+
+ struct RwFrame *child;
+ struct RwFrame *next;
+ struct RwFrame *root; /* Root of the tree */
+
+#if (RWFRAMESTATICPLUGINSSIZE)
+ RWALIGN(RwUInt8 pluginData[RWFRAMESTATICPLUGINSSIZE], rwFRAMEALIGNMENT);
+#endif /* defined(RWFRAMESTATICPLUGINSIZE)) */
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwFrame
+ Frame for defining object position and orientation.
+ * This should be considered an opaque type.
+ * Use the RwFrame API functions to access.
+ */
+typedef struct RwFrame RWALIGN(RwFrame, rwFRAMEALIGNMENT);
+
+/**
+ * \ingroup datatypes
+ * \typedef RwFrameCallBack
+ * \ref RwFrameCallBack type represents the function
+ * called from \ref RwFrameForAllChildren for all child frames linked to a given frame.
+ * This function should return a pointer to the current frame to indicate success.
+ * The callback may return NULL to terminate further callbacks on the child frames.
+ *
+ * \param frame Pointer to the current frame, supplied by
+ * iterator.
+ * \param data Pointer to developer-defined data structure.
+ *
+ * \see RwFrameForAllChildren
+ *
+ */
+typedef RwFrame *(*RwFrameCallBack)(RwFrame *frame, void *data);
+
+
+#define RwFrameGetParentMacro(_f) ((RwFrame *)rwObjectGetParent(_f))
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+#define RwFrameGetParent(_f) RwFrameGetParentMacro(_f)
+#endif
+
+#define RwFrameGetMatrixMacro(_f) (&(_f)->modelling)
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+#define RwFrameGetMatrix(_f) RwFrameGetMatrixMacro(_f)
+#endif
+
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Finding what is attached to a frame */
+extern RwFrame *
+RwFrameForAllObjects(RwFrame * frame,
+ RwObjectCallBack callBack,
+ void *data);
+
+/* Matrix operations */
+extern RwFrame *
+RwFrameTranslate(RwFrame * frame,
+ const RwV3d * v,
+ RwOpCombineType combine);
+
+extern RwFrame *
+RwFrameRotate(RwFrame * frame,
+ const RwV3d * axis,
+ RwReal angle,
+ RwOpCombineType combine);
+
+extern RwFrame *
+RwFrameScale(RwFrame * frame,
+ const RwV3d * v,
+ RwOpCombineType combine);
+
+extern RwFrame *
+RwFrameTransform(RwFrame * frame,
+ const RwMatrix * m,
+ RwOpCombineType combine);
+
+extern RwFrame *
+RwFrameOrthoNormalize(RwFrame * frame);
+
+extern RwFrame *
+RwFrameSetIdentity(RwFrame * frame);
+
+/* Cloning */
+extern RwFrame *
+RwFrameCloneHierarchy(RwFrame * root);
+
+/* Destruction */
+extern RwBool
+RwFrameDestroyHierarchy(RwFrame * frame);
+
+/* Building a frame */
+extern RwFrame *
+RwFrameForAllChildren(RwFrame * frame,
+ RwFrameCallBack callBack,
+ void *data);
+
+extern RwFrame *
+RwFrameRemoveChild(RwFrame * child);
+
+extern RwFrame *
+RwFrameAddChild(RwFrame * parent,
+ RwFrame * child);
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+extern RwFrame *
+RwFrameGetParent(const RwFrame * frame);
+#endif
+
+/* Getting the root */
+extern RwFrame *
+RwFrameGetRoot(const RwFrame * frame);
+
+/* Getting Matrices */
+extern RwMatrix *
+RwFrameGetLTM(RwFrame * frame);
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+extern RwMatrix *
+RwFrameGetMatrix(RwFrame * frame);
+#endif
+
+/* Elements */
+extern RwFrame *
+RwFrameUpdateObjects(RwFrame * frame);
+
+/* Creating destroying frames */
+extern RwFrame *
+RwFrameCreate(void);
+
+extern RwBool
+RwFrameInit(RwFrame *frame);
+
+extern RwBool
+RwFrameDeInit(RwFrame *frame);
+
+extern RwBool
+RwFrameDestroy(RwFrame * frame);
+
+/* internal function used by Create and Init */
+extern void
+_rwFrameInit(RwFrame *frame);
+
+/* internal function used by Destroy and DeInit */
+extern void
+_rwFrameDeInit(RwFrame *frame);
+
+/* Finding a frames state */
+extern RwBool
+RwFrameDirty(const RwFrame * frame);
+
+/* Find the amount of frames in a hierarchy */
+extern RwInt32
+RwFrameCount(RwFrame * frame);
+
+/* Plugins */
+extern RwBool
+RwFrameSetStaticPluginsSize(RwInt32 size);
+
+extern RwInt32
+RwFrameRegisterPlugin(RwInt32 size,
+ RwUInt32 pluginID,
+ RwPluginObjectConstructor constructCB,
+ RwPluginObjectDestructor destructCB,
+ RwPluginObjectCopy copyCB);
+
+extern RwInt32
+RwFrameGetPluginOffset(RwUInt32 pluginID);
+
+extern RwBool
+RwFrameValidatePlugins(const RwFrame * frame);
+
+/* Cloning */
+extern RwFrame *
+_rwFrameCloneAndLinkClones(RwFrame * root);
+
+extern
+RwFrame *
+_rwFramePurgeClone(RwFrame *root);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* Compatibility macros */
+
+#define rwFrameGetParent(frame) \
+ _rwFrameGetParent(frame)
+
+#define rwFrameInit(frame) \
+ _rwFrameInit(frame)
+
+#define rwFrameDeInit(frame) \
+ _rwFrameDeInit(frame)
+
+#define rwFrameCloneAndLinkClones(root) \
+ _rwFrameCloneAndLinkClones(root)
+
+#define rwFramePurgeClone(root) \
+ _rwFramePurgeClone(root)
+
+#define rwFrameClose(instance, offset, size) \
+ _rwFrameClose(instance, offset, size)
+
+#define rwFrameOpen(instance, offset, size) \
+ _rwFrameOpen(instance, offset, size)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/batypehf.h ---*/
+
+typedef struct RwObjectHasFrame RwObjectHasFrame;
+typedef RwObjectHasFrame * (*RwObjectHasFrameSyncFunction)(RwObjectHasFrame *object);
+struct RwObjectHasFrame
+{
+ RwObject object;
+ RwLLLink lFrame;
+ RwObjectHasFrameSyncFunction sync;
+};
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Frames */
+extern void _rwObjectHasFrameSetFrame(void *object, RwFrame *frame);
+extern void _rwObjectHasFrameReleaseFrame(void *object);
+
+/* ObjectHASFRAME METHODS */
+#define rwObjectHasFrameInitialize(o, type, subtype, syncFunc) \
+MACRO_START \
+{ \
+ rwObjectInitialize(o, type, subtype); \
+ ((RwObjectHasFrame *)o)->sync = syncFunc; \
+} \
+MACRO_STOP
+
+#define rwObjectHasFrameSync(o) \
+ ((RwObjectHasFrame *)(o))->sync(o)
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* Compatibility macros */
+
+#define rwObjectHasFrameSetFrame(object, frame) \
+ _rwObjectHasFrameSetFrame(object, frame)
+#define rwObjectHasFrameReleaseFrame(object) \
+ _rwObjectHasFrameReleaseFrame(object)
+
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/basync.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/babintex.h ---*/
+/****************************************************************************
+ Global types
+ */
+typedef struct rpTextureChunkInfo RwTextureChunkInfo;
+struct rpTextureChunkInfo
+{
+ RwTextureFilterMode filtering;
+ RwTextureAddressMode addressingU;
+ RwTextureAddressMode addressingV;
+};
+
+/* Bit flags defining properties of textures when stream */
+enum RwTextureStreamFlags
+{
+ rwNATEXTURESTREAMFLAG = 0x00,
+ rwTEXTURESTREAMFLAGSUSERMIPMAPS = 0x01,
+ rwTEXTURESTREAMFLAGSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwTextureStreamFlags RwTextureStreamFlags;
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Texture binary format */
+extern RwInt32
+RwTextureRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack readCB,
+ RwPluginDataChunkWriteCallBack writeCB,
+ RwPluginDataChunkGetSizeCallBack getSizeCB);
+
+extern RwInt32
+RwTextureSetStreamAlwaysCallBack(RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+
+extern RwUInt32
+RwTextureStreamGetSize(const RwTexture *texture);
+
+extern RwTexture *
+RwTextureStreamRead(RwStream *stream);
+
+extern const RwTexture *
+RwTextureStreamWrite(const RwTexture *texture,
+ RwStream *stream);
+
+/* Texture dictionary binary format */
+extern RwInt32
+RwTexDictionaryRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack readCB,
+ RwPluginDataChunkWriteCallBack writeCB,
+ RwPluginDataChunkGetSizeCallBack getSizeCB);
+
+extern RwInt32
+RwTexDictionarySetStreamAlwaysCallBack(RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+
+extern RwUInt32
+RwTexDictionaryStreamGetSize(const RwTexDictionary *texDict);
+
+extern RwTexDictionary
+*RwTexDictionaryStreamRead(RwStream *stream);
+
+extern const RwTexDictionary *
+RwTexDictionaryStreamWrite(const RwTexDictionary *texDict,
+ RwStream *stream);
+
+extern RwTextureChunkInfo *
+_rwTextureChunkInfoRead(RwStream *stream,
+ RwTextureChunkInfo *textureChunkInfo,
+ RwInt32 *bytesRead);
+
+/* Compatibility macro */
+
+#define RwTextureChunkInfoRead(_stream, _textureChunkInfo, _bytesRead) \
+ _rwTextureChunkInfoRead(_stream, _textureChunkInfo, _bytesRead)
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/babinfrm.h ---*/
+/****************************************************************************
+ Global types
+ */
+
+typedef struct rwFrameList rwFrameList;
+struct rwFrameList
+{
+ RwFrame **frames;
+ RwInt32 numFrames;
+};
+
+/****************************************************************************
+ Global Variables
+ */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Frame binary format */
+
+extern RwInt32
+RwFrameRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack readCB,
+ RwPluginDataChunkWriteCallBack writeCB,
+ RwPluginDataChunkGetSizeCallBack getSizeCB);
+
+extern RwInt32
+RwFrameSetStreamAlwaysCallBack(RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+
+
+extern rwFrameList *
+_rwFrameListInitialize(rwFrameList *frameList,
+ RwFrame *frame);
+
+extern RwBool
+_rwFrameListFindFrame(const rwFrameList *frameList,
+ const RwFrame *frame,
+ RwInt32 *npIndex);
+
+extern rwFrameList *
+_rwFrameListDeinitialize(rwFrameList *frameList);
+
+extern RwUInt32
+_rwFrameListStreamGetSize(const rwFrameList *frameList);
+
+extern rwFrameList *
+_rwFrameListStreamRead(RwStream *stream,
+ rwFrameList *fl);
+
+extern const rwFrameList *
+_rwFrameListStreamWrite(const rwFrameList *frameList,
+ RwStream *stream);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* Comparibility macros */
+
+#define rwFrameListInitialize(frameList,frame) \
+ _rwFrameListInitialize(frameList,frame)
+
+#define rwFrameListFindFrame(frameList, frame, index) \
+ _rwFrameListFindFrame(frameList, frame, index)
+
+#define rwFrameListDeinitialize(frameList) \
+ _rwFrameListDeinitialize(frameList)
+
+#define rwFrameListStreamGetSize(frameList) \
+ _rwFrameListStreamGetSize(frameList)
+
+#define rwFrameListStreamRead(stream, fl) \
+ _rwFrameListStreamRead(stream, fl)
+
+#define rwFrameListStreamWrite(frameList, stream) \
+ _rwFrameListStreamWrite(frameList, stream)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/babbox.h ---*/
+/****************************************************************************
+ Global types
+ */
+
+typedef struct RwBBox RwBBox;
+/**
+ * \ingroup datatypes
+ * \struct RwBBox
+ * This type represents a 3D axis-aligned bounding-box
+ * specified by the positions of two corners which lie on a diagonal.
+ * Typically used to specify a world bounding-box when the world is created
+ *
+ * \param sup Supremum vertex (contains largest values)
+ * \param inf Infimum vertex (contains smallest values)
+ *
+ * \see RpWorldCreate
+ */
+struct RwBBox
+{
+ /* Must be in this order */
+ RwV3d sup; /**< Supremum vertex. */
+ RwV3d inf; /**< Infimum vertex. */
+};
+
+#if (!defined(RwBBoxAssign))
+#define RwBBoxAssign(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RwBBoxAssign)) */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+extern RwBBox *RwBBoxCalculate(RwBBox *boundBox,
+ const RwV3d *verts,
+ RwInt32 numVerts);
+extern RwBBox *RwBBoxInitialize(RwBBox *boundBox,
+ const RwV3d *vertex);
+extern RwBBox *RwBBoxAddPoint(RwBBox *boundBox,
+ const RwV3d *vertex);
+extern RwBool RwBBoxContainsPoint(const RwBBox *boundBox,
+ const RwV3d *vertex);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/bacamera.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+/* Type ID */
+#define rwCAMERA 4
+
+
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RwCameraGetViewOffsetMacro(_camera) \
+ (&((_camera)->viewOffset))
+
+#define RwCameraSetRasterMacro(_camera, _raster) \
+ (((_camera)->frameBuffer = (_raster)), (_camera))
+
+#define RwCameraSetRasterVoidMacro(_camera, _raster) \
+MACRO_START \
+{ \
+ (_camera)->frameBuffer = (_raster); \
+} \
+MACRO_STOP
+
+#define RwCameraGetRasterMacro(_camera) \
+ ((_camera)->frameBuffer)
+
+#define RwCameraSetZRasterMacro(_camera, _raster) \
+ (((_camera)->zBuffer = (_raster)), (_camera))
+
+#define RwCameraSetZRasterVoidMacro(_camera, _raster) \
+MACRO_START \
+{ \
+ (_camera)->zBuffer = (_raster); \
+} \
+MACRO_STOP
+
+#define RwCameraGetZRasterMacro(_camera) \
+ ((_camera)->zBuffer)
+
+#define RwCameraGetNearClipPlaneMacro(_camera) \
+ ((_camera)->nearPlane)
+
+#define RwCameraGetFarClipPlaneMacro(_camera) \
+ ((_camera)->farPlane)
+
+#define RwCameraSetFogDistanceMacro(_camera, _distance) \
+ (((_camera)->fogPlane = (_distance)), (_camera))
+
+#define RwCameraGetFogDistanceMacro(_camera) \
+ ((_camera)->fogPlane)
+
+#define RwCameraGetCurrentCameraMacro() \
+ ((RwCamera *)RWSRCGLOBAL(curCamera))
+
+#define RwCameraGetProjectionMacro(_camera) \
+ ((_camera)->projectionType)
+
+#define RwCameraGetViewWindowMacro(_camera) \
+ (&((_camera)->viewWindow))
+
+#define RwCameraGetViewMatrixMacro(_camera) \
+ (&((_camera)->viewMatrix))
+
+#define RwCameraSetFrameMacro(_camera, _frame) \
+ (_rwObjectHasFrameSetFrame((_camera), (_frame)), (_camera))
+
+#define RwCameraSetFrameVoidMacro(_camera, _frame) \
+MACRO_START \
+{ \
+ _rwObjectHasFrameSetFrame((_camera), (_frame)); \
+} \
+MACRO_STOP
+
+
+#define RwCameraGetFrameMacro(_camera) \
+ ((RwFrame *)rwObjectGetParent((_camera)))
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RwCameraGetViewOffset(_camera) \
+ RwCameraGetViewOffsetMacro(_camera)
+
+#define RwCameraSetRaster(_camera, _raster) \
+ RwCameraSetRasterMacro(_camera, _raster)
+
+#define RwCameraGetRaster(_camera) \
+ RwCameraGetRasterMacro(_camera)
+
+#define RwCameraSetZRaster(_camera, _raster) \
+ RwCameraSetZRasterMacro(_camera, _raster)
+
+#define RwCameraGetZRaster(_camera) \
+ RwCameraGetZRasterMacro(_camera)
+
+#define RwCameraGetNearClipPlane(_camera) \
+ RwCameraGetNearClipPlaneMacro(_camera)
+
+#define RwCameraGetFarClipPlane(_camera) \
+ RwCameraGetFarClipPlaneMacro(_camera)
+
+#define RwCameraSetFogDistance(_camera, _distance) \
+ RwCameraSetFogDistanceMacro(_camera, _distance)
+
+#define RwCameraGetFogDistance(_camera) \
+ RwCameraGetFogDistanceMacro(_camera)
+
+#define RwCameraGetCurrentCamera() \
+ RwCameraGetCurrentCameraMacro()
+
+#define RwCameraGetProjection(_camera) \
+ RwCameraGetProjectionMacro(_camera)
+
+#define RwCameraGetViewWindow(_camera) \
+ RwCameraGetViewWindowMacro(_camera)
+
+#define RwCameraGetViewMatrix(_camera) \
+ RwCameraGetViewMatrixMacro(_camera)
+
+#define RwCameraSetFrame(_camera, _frame) \
+ RwCameraSetFrameMacro(_camera, _frame)
+
+#define RwCameraGetFrame(_camera) \
+ RwCameraGetFrameMacro(_camera)
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * RwCameraClearMode
+ * Camera clear flags */
+enum RwCameraClearMode
+{
+ rwCAMERACLEARIMAGE = 0x1, /**<Clear the frame buffer */
+ rwCAMERACLEARZ = 0x2, /**<Clear the Z buffer */
+ rwCAMERACLEARSTENCIL = 0x4, /**<\if xbox Clear the stencil buffer \endif
+ * \if d3d8 Clear the stencil buffer \endif
+ * \if opengl Clear the stencil buffer \endif
+ */
+ rwCAMERACLEARMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwCameraClearMode RwCameraClearMode;
+
+/**
+ * \ingroup datatypes
+ * RwCameraProjection
+ * This type represents the options available for
+ * setting the camera projection model, either perspective projection or
+* parallel projection (see API function \ref RwCameraSetProjection)*/
+enum RwCameraProjection
+{
+ rwNACAMERAPROJECTION = 0, /**<Invalid projection */
+ rwPERSPECTIVE = 1, /**<Perspective projection */
+ rwPARALLEL = 2, /**<Parallel projection */
+ rwCAMERAPROJECTIONFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwCameraProjection RwCameraProjection;
+
+/**
+ * \ingroup datatypes
+ * RwFrustumTestResult
+ * This type represents the results from a
+ * camera frustum test on a given sphere (see API function
+ * \ref RwCameraFrustumTestSphere)*/
+enum RwFrustumTestResult
+{
+ rwSPHEREOUTSIDE = 0, /**<Outside the frustum */
+ rwSPHEREBOUNDARY = 1, /**<On the boundary of the frustum */
+ rwSPHEREINSIDE = 2, /**<Inside the frustum */
+ rwFRUSTUMTESTRESULTFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwFrustumTestResult RwFrustumTestResult;
+
+
+/**
+ * \ingroup datatypes
+ * \typedef RwCamera
+ * Camera object for rendering a view.
+ * This should be considered an opaque type.
+ * Use the RwCamera API functions to access.
+ */
+typedef struct RwCamera RWALIGN(RwCamera, rwMATRIXALIGNMENT);
+
+/* This allows a world to overload functionality */
+typedef RwCamera *(*RwCameraBeginUpdateFunc) (RwCamera * camera);
+typedef RwCamera *(*RwCameraEndUpdateFunc) (RwCamera * camera);
+
+typedef struct RwFrustumPlane RwFrustumPlane;
+/*
+ * Structure describing a frustrum plane.
+ */
+struct RwFrustumPlane
+{
+ RwPlane plane;
+ RwUInt8 closestX;
+ RwUInt8 closestY;
+ RwUInt8 closestZ;
+ RwUInt8 pad;
+};
+
+#if (!defined(DOXYGEN))
+struct RwCamera
+{
+ RwObjectHasFrame object;
+
+ /* Parallel or perspective projection */
+ RwCameraProjection projectionType;
+
+ /* Start/end update functions */
+ RwCameraBeginUpdateFunc beginUpdate;
+ RwCameraEndUpdateFunc endUpdate;
+
+ /* The view matrix */
+ RwMatrix viewMatrix;
+
+ /* The cameras image buffer */
+ RwRaster *frameBuffer;
+
+ /* The Z buffer */
+ RwRaster *zBuffer;
+
+ /* Cameras mathmatical characteristics */
+ RwV2d viewWindow;
+ RwV2d recipViewWindow;
+ RwV2d viewOffset;
+ RwReal nearPlane;
+ RwReal farPlane;
+ RwReal fogPlane;
+
+ /* Transformation to turn camera z or 1/z into a Z buffer z */
+ RwReal zScale, zShift;
+
+ /* Render frame counter -> used for the frustum callback stuff */
+ RwUInt16 renderFrame;
+ RwUInt16 pad;
+
+ /* The clip-planes making up the viewing frustum */
+ RwFrustumPlane frustumPlanes[6];
+ RwBBox frustumBoundBox;
+
+ /* Points on the tips of the view frustum */
+ RwV3d frustumCorners[8];
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwCameraCallBack
+ * \ref RwCameraCallBack type represents a function called from any camera
+ * iterator that may be implemented in plugins. This function should return a
+ * pointer to the current camera to indicate success. The callback may return
+ * NULL to terminate further callbacks on other cameras.
+ *
+ * \param camera Pointer to the current camera, supplied by iterator.
+ * \param data Pointer to developer-defined data structure.
+ */
+typedef RwCamera *(*RwCameraCallBack)(RwCamera *camera, void *data);
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+ /* Rendering */
+extern RwCamera *RwCameraBeginUpdate(RwCamera * camera);
+extern RwCamera *RwCameraEndUpdate(RwCamera * camera);
+
+extern RwCamera *RwCameraClear(RwCamera * camera, RwRGBA * colour,
+ RwInt32 clearMode);
+
+/* Displaying results */
+extern RwCamera *RwCameraShowRaster(RwCamera * camera, void *pDev,
+ RwUInt32 flags);
+
+/* Creation and destruction */
+extern RwBool RwCameraDestroy(RwCamera * camera);
+extern RwCamera *RwCameraCreate(void);
+extern RwCamera *RwCameraClone(RwCamera * camera);
+
+/* Offset */
+extern RwCamera *RwCameraSetViewOffset(RwCamera *camera,
+ const RwV2d *offset);
+
+/* View window */
+extern RwCamera *RwCameraSetViewWindow(RwCamera *camera,
+ const RwV2d *viewWindow);
+
+/* Projection */
+extern RwCamera *RwCameraSetProjection(RwCamera *camera,
+ RwCameraProjection projection);
+
+/* Clip planes */
+extern RwCamera *RwCameraSetNearClipPlane(RwCamera *camera, RwReal nearClip);
+extern RwCamera *RwCameraSetFarClipPlane(RwCamera *camera, RwReal farClip);
+
+/* Attaching toolkits */
+extern RwInt32 RwCameraRegisterPlugin(RwInt32 size,
+ RwUInt32 pluginID,
+ RwPluginObjectConstructor
+ constructCB,
+ RwPluginObjectDestructor
+ destructCB,
+ RwPluginObjectCopy copyCB);
+extern RwInt32 RwCameraGetPluginOffset(RwUInt32 pluginID);
+extern RwBool RwCameraValidatePlugins(const RwCamera * camera);
+
+/* Frustum testing */
+extern RwFrustumTestResult RwCameraFrustumTestSphere(const RwCamera *
+ camera,
+ const RwSphere *
+ sphere);
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+/* Offset */
+extern const RwV2d *RwCameraGetViewOffset(const RwCamera *camera);
+
+/* Rasters */
+extern RwCamera *RwCameraSetRaster(RwCamera *camera, RwRaster *raster);
+extern RwRaster *RwCameraGetRaster(const RwCamera *camera);
+extern RwCamera *RwCameraSetZRaster(RwCamera *camera, RwRaster *zRaster);
+extern RwRaster *RwCameraGetZRaster(const RwCamera *camera);
+
+/* Clip planes */
+extern RwReal RwCameraGetNearClipPlane(const RwCamera *camera);
+extern RwReal RwCameraGetFarClipPlane(const RwCamera *camera);
+extern RwCamera *RwCameraSetFogDistance(RwCamera *camera, RwReal fogDistance);
+extern RwReal RwCameraGetFogDistance(const RwCamera *camera);
+
+extern RwCamera *RwCameraGetCurrentCamera(void);
+
+/* Projection */
+extern RwCameraProjection RwCameraGetProjection(const RwCamera *camera);
+
+/* View window */
+extern const RwV2d *RwCameraGetViewWindow(const RwCamera *camera);
+
+extern RwMatrix *RwCameraGetViewMatrix(RwCamera *camera);
+
+/* Frames */
+extern RwCamera *RwCameraSetFrame(RwCamera *camera, RwFrame *frame);
+extern RwFrame *RwCameraGetFrame(const RwCamera *camera);
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/barwtyp.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/bacamval.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/bapipe.h ---*/
+
+struct rwPipeGlobals
+{
+ RwFreeList *pipesFreeList; /* Save mallocs, use a freelist */
+ RxRenderStateVector defaultRenderState;
+ RwLinkList allPipelines; /* Unused as of yet, meant to be used to keep track of all
+ * created pipelines (for CBs and maybe cleanup) */
+ RwUInt32 maxNodesPerPipe; /* Initialised from _rxPipelineMaxNodes at startup. Used to
+ * allow conservative, single allocations during pipelock */
+
+ /* NOTE: Rw and RpWorld PowerPipe globals kept together for simplicity */
+
+ /* The current default pipelines (used if pipe == NULL for an object) */
+ RxPipeline *currentAtomicPipeline;
+ RxPipeline *currentWorldSectorPipeline;
+ RxPipeline *currentMaterialPipeline;
+ /* Generic C-based pipes that run on all platforms
+ * - these are set as the current pipes at startup unless
+ * platform-specific pipes (below) are created */
+ RxPipeline *genericAtomicPipeline;
+ RxPipeline *genericWorldSectorPipeline;
+ RxPipeline *genericMaterialPipeline;
+ /* Platforms that have their own non-generic pipelines
+ * (OPENGL, D3D7, SKY2, KAMUI2, DOLPHIN) put them here: */
+ RxPipeline *platformAtomicPipeline;
+ RxPipeline *platformWorldSectorPipeline;
+ RxPipeline *platformMaterialPipeline;
+#if (defined(SKY2_DRVMODEL_H))
+ /* We have extra flavours of pipe under SKY2.
+ * PS2All and PS2AllMat are the defaults.
+ * - see RpWorldSectorSkyGetPS2AllPipeline, etc */
+ RxPipeline *ps2ManagerAtomicPipeline;
+ RxPipeline *allInOneAtomicPipeline;
+ RxPipeline *vanillaAtomicPipeline;
+ RxPipeline *ps2ManagerWorldSectorPipeline;
+ RxPipeline *allInOneWorldSectorPipeline;
+ RxPipeline *vanillaWorldSectorPipeline;
+ RxPipeline *vanillaMaterialPipeline;
+#endif /* (SKY2_DRVMODEL_H) */
+
+};
+
+typedef struct rwPipeGlobals rwPipeGlobals;
+
+#define RXPIPELINEGLOBAL(var) (RWPLUGINOFFSET(rwPipeGlobals, RwEngineInstance, _rxPipelineGlobalsOffset)->var)
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwInt32 _rxPipelineGlobalsOffset;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/imrascnv.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/babincam.h ---*/
+/****************************************************************************
+ Global types
+ */
+
+/* Camera stream format */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwCameraChunkInfo
+ *
+ * \ref RwCameraChunkInfo is typedef'd to a structure that holds camera
+ * data. This should be considered an opaque type. Use the RwCamera
+ * API functions to access it.
+ */
+
+typedef struct rwStreamCamera RwCameraChunkInfo;
+typedef struct rwStreamCamera rwStreamCamera;
+struct rwStreamCamera
+{
+ RwV2d viewWindow;
+ RwV2d viewOffset;
+ RwReal nearPlane, farPlane;
+ RwReal fogPlane;
+ RwUInt32 projection;
+};
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Camera binary format */
+extern RwInt32 RwCameraRegisterPluginStream(RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack readCB,
+ RwPluginDataChunkWriteCallBack writeCB,
+ RwPluginDataChunkGetSizeCallBack getSizeCB);
+extern RwInt32 RwCameraSetStreamAlwaysCallBack(
+ RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+extern RwUInt32 RwCameraStreamGetSize(const RwCamera *camera);
+extern RwCamera *RwCameraStreamRead(RwStream *stream);
+extern const RwCamera *RwCameraStreamWrite(const RwCamera *camera,
+ RwStream *stream);
+extern RwCameraChunkInfo * RwCameraChunkInfoRead(RwStream *stream,
+ RwCameraChunkInfo *cameraChunkInfo,
+ RwInt32 *bytesRead);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RWCORE_H */
diff --git a/rwsdk/include/d3d8/rwplcore.h b/rwsdk/include/d3d8/rwplcore.h
new file mode 100644
index 00000000..152261cc
--- /dev/null
+++ b/rwsdk/include/d3d8/rwplcore.h
@@ -0,0 +1,6080 @@
+/******************************************/
+/* */
+/* RenderWare(TM) Graphics Library */
+/* */
+/******************************************/
+
+/*
+ * This file is a product of Criterion Software Ltd.
+ *
+ * This file is provided as is with no warranties of any kind and is
+ * provided without any obligation on Criterion Software Ltd.
+ * or Canon Inc. to assist in its use or modification.
+ *
+ * Criterion Software Ltd. and Canon Inc. will not, under any
+ * circumstances, be liable for any lost revenue or other damages
+ * arising from the use of this file.
+ *
+ * Copyright (c) 1999. Criterion Software Ltd.
+ * All Rights Reserved.
+ */
+
+/*************************************************************************
+ *
+ * Filename: <C:/daily/rwsdk/include/d3d8/rwplcore.h>
+ * Automatically Generated on: Wed Jul 10 10:45:00 2002
+ *
+ ************************************************************************/
+
+#ifndef RWPLCORE_H
+#define RWPLCORE_H
+
+/*--- System Header Files ---*/
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/os/win/ostypes.h ---*/
+#ifndef WIN_OSTYPES_H
+#define WIN_OSTYPES_H
+
+#define rwLITTLEENDIAN /* This is a little endian machine */
+
+typedef long RwFixed;
+typedef int RwInt32;
+typedef unsigned int RwUInt32;
+typedef short RwInt16;
+typedef unsigned short RwUInt16;
+typedef unsigned char RwUInt8;
+typedef signed char RwInt8;
+
+#ifdef RWUNICODE
+typedef wchar_t RwChar;
+#else /* RWUNICODE */
+typedef char RwChar;
+#endif /* RWUNICODE */
+typedef float RwReal;
+typedef RwInt32 RwBool;
+
+#ifdef _MSC_VER
+typedef __int64 RwInt64;
+typedef unsigned __int64 RwUInt64;
+#define RWZERO64 ((RwUInt64)0)
+#else /* _MSC_VER */
+
+typedef struct _RwUInt64 RwUInt64;
+typedef struct _RwInt64 RwInt64;
+
+/* We'll do it with structures (can't do maths on these, but OK for allocation): */
+#ifdef rwBIGENDIAN
+struct _RwUInt64
+{
+ RwUInt32 top;
+ RwUInt32 bottom;
+};
+
+struct _RwInt64
+{
+ RwInt32 top;
+ RwUInt32 bottom;
+};
+
+#else /* rwBIGENDIAN */
+#ifdef rwLITTLEENDIAN
+struct _RwUInt64
+{
+ RwUInt32 bottom;
+ RwUInt32 top;
+};
+
+struct _RwInt64
+{
+ RwUInt32 bottom;
+ RwInt32 top;
+};
+
+#else /* rwLITTLEENDIAN */
+#error "ENDIAN-ness undefined!"
+#endif /* rwLITTLEENDIAN */
+#endif /* rwBIGENDIAN */
+
+#define RWZERO64 { (RwUInt32)0, (RwUInt32)0 }
+#endif /* _MSC_VER */
+
+typedef struct _RwUInt128 RwUInt128;
+typedef struct _RwInt128 RwInt128;
+
+/* We'll do it with structures
+ * (can't do maths on these, but OK for allocation): */
+#ifdef rwBIGENDIAN
+struct _RwUInt128
+{
+ RwUInt64 top;
+ RwUInt64 bottom;
+};
+
+struct _RwInt128
+{
+ RwInt64 top;
+ RwUInt64 bottom;
+};
+
+#else /* rwBIGENDIAN */
+#ifdef rwLITTLEENDIAN
+struct _RwUInt128
+{
+ RwUInt64 bottom;
+ RwUInt64 top;
+};
+
+struct _RwInt128
+{
+ RwUInt64 bottom;
+ RwInt64 top;
+};
+
+#else /* rwLITTLEENDIAN */
+#error "ENDIAN-ness undefined!"
+#endif /* rwLITTLEENDIAN */
+#endif /* rwBIGENDIAN */
+
+#define RWZERO128 { RWZERO64, RWZERO64 }
+
+/* Limits of types */
+#define RwInt32MAXVAL 0x7FFFFFFF
+#define RwInt32MINVAL 0x80000000
+#define RwUInt32MAXVAL 0xFFFFFFFF
+#define RwUInt32MINVAL 0x00000000
+#define RwRealMAXVAL (RwReal)(3.40282347e+38)
+#define RwRealMINVAL (RwReal)(1.17549435e-38)
+#define RwInt16MAXVAL 0x7FFF
+#define RwInt16MINVAL 0x8000
+#define RwUInt16MAXVAL 0xFFFF
+#define RwUInt16MINVAL 0x0000
+
+/* Structure alignment */
+#define RWALIGN(type, x) type /* nothing */
+#define rwMATRIXALIGNMENT sizeof(RwUInt32)
+#define rwFRAMEALIGNMENT sizeof(RwUInt32)
+#define rwV4DALIGNMENT sizeof(RwUInt32)
+
+#if (defined(_MSC_VER))
+
+#if (defined(RWVERBOSE))
+#include <tchar.h>
+#pragma comment (lib , "advapi32.LIB") /* Registry functions */
+
+/*
+ * registry code
+ */
+
+#if (defined(RpWinRegGetDWordValue))
+#undef RpWinRegGetDWordValue
+#endif /* (defined(RpWinRegGetDWordValue)) */
+
+#define RpWinRegGetDWordValue(_result, _hKey, _name, _val) \
+MACRO_START \
+{ \
+ DWORD _size; \
+ DWORD _type; \
+ LONG _status; \
+ \
+ _status = \
+ RegQueryValueEx((_hKey), (_name), 0, &_type, NULL, &_size); \
+ (_result) = ((ERROR_SUCCESS == _status) && (REG_DWORD == _type)); \
+ \
+ if ((_result)) \
+ { \
+ _status = \
+ RegQueryValueEx((_hKey), (_name), 0, &_type, \
+ (BYTE *) (_val), &_size); \
+ (_result) = (ERROR_SUCCESS == _status); \
+ } \
+} \
+MACRO_STOP
+
+#if (defined(RpWinRegGetBinaryValue))
+#undef RpWinRegGetBinaryValue
+#endif /* (defined(RpWinRegGetBinaryValue)) */
+
+#define RpWinRegGetBinaryValue(_result, _hKey, _name, _val) \
+MACRO_START \
+{ \
+ DWORD _size; \
+ DWORD _type; \
+ LONG _status; \
+ \
+ _status = \
+ RegQueryValueEx((_hKey), (_name), 0, &_type, NULL, &_size); \
+ (_result) = \
+ ((ERROR_SUCCESS == _status) && \
+ (REG_BINARY == _type) && (0 < _size)); \
+ \
+ if ((_result)) \
+ { \
+ *(_val) = RwMalloc(sizeof(BYTE) * _size); \
+ (_result) = (NULL != *(_val)); \
+ \
+ if ((_result)) \
+ { \
+ \
+ _status = \
+ RegQueryValueEx((_hKey), \
+ (_name), 0, &_type, \
+ (BYTE *) * (_val), &_size); \
+ (_result =) (ERROR_SUCCESS == _status); \
+ \
+ if (!(_result)) \
+ { \
+ RwFree(*(_val)); \
+ *(_val) = NULL; \
+ } \
+ \
+ } \
+ \
+ } \
+} \
+MACRO_STOP
+
+#if (defined(RpWinRegGetStringValue))
+#undef RpWinRegGetStringValue
+#endif /* (defined(RpWinRegGetStringValue)) */
+
+#define RpWinRegGetStringValue(_result, _hKey, _name, _val) \
+MACRO_START \
+{ \
+ DWORD _size; \
+ DWORD _type; \
+ LONG _status; \
+ \
+ _status = \
+ RegQueryValueEx((_hKey), (_name), 0, &_type, NULL, &_size); \
+ (_result) = \
+ ((ERROR_SUCCESS == _status) && \
+ (REG_SZ == _type) && (0 < _size)); \
+ \
+ if ((_result)) \
+ { \
+ \
+ *(_val) = RwMalloc(sizeof(TCHAR) * _size); \
+ (_result) = (NULL != *(_val)); \
+ \
+ if ((_result)) \
+ { \
+ _status = \
+ RegQueryValueEx((_hKey), (_name), 0, &_type, \
+ (BYTE *) * (_val), &_size); \
+ (_result) = (ERROR_SUCCESS == _status); \
+ \
+ if (!(_result)) \
+ { \
+ RwFree(*(_val)); \
+ *(_val) = NULL; \
+ } \
+ } \
+ } \
+} \
+MACRO_STOP
+
+/* ------------------------------------------------------------------- */
+
+#define RpWinRegCloseKey(hKey) \
+MACRO_START \
+{ \
+ RegCloseKey(hKey); \
+} \
+MACRO_STOP
+
+/* ------------------------------------------------------------------- */
+
+#define RpWinRegOpenMachineKey(result) \
+MACRO_START \
+{ \
+ static const TCHAR RenderWareKey[] = \
+ "Software\\Criterion\\RenderWare"; \
+ DWORD disposition; \
+ LONG status = \
+ RegCreateKeyEx(HKEY_LOCAL_MACHINE, RenderWareKey, 0, \
+ REG_NONE, REG_OPTION_NON_VOLATILE, \
+ KEY_READ | KEY_WRITE, \
+ NULL, &result, &disposition); \
+ \
+ if (status != ERROR_SUCCESS) \
+ { \
+ result = NULL; \
+ } \
+} \
+MACRO_STOP
+
+/* ------------------------------------------------------------------- */
+
+#if (defined(RWGETWINREGDWORD))
+#undef RWGETWINREGDWORD
+#endif /* (defined(RWGETWINREGDWORD)) */
+
+#define RWGETWINREGDWORD(result, match) \
+MACRO_START \
+{ \
+ HKEY hKey; \
+ \
+ RpWinRegOpenMachineKey(hKey); \
+ if (hKey) \
+ { \
+ RwBool success; \
+ \
+ RpWinRegGetDWordValue(success, hKey, match, \
+ &result); \
+ \
+ RpWinRegCloseKey(hKey); \
+ } \
+} \
+MACRO_STOP
+
+#if (defined(RWGETWINREGBINARY))
+#undef RWGETWINREGBINARY
+#endif /* (defined(RWGETWINREGBINARY)) */
+
+#define RWGETWINREGBINARY(result, match) \
+MACRO_START \
+{ \
+ HKEY hKey; \
+ \
+ result = NULL; \
+ RpWinRegOpenMachineKey(hKey); \
+ if (hKey) \
+ { \
+ RwBool success; \
+ \
+ RpWinRegGetBinaryValue(success, hKey, match, \
+ &result, NULL); \
+ \
+ if (!success) \
+ result = NULL; \
+ \
+ RpWinRegCloseKey(hKey); \
+ } \
+} \
+MACRO_STOP
+
+#if (defined(RWGETWINREGSTRING))
+#undef RWGETWINREGSTRING
+#endif /* (defined(RWGETWINREGSTRING)) */
+
+#define RWGETWINREGSTRING(result, match) \
+MACRO_START \
+{ \
+ HKEY hKey; \
+ \
+ result = NULL; \
+ RpWinRegOpenMachineKey(hKey); \
+ if (hKey) \
+ { \
+ RwBool success; \
+ \
+ RpWinRegGetStringValue(success, hKey, match, \
+ &result); \
+ \
+ if (!success) \
+ result = NULL; \
+ \
+ RpWinRegCloseKey(hKey); \
+ } \
+} \
+MACRO_STOP
+
+#if (defined(_DEBUG))
+
+#if (defined(RWREGSETBREAKALLOC))
+#undef RWREGSETBREAKALLOC
+#endif /* (defined(RWREGSETBREAKALLOC)) */
+
+#define RWREGSETBREAKALLOC(_name) \
+MACRO_START \
+{ \
+ char _message[256]; \
+ long _lBreakAlloc = -1; \
+ \
+ RWGETWINREGDWORD(_lBreakAlloc, _name); \
+ \
+ RWCRTSETBREAKALLOC(_lBreakAlloc); \
+ \
+ _snprintf(_message, sizeof(_message), \
+ "%s(%d): RWCRTSETBREAKALLOC(%ld)\n", \
+ __FILE__, __LINE__, \
+ _lBreakAlloc); \
+ OutputDebugString(_message); \
+ \
+} \
+MACRO_STOP
+
+#if (defined(RWREGSETDEBUGTRACE))
+#undef RWREGSETDEBUGTRACE
+#endif /* (defined(RWREGSETDEBUGTRACE)) */
+
+#define RWREGSETDEBUGTRACE(_name) \
+MACRO_START \
+{ \
+ char _message[256]; \
+ long _lDebugtrace = 0; \
+ \
+ RWGETWINREGDWORD(_lDebugtrace, _name); \
+ \
+ RwDebugSetTraceState(_lDebugtrace); \
+ \
+ _snprintf(_message, sizeof(_message), \
+ "%s(%d): RwDebugSetTraceState(%ld)\n", \
+ __FILE__, __LINE__, \
+ _lDebugtrace); \
+ OutputDebugString(_message); \
+ \
+} \
+MACRO_STOP
+
+#if (defined(_CRTDBG_FLAGS))
+#undef _CRTDBG_FLAGS
+#endif /* (defined(_CRTDBG_FLAGS)) */
+
+#define _CRTDBG_FLAGS \
+( _CRTDBG_ALLOC_MEM_DF || /* Turn on the debug heap allocations \
+ * and use the memory block identifiers. \
+ * This is the only flag that's on by default. */ \
+ _CRTDBG_CHECK_ALWAYS_DF || /* Check and validate all memory \
+ * on each allocation and deallocation request. \
+ * Setting this flag on is what catches the \
+ * under and overwrites \
+ * so it is very important to \
+ * get it turned on. */ \
+ _CRTDBG_CHECK_CRT_DF || /* Include _CRT_BLOCK memory allocations \
+ * in all leak detection and state differences. */ \
+ _CRTDBG_DELAY_FREE_MEM_DF || /* Instead of truly freeing memory, \
+ * keep the block allocated and \
+ * in the internal heap list. \
+ * The blocks are filled with the value0xDD \
+ * so you know the memory is freed when \
+ * looking at it in the debugger. \
+ * By also not freeing the memory, \
+ * this can help provide stress \
+ * conditions for the program. */ \
+ _CRTDBG_LEAK_CHECK_DF) /* Do memory leak checking at \
+ * the end of the program. */
+
+#endif /* (defined(_DEBUG)) */
+#endif /* (defined(RWVERBOSE)) */
+
+#include <math.h>
+/*
+ * Keep true calls to these functions since
+ * some x86 runtime libraries do not support _CIpow() etc
+ */
+#pragma function( acos, asin, cosh, fmod, pow, sinh , tanh )
+
+#if (!defined(RWINT32FROMFLOAT))
+
+static __inline RwInt32
+int32fromreal(RwReal x)
+{
+ RwInt16 savemode;
+ RwInt16 workmode;
+ RwInt32 res;
+
+ _asm
+ {
+ fnstcw savemode ; get fpu mode
+ fld dword ptr[x] ; load rwreal x
+
+ mov ax,savemode ; put fpu mode in register
+ or ah,0ch ; or-in truncate mode
+
+ mov workmode,ax ; make ready to set fpu mode
+ fldcw workmode ; set fpu to truncate mode
+ fistp dword ptr[res]; store the rwint32eger result
+ fldcw savemode ; restore fpu mode
+ }
+
+ return res;
+}
+#define RwInt32FromRealMacro(x) int32fromreal(x)
+
+#endif /* (!defined(RWINT32FROMFLOAT)) */
+
+#if (!defined(NOASM))
+static __inline RwUInt32
+RwFastRealToUInt32(RwReal x)
+{
+ RwUInt32 res;
+
+ __asm FLD DWord Ptr[x];
+ __asm FISTP DWord Ptr[res];
+
+ return(res);
+}
+#endif /* (defined(NOASM)) */
+
+#endif /* (defined(_MSC_VER)) */
+
+#endif /* WIN_OSTYPES_H */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bamath.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+#if (!defined(RwInt32FromRealMacro))
+#define RwInt32FromRealMacro(x) \
+ ((RwInt32)(x))
+#endif /* (!defined(RwInt32FromRealMacro)) */
+
+#if (!defined(RwFastRealToUInt32))
+#define RwFastRealToUInt32(_x) \
+ ((RwUInt32)RwInt32FromRealMacro(((RwReal)(_x))))
+#endif /* (!defined(RwFastRealToUInt32)) */
+
+/*
+ * Ensure inclusion of prototypes for single precison maths functions
+ * e.g. from
+ * /usr/local/sce/ee/gcc/ee/include/math.h
+ * /Program Files/Intel/Compiler4.0/include/mathf.h
+ */
+
+#if (defined(__ICL))
+
+#if (defined(RWVERBOSE))
+
+/*
+ * See
+ * http://www.eskimo.com/~scs/C-faq/q11.17.html
+ */
+
+#define _STRINGIFY(X) #X
+#define _STRINGIFY_EXP(X) _STRINGIFY(X)
+
+#pragma message ("Intel Compiler Version " _STRINGIFY_EXP(__ICL) ":" __FILE__ "(" _STRINGIFY_EXP(__LINE__) ")\n")
+#pragma comment ( user, "comment:" "Intel Compiler Version " _STRINGIFY_EXP(__ICL) ":" __FILE__ "(" _STRINGIFY_EXP(__LINE__) ")\n")
+
+#endif /* (defined(RWVERBOSE)) */
+
+#if (400 <= __ICL)
+#if (defined(__cplusplus))
+#define _INC_MATH
+#endif /* (defined(__cplusplus)) */
+#include <mathf.h>
+#else /* (400 < __ICL) */
+#undef RW_USE_SPF
+#endif /* (400 < __ICL) */
+
+#endif /* (defined(__ICL)) */
+
+#include <math.h>
+
+#define _RW_C1 ( (float) 4.1666667908e-02 )
+#define _RW_C2 ( (float)-1.3888889225e-03 )
+#define _RW_C3 ( (float) 2.4801587642e-05 )
+#define _RW_C4 ( (float)-2.7557314297e-07 )
+#define _RW_C5 ( (float) 2.0875723372e-09 )
+#define _RW_C6 ( (float)-1.1359647598e-11 )
+#define _RW_S1 ( (float)-1.6666667163e-01 )
+#define _RW_S2 ( (float) 8.3333337680e-03 )
+#define _RW_S3 ( (float)-1.9841270114e-04 )
+#define _RW_S4 ( (float) 2.7557314297e-06 )
+#define _RW_S5 ( (float)-2.5050759689e-08 )
+#define _RW_S6 ( (float) 1.5896910177e-10 )
+#define _RW_one ( (float) 1.0000000000e+00 )
+#define _RW_pS0 ( (float) 1.6666667163e-01 )
+#define _RW_pS1 ( (float)-3.2556581497e-01 )
+#define _RW_pS2 ( (float) 2.0121252537e-01 )
+#define _RW_pS3 ( (float)-4.0055535734e-02 )
+#define _RW_pS4 ( (float) 7.9153501429e-04 )
+#define _RW_pS5 ( (float) 3.4793309169e-05 )
+#define _RW_pi ( (float) 3.1415925026e+00 )
+#define _RW_pi_tol ( (float) 0.0312500000e+00 )
+#define _RW_pio2_hi ( (float) 1.5707962513e+00 )
+#define _RW_pio2_lo ( (float) 7.5497894159e-08 )
+#define _RW_qS1 ( (float)-2.4033949375e+00 )
+#define _RW_qS2 ( (float) 2.0209457874e+00 )
+#define _RW_qS3 ( (float)-6.8828397989e-01 )
+#define _RW_qS4 ( (float) 7.7038154006e-02 )
+
+#define RwCosMinusPiToPiMacro(result, x) \
+MACRO_START \
+{ \
+ const float z = x * x; \
+ const float r = ( z * (_RW_C1 + \
+ z * (_RW_C2 + \
+ z * (_RW_C3 + \
+ z * (_RW_C4 + \
+ z * (_RW_C5 + \
+ z * _RW_C6)))))); \
+ result = (_RW_one - ((float) 0.5 * z - (z * r ))); \
+} \
+MACRO_STOP
+
+#define RwSinMinusPiToPiMacro(result, x) \
+do \
+{ \
+ const float z = x * x; \
+ const float v = z * x; \
+ const float r = ( _RW_S2 + \
+ z * (_RW_S3 + \
+ z * (_RW_S4 + \
+ z * (_RW_S5 + \
+ z * _RW_S6))) ); \
+ result = x + v * (_RW_S1 + z * r); \
+} \
+while(0)
+
+typedef union _rwIEEEFloatShapeType _rwIEEEFloatShapeType;
+union _rwIEEEFloatShapeType
+{
+ float value;
+ unsigned int word;
+};
+
+#define _RW_GET_FLOAT_WORD(i,d) \
+do { \
+ _rwIEEEFloatShapeType gf_u; \
+ gf_u.value = (d); \
+ (i) = gf_u.word; \
+} while (0)
+
+/* Set a float from a 32 bit int. */
+
+#define _RW_SET_FLOAT_WORD(d,i) \
+do { \
+ _rwIEEEFloatShapeType sf_u; \
+ sf_u.word = (i); \
+ (d) = sf_u.value; \
+} while (0)
+
+#define RwIEEEACosfMacro(result, x) \
+do \
+{ \
+ float z, p, q, r, w, s, c, df; \
+ int hx, ix; \
+ \
+ _RW_GET_FLOAT_WORD(hx, x); \
+ ix = hx & 0x7fffffff; \
+ if (ix >= 0x3f800000) \
+ { /* |x|>=1 */ \
+ if (hx > 0) \
+ { \
+ /* acos(1) = 0 */ \
+ result = (0.0); \
+ } \
+ else \
+ { \
+ /* acos(-1)= _RW_pi */ \
+ result = (_RW_pi + (float) 2.0 * _RW_pio2_lo); \
+ } \
+ \
+ } \
+ else if (ix < 0x3f000000) \
+ { /* |x| < 0.5 */ \
+ if (ix <= 0x23000000) \
+ { \
+ /*if |x|<2**-57 */ \
+ result = (_RW_pio2_hi + _RW_pio2_lo); \
+ } \
+ else \
+ { \
+ z = x * x; \
+ p = z * (_RW_pS0 + \
+ z * (_RW_pS1 + \
+ z * (_RW_pS2 + \
+ z * (_RW_pS3 + \
+ z * (_RW_pS4 + z * _RW_pS5))))); \
+ q = _RW_one + z * (_RW_qS1 + \
+ z * (_RW_qS2 + \
+ z * (_RW_qS3 + z * _RW_qS4))); \
+ r = p / q; \
+ result = (_RW_pio2_hi - (x - (_RW_pio2_lo - x * r))); \
+ } \
+ \
+ } \
+ else if (hx < 0) \
+ { /* x < -0.5 */ \
+ z = (_RW_one + x) * (float) 0.5; \
+ p = z * (_RW_pS0 + \
+ z * (_RW_pS1 + \
+ z * (_RW_pS2 + \
+ z * (_RW_pS3 + \
+ z * (_RW_pS4 + z * _RW_pS5))))); \
+ q = _RW_one + z * (_RW_qS1 + \
+ z * (_RW_qS2 + z * (_RW_qS3 + z * _RW_qS4))); \
+ rwSqrtMacro(&s, z); \
+ r = p / q; \
+ w = r * s - _RW_pio2_lo; \
+ result = (_RW_pi - (float) 2.0 * (s + w)); \
+ } \
+ else \
+ { /* x > 0.5 */ \
+ int idf; \
+ \
+ z = (_RW_one - x) * (float) 0.5; \
+ rwSqrtMacro(&s, z); \
+ df = s; \
+ _RW_GET_FLOAT_WORD(idf, df); \
+ _RW_SET_FLOAT_WORD(df, idf & 0xfffff000); \
+ c = (z - df * df) / (s + df); \
+ p = z * (_RW_pS0 + \
+ z * (_RW_pS1 + \
+ z * (_RW_pS2 + \
+ z * (_RW_pS3 + \
+ z * (_RW_pS4 + z * _RW_pS5))))); \
+ q = _RW_one + z * (_RW_qS1 + \
+ z * (_RW_qS2 + z * (_RW_qS3 + z * _RW_qS4))); \
+ r = p / q; \
+ w = r * s + c; \
+ result = ((float) 2.0 * (df + w)); \
+ } \
+} \
+while(0)
+
+#if (defined(RW_USE_SPF))
+
+#define RwACos(_x) acosf(_x)
+#define RwACosh(_x) acoshf(_x)
+#define RwASin(_x) asinf(_x)
+#define RwASinh(_x) asinhf(_x)
+
+#if (!defined(__ICL))
+/*
+ * No SPF version in
+ * Program Files/Intel/compilerXXX/include/mathf.h
+ * of atan2()
+ */
+#define RwATan2(_x, _y) atan2f(_x, _y)
+#endif /* (!defined(__ICL)) */
+
+#define RwATan(_x) atanf(_x)
+#define RwATanh(_x) atanhf(_x)
+#define RwCabs() cabsf()
+#define RwCbrt(_x) cbrtf(_x)
+#define RwCeil(_x) ceilf(_x)
+#define RwCopysign(_x, _y) copysignf(_x, _y)
+#define RwCos(_x) cosf(_x)
+#define RwCosh(_x) coshf(_x)
+#define RwDrem(_x, _y) dremf(_x, _y)
+#define RwErfc(_x) erfcf(_x)
+#define RwErf(_x) erff(_x)
+#define RwExp(_x) expf(_x)
+#define RwExpm1(_x) expm1f(_x)
+#define RwFinite(_x) finitef(_x)
+#define RwIlogb(_x) ilogbf(_x)
+#define RwIsinf(_x) isinff(_x)
+#define RwIsnan(_x) isnanf(_x)
+#define RwFabs(_x) fabsf(_x)
+#define RwFloor(_x) floorf(_x)
+#define RwFmod(_x, _y) fmodf(_x, _y)
+#define RwFrexp(_x, _iptr) frexpf(_x, _iptr)
+#define RwGamma(_x) gammaf(_x)
+#define RwGammaf_(_x, _iptr) gammaf_r(_x, _iptr)
+#define RwHypot(_x, _y) hypotf(_x, _y)
+#define RwInfinity() infinityf()
+#define RwJ0(_x) j0f(_x)
+#define RwJ1(_x) j1f(_x)
+#define RwJn(_i, _x) jnf(_i, _x)
+#define RwLdexp(_x, _i) ldexpf(_x, _i)
+#define RwLgamma(_x) lgammaf(_x)
+#define RwLgammaf_(_x, _iptr) lgammaf_r(_x, _iptr)
+#define RwLog10(_x) log10f(_x)
+#define RwLog1p(_x) log1pf(_x)
+#define RwLog(_x) logf(_x)
+#define RwModf(_x, _y) modff(_x, _y)
+#define RwNan() nanf()
+#define RwNextafter(_x, _y) nextafterf(_x, _y)
+#define RwPow(_x, _y) powf(_x, _y)
+#define RwRemainder(_x, _y) remainderf(_x, _y)
+#define RwRint(_x) rintf(_x)
+#define RwScalbn(_x, _i) scalbnf(_x, _i)
+#define RwSin(_x) sinf(_x)
+#define RwSinh(_x) sinhf(_x)
+/* rwSqrtMacro/rwInvSqrtMacro are overloaded in drvmodel.h
+ * (if they are at all) and wrapped as func/macro below */
+#define RwTan(_x) tanf(_x)
+#define RwTanh(_x) tanhf(_x)
+#define RwY0(_x) y0f(_x)
+#define RwY1(_x) y1f(_x)
+#define RwYn(_i, _x) ynf(_i, _x)
+
+#endif /* (defined(RW_USE_SPF)) */
+
+#if (!defined(RwACos))
+#define RwACos(_x) acos(_x)
+#endif /* (!defined(RwACos)) */
+#if (!defined(RwACosh))
+#define RwACosh(_x) acosh(_x)
+#endif /* (!defined(RwACosh)) */
+#if (!defined(RwASin))
+#define RwASin(_x) asin(_x)
+#endif /* (!defined(RwASin)) */
+#if (!defined(RwASinh))
+#define RwASinh(_x) asinh(_x)
+#endif /* (!defined(RwASinh)) */
+#if (!defined(RwATan2))
+#define RwATan2(_x, _y) atan2(_x, _y)
+#endif /* (!defined(RwATan2)) */
+#if (!defined(RwATan))
+#define RwATan(_x) atan(_x)
+#endif /* (!defined(RwATan)) */
+#if (!defined(RwATanh))
+#define RwATanh(_x) atanh(_x)
+#endif /* (!defined(RwATanh)) */
+#if (!defined(RwCabs))
+#define RwCabs() cabs()
+#endif /* (!defined(RwCabs)) */
+#if (!defined(RwCbrt))
+#define RwCbrt(_x) cbrt(_x)
+#endif /* (!defined(RwCbrt)) */
+#if (!defined(RwCeil))
+#define RwCeil(_x) ceil(_x)
+#endif /* (!defined(RwCeil)) */
+#if (!defined(RwCopysign))
+#define RwCopysign(_x, _y) copysign(_x, _y)
+#endif /* (!defined(RwCopysign)) */
+#if (!defined(RwCos))
+#define RwCos(_x) cos(_x)
+#endif /* (!defined(RwCos)) */
+#if (!defined(RwCosh))
+#define RwCosh(_x) cosh(_x)
+#endif /* (!defined(RwCosh)) */
+#if (!defined(RwDrem))
+#define RwDrem(_x, _y) drem(_x, _y)
+#endif /* (!defined(RwDrem)) */
+#if (!defined(RwErfc))
+#define RwErfc(_x) erfc(_x)
+#endif /* (!defined(RwErfc)) */
+#if (!defined(RwEr))
+#define RwEr(_x) erf(_x)
+#endif /* (!defined(RwEr)) */
+#if (!defined(RwExp))
+#define RwExp(_x) exp(_x)
+#endif /* (!defined(RwExp)) */
+#if (!defined(RwExpm1))
+#define RwExpm1(_x) expm1(_x)
+#endif /* (!defined(RwExpm1)) */
+#if (!defined(RwFinite))
+#define RwFinite(_x) finite(_x)
+#endif /* (!defined(RwFinite)) */
+#if (!defined(RwIlogb))
+#define RwIlogb(_x) ilogb(_x)
+#endif /* (!defined(RwIlogb)) */
+#if (!defined(RwIsin))
+#define RwIsin(_x) isinf(_x)
+#endif /* (!defined(RwIsin)) */
+#if (!defined(RwIsnan))
+#define RwIsnan(_x) isnan(_x)
+#endif /* (!defined(RwIsnan)) */
+#if (!defined(RwFabs))
+#define RwFabs(_x) fabs(_x)
+#endif /* (!defined(RwFabs)) */
+#if (!defined(RwFloor))
+#define RwFloor(_x) floor(_x)
+#endif /* (!defined(RwFloor)) */
+#if (!defined(RwFmod))
+#define RwFmod(_x, _y) fmod(_x, _y)
+#endif /* (!defined(RwFmod)) */
+#if (!defined(RwFrexp))
+#define RwFrexp(_x, _iptr) frexp(_x, _iptr)
+#endif /* (!defined(RwFrexp)) */
+#if (!defined(RwGamma))
+#define RwGamma(_x) gamma(_x)
+#endif /* (!defined(RwGamma)) */
+#if (!defined(RwGammaf_))
+#define RwGammaf_(_x, _iptr) gammaf_r(_x, _iptr)
+#endif /* (!defined(RwGammaf_)) */
+#if (!defined(RwHypot))
+#define RwHypot(_x, _y) hypot(_x, _y)
+#endif /* (!defined(RwHypot)) */
+#if (!defined(RwInfinity))
+#define RwInfinity() infinity()
+#endif /* (!defined(RwInfinity)) */
+#if (!defined(RwJ0))
+#define RwJ0(_x) j0(_x)
+#endif /* (!defined(RwJ0)) */
+#if (!defined(RwJ1))
+#define RwJ1(_x) j1(_x)
+#endif /* (!defined(RwJ1)) */
+#if (!defined(RwJn))
+#define RwJn(_i, _x) jn(_i, _x)
+#endif /* (!defined(RwJn)) */
+#if (!defined(RwLdexp))
+#define RwLdexp(_x, _i) ldexp(_x, _i)
+#endif /* (!defined(RwLdexp)) */
+#if (!defined(RwLgamma))
+#define RwLgamma(_x) lgamma(_x)
+#endif /* (!defined(RwLgamma)) */
+#if (!defined(RwLgammaf_))
+#define RwLgammaf_(_x, _iptr) lgammaf_r(_x, _iptr)
+#endif /* (!defined(RwLgammaf_)) */
+#if (!defined(RwLog10))
+#define RwLog10(_x) log10(_x)
+#endif /* (!defined(RwLog10)) */
+#if (!defined(RwLog1p))
+#define RwLog1p(_x) log1p(_x)
+#endif /* (!defined(RwLog1p)) */
+#if (!defined(RwLog))
+#define RwLog(_x) log(_x)
+#endif /* (!defined(RwLog)) */
+#if (!defined(RwMod))
+#define RwMod(_x, _y) mod(_x, _y )
+#endif /* (!defined(RwMod)) */
+#if (!defined(RwNan))
+#define RwNan() nan()
+#endif /* (!defined(RwNan)) */
+#if (!defined(RwNextafter))
+#define RwNextafter(_x, _y) nextafter(_x, _y)
+#endif /* (!defined(RwNextafter)) */
+#if (!defined(RwPow))
+#define RwPow(_x, _y) pow(_x, _y)
+#endif /* (!defined(RwPow)) */
+#if (!defined(RwRemainder))
+#define RwRemainder(_x, _y) remainder(_x, _y)
+#endif /* (!defined(RwRemainder)) */
+#if (!defined(RwRint))
+#define RwRint(_x) rint(_x)
+#endif /* (!defined(RwRint)) */
+#if (!defined(RwScalbn))
+#define RwScalbn(_x, _i) scalbn(_x, _i)
+#endif /* (!defined(RwScalbn)) */
+#if (!defined(RwSin))
+#define RwSin(_x) sin(_x)
+#endif /* (!defined(RwSin)) */
+#if (!defined(RwSinh))
+#define RwSinh(_x) sinh(_x)
+#endif /* (!defined(RwSinh)) */
+#if (!defined(rwSqrt))
+/* NOTE: this is overloaded in drvmodel.h for some targets (SKY2 and XBOX atm)
+ * [we do in fact do overload w/ sqrtf there, if RW_USE_SPF,
+ * for D3D7, D3D8, OpenGL and SoftRas] */
+#define rwSqrt(_result, _x) rwSqrtMacro(_result, _x)
+#endif /* (!defined(rwSqrt)) */
+#if (!defined(rwInvSqrt))
+/* NOTE: this is overloaded in drvmodel.h for some targets (SKY2 and XBOX atm)
+ * [we do in fact do overload w/ (1 / sqrtf) there, if RW_USE_SPF,
+ * for D3D7, D3D8, OpenGL and SoftRas] */
+#define rwInvSqrt(_recip, _x) rwInvSqrtMacro(_recip, _x)
+#endif /* (!defined(rwInvSqrt)) */
+#if (!defined(RwTan))
+#define RwTan(_x) tan(_x)
+#endif /* (!defined(RwTan)) */
+#if (!defined(RwTanh))
+#define RwTanh(_x) tanh(_x)
+#endif /* (!defined(RwTanh)) */
+#if (!defined(RwY0))
+#define RwY0(_x) y0(_x)
+#endif /* (!defined(RwY0)) */
+#if (!defined(RwY1))
+#define RwY1(_x) y1(_x)
+#endif /* (!defined(RwY1)) */
+#if (!defined(RwYn))
+#define RwYn(_i, _x) yn(_i, _x)
+#endif /* (!defined(RwYn)) */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/batypes.h ---*/
+#define rwLIBRARYBASEVERSION 0x31000
+#define rwLIBRARYCURRENTVERSION 0x33002
+
+/*
+ * RWBUILDNUMBER
+ * This 16-bit int will be externally defined in an official build, and
+ * is used to construct chunk header library ID when streaming out. All
+ * unofficial builds will be stamped with the following:-
+ */
+#if !defined(RWBUILDNUMBER)
+#define RWBUILDNUMBER 0xffff
+#endif
+
+/* IMPORTANT:
+ * The following Doxygen comment MUST be copied into RwCore.h,
+ * so don't move it from here. */
+
+/**
+ * \ingroup rwcore
+ * \page rwcoreoverview Core Library Overview
+ *
+ * LIBRARY: rwcore.lib
+ * HEADER: rwcore.h
+ *
+ * This library provides the fundamental RenderWare features.
+ *
+ * When creating a RenderWare application, this library must always be
+ * linked.
+ *
+ * Functionality includes:
+ * \li Immediate Modes (2D \ref rwim2d and 3D \ref rwim3d )
+ * \li Plugin Management
+ * \li Base Datatypes
+ * \li Cameras \ref rwcamera
+ * \li Frames \ref rwframe
+ * \li the RenderWare Engine \ref rwengine
+ *
+ * RenderWare uses an object-oriented design philosophy, so this
+ * documentation is split across a number of objects.
+ *
+ * These objects are implemented in C, so C terminology is generally
+ * used, rather than C++ -- hence 'functions' instead of 'methods' and
+ * 'elements' instead of 'members'.
+ *
+ * If you are new to RenderWare programming, please read through the
+ * supplied User Guide. The RenderWare Engine \ref rwengine API is
+ * usually the starting point for new developers.
+ */
+
+
+#if (!defined(RWFORCEENUMSIZEINT))
+#define RWFORCEENUMSIZEINT ((RwInt32)((~((RwUInt32)0))>>1))
+#endif /* (!defined(RWFORCEENUMSIZEINT)) */
+
+/*
+ * See
+ * http://www.eskimo.com/~scs/C-faq/q11.17.html
+ */
+
+#define RW_STRINGIFY(X) #X
+#define RW_STRINGIFY_EXPANDED(X) RW_STRINGIFY(X)
+
+/****************************************************************************
+ Attributes
+ */
+
+#if (defined(__GNUC__))
+
+/* See http://www.gnu.org/software/gcc/onlinedocs/gcc_4.html#SEC91 */
+
+#if (!(defined(__cplusplus) || defined(__MWERKS__) || defined(__RWUNUSED__)))
+#define __RWUNUSED__ __attribute__ ((unused))
+#endif /* (!(defined(__cplusplus) || defined(__MWERKS__) || defined(__RWUNUSED__))) */
+
+#if (!(defined(__RWUNUSEDRELEASE__) || defined(RWVALIDATEPARAM)))
+#if (!( defined(__cplusplus) || defined(__MWERKS__) || defined(RWDEBUG)))
+#define __RWUNUSEDRELEASE__ __attribute__ ((unused))
+#endif /* (!(defined(__cplusplus) || defined(__MWERKS__) || defined(RWDEBUG))) */
+#endif /* (!(defined(__RWUNUSEDRELEASE__) || defined(RWVALIDATEPARAM))) */
+
+#if (!defined(__RWFORMAT__))
+#define __RWFORMAT__(_archetype, _string_index, _first_to_check) \
+ __attribute__ ((format (_archetype, _string_index, _first_to_check)))
+#endif /* (!defined(__RWFORMAT__)) */
+
+#endif /* (defined(__GNUC__)) */
+
+#if (!defined(__RWUNUSED__))
+#define __RWUNUSED__ /* No op */
+#endif /* (!defined(__RWUNUSED__)) */
+
+#if (!defined(__RWUNUSEDRELEASE__))
+#define __RWUNUSEDRELEASE__ /* No op */
+#endif /* (!defined(__RWUNUSEDRELEASE__)) */
+
+#if (!defined(__RWFORMAT__))
+#define __RWFORMAT__(_archetype, _string_index, _first_to_check) /* No op */
+#endif /* (!defined(__RWFORMAT__)) */
+
+/****************************************************************************
+ Calling conventions
+ */
+
+#if (defined(WIN32))
+#define RWASMCALL __cdecl
+#define RWASMAPI(TYPE) TYPE RWASMCALL
+#endif /* (defined(WIN32)) */
+
+#if (!defined(RWASMCALL))
+#define RWASMCALL /* No op */
+#endif /* (!defined(RWASMCALL)) */
+
+#if (!defined(RWASMAPI))
+#define RWASMAPI(TYPE) TYPE
+#endif /* (!defined(RWASMAPI)) */
+
+
+/* Maximum number of nested contexts */
+#define rwMAXPIPECONTEXT 10
+
+
+/****************************************************************************
+ Macro wrappers. These are needed everywhere.
+ */
+
+#ifndef MACRO_START
+#define MACRO_START do
+#endif /* MACRO_START */
+
+#ifndef MACRO_STOP
+#define MACRO_STOP while(0)
+#endif /* MACRO_STOP */
+
+/****************************************************************************
+ Types needed everywhere
+ */
+
+#ifdef FALSE
+#undef FALSE
+#endif
+#define FALSE 0
+
+#ifdef TRUE
+#undef TRUE
+#endif
+#define TRUE !FALSE
+
+/****************************************************************************
+ MS VC/C++ Specific
+ */
+
+#if (defined(_MSC_VER))
+#if (_MSC_VER>=1000)
+
+
+/*
+ * Check for correct compiler version
+ */
+#define RW_MSC_VER 1200
+
+#if (0 && !defined(RW_NO_COMPILER_CHECK))
+#if (_MSC_VER != RW_MSC_VER )
+# pragma message (__FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) "):" "\n This compiler is a different version (" RW_STRINGIFY_EXPANDED(_MSC_VER) ")\n to the compiler used to build the RenderWare product libraries (" RW_STRINGIFY_EXPANDED(RW_MSC_VER) ") \n To turn off this warning please define RW_NO_COMPILER_CHECK " )
+# pragma comment ( user, "comment:" __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) "):" "\n This compiler is a different version (" RW_STRINGIFY_EXPANDED(_MSC_VER) ")\n to the compiler used to build the RenderWare product libraries (" RW_STRINGIFY_EXPANDED(RW_MSC_VER) ") \n To turn off this warning please define RW_NO_COMPILER_CHECK " )
+#endif /* (_MSC_VER != RW_MSC_VER ) */
+#endif /* (0 && !defined(RW_NO_COMPILER_CHECK)) */
+
+/*
+ * Output some compiler messages and object file comments
+ */
+
+#pragma comment ( compiler )
+
+#pragma comment ( user, "comment:" __DATE__" " __TIME__ " - " __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) ")")
+#pragma comment ( user, "comment:" " _MSC_VER==" RW_STRINGIFY_EXPANDED(_MSC_VER) "; _M_IX86==" RW_STRINGIFY_EXPANDED(_M_IX86))
+#if (defined(rwLIBRARYCURRENTVERSION))
+#pragma comment ( user, "comment:" "rwLIBRARYCURRENTVERSION:" RW_STRINGIFY_EXPANDED(rwLIBRARYCURRENTVERSION) )
+#endif /* (defined(rwLIBRARYCURRENTVERSION)) */
+
+#if (defined(RWDEBUG) && defined(RWVERBOSE))
+
+/* #include <windows.h> */
+#if (defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC))
+#define _CRTDBG_MAP_ALLOC
+#endif /* defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) */
+#include <crtdbg.h>
+
+#pragma message (__DATE__" " __TIME__ " - " __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) ")" )
+#pragma message ("_MSC_VER==" RW_STRINGIFY_EXPANDED(_MSC_VER) "; _M_IX86==" RW_STRINGIFY_EXPANDED(_M_IX86))
+
+#if (defined(rwLIBRARYCURRENTVERSION))
+#pragma message ( "rwLIBRARYCURRENTVERSION:" RW_STRINGIFY_EXPANDED(rwLIBRARYCURRENTVERSION) )
+#endif /* (defined(rwLIBRARYCURRENTVERSION)) */
+
+#endif /* (defined(RWDEBUG) && defined(RWVERBOSE) ) */
+
+#endif /* (_MSC_VER>=1000) */
+#endif /* (defined(_MSC_VER)) */
+
+/*******************/
+/* Primitive types */
+/*******************/
+
+/* String construction stuff (gets us UNICODE support) */
+#ifdef RWUNICODE
+#define _RWSTRING(x) L ## x
+#else /* RWUNICODE */
+#define _RWSTRING(x) x
+#endif /* RWUNICODE */
+#define RWSTRING(x) _RWSTRING(x)
+
+/* NB volatile keyword required for VC5.0 to ensure a reload - AMB */
+typedef union RwSplitBits RwSplitBits;
+union RwSplitBits
+{
+ RwReal nReal;
+ volatile RwInt32 nInt;
+ volatile RwUInt32 nUInt;
+};
+
+typedef struct RwSplitFixed RwSplitFixed;
+
+#ifdef rwBIGENDIAN
+struct RwSplitFixed
+{
+ RwInt16 integral;
+ RwUInt16 fractional;
+};
+
+#else /* rwBIGENDIAN */
+#ifdef rwLITTLEENDIAN
+struct RwSplitFixed
+{
+ RwUInt16 fractional;
+ RwInt16 integral;
+};
+
+#else /* rwLITTLEENDIAN */
+#error "ENDIAN-ness undefined!"
+#endif /* rwLITTLEENDIAN */
+#endif /* rwBIGENDIAN */
+
+typedef union RwUnionReal RwUnionReal;
+union RwUnionReal /* MSB is sign bit in any circumstance */
+{
+ RwReal real; /* 4 bytes interpreted as RwReal */
+ float floating; /* 4 bytes interpreted as float */
+ RwFixed fixed; /* 4 bytes interpreted as 16:16 fixed */
+ RwSplitFixed splitfixed; /* 4 bytes interpreted as 16:16 fixed */
+};
+
+/*****************/
+
+/* Complex types */
+
+/*****************/
+
+/**
+ * \ingroup datatypes
+ * \typedef RwV2d
+ * typedef for struct RwV2d
+ */
+typedef struct RwV2d RwV2d;
+/**
+ * \ingroup datatypes
+ * \struct RwV2d
+ * This type represents points in a 2D space, such as device
+ * space, specified by the (x, y) coordinates of the point.
+ */
+struct RwV2d
+{
+ RwReal x; /**< X value*/
+ RwReal y; /**< Y vlaue */
+};
+
+/**
+ * \ingroup datatypes
+ * \typedef RwV3d
+ * typedef for struct RwV3d
+ */
+typedef struct RwV3d RwV3d;
+/**
+ * \ingroup datatypes
+ * \struct RwV3d
+ * This type represents 3D points and vectors specified by
+ * the (x, y, z) coordinates of a 3D point or the (x, y, z) components of a
+ * 3D vector.
+ */
+struct RwV3d
+{
+ RwReal x; /**< X value */
+ RwReal y; /**< Y value */
+ RwReal z; /**< Z value */
+};
+
+#define RWV4DALIGNMENT(_v4d) \
+ (! (((rwV4DALIGNMENT)-1) & ((RwUInt32)(_v4d))))
+
+/**
+ * \ingroup datatypes
+ * \struct RwV4d
+ * This type represents 4D points and vectors specified by
+ * the (x, y, z, w) coordinates of a 4D point or the (x, y, z, w) components of a
+ * 4D vector.
+ */
+struct RwV4d
+{
+ RwReal x; /**< X value */
+ RwReal y; /**< Y value */
+ RwReal z; /**< Z value */
+ RwReal w; /**< W value */
+};
+
+/**
+ * \ingroup datatypes
+ * \typedef RwV4d
+ * typedef for struct RwV4d
+ */
+typedef struct RwV4d RWALIGN(RwV4d, rwV4DALIGNMENT);
+
+
+/**
+ * \ingroup datatypes
+ * \typedef RwRect
+ * typedef for struct RwRect
+ */
+typedef struct RwRect RwRect;
+/**
+ * \ingroup datatypes
+ * \struct RwRect
+ * This type represents a 2D device space rectangle specified
+ * by the position of the top-left corner (the offset x, y) and its width (w)
+ * and height (h).
+ */
+struct RwRect
+{
+ RwInt32 x; /**< X value of the top-left corner */
+ RwInt32 y; /**< Y value of the top-left corner */
+ RwInt32 w; /**< Width of the rectangle */
+ RwInt32 h; /**< Height of the rectangle */
+};
+
+/**
+ * \ingroup datatypes
+ * \typedef RwSphere
+ * typedef for struct RwSphere
+ */
+typedef struct RwSphere RwSphere;
+/**
+ * \ingroup datatypes
+ * \struct RwSphere
+ * This type represents a sphere specified by the position
+ * of its center and its radius
+ */
+struct RwSphere
+{
+ RwV3d center; /**< Sphere center */
+ RwReal radius; /**< Sphere radius */
+};
+
+#if (!defined(RwSphereAssign))
+#define RwSphereAssign(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RwSphereAssign)) */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwLine
+ * typedef for struct RwLine
+ */
+typedef struct RwLine RwLine;
+/**
+ * \ingroup datatypes
+ * \struct RwLine
+ * This type represents a 3D line specified by the position
+ * of its start and end points.
+ */
+struct RwLine
+{
+ RwV3d start; /**< Line start */
+ RwV3d end; /**< Line end */
+};
+
+#if (!defined(RwLineAssign))
+#define RwLineAssign(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RwLineAssign)) */
+
+/* The maximum number of texture coordinates */
+#define rwMAXTEXTURECOORDS 8
+
+/**
+ * \ingroup datatypes
+ * RwTextureCoordinateIndex
+ * This type represents the index for texture coordinates.
+ */
+enum RwTextureCoordinateIndex
+{
+ rwNARWTEXTURECOORDINATEINDEX = 0,
+ rwTEXTURECOORDINATEINDEX0,
+ rwTEXTURECOORDINATEINDEX1,
+ rwTEXTURECOORDINATEINDEX2,
+ rwTEXTURECOORDINATEINDEX3,
+ rwTEXTURECOORDINATEINDEX4,
+ rwTEXTURECOORDINATEINDEX5,
+ rwTEXTURECOORDINATEINDEX6,
+ rwTEXTURECOORDINATEINDEX7,
+ rwTEXTURECOORDINATEINDEXFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwTextureCoordinateIndex RwTextureCoordinateIndex;
+
+/**
+ * \ingroup datatypes
+ * \typedef RwTexCoords
+ * typedef for struct RwTexCoords
+ */
+typedef struct RwTexCoords RwTexCoords;
+/**
+ * \ingroup datatypes
+ * \struct RwTexCoords
+ * This type represents the the u and v texture
+ * coordinates of a particular vertex.
+ */
+struct RwTexCoords
+{
+ RwReal u; /**< U value */
+ RwReal v; /**< V value */
+};
+
+
+/* Singley linked list macros. End marked as NULL */
+
+typedef struct RwSLLink RwSLLink; /*** RwSLLink ***/
+struct RwSLLink
+{
+ RwSLLink *next;
+};
+
+#define rwSLLinkGetData(link,type,entry) \
+ ((type *)(((RwUInt8 *)(link))-offsetof(type,entry)))
+
+#define rwSLLinkGetConstData(link,type,entry) \
+ ((const type *)(((const RwUInt8 *)(link))-offsetof(type,entry)))
+
+#define rwSLLinkInitialize(linkvar) \
+ (linkvar)->next = NULL;
+
+#define rwSLLinkGetNext(linkvar) \
+ ((linkvar)->next)
+
+typedef struct RwSingleList RwSingleList;
+struct RwSingleList
+{
+ RwSLLink link;
+};
+
+#define rwSingleListInitialize(list) \
+ (list)->link.next= NULL;
+#define rwSingleListEmpty(list) \
+ (((list)->link.next)==NULL)
+#define rwSingleListAddSLLink(list,linkvar) \
+ ( (linkvar)->next = (list)->link.next, \
+ (list)->link.next = (linkvar) )
+#define rwSingleListGetFirstSLLink(list) \
+ ((list)->link.next)
+#define rwSingleListGetTerminator(list) (NULL)
+
+/* Doubly linked list. End marked as start (its a ring) */
+
+typedef struct RwLLLink RwLLLink; /*** RwLLLink ***/
+struct RwLLLink
+{
+ RwLLLink *next;
+ RwLLLink *prev;
+};
+
+#define rwLLLinkGetData(linkvar,type,entry) \
+ ((type *)(((RwUInt8 *)(linkvar))-offsetof(type,entry)))
+
+#define rwLLLinkGetConstData(linkvar,type,entry) \
+ ((const type *)(((const RwUInt8 *)(linkvar))-offsetof(type,entry)))
+
+#define rwLLLinkGetNext(linkvar) \
+ ((linkvar)->next)
+
+#define rwLLLinkGetPrevious(linkvar) \
+ ((linkvar)->prev)
+
+#define rwLLLinkInitialize(linkvar) \
+ ( (linkvar)->prev = (RwLLLink *)NULL, \
+ (linkvar)->next = (RwLLLink *)NULL )
+
+#define rwLLLinkAttached(linkvar) \
+ ((linkvar)->next)
+
+typedef struct RwLinkList RwLinkList;
+struct RwLinkList
+{
+ RwLLLink link;
+};
+
+#define rwLinkListInitialize(list) \
+ ( (list)->link.next = ((RwLLLink *)(list)), \
+ (list)->link.prev = ((RwLLLink *)(list)) )
+#define rwLinkListEmpty(list) \
+ (((list)->link.next) == (&(list)->link))
+#define rwLinkListAddLLLink(list, linkvar) \
+ ( (linkvar)->next = (list)->link.next, \
+ (linkvar)->prev = (&(list)->link), \
+ ((list)->link.next)->prev = (linkvar), \
+ (list)->link.next = (linkvar) )
+#define rwLinkListRemoveLLLink(linkvar) \
+ ( ((linkvar)->prev)->next = (linkvar)->next, \
+ ((linkvar)->next)->prev = (linkvar)->prev )
+#define rwLinkListGetFirstLLLink(list) \
+ ((list)->link.next)
+#define rwLinkListGetLastLLLink(list) \
+ ((list)->link.prev)
+#define rwLinkListGetTerminator(list) \
+ (&((list)->link))
+
+/**
+ * \ingroup datatypes
+ * \typedef RwSurfaceProperties
+ * typedef for struct RwSurfaceProperties
+ */
+typedef struct RwSurfaceProperties RwSurfaceProperties;
+/**
+ * \ingroup datatypes
+ * \struct RwSurfaceProperties
+ * This type represents the ambient, diffuse and
+ * specular reflection coefficients of a particular geometry. Each coefficient
+ * is specified in the range 0.0 (no reflection) to 1.0 (maximum reflection).
+ */
+struct RwSurfaceProperties
+{
+ RwReal ambient; /**< ambient reflection coefficient */
+ RwReal specular; /**< specular reflection coefficient */
+ RwReal diffuse; /**< reflection coefficient */
+};
+
+#if (!defined(RwSurfacePropertiesAssign))
+#define RwSurfacePropertiesAssign(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RwSurfacePropertiesAssign)) */
+
+/**********
+ * Macros *
+ **********/
+
+/* ANSI C defines the offsetof(type,member) macro; should be in <stddef.h> */
+
+/* If not, fall back to this: */
+#ifndef offsetof
+#define offsetof(type, member) \
+ ((size_t)((RwUInt8 *)&((type *) 0)->member - (RwUInt8 *)((type *) 0)))
+#endif /* offsetof */
+
+/*
+ *
+ * Numeric Macros to handle Fixed/Floating point versions of RenderWare
+ *
+ */
+#define RWFIX_MIN (1)
+#define RWFIX_MAX (0x7fffffff)
+#define RwFixedCast(A) (RwInt32FromRealMacro((A) * 65536.0f))
+#define RwFixedToInt(A) ((A) >> 16)
+#define RwFixedToFloat(A) ((float)(((float)(A)) * (1.0f / 65536.0f)))
+#define RwFixedToReal(a) ((RwReal)(((RwReal)(a)) * (1.0f / 65536.0f)))
+#define RwRealToFixed(a) (RwInt32FromRealMacro((a) * 65536.0f))
+#define RwRealAbs(a) ((RwReal)((a) >= (RwReal)(0.0) ? (a) : (-(a))))
+#define RwRealMin2(a,b) ((RwReal)( ((a) <= (b)) ? (a) : (b)))
+#define RwRealMax2(a,b) ((RwReal)( ((a) >= (b)) ? (a) : (b)))
+#define RwRealMin3(a,b,c) RwRealMin2(a,RwRealMin2(b,c))
+#define RwRealMax3(a,b,c) RwRealMax2(a,RwRealMax2(b,c))
+
+#ifndef NORWREALSHORTCUT
+#define RToFixed RwRealToFixed
+#define RAbs RwRealAbs
+#define FxCast RwFixedCast
+#define FxToInt RwFixedToInt
+#define FxToFloat RwFixedToFloat
+#define FxToReal RwFixedToFloat
+
+#endif
+
+#ifndef rwPI
+#define rwPI ((RwReal)(3.1415926535f))
+#define rwPIOVER2 (rwPI / (RwReal)(2.0f))
+#endif
+#define RWRGBALONG(r,g,b,a) \
+ ((RwUInt32) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b)))
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+ RwPlane
+
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+
+
+/*
+ * typedef for struct RwPlane
+ */
+typedef struct RwPlane RwPlane;
+/*
+ * This type represents a plane
+ */
+struct RwPlane
+{
+ RwV3d normal; /**< Normal to the plane */
+ RwReal distance; /**< Distance to plane from origin in normal direction*/
+};
+
+
+/****************************************************************************
+ Defines
+ */
+
+enum RwPlaneType
+{
+ rwXPLANE = 0, /* These are deliberately multiples of sizeof(RwReal) */
+ rwYPLANE = 4,
+ rwZPLANE = 8,
+ rwPLANETYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwPlaneType RwPlaneType;
+
+#define rwSECTORATOMIC -1
+#define rwSECTORBUILD -2 /* Only used when building a world */
+
+/* vect is a RwV3d, y is the component */
+#define GETCOORD(vect,y) \
+ (*(RwReal *)(((RwUInt8 *)(&((vect).x)))+(RwInt32)(y)))
+#define GETCONSTCOORD(vect,y) \
+ (*(const RwReal *)(((const RwUInt8 *)(&((vect).x)))+(RwInt32)(y)))
+#define SETCOORD(vect,y,value) \
+ (((*(RwReal *)(((RwUInt8 *)(&((vect).x)))+(RwInt32)(y))))=(value))
+#define SETCONTCOORD(vect,y,value) \
+ (((*(const RwReal *) \
+ (((const RwUInt8 *) \
+ (&((vect).x)))+(RwInt32)(y))))=(value))
+#define GETCOORDINT(vect,y) \
+ (*(RwInt32 *)(((RwUInt8 *)(&((vect).x)))+(y)))
+#define GETCONSTCOORDINT(vect,y) \
+ (*(const RwInt32 *)(((const RwUInt8 *)(&((vect).x)))+(y)))
+
+
+/**
+ * \ingroup rwcore
+ * \page inttypes Integer Types
+ *
+ * RenderWare supports a number of integer types:
+ *
+ * RwInt8 8-bit signed integer.
+ * \li RwUInt8 8-bit unsigned integer.
+ * \li RwChar Character type.
+ * \li RwInt16 16-bit signed integer.
+ * \li RwUInt16 16-bit unsigned integer.
+ * \li RwInt32 32-bit signed integer.
+ * \li RwUInt32 32-bit unsigned integer.
+ * \li RwInt64 64-bit signed integer.
+ * \li RwUInt64 64-bit unsigned integer.
+ * \li RwInt128 128-bit signed integer.
+ * \li RwUInt128 128-bit unsigned integer.
+ * \li RwBool Boolean type (in 32 bits).
+ *
+ * These types should be used in applications in preference to the underlying
+ * native types.
+ *
+ * The following constants indicate the maximum and minimum values possible
+ * for the various RenderWare integer types:
+ *
+ * \li RwInt32MAXVAL Maximum RwInt32 value.
+ * \li RwInt32MINVAL Minimum RwInt32 value.
+ * \li RwUInt32MAXVAL Maximum RwUInt32 value.
+ * \li RwUInt32MINVAL Minimum RwUInt32 value.
+ * \li RwInt16MAXVAL Maximum RwInt16 value.
+ * \li RwInt16MINVAL Minimum RwInt16 value.
+ * \li RwUInt16MAXVAL Maximum RwUInt16 value.
+ * \li RwUInt16MINVAL Minimum RwUInt16 value.
+ *
+ * \see RwReal
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwReal
+ *
+ * RenderWare supports a single RwReal floating-point type to aid portability
+ * across platforms. This type should be used in applications in preference to
+ * the underlying native type.
+ *
+ * The constants RwRealMAXVAL and RwRealMINVAL are provided for determining
+ * the maximum and minimum values possible using the RwReal type.
+ *
+ * In addition, the following macros are available for operations on RwReal
+ * types:
+ * \li RwRealMin2(a, b) Find the minimum of two RwReal values.
+ * \li RwRealMax2(a, b) Find the maximum of two RwReal values.
+ * \li RwRealMin3(a, b, c) Find the minimum of three RwReal values.
+ * \li RwRealMax3(a, b, c) Find the maximum of three RwReal values.
+ * \li RwRealAbs(x) Find the absolute value of a RwReal value.
+ *
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwFixed
+ *
+ * RenderWare supports a single RwFixed fixed-point type.
+ *
+ * Although popular in the days when integer mathematics was much faster than
+ * floating point mathematics, fixed-point math is now rarely used. It is
+ * provided because it is still useful for some processes.
+ *
+ * The maximum and minimum size of an RwFixed value are defined by the constants
+ * RWFIX_MAX and RWFIX_MIN respectively.
+ *
+ * The following macros are provided to help you work with RwFixed datatypes:
+ * \li RwFixedCast(x) Cast the integer portion of an RwFixed to another type.
+ * \li RwFixedToInt(x) Convert an RwFixed to an integer. (The fractional portion is lost.)
+ * \li RwFixedToFloat(x) Convert an RwFixed to a float.
+ * \li RwFixedToReal(x) Convert an RwFixed to an RwReal.
+ * \li RwRealToFixed(x) Convert an RwReal to an RwFixed. (Some precision may be lost.)
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwInt8
+ *
+ * Signed 8 bit integer type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwUInt8
+ *
+ * Unsigned 8bit integer type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwChar
+ *
+ * Character type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwInt16
+ *
+ * Signed 16 bit integer type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwUInt16
+ *
+ * Unsigned 16 bit integer type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwInt32
+ *
+ * Signed 32 bit integer type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwUInt32
+ *
+ * Unsigned 32 bit integer type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwInt64
+ *
+ * Signed 64 bit integer type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwUInt64
+ *
+ * Unsigned 64 bit integer type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwInt128
+ *
+ * Signed 128 bit integer type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwUInt128
+ *
+ * Unsigned 128 bit integer type.
+ * \see \ref inttypes
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwBool
+ *
+ * Boolean type.
+ * \see \ref inttypes
+ */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/batype.h ---*/
+/****************************************************************************
+ Defines
+*/
+
+/*
+ * Object Types - these are used in the binary object
+ * representations and in the debug library. They must
+ * be unique. They are the old system.
+ */
+
+#define rwID_DATABASE 0x64617462 /* datb */
+
+#define MAKECHUNKID(vendorID, chunkID) (((vendorID & 0xFFFFFF) << 8) | (chunkID & 0xFF))
+#define GETOBJECTID(chunkID) (chunkID & 0xFF)
+#define GETVENDORID(chunkID) ((chunkID >> 8) & 0xFFFFFF)
+
+/***
+ *** These are the vendor IDs. A customer must reserve a vendor ID in order
+ *** to be able to write toolkits (this prevents clashes between toolkits).
+ *** We reserve some for our own use as shown below. These are all 24 bit.
+ ***
+ *** IMPORTANT NOTE: DO NOT UNDER ANY CIRCUMSTANCES CHANGE THESE VALUES. IF
+ *** YOU ARE ADDING A NEW ONE, APPEND IT!
+ ***
+ *** They must all be unique.
+ ***/
+
+enum RwPluginVendor
+{
+ rwVENDORID_CORE = 0x000000L,
+ rwVENDORID_CRITERIONTK = 0x000001L,
+ rwVENDORID_REDLINERACER = 0x000002L,
+ rwVENDORID_CSLRD = 0x000003L,
+ rwVENDORID_CRITERIONINT = 0x000004L,
+ rwVENDORID_CRITERIONWORLD = 0x000005L,
+ rwVENDORID_BETA = 0x000006L,
+ rwVENDORID_CRITERIONRM = 0x000007L,
+ rwVENDORID_CRITERIONRWA = 0x000008L, /* RenderWare Audio */
+ rwPLUGINVENDORFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwPluginVendor RwPluginVendor;
+
+/***
+ *** These are the core objects (8 bit IDs). They must all be unique.
+ *** We can get away without using the MAKECHUNKID macro because the
+ *** vendor ID in all cases will be zero (rwVENDORID_CORE).
+ ***
+ *** IMPORTANT NOTE: DO NOT UNDER ANY CIRCUMSTANCES CHANGE THESE VALUES. IF
+ *** YOU ARE ADDING A NEW ONE, APPEND IT!
+ ***/
+
+/* These are the internal ones. Because the core ID is 0, we can get away without
+ * using the MAKECHUNKID macro for the CORE chunks.
+ */
+
+enum RwCorePluginID
+{
+ rwID_NAOBJECT = 0x00,
+ rwID_STRUCT = 0x01,
+ rwID_STRING = 0x02,
+ rwID_EXTENSION = 0x03,
+ rwID_CAMERA = 0x05,
+ rwID_TEXTURE = 0x06,
+ rwID_MATERIAL = 0x07,
+ rwID_MATLIST = 0x08,
+ rwID_ATOMICSECT = 0x09,
+ rwID_PLANESECT = 0x0A,
+ rwID_WORLD = 0x0B,
+ rwID_SPLINE = 0x0C,
+ rwID_MATRIX = 0x0D,
+ rwID_FRAMELIST = 0x0E,
+ rwID_GEOMETRY = 0x0F,
+ rwID_CLUMP = 0x10,
+ rwID_LIGHT = 0x12,
+ rwID_UNICODESTRING = 0x13,
+ rwID_ATOMIC = 0x14,
+ rwID_TEXTURENATIVE = 0x15,
+ rwID_TEXDICTIONARY = 0x16,
+ rwID_ANIMDATABASE = 0x17,
+ rwID_IMAGE = 0x18,
+ rwID_SKINANIMATION = 0x19,
+ rwID_GEOMETRYLIST = 0x1A,
+ rwID_HANIMANIMATION = 0x1B,
+ rwID_TEAM = 0x1C,
+ rwID_CROWD = 0x1D,
+ rwID_DMORPHANIMATION = 0x1E,
+ rwID_RIGHTTORENDER = 0x1f,
+ rwID_MTEFFECTNATIVE = 0x20,
+ rwID_MTEFFECTDICT = 0x21,
+ rwID_TEAMDICTIONARY = 0x22,
+ rwID_PITEXDICTIONARY = 0x23,
+ rwID_TOC = 0x24,
+ rwID_PRTSTDGLOBALDATA = 0x25,
+ /* Insert before MAX and increment MAX */
+ rwID_COREPLUGINIDMAX = 0x26,
+ rwCOREPLUGINIDFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwCorePluginID RwCorePluginID ;
+
+/***
+ *** These are the Criterion internal plugin extensions. Use with rwVENDORID_CRITERIONINT.
+ ***
+ *** IMPORTANT NOTE: DO NOT UNDER ANY CIRCUMSTANCES CHANGE THESE VALUES. IF
+ *** YOU ARE ADDING A NEW ONE, APPEND IT!
+ ***/
+
+enum RwCriterionPluginID
+{
+ rwID_COREPLUGIN = 0x01,
+ rwID_WORLDPLUGIN = 0x02,
+ rwID_TOOLPLUGIN = 0x03,
+ rwID_TOOL2PLUGIN = 0x04,
+ rwCRITERIONPLUGINIDFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwCriterionPluginID RwCriterionPluginID;
+
+
+/***
+ *** These are the Criterion internal platform identifies.
+ ***
+ *** IMPORTANT NOTE: DO NOT UNDER ANY CIRCUMSTANCES CHANGE THESE VALUES. IF
+ *** YOU ARE ADDING A NEW ONE, APPEND IT!
+ ***/
+enum RwPlatformID
+{
+ rwID_PCD3D7 = 1,
+ rwID_PCOGL,
+ rwID_MAC,
+ rwID_PS2,
+ rwID_XBOX,
+ rwID_GAMECUBE,
+ rwID_SOFTRAS,
+ rwID_PCD3D8,
+ rwPLATFROMIDFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwPlatformID RwPlatformID;
+
+
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct RwObject RwObject;
+/**
+ * \ingroup datatypes
+ * \struct RwObject
+ * This should be considered an opaque type. Use
+ * the RwObject API functions to access.
+ */
+struct RwObject
+{
+ RwUInt8 type; /**< Internal Use */
+ RwUInt8 subType; /**< Internal Use */
+ RwUInt8 flags; /**< Internal Use */
+ RwUInt8 privateFlags; /**< Internal Use */
+ void *parent; /**< Internal Use */
+ /* Often a Frame */
+};
+
+/**
+ * \ingroup datatypes
+ * \typedef RwObjectCallBack
+ * callback function supplied for object callback functions.
+ *
+ * \return Pointer to the current object
+ *
+ * \param object Pointer to the current object, supplied by
+ * iterator.
+ * \param data Pointer to developer-defined data structure.
+ *
+ * \see RwFrameForAllObjects
+ *
+ */
+typedef RwObject *(*RwObjectCallBack)(RwObject *object, void *data);
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* TYPE METHODS */
+
+/* Creation/cloning */
+
+#define rwObjectCopy(d,s) \
+MACRO_START \
+{ \
+ ((RwObject *)(d))->type = \
+ ((const RwObject *)(s))->type; \
+ ((RwObject *)(d))->subType = \
+ ((const RwObject *)(s))->subType; \
+ ((RwObject *)(d))->flags = \
+ ((const RwObject *)(s))->flags; \
+ ((RwObject *)(d))->privateFlags = \
+ ((const RwObject *)(s))->privateFlags; \
+ ((RwObject *)(d))->parent = \
+ NULL; \
+} \
+MACRO_STOP
+
+#define rwObjectInitialize(o, t, s) \
+MACRO_START \
+{ \
+ ((RwObject *)(o))->type = (RwUInt8)(t); \
+ ((RwObject *)(o))->subType = (RwUInt8)(s); \
+ ((RwObject *)(o))->flags = 0; \
+ ((RwObject *)(o))->privateFlags = 0; \
+ ((RwObject *)(o))->parent = NULL; \
+} \
+MACRO_STOP
+
+/* Debug */
+#define RwObjectGetType(o) (((const RwObject *)(o))->type)
+
+#define rwObjectSetType(o, t) (((RwObject *)(o))->type) = (RwUInt8)(t)
+
+/* Sub type */
+#define rwObjectGetSubType(o) (((const RwObject *)(o))->subType)
+#define rwObjectSetSubType(o, t) (((RwObject *)(o))->subType) = (RwUInt8)(t)
+
+/* Flags */
+#define rwObjectGetFlags(o) (((const RwObject *)(o))->flags)
+#define rwObjectSetFlags(o, f) (((RwObject *)(o))->flags) = (RwUInt8)(f)
+#define rwObjectTestFlags(o, f) ((((const RwObject *)(o))->flags) & (RwUInt8)(f))
+
+/* Private flags */
+#define rwObjectGetPrivateFlags(c) (((const RwObject *)(c))->privateFlags)
+#define rwObjectSetPrivateFlags(c,f) (((RwObject *)(c))->privateFlags) = (RwUInt8)(f)
+#define rwObjectTestPrivateFlags(c,flag) ((((const RwObject *)(c))->privateFlags) & (RwUInt8)(flag))
+
+/* Hierarchy */
+#define rwObjectGetParent(object) (((const RwObject *)(object))->parent)
+#define rwObjectSetParent(c,p) (((RwObject *)(c))->parent) = (void *)(p)
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/os/win/osintf.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/rwstring.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+#define rwsprintf RWSRCGLOBAL(stringFuncs).vecSprintf
+#define rwvsprintf RWSRCGLOBAL(stringFuncs).vecVsprintf
+#define rwstrcpy RWSRCGLOBAL(stringFuncs).vecStrcpy
+#define rwstrncpy RWSRCGLOBAL(stringFuncs).vecStrncpy
+#define rwstrcat RWSRCGLOBAL(stringFuncs).vecStrcat
+#define rwstrncat RWSRCGLOBAL(stringFuncs).vecStrncat
+#define rwstrrchr RWSRCGLOBAL(stringFuncs).vecStrrchr
+#define rwstrchr RWSRCGLOBAL(stringFuncs).vecStrchr
+#define rwstrstr RWSRCGLOBAL(stringFuncs).vecStrstr
+#define rwstrcmp RWSRCGLOBAL(stringFuncs).vecStrcmp
+#define rwstricmp RWSRCGLOBAL(stringFuncs).vecStricmp
+#define rwstrlen RWSRCGLOBAL(stringFuncs).vecStrlen
+#define rwstrupr RWSRCGLOBAL(stringFuncs).vecStrupr
+#define rwstrlwr RWSRCGLOBAL(stringFuncs).vecStrlwr
+#define rwstrtok RWSRCGLOBAL(stringFuncs).vecStrtok
+#define rwsscanf RWSRCGLOBAL(stringFuncs).vecSscanf
+
+#define rwstrdup(_result, _string) \
+do \
+{ \
+ _result = ((RwChar*)NULL); \
+ \
+ if (((RwChar*)NULL) != (_string)) \
+ { \
+ _result = (RwChar *) \
+ RwMalloc( (rwstrlen(_string) + 1) * \
+ sizeof (RwChar) ); \
+ \
+ if (((RwChar*)NULL) != (_result)) \
+ { \
+ rwstrcpy(_result, _string); \
+ } \
+ } \
+} \
+while (0)
+
+
+/****************************************************************************
+ Global Types
+ */
+
+typedef int (*vecSprintfFunc)(RwChar *buffer,
+ const RwChar *format,
+ ...) /* __RWFORMAT__(printf, 2, 3) */;
+typedef int (*vecVsprintfFunc)(RwChar *buffer,
+ const RwChar *format,
+ va_list argptr);
+typedef RwChar *(*vecStrcpyFunc)(RwChar *dest,
+ const RwChar *srce);
+typedef RwChar *(*vecStrncpyFunc)(RwChar *dest,
+ const RwChar *srce,
+ size_t size);
+typedef RwChar *(*vecStrcatFunc)(RwChar *dest,
+ const RwChar *srce);
+typedef RwChar *(*vecStrncatFunc)(RwChar *dest,
+ const RwChar *srce,
+ size_t size);
+typedef RwChar *(*vecStrrchrFunc)(const RwChar *string,
+ int findThis);
+typedef RwChar *(*vecStrchrFunc)(const RwChar *string,
+ int findThis);
+typedef RwChar *(*vecStrstrFunc)(const RwChar *string,
+ const RwChar *findThis);
+typedef int (*vecStrcmpFunc)(const RwChar *string1,
+ const RwChar *string2);
+typedef int (*vecStricmpFunc)(const RwChar *string1,
+ const RwChar *string2);
+typedef size_t (*vecStrlenFunc)(const RwChar *string);
+typedef RwChar *(*vecStruprFunc)(RwChar *string);
+typedef RwChar *(*vecStrlwrFunc)(RwChar *string);
+typedef RwChar *(*vecStrtokFunc)(RwChar *string, const RwChar *delimit);
+typedef int (*vecSscanfFunc)(const RwChar *buffer,
+ const RwChar *format,
+ ...) /* __RWFORMAT__(scanf, 2, 3) */;
+
+typedef struct RwStringFunctions RwStringFunctions;
+struct RwStringFunctions
+{
+ vecSprintfFunc vecSprintf ;
+ vecVsprintfFunc vecVsprintf;
+ vecStrcpyFunc vecStrcpy;
+ vecStrncpyFunc vecStrncpy;
+ vecStrcatFunc vecStrcat;
+ vecStrncatFunc vecStrncat;
+ vecStrrchrFunc vecStrrchr;
+ vecStrchrFunc vecStrchr;
+ vecStrstrFunc vecStrstr;
+ vecStrcmpFunc vecStrcmp;
+ vecStricmpFunc vecStricmp;
+ vecStrlenFunc vecStrlen;
+ vecStruprFunc vecStrupr;
+ vecStrlwrFunc vecStrlwr;
+ vecStrtokFunc vecStrtok;
+ vecSscanfFunc vecSscanf;
+};
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/rwdbgerr.h ---*/
+#define RWECODE(a,b) a,
+
+/* Construct an enum type with all the plugin error codes (for the app to use) */
+enum RwErrorCodePlugin_errcore
+{
+#include "errcore.def"
+ rwLASTERROR_errcore = RWFORCEENUMSIZEINT
+};
+typedef enum RwErrorCodePlugin_errcore RwErrorCodePlugin_errcore;
+
+
+#undef RWECODE
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/resmem.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bamemory.h ---*/
+#if (defined(RWMEMDEBUG))
+#ifdef _XBOX
+/* Need OutputDebugString macros */
+#include <xtl.h>
+#endif
+#endif
+
+/****************************************************************************
+ Defines
+ */
+
+/*
+ * Debug fill bytes for compatibility with MSVC/C++ debug heap
+ * See
+ * \Program Files\Microsoft Visual Studio\VC98\CRT\SRC\DBGHEAP.C:
+ * static unsigned char _bNoMansLandFill = 0xFD;
+ * // fill no-man's land with this
+ * static unsigned char _bDeadLandFill = 0xDD;
+ * // fill free objects with this
+ * static unsigned char _bCleanLandFill = 0xCD;
+ * // fill new objects with this
+ */
+
+#if (!defined(rwFREELISTNOMANSLANDFILL))
+#define rwFREELISTNOMANSLANDFILL 0xFD
+#endif /* (!defined(rwFREELISTNOMANSLANDFILL)) */
+
+#if (!defined(rwFREELISTDEADLANDFILL))
+#define rwFREELISTDEADLANDFILL 0xDD
+#endif /* (!defined(rwFREELISTDEADLANDFILL)) */
+
+#if (!defined(rwFREELISTCLEANLANDFILL))
+#define rwFREELISTCLEANLANDFILL 0xCD
+#endif /* (!defined(rwFREELISTCLEANLANDFILL)) */
+
+#define RWFREELISTALIGNED(_pData, _freelist) \
+ (! (((RwUInt32)(_pData)) & ((_freelist)->alignmentMinusOne)) )
+
+/*****************************
+ * REGULAR MEMORY ALLOCATION *
+ *****************************/
+
+/**
+ * \ingroup rwmem
+ * \def RwMalloc
+ * RwMalloc(_s) is a macro for malloc(_s).
+ */
+
+/**
+ * \ingroup rwmem
+ * \def RwFree
+ * RwFree(_p) is a macro for free(_p).
+ */
+
+/**
+ * \ingroup rwmem
+ * \def RwCalloc
+ * RwCalloc(_n, _s) is a macro for calloc(_n, _s).
+ */
+
+/**
+ * \ingroup rwmem
+ * \def RwRealloc
+ * RwRealloc(_p, _s) is a macro for realloc(_p, _s).
+ */
+
+#if ( (defined(RWMEMDEBUG)) && defined(RWDEBUG) )
+
+#if (!defined(RWNOFREELISTS))
+#define RWNOFREELISTS
+#endif /* (!defined(RWNOFREELISTS)) */
+
+#if (defined(rwPLUGIN_ID))
+#define _CLIENT_TAG \
+ ( 0xFFFF & (rwPLUGIN_ID) )
+#endif /* (defined(rwPLUGIN_ID)) */
+
+#if (!defined(_CLIENT_TAG))
+#define _CLIENT_TAG \
+ ( 0xFFFF & (MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x00) ) )
+#endif /* (!defined(_CLIENT_TAG)) */
+
+# if (defined(_MSC_VER))
+# if ((_MSC_VER>=1000) && defined(_DEBUG))
+
+/* Pick up _ASSERTE() macro */
+/* #include <windows.h> */
+#if (defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC))
+#define _CRTDBG_MAP_ALLOC
+#endif /* defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) */
+#include <crtdbg.h>
+
+#define RwMalloc(_s) \
+ _malloc_dbg((_s), \
+ _CLIENT_BLOCK | ((_CLIENT_TAG)<<16), \
+ __FILE__, \
+ __LINE__)
+
+#define RwFree(_p) \
+ _free_dbg((_p), \
+ _CLIENT_BLOCK | ((_CLIENT_TAG)<<16))
+
+#define RwCalloc(_n, _s) \
+ _calloc_dbg((_n), (_s), \
+ _CLIENT_BLOCK | ((_CLIENT_TAG)<<16), \
+ __FILE__, \
+ __LINE__)
+
+#define RwRealloc(_p, _s) \
+ _realloc_dbg((_p), \
+ (_s), \
+ _CLIENT_BLOCK | ((_CLIENT_TAG)<<16), \
+ __FILE__, \
+ __LINE__)
+
+#define RWCRTORDBGFLAG(_flag) \
+ do \
+ { \
+ int _DbgFlag; \
+ \
+ _DbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); \
+ _DbgFlag |= (_flag); \
+ _CrtSetDbgFlag(_DbgFlag); \
+ } while(0)
+
+#define VALID_HEAP_STR \
+ __FILE__##"("##RW_STRINGIFY_EXPANDED(__LINE__)##"): valid heap\n"
+
+#define RWCRTCHECKMEMORY() \
+ do \
+ { \
+ int valid_heap; \
+ \
+ valid_heap = _CrtCheckMemory(); \
+ _ASSERTE(valid_heap); \
+ } while(0)
+
+/*
+ * if (valid_heap) \
+ * OutputDebugString(VALID_HEAP_STR); \
+ */
+
+#define NO_LEAKS_FOUND_STR \
+ __FILE__##"("##RW_STRINGIFY_EXPANDED(__LINE__)##"): no heap leaks found\n"
+
+#define RWCRTDUMPMEMORYLEAKS() \
+ do \
+ { \
+ int leaks_found; \
+ \
+ leaks_found = _CrtDumpMemoryLeaks(); \
+ _ASSERTE(!leaks_found); \
+ if (!leaks_found) \
+ OutputDebugString(NO_LEAKS_FOUND_STR); \
+ } while(0)
+
+#define HEAP_DIFFERENCES_FOUND_STR \
+ __FILE__##"("##RW_STRINGIFY_EXPANDED(__LINE__)##"): heap differences found\n"
+
+#define NO_DIFFERENCES_FOUND_STR \
+ __FILE__##"("##RW_STRINGIFY_EXPANDED(__LINE__)##"): no heap differences found\n"
+
+#define RWCRTHEAPDIFFERENCESINCE(_Then) \
+ do \
+ { \
+ /* only dump differences when \
+ * there are in fact differences */ \
+ _CrtMemState _Now; \
+ _CrtMemState _Delta; \
+ const int _DbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); \
+ int Differences; \
+ \
+ _CrtMemCheckpoint(&_Now); \
+ _CrtMemDifference(&_Delta, _Then, &_Now); \
+ \
+ (Differences) = ( ( 0 != _Delta.lCounts[_CLIENT_BLOCK] ) || \
+ ( 0 != _Delta.lCounts[_NORMAL_BLOCK] ) || \
+ ( (_DbgFlag & _CRTDBG_CHECK_CRT_DF) && \
+ ( 0 != _Delta.lCounts[_CRT_BLOCK]) ) ); \
+ \
+ if ( (Differences) ) \
+ { \
+ /* difference detected: dump objects since _Then. */ \
+ OutputDebugString(HEAP_DIFFERENCES_FOUND_STR); \
+ _CrtMemDumpAllObjectsSince(_Then); \
+ _CrtMemDumpStatistics(&_Delta); \
+ } \
+ else \
+ { \
+ OutputDebugString(NO_DIFFERENCES_FOUND_STR); \
+ } \
+ } while (0)
+
+#define RWCRTDBGBREAK() \
+ _CrtDbgBreak()
+
+#define RWCRTDOFORALLCLIENTOBJECTS(_f, _c) \
+ _CrtDoForAllClientObjects(_f, _c)
+
+#define RWCRTISMEMORYBLOCK(_p, _t, _r, _f, _l) \
+ _CrtIsMemoryBlock(_p, _t, _r, _f, _l)
+
+#define RWCRTISVALIDHEAPPOINTER(_p) \
+ _CrtIsValidHeapPointer(_p)
+
+#define RWCRTISVALIDPOINTER(_p, _n, _r) \
+ _CrtIsValidPointer(_p, _n, _r)
+
+#define RWCRTMEMCHECKPOINT(_s) \
+ _CrtMemCheckpoint(_s)
+
+#define RWCRTMEMDIFFERENCE(_s1, _s2, _s3) \
+ _CrtMemDifference(_s1, _s2, _s3)
+
+#define RWCRTMEMDUMPALLOBJECTSSINCE(_s) \
+ _CrtMemDumpAllObjectsSince(_s)
+
+#define RWCRTMEMDUMPSTATISTICS(_s) \
+ _CrtMemDumpStatistics(_s)
+
+#define RWCRTSETALLOCHOOK(_f) \
+ _CrtSetAllocHook(_f)
+
+#define RWCRTSETBREAKALLOC(_a) \
+ _CrtSetBreakAlloc(_a)
+
+#define RWCRTSETDBGFLAG(_f) \
+ _CrtSetDbgFlag(_f)
+
+#define RWCRTSETDUMPCLIENT(_f) \
+ _CrtSetDumpClient(_f)
+
+#define RWCRTSETREPORTFILE(_t, _f) \
+ _CrtSetReportFile(_t, _f)
+
+#define RWCRTSETREPORTHOOK(_f) \
+ _CrtSetReportHook(_f)
+
+#define RWCRTSETREPORTMODE(_t, _f) \
+ _CrtSetReportMode(_t, _f)
+
+#if (!defined(_CRTDBG_FLAGS))
+#define _CRTDBG_FLAGS \
+ ( (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_DELAY_FREE_MEM_DF | \
+ _CRTDBG_CHECK_CRT_DF | _CRTDBG_LEAK_CHECK_DF) & \
+ ~(_CRTDBG_CHECK_ALWAYS_DF |_CRTDBG_RESERVED_DF) )
+#endif /* (!defined(_CRTDBG_FLAGS)) */
+
+# endif /* ((_MSC_VER>=1000) && defined(_DEBUG)) */
+# endif /* (defined(_MSC_VER)) */
+
+
+
+#if (!defined(rwDEADPTRFILL))
+#define rwDEADPTRFILL ((void *)0xDDDDDDDD)
+#endif /* (!defined(rwDEADPTRFILL)) */
+
+#endif /* (defined(RWDEBUG) && (defined(RWMEMDEBUG))) */
+
+#if (!defined(rwDEADPTRFILL))
+#define rwDEADPTRFILL (NULL)
+#endif /* (!defined(rwDEADPTRFILL)) */
+
+#if (!defined(RwMalloc))
+#define RwMalloc(_s) ((RWSRCGLOBAL(memoryFuncs).rwmalloc)((_s)))
+#endif /* (!defined(RwMalloc)) */
+
+#if (!defined(RwFree))
+#define RwFree(_p) ((RWSRCGLOBAL(memoryFuncs).rwfree)((_p)))
+#endif /* (!defined(RwFree)) */
+
+#if (!defined(RwCalloc))
+#define RwCalloc(_n, _s) ((RWSRCGLOBAL(memoryFuncs).rwcalloc)((_n), (_s)))
+#endif /* (!defined(RwCalloc)) */
+
+#if (!defined(RwRealloc))
+#define RwRealloc(_p, _s) ((RWSRCGLOBAL(memoryFuncs).rwrealloc)((_p),(_s)))
+#endif /* (!defined(RwRealloc)) */
+
+#if (!defined(RWCRTORDBGFLAG))
+#define RWCRTORDBGFLAG(_flag) /* No op */
+#endif /* (!defined(RWCRTORDBGFLAG)) */
+
+#if (!defined(RWCRTCHECKMEMORY))
+#define RWCRTCHECKMEMORY() /* No Op */
+#endif /* (!defined(RWCRTCHECKMEMORY)) */
+
+#if (!defined(RWCRTDBGBREAK))
+#define RWCRTDBGBREAK() /* No Op */
+#endif /* (!defined(RWCRTDBGBREAK)) */
+
+#if (!defined(RWCRTDOFORALLCLIENTOBJECTS))
+#define RWCRTDOFORALLCLIENTOBJECTS(_f, _c) /* No Op */
+#endif /* (!defined(RWCRTDOFORALLCLIENTOBJECTS)) */
+
+#if (!defined(RWCRTDUMPMEMORYLEAKS))
+#define RWCRTDUMPMEMORYLEAKS() /* No Op */
+#endif /* (!defined(RWCRTDUMPMEMORYLEAKS)) */
+
+#if (!defined(RWCRTHEAPDIFFERENCESINCE))
+#define RWCRTHEAPDIFFERENCESINCE(_Then) /* No Op */
+#endif /* (!defined(RWCRTHEAPDIFFERENCESINCE)) */
+
+#if (!defined(RWCRTISMEMORYBLOCK))
+#define RWCRTISMEMORYBLOCK(_p, _t, _r, _f, _l) (NULL != (_p))
+#endif /* (!defined(RWCRTISMEMORYBLOCK)) */
+
+#if (!defined(RWCRTISVALIDHEAPPOINTER))
+#define RWCRTISVALIDHEAPPOINTER(_p) (NULL != (_p))
+#endif /* (!defined(RWCRTISVALIDHEAPPOINTER)) */
+
+#if (!defined(RWCRTISVALIDPOINTER))
+#define RWCRTISVALIDPOINTER(_p, _n, _r) (NULL != (_p))
+#endif /* (!defined(RWCRTISVALIDPOINTER)) */
+
+#if (!defined(RWCRTMEMCHECKPOINT))
+#define RWCRTMEMCHECKPOINT(_s) /* No Op */
+#endif /* (!defined(RWCRTMEMCHECKPOINT)) */
+
+#if (!defined(RWCRTMEMDIFFERENCE))
+#define RWCRTMEMDIFFERENCE(_s1, _s2, _s3) /* No Op */
+#endif /* (!defined(RWCRTMEMDIFFERENCE)) */
+
+#if (!defined(RWCRTMEMDUMPALLOBJECTSSINCE))
+#define RWCRTMEMDUMPALLOBJECTSSINCE(_s) /* No Op */
+#endif /* (!defined(RWCRTMEMDUMPALLOBJECTSSINCE)) */
+
+#if (!defined(RWCRTMEMDUMPSTATISTICS))
+#define RWCRTMEMDUMPSTATISTICS(_s) (NULL)
+#endif /* (!defined(RWCRTMEMDUMPSTATISTICS)) */
+
+#if (!defined(RWCRTSETALLOCHOOK))
+#define RWCRTSETALLOCHOOK(_f) (NULL)
+#endif /* (!defined(RWCRTSETALLOCHOOK)) */
+
+#if (!defined(RWCRTSETBREAKALLOC))
+#define RWCRTSETBREAKALLOC(_a) (0)
+#endif /* (!defined(RWCRTSETBREAKALLOC)) */
+
+#if (!defined(RWCRTSETDBGFLAG))
+#define RWCRTSETDBGFLAG(_f) (0)
+#endif /* (!defined(RWCRTSETDBGFLAG)) */
+
+#if (!defined(RWCRTSETDUMPCLIENT))
+#define RWCRTSETDUMPCLIENT(_f) (NULL)
+#endif /* (!defined(RWCRTSETDUMPCLIENT)) */
+
+#if (!defined(RWCRTSETREPORTFILE))
+#define RWCRTSETREPORTFILE(_t, _f) (NULL)
+#endif /* (!defined(RWCRTSETREPORTFILE)) */
+
+#if (!defined(RWCRTSETREPORTHOOK))
+#define RWCRTSETREPORTHOOK(_f) (NULL)
+#endif /* (!defined(RWCRTSETREPORTHOOK)) */
+
+#if (!defined(RWCRTSETREPORTMODE))
+#define RWCRTSETREPORTMODE(_t, _f) (0)
+#endif /* (!defined(RWCRTSETREPORTMODE)) */
+
+#if (!defined(RWREGSETBREAKALLOC))
+#define RWREGSETBREAKALLOC(_name) /* No op */
+#endif /* (!defined(RWREGSETBREAKALLOC)) */
+
+#if (!defined(RWREGSETASSERTPRINT))
+#define RWREGSETASSERTPRINT(_name) /* No op */
+#endif /* (!defined(RWREGSETASSERTPRINT)) */
+
+#if (!defined(RWGETWINREGDWORD))
+#define RWGETWINREGDWORD(_env_var, _match) /* No op */
+#endif /* (!defined(RWGETWINREGDWORD)) */
+
+#if (!defined(RWGETWINREGBINARY))
+#define RWGETWINREGBINARY(_env_var, _match) /* No op */
+#endif /* (!defined(RWGETWINREGBINARY)) */
+
+#if (!defined(RWGETWINREGSTRING))
+#define RWGETWINREGSTRING(_env_var, _match) /* No op */
+#endif /* (!defined(RWGETWINREGSTRING)) */
+
+#if (!defined(_CRTDBG_FLAGS))
+#define _CRTDBG_FLAGS 0x33
+#endif /* (!defined(_CRTDBG_FLAGS)) */
+
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct RwMemoryFunctions RwMemoryFunctions;
+/**
+ * \ingroup datatypes
+ * \struct RwMemoryFunctions
+ * This type represents the memory functions used
+ * by RenderWare. By default, the standard ANSI functions are used. The
+ * application may install an alternative interface providing that it is ANSI
+ * compliant (see API function \ref RwEngineInit):
+ */
+struct RwMemoryFunctions
+{
+ /* c.f.
+ * Program Files/Microsoft Visual Studio/VC98/Include/MALLOC.H
+ */
+ void *(*rwmalloc)(size_t size); /**< rwmalloc malloc */
+ void (*rwfree)(void *mem); /**< rwfree free */
+ void *(*rwrealloc)(void *mem, size_t newSize); /**< rwrealloc realloc */
+ void *(*rwcalloc)(size_t numObj, size_t sizeObj); /**< calloc calloc */
+};
+
+typedef struct RwFreeBlock RwFreeBlock;
+/*
+ * Freelists -- from Page 131
+ * Advanced Animation and Rendering Techniques
+ * Alan Watt and Mark Watt
+ * Addison-Wesley 1993,
+ * ISBN 0-201-54412-1:
+ *
+ * "Lastly, on a more general note concerning speedups for renderers, the
+ * implementor should be aware that a lot of suggestions for improving
+ * efficiency fall into the category of ingenious, but complex,
+ * algorithms for very specific contexts that may save a few microseconds
+ * but which make your code unreadable. A more general computer science
+ * perspective that takes a `global view' of the renderer can be more
+ * fruitful. For example, the renderer devotes a lot of time to
+ * allocating and deallocating chunks of memory for storing data. A lot
+ * of these chunks are always the same size - such as those that are
+ * continually required to store the data structure for fragment lists.
+ * Using memory management techniques that recognize this fact can yield
+ * considerable dividends. One such scheme would be to hold a series of
+ * empty lists in memory for all the commonly used data structures. An
+ * empty list for fragments, say, would contain a list of previously
+ * allocated, but no longer needed, fragment structures. When the
+ * renderer needs memory for a new fragment, it looks first at this empty
+ * list. If there is nothing there it allocates space directly,
+ * otherwise it takes a fragments off the end of the list and uses that.
+ * Conversely, when the renderer no longer needs a fragment, instead of
+ * freeing it, it goes onto the end of the empty list. In the authors'
+ * experience, replacing the naive allocate/deallocate scheme with this
+ * way of managing memory can result in 100% speedup. "
+ */
+struct RwFreeBlock
+{
+ RwFreeBlock *nextBlock;
+};
+
+typedef struct RwFreeList RwFreeList;
+struct RwFreeList
+{
+ void **freeListStack; /* Stack of unused entries */
+ void **freeListStackTop; /* Pointer to the top of the stack */
+
+ RwFreeBlock *firstBlock; /* Data start */
+
+ RwInt32 blockSize; /* Size of block in bytes */
+ RwInt32 entrySize; /* Entry size */
+ RwInt32 alignmentMinusOne; /* Entry alignment minus 1 */
+ RwInt32 entriesPerBlock; /* Amount of space in a block */
+
+ RwInt32 entriesAllocated; /* Total slots allocated
+ * (but not necessarily being used */
+
+ /* All freelists */
+ RwLLLink lFreeList;
+
+#if (defined(RWDEBUG) && !defined(DOXYGEN))
+ const RwChar *fileCreate;
+ RwUInt32 lineCreate;
+#endif /* (defined(RWDEBUG) && !defined(DOXYGEN)) */
+};
+
+/**
+ * \ingroup datatypes
+ * \ref RwFreeListCallBack represents
+ * the function called from \ref RwFreeListForAllUsed for all used entries in a
+ * given free list.
+ *
+ * \param pMem Pointer to the start of the current entries.
+ *
+ * \param pData User-defined data pointer.
+ *
+ * \see RwFreeListForAllUsed
+ *
+ */
+typedef void (*RwFreeListCallBack) (void *pMem, void *pData);
+typedef void *(*RwMemoryAllocFn) (RwFreeList * fl);
+typedef RwFreeList *(*RwMemoryFreeFn) (RwFreeList * fl, void *pData);
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwMemoryFunctions *RwOsGetMemoryInterface(void);
+
+/*************
+ * FREELISTS *
+ *************/
+
+/* Allocation and freeing */
+#if (defined(RWDEBUG) && !defined(DOXYGEN))
+
+extern RwFreeList *_rwFreeListCreate(RwInt32 entrySize,
+ RwInt32 entriesPerBlock,
+ RwInt32 alignment,
+ const RwChar *fileCreate,
+ RwUInt32 lineCreate );
+
+#define RwFreeListCreate(entrySize, entriesPerBlock, alignment) \
+ _rwFreeListCreate(entrySize, \
+ entriesPerBlock, \
+ alignment, \
+ __FILE__, \
+ __LINE__)
+#else /* (defined(RWDEBUG) && !defined(DOXYGEN)) */
+
+extern RwFreeList *RwFreeListCreate(RwInt32 entrySize,
+ RwInt32 entriesPerBlock,
+ RwInt32 alignment);
+#endif /* (defined(RWDEBUG) && !defined(DOXYGEN)) */
+
+extern RwBool RwFreeListDestroy(RwFreeList * freelist);
+/* Garbage collection/enumeration */
+extern RwInt32 RwFreeListPurge(RwFreeList * freelist);
+extern RwFreeList *RwFreeListForAllUsed(RwFreeList * freelist,
+ RwFreeListCallBack
+ fpCallBack, void *pData);
+extern RwInt32 RwFreeListPurgeAllFreeLists(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#if (defined(RWDEBUG) && defined(RWNOFREELISTS) && !defined(RWKEEPFREELISTS))
+
+#if ((defined(__MWERKS__) || defined(__GNUC__)) && defined(__R5900__))
+
+/*
+ * for more on memalign, see
+ * http://www.gnu.org/manual/glibc-2.0.6/html_chapter/libc_3.html#SEC28
+ */
+#include <rtdbmalloc.h>
+
+#define RwFreeListAlloc(_f) \
+ memalign((1 + (_f)->alignmentMinusOne), (_f)->entrySize)
+
+#else /* ((defined(__MWERKS__) || defined(__GNUC__)) && defined(__R5900__)) */
+
+#define RwFreeListAlloc(_f) \
+ RwMalloc((_f)->entrySize)
+
+#endif /* ((defined(__MWERKS__) || defined(__GNUC__)) && defined(__R5900__)) */
+
+#define RwFreeListFree(_f, _p) \
+ RwFree((_p))
+
+#endif /* (defined(RWDEBUG) && defined(RWNOFREELISTS) && !defined(RWKEEPFREELISTS)) */
+
+#if (!defined(RwFreeListAlloc))
+#define RwFreeListAlloc(_f) \
+ RWSRCGLOBAL(memoryAlloc)(_f)
+#endif /* (!defined(RwFreeListAlloc)) */
+
+#if (!defined(RwFreeListFree))
+#define RwFreeListFree(_f, _p) \
+ RWSRCGLOBAL(memoryFree)(_f, _p)
+#endif /* (!defined(RwFreeListFree)) */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bastream.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+#define rwSTREAMSTACKSIZE 512
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * \ref RwStreamType
+ * This type represents the different types of stream that
+ * can be used.
+ * See API section \ref rwstream
+ */
+enum RwStreamType
+{
+ rwNASTREAM = 0, /**<Invalid stream type */
+ rwSTREAMFILE, /**<File */
+ rwSTREAMFILENAME, /**<File name */
+ rwSTREAMMEMORY, /**<Memory*/
+ rwSTREAMCUSTOM, /**<Custom */
+ rwSTREAMTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwStreamType RwStreamType;
+
+/**
+ * \ingroup datatypes
+ * \ref RwStreamAccessType
+ * This type represents the options available for
+ * accessing a stream when it is opened.
+ * See API section \ref rwstream */
+enum RwStreamAccessType
+{
+ rwNASTREAMACCESS = 0, /**<Invalid stream access */
+ rwSTREAMREAD, /**<Read */
+ rwSTREAMWRITE, /**<Write */
+ rwSTREAMAPPEND, /**<Append */
+ rwSTREAMACCESSTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwStreamAccessType RwStreamAccessType;
+
+/* Memory stream */
+/**
+ * \ingroup datatypes
+ * \typedef RwStreamMemory
+ * This should be considered an opaque type.
+ * Use the RwStream API functions to access.
+ */
+typedef struct RwStreamMemory RwStreamMemory;
+#if (!defined(DOXYGEN))
+struct RwStreamMemory
+{
+ RwUInt32 position; /* Current 'memory' position 0 is first byte */
+ RwUInt32 nSize; /* Space allocated currently */
+ RwUInt8 *memBlock; /* Current memory block pointer */
+};
+#endif /* (!defined(DOXYGEN)) */
+
+
+typedef union RwStreamFile RwStreamFile;
+/**
+ * \ingroup datatypes
+ * \union RwStreamFile
+ * This type is used to represent a file pointer for
+ * accessing data on disk through the stream mechanism.
+ * See API section \ref rwstream. */
+union RwStreamFile
+{
+ void *fpFile; /**< file pointer */
+ const void *constfpFile; /**< const file pointer */
+};
+
+
+/* Custom stream function pointer types */
+typedef RwBool(*rwCustomStreamFnClose) (void *data);
+typedef RwUInt32(*rwCustomStreamFnRead) (void *data, void *buffer,
+ RwUInt32 length);
+typedef RwBool(*rwCustomStreamFnWrite) (void *data,
+ const void *buffer,
+
+ RwUInt32 length);
+typedef RwBool(*rwCustomStreamFnSkip) (void *data,
+
+ RwUInt32 offset);
+
+/* Custom stream */
+/**
+ * \ingroup datatypes
+ * \typedef RwStreamCustom
+ * This should be considered an opaque type.
+ * Use the RwStream API functions to access.
+ */
+typedef struct RwStreamCustom RwStreamCustom;
+#if (!defined(DOXYGEN))
+struct RwStreamCustom
+{
+ rwCustomStreamFnClose sfnclose;
+ rwCustomStreamFnRead sfnread;
+ rwCustomStreamFnWrite sfnwrite;
+ rwCustomStreamFnSkip sfnskip;
+ void *data;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/* Stream */
+
+typedef union RwStreamUnion RwStreamUnion;
+/**
+ * \ingroup datatypes
+ * \union RwStreamUnion
+ * The union of all supported stream types
+ */
+union RwStreamUnion
+{
+ RwStreamMemory memory; /**< memory */
+ RwStreamFile file; /**< file */
+ RwStreamCustom custom; /**< custom */
+};
+
+/**
+ * \ingroup datatypes
+ * \typedef RwStream
+ * Binary stream for reading or writing object data.
+ * This should be considered an opaque type.
+ * Use the RwStream API functions to access.
+ */
+typedef struct RwStream RwStream;
+#if (!defined(DOXYGEN))
+struct RwStream
+{
+ RwStreamType type;
+ RwStreamAccessType accessType;
+ RwInt32 position;
+ RwStreamUnion Type;
+ RwBool rwOwned;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+
+typedef struct RwMemory RwMemory;
+/**
+ * \ingroup datatypes
+ * \struct RwMemory
+ * This type represents a block of allocated memory.
+ * It is used to specify an area of memory connected to a stream of type
+ * rwSTREAMMEMORY.
+ * See \ref rwstream */
+struct RwMemory
+{
+ RwUInt8 *start; /**< starting address */
+ RwUInt32 length; /**< length in bytes*/
+};
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Open/Close streams */
+
+extern RwStream *
+_rwStreamInitialize(RwStream *stream,
+ RwBool rwOwned,
+ RwStreamType type,
+ RwStreamAccessType accessType,
+ const void *pData);
+
+extern RwStream *
+RwStreamOpen(RwStreamType type,
+ RwStreamAccessType accessType,
+ const void *pData);
+
+extern RwBool
+RwStreamClose(RwStream * stream,
+ void *pData);
+
+
+/* Stream read/write */
+extern RwUInt32
+RwStreamRead(RwStream * stream,
+ void *buffer,
+ RwUInt32 length);
+
+extern RwStream *
+RwStreamWrite(RwStream * stream,
+ const void *buffer,
+ RwUInt32 length);
+
+
+/* Stream skipping */
+extern RwStream *
+RwStreamSkip(RwStream * stream,
+ RwUInt32 offset);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/batkreg.h ---*/
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * \ref RwPluginDataChunkWriteCallBack represents the function
+ * registered by \ref RwCameraRegisterPluginStream, etc. as the function that
+ * writes extension data to a binary stream.
+ *
+ * \param stream Pointer to the binary stream
+ *
+ * \param binaryLength A RwInt32 value equal to the binary
+ * size (in bytes) of the extension data that will be written to the binary
+ * stream.
+ *
+ * \param object Pointer to the object containing the extension
+ * data.
+ *
+ * \param offsetInObject A RwInt32 value equal to the byte
+ * offset of the extension data in the object.
+ *
+ * \param sizeInObject A RwInt32 value equal to the size
+ * (in bytes) of the extension data.
+ *
+ * \return Pointer to the stream
+ */
+typedef RwStream *(*RwPluginDataChunkWriteCallBack)(RwStream *stream, RwInt32 binaryLength, const void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+
+/**
+ * \ingroup datatypes
+ * \ref RwPluginDataChunkReadCallBack represents the function
+ * registered by \ref RwCameraRegisterPluginStream, etc. as the function that
+ * reads extension data from a binary stream.
+ *
+ * \param stream Pointer to the binary stream
+ *
+ * \param binaryLength A RwInt32 value equal to the binary
+ * size (in bytes) of the extension data that will be read from a binary
+ * stream.
+ *
+ * \param object Pointer to the object containing the extension
+ * data.
+ *
+ * \param offsetInObject A RwInt32 value equal to the byte
+ * offset of the extension data in the object.
+ *
+ * \param sizeInObject A RwInt32 value equal to the size
+ * (in bytes) of the extension data.
+ *
+ * \return Pointer to the stream
+ */
+typedef RwStream *(*RwPluginDataChunkReadCallBack)(RwStream *stream, RwInt32 binaryLength, void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+
+/**
+ * \ingroup datatypes
+ * \ref RwPluginDataChunkGetSizeCallBack represents the callback
+ * registered by \ref RwCameraRegisterPluginStream, etc. as the function that
+ * determines the binary size of the extension data.
+ *
+ * \param object Pointer to the object containing the extension data.
+ *
+ * \param offsetInObject A RwInt32 value equal to the byte
+ * offset of the extension data in the object.
+ *
+ * \param sizeInObject A RwInt32 value equal to the size
+ * (in bytes) of the extension data.
+ *
+ * \return A RwInt32 value equal to the size in bytes of the plugin extension data.
+ */
+typedef RwInt32(*RwPluginDataChunkGetSizeCallBack)(const void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+
+/**
+ * \ingroup datatypes
+ * \ref RwPluginDataChunkAlwaysCallBack represents the callback
+ * registered by \ref RwCameraSetStreamAlwaysCallBack, etc. as the
+ * function that is called after the reading of plugin stream data is
+ * finished (useful to set up plugin data for plugins that found no
+ * data in the stream, but that cannot set up the data during the
+ * \ref RwPluginObjectConstructor callback).
+ *
+ * \param object Pointer to the object containing the extension data.
+ *
+ * \param offsetInObject A RwInt32 value equal to the byte
+ * offset of the extension data in the object.
+ *
+ * \param sizeInObject A RwInt32 value equal to the size
+ * (in bytes) of the extension data.
+ */
+typedef RwBool(*RwPluginDataChunkAlwaysCallBack)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+
+/**
+ * \ingroup datatypes
+ * \ref RwPluginDataChunkRightsCallBack represents the callback
+ * registered by RwCameraSetStreamRightsCallBack, etc. as the
+ * function that is called after the reading of plugin stream data is
+ * finished, and the object finalised, if and only if the object's rights
+ * id was equal to that of the plugin registering the call.
+ * For convience the extension data is passed to the callback.
+ *
+ * \param object Pointer to the object containing the extension data.
+ *
+ * \param offsetInObject A RwInt32 value equal to the byte
+ * offset of the extension data in the object.
+ *
+ * \param sizeInObject A RwInt32 value equal to the size
+ * (in bytes) of the extension data.
+ *
+ * \param extraData An RwUInt32 writen with the plugin id.
+ */
+typedef RwBool(*RwPluginDataChunkRightsCallBack)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject, RwUInt32 extraData);
+
+/**
+ * \ingroup datatypes
+ * \ref RwPluginObjectConstructor represents the callback
+ * registered by \ref RwEngineRegisterPlugin, \ref RwCameraRegisterPlugin, etc.
+ * as the function that initializes either the global extension data (in the
+ * case of \ref RwEngineRegisterPlugin) or the object extension data (in all
+ * other cases). Registered by \ref RwCameraSetStreamAlwaysCallBack, etc.
+ *
+ * \param object Pointer to the object (global or otherwise)
+ * that contains the extension data.
+ *
+ * \param offsetInObject A RwInt32 value equal to the
+ * byte offset of the extension data in the object.
+ *
+ * \param sizeInObject A RwInt32 value equal to the size
+ * (in bytes) of the extension data.
+ *
+ * \return Pointer to the object
+ */
+typedef void *(*RwPluginObjectConstructor)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+
+/**
+ * \ingroup datatypes
+ * \ref RwPluginObjectCopy represents the callback registered by
+ * \ref RwCameraRegisterPlugin, etc. as the function that copies the object
+ * extension data when an object is duplicated.
+ *
+ * \param dstObject Pointer to the destination object that will
+ * receive the extension data.
+ *
+ * \param srcObject Pointer to the source object containing
+ * extension data.
+ *
+ * \param offsetInObject A RwInt32 value equal to the byte offset
+ * of the extension data in the object.
+ *
+ * \param sizeInObject A RwInt32 value equal to the size
+ * (in bytes) of the extension data.
+ *
+ * \return Pointer to the object
+ */
+typedef void *(*RwPluginObjectCopy)(void *dstObject, const void *srcObject, RwInt32 offsetInObject, RwInt32 sizeInObject);
+
+/**
+ * \ingroup datatypes
+ * \ref RwPluginObjectDestructor represents the callback registered
+ * by \ref RwEngineRegisterPlugin, \ref RwCameraRegisterPlugin, etc. as the
+ * function that destroys either the global extension data (in the case of
+ * \ref RwEngineRegisterPlugin) or the object extension data (in all other
+ * cases).
+ *
+ * \param object Pointer to the object (global or otherwise)
+ * containing the extension data.
+ *
+ * \param offsetInObject A RwInt32 value equal to the byte
+ * offset of the extension data in the object.
+ *
+ * \param sizeInObject A RwInt32 value equal to the size
+ * (in bytes) of the extension data.
+ *
+ * \return Pointer to the object.
+ */
+typedef void *(*RwPluginObjectDestructor)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+
+typedef void *(*RwPluginErrorStrCallBack)(void *);
+
+typedef struct RwPluginRegistry RwPluginRegistry;
+typedef struct RwPluginRegEntry RwPluginRegEntry;
+
+struct RwPluginRegistry
+{
+ RwInt32 sizeOfStruct;
+ RwInt32 origSizeOfStruct;
+ RwInt32 maxSizeOfStruct;
+ RwInt32 staticAlloc;
+ RwPluginRegEntry *firstRegEntry;
+ RwPluginRegEntry *lastRegEntry;
+};
+
+struct RwPluginRegEntry
+{
+ RwInt32 offset;
+ RwInt32 size;
+ RwUInt32 pluginID;
+ RwPluginDataChunkReadCallBack readCB;
+ RwPluginDataChunkWriteCallBack writeCB;
+ RwPluginDataChunkGetSizeCallBack getSizeCB;
+ RwPluginDataChunkAlwaysCallBack alwaysCB;
+ RwPluginDataChunkRightsCallBack rightsCB;
+ RwPluginObjectConstructor constructCB;
+ RwPluginObjectDestructor destructCB;
+ RwPluginObjectCopy copyCB;
+ RwPluginErrorStrCallBack errStrCB;
+ RwPluginRegEntry *nextRegEntry;
+ RwPluginRegEntry *prevRegEntry;
+ RwPluginRegistry *parentRegistry;
+};
+
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+/* Registering toolkits and allocating memory */
+extern RwBool
+_rwPluginRegistrySetStaticPluginsSize(RwPluginRegistry * reg,
+ RwInt32 size);
+extern RwInt32
+_rwPluginRegistryAddPlugin(RwPluginRegistry * reg,
+ RwInt32 size,
+ RwUInt32 pluginID,
+ RwPluginObjectConstructor constructCB,
+ RwPluginObjectDestructor destructCB,
+ RwPluginObjectCopy copyCB);
+extern RwInt32
+_rwPluginRegistryGetPluginOffset(const RwPluginRegistry *reg,
+ RwUInt32 pluginID);
+
+/* Initializing/De-initializing instances */
+extern const
+RwPluginRegistry *_rwPluginRegistryInitObject(const RwPluginRegistry * reg,
+ void *object);
+extern const
+RwPluginRegistry *_rwPluginRegistryDeInitObject(const RwPluginRegistry * reg,
+ void *object);
+extern const
+RwPluginRegistry *_rwPluginRegistryCopyObject(const RwPluginRegistry * reg,
+ void *dstObject,
+ const void *srcObject);
+
+#ifdef RWDEBUG
+extern RwBool
+_rwPluginRegistryValidateObject(const RwPluginRegistry * reg,
+ const void *object);
+#endif /* RWDEBUG */
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* Compatibility macros */
+
+#define rwPluginRegistryOpen() \
+ _rwPluginRegistryOpen()
+#define rwPluginRegistryClose() \
+ _rwPluginRegistryClose()
+#define rwPluginRegistrySetStaticPluginsSize(reg, size) \
+ _rwPluginRegistrySetStaticPluginsSize(reg, size)
+#define rwPluginRegistryAddPlugin(reg, size, pluginID, constructCB, destructCB, copyCB) \
+ _rwPluginRegistryAddPlugin(reg, size, pluginID, constructCB, destructCB, copyCB)
+#define rwPluginRegistryGetPluginOffset(reg, pluginID) \
+ _rwPluginRegistryGetPluginOffset(reg, pluginID)
+#define rwPluginRegistryInitObject(reg, object) \
+ _rwPluginRegistryInitObject(reg, object)
+#define rwPluginRegistryDeInitObject(reg, object) \
+ _rwPluginRegistryDeInitObject(reg, object)
+#define rwPluginRegistryCopyObject(reg, dstObject, srcObject) \
+ _rwPluginRegistryCopyObject(reg, dstObject, srcObject)
+#define rwPluginRegistryValidateObject(reg, object) \
+ _rwPluginRegistryValidateObject(reg, object)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/batkbin.h ---*/
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Plugin binary stream stuff */
+extern RwInt32 _rwPluginRegistryAddPluginStream(
+ RwPluginRegistry *reg,
+ RwUInt32 pluginID,
+ RwPluginDataChunkReadCallBack readCB,
+ RwPluginDataChunkWriteCallBack writeCB,
+ RwPluginDataChunkGetSizeCallBack getSizeCB);
+extern RwInt32 _rwPluginRegistryAddPlgnStrmlwysCB(
+ RwPluginRegistry *reg,
+ RwUInt32 pluginID,
+ RwPluginDataChunkAlwaysCallBack alwaysCB);
+extern RwInt32 _rwPluginRegistryAddPlgnStrmRightsCB(
+ RwPluginRegistry *reg,
+ RwUInt32 pluginID,
+ RwPluginDataChunkRightsCallBack rightsCB);
+extern const RwPluginRegistry *_rwPluginRegistryReadDataChunks(const RwPluginRegistry *reg,
+ RwStream *stream,
+ void *object);
+extern const RwPluginRegistry *_rwPluginRegistryWriteDataChunks(const RwPluginRegistry *reg,
+ RwStream *stream,
+ const void *object);
+extern const RwPluginRegistry *_rwPluginRegistrySkipDataChunks(const RwPluginRegistry * reg,
+ RwStream * stream);
+extern RwInt32 _rwPluginRegistryGetSize(const RwPluginRegistry *reg, const void *object);
+extern const RwPluginRegistry *_rwPluginRegistryInvokeRights(const RwPluginRegistry *reg,
+ RwUInt32 id,
+ void *obj,
+ RwUInt32 extraData);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* Compatibility macros */
+
+#define rwPluginRegistryAddPluginStream(reg, pluginID, readCB, writeCB, getSizeCB) \
+ _rwPluginRegistryAddPluginStream(reg, pluginID, readCB, writeCB, getSizeCB)
+#define rwPluginRegistryAddPluginStreamAlwaysCB(reg, pluginID, alwaysCB) \
+ _rwPluginRegistryAddPlgnStrmlwysCB(reg, pluginID, alwaysCB)
+#define rwPluginRegistryReadDataChunks(reg, stream, object) \
+ _rwPluginRegistryReadDataChunks(reg, stream, object)
+#define rwPluginRegistryWriteDataChunks(reg, stream, object) \
+ _rwPluginRegistryWriteDataChunks(reg, stream, object)
+#define rwPluginRegistrySkipDataChunks(reg, stream) \
+ _rwPluginRegistrySkipDataChunks(reg, stream)
+#define rwPluginRegistryGetSize(reg, object) \
+ _rwPluginRegistryGetSize(reg, object)
+
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bamatrix.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+#define RWMATRIXALIGNMENT(_mat) \
+ (! (((rwMATRIXALIGNMENT)-1) & ((RwUInt32)(_mat))))
+
+#if (defined(RWMATRIXMONITOR))
+# if (defined(_MSC_VER))
+# if ((_MSC_VER>=1000) && defined(_DEBUG))
+
+typedef char MatrixString[1024];
+
+#define RWMATRIXPRINT(_matrix) \
+MACRO_START \
+{ \
+ MatrixString message; \
+ MatrixString output; \
+ \
+ if (NULL != (_matrix)) \
+ { \
+ const RwV3d * const _x = &(_matrix)->right; \
+ const RwV3d * const _y = &(_matrix)->up; \
+ const RwV3d * const _z = &(_matrix)->at; \
+ const RwV3d * const _w = &(_matrix)->pos; \
+ \
+ _snprintf(message, sizeof(MatrixString), \
+ "[ [ %8.4f, %8.4f, %8.4f, %8.4f ]\n" \
+ " [ %8.4f, %8.4f, %8.4f, %8.4f ]\n" \
+ " [ %8.4f, %8.4f, %8.4f, %8.4f ]\n" \
+ " [ %8.4f, %8.4f, %8.4f, %8.4f ] ]\n" \
+ " %08x == flags\n", \
+ _x->x, _x->y, _x->z, (RwReal) 0, \
+ _y->x, _y->y, _y->z, (RwReal) 0, \
+ _z->x, _z->y, _z->z, (RwReal) 0, \
+ _w->x, _w->y, _w->z, (RwReal) 1, \
+ (_matrix)->flags); \
+ } \
+ else \
+ { \
+ _snprintf(message, sizeof(MatrixString), \
+ "NULL"); \
+ } \
+ \
+ _snprintf(output, sizeof(MatrixString), \
+ "%s(%d): %s [%p] ==\n%s\n", \
+ __FILE__, __LINE__, \
+ #_matrix, _matrix, message); \
+ \
+ OutputDebugString(RWSTRING(output)); \
+} \
+MACRO_STOP
+
+# endif /* ((_MSC_VER>=1000) && defined(_DEBUG)) */
+# endif /* (defined(_MSC_VER)) */
+#endif /* (defined(RWMATRIXMONITOR)) */
+
+#if (!(defined(RWMATRIXPRINT)))
+#define RWMATRIXPRINT(_matrix) /* No op */
+#endif /* (!(defined(RWMATRIXPRINT))) */
+
+/**
+ * \ingroup datatypes
+ * enum RwOpCombineType
+ * This type represents a combination operator which
+ * can be applied to frames and matrices.
+ * The operator determines the order
+ * in which one object is combined with another
+ */
+enum RwOpCombineType
+{
+ rwCOMBINEREPLACE = 0, /**<Replace -
+ all previous transformations are lost */
+ rwCOMBINEPRECONCAT, /**<Pre-concatenation -
+ the given transformation is applied
+ before all others */
+ rwCOMBINEPOSTCONCAT, /**<Post-concatenation -
+ the given transformation is applied
+ after all others */
+ rwOPCOMBINETYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+/**
+ * \ingroup datatypes
+ * \typedef RwOpCombineType typedef for enum RwOpCombineType
+ */
+typedef enum RwOpCombineType RwOpCombineType;
+
+/* External flags (bits 0-15) */
+
+/* Internal flags (bits 16-31) */
+enum RwMatrixType
+{
+ rwMATRIXTYPENORMAL = 0x00000001,
+ rwMATRIXTYPEORTHOGANAL = 0x00000002,
+ rwMATRIXTYPEORTHONORMAL = 0x00000003,
+ rwMATRIXTYPEMASK = 0x00000003,
+ rwMATRIXTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwMatrixType RwMatrixType;
+
+enum RwMatrixFlag
+{
+ rwMATRIXINTERNALIDENTITY = 0x00020000,
+ rwMATRIXFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwMatrixFlag RwMatrixFlag;
+
+/* Flags describing what will optimize for */
+enum RwMatrixOptimizations
+{
+ rwMATRIXOPTIMIZE_IDENTITY = 0x00020000,
+ rwMATRIXOPTIMIZATIONSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwMatrixOptimizations RwMatrixOptimizations;
+
+/****************************************************************************
+ Global Types
+ */
+
+#if (!defined(DOXYGEN))
+struct RwMatrixTag
+{
+ /* These are padded to be 16 byte quantities per line */
+ RwV3d right;
+ RwUInt32 flags;
+ RwV3d up;
+ RwUInt32 pad1;
+ RwV3d at;
+ RwUInt32 pad2;
+ RwV3d pos;
+ RwUInt32 pad3;
+};
+
+/*
+ * RwMatrix & RwMatrixTag must be different otherwise the alignment
+ * directive is ignored when compiling under C++ on Visual C
+ */
+typedef struct RwMatrixTag RWALIGN(RwMatrix, rwMATRIXALIGNMENT);
+
+#else
+
+/*
+ * RwMatrix must appear as the struct name & the typedef,
+ * otherwise Doxygen puts RwMatrixTag in the API ref instead of RwMatrix!
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwMatrix
+ * Matrix to define transformations.
+ * This should be considered an opaque type.
+ * Use the RwMatrix API functions to access.
+ */
+typedef struct RwMatrix RWALIGN(RwMatrix, rwMATRIXALIGNMENT);
+#endif /* (!defined(DOXYGEN)) */
+
+#if (!defined(RwMatrixCopyMacro))
+#define RwMatrixCopyMacro(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RwMatrixCopyMacro)) */
+
+#if (!defined(RwMatrixSetIdentityMacro))
+#define RwMatrixSetIdentityMacro(m) \
+MACRO_START \
+{ \
+ (m)->right.x = (m)->up.y = (m)->at.z = (RwReal)((1.0)); \
+ (m)->right.y = (m)->right.z = (m)->up.x = (RwReal)((0.0)); \
+ (m)->up.z = (m)->at.x = (m)->at.y = (RwReal)((0.0)); \
+ (m)->pos.x = (m)->pos.y = (m)->pos.z = (RwReal)((0.0)); \
+ rwMatrixSetFlags((m), \
+ rwMatrixGetFlags(m) | \
+ (rwMATRIXINTERNALIDENTITY | \
+ rwMATRIXTYPEORTHONORMAL)); \
+} \
+MACRO_STOP
+#endif /* (!defined(RwMatrixSetIdentityMacro)) */
+
+typedef void (RWASMCALL * rwMatrixMultFn) (RwMatrix * dstMat,
+ const RwMatrix * matA,
+ const RwMatrix * matB);
+
+/*
+ * \ingroup datatypes
+ * \typedef RwMatrixTolerance
+ * Typedef for RwMatrixTolerance structure
+ */
+typedef struct RwMatrixTolerance RwMatrixTolerance;
+
+/*
+ * \ingroup datatypes
+ * \struct RwMatrixTolerance
+ * Holds tolerances for matrix optimizations with \ref RwMatrixOptimize
+ */
+struct RwMatrixTolerance
+{
+ RwReal Normal;
+ /**< Tolerance within which matrix is deemed to be normal */
+ RwReal Orthogonal;
+ /**< Tolerance within which matrix is deemed to be orthogonal */
+ RwReal Identity;
+ /**< Tolerance within which matrix is deemed to be identity */
+};
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+/* Matrix operations */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwBool
+RwEngineGetMatrixTolerances(RwMatrixTolerance * const tolerance);
+
+extern RwBool
+RwEngineSetMatrixTolerances(const RwMatrixTolerance * const tolerance);
+
+/* Update */
+#define rwMatrixSetFlags(m, flagsbit) ((m)->flags = (flagsbit))
+#define rwMatrixGetFlags(m) ((m)->flags)
+#define rwMatrixTestFlags(m, flagsbit) ((m)->flags & (RwInt32)(flagsbit))
+
+/* Creation/destruction */
+extern RwBool
+RwMatrixDestroy(RwMatrix * mpMat);
+
+extern RwMatrix *
+RwMatrixCreate(void);
+
+#ifdef RWDEBUG
+
+/* Functions for debug */
+extern void
+RwMatrixCopy(RwMatrix * dstMatrix, const RwMatrix * srcMatrix);
+
+extern void
+RwMatrixSetIdentity(RwMatrix * matrix);
+
+#else /* RWDEBUG */
+
+#define RwMatrixCopy(dst, src) RwMatrixCopyMacro(dst, src)
+#define RwMatrixSetIdentity(m) RwMatrixSetIdentityMacro(m)
+
+#endif /* RWDEBUG */
+
+/* Matrix multiply */
+extern RwMatrix *
+RwMatrixMultiply(RwMatrix * matrixOut,
+ const RwMatrix * MatrixIn1,
+ const RwMatrix * matrixIn2);
+
+extern RwMatrix *
+RwMatrixTransform(RwMatrix * matrix,
+ const RwMatrix * transform,
+ RwOpCombineType combineOp);
+
+/* Normalise */
+extern RwMatrix *
+RwMatrixOrthoNormalize(RwMatrix * matrixOut,
+ const RwMatrix * matrixIn);
+
+/* Inversion */
+extern RwMatrix *
+RwMatrixInvert(RwMatrix * matrixOut,
+ const RwMatrix * matrixIn);
+
+/* Unary matrix operations */
+extern RwMatrix *
+RwMatrixScale(RwMatrix * matrix,
+ const RwV3d * scale,
+ RwOpCombineType combineOp);
+
+extern RwMatrix *
+RwMatrixTranslate(RwMatrix * matrix,
+ const RwV3d * translation,
+ RwOpCombineType combineOp);
+
+extern RwMatrix *
+RwMatrixRotate(RwMatrix * matrix,
+ const RwV3d * axis,
+ RwReal angle,
+ RwOpCombineType combineOp);
+
+extern RwMatrix *
+RwMatrixRotateOneMinusCosineSine(RwMatrix * matrix,
+ const RwV3d * unitAxis,
+ RwReal oneMinusCosine,
+ RwReal sine,
+ RwOpCombineType combineOp);
+
+/* Query what the matrix is */
+extern const RwMatrix *RwMatrixQueryRotate(const RwMatrix * matrix,
+ RwV3d * unitAxis,
+ RwReal * angle,
+ RwV3d * center);
+
+/* Get components */
+#ifndef RWDEBUG
+
+#define RwMatrixGetRight(m) (&(m)->right)
+#define RwMatrixGetUp(m) (&(m)->up)
+#define RwMatrixGetAt(m) (&(m)->at)
+#define RwMatrixGetPos(m) (&(m)->pos)
+
+#else /* RWDEBUG */
+
+extern RwV3d *
+RwMatrixGetRight(RwMatrix * matrix);
+
+extern RwV3d *
+RwMatrixGetUp(RwMatrix * matrix);
+
+extern RwV3d *
+RwMatrixGetAt(RwMatrix * matrix);
+
+extern RwV3d *
+RwMatrixGetPos(RwMatrix * matrix);
+
+#endif /* RWDEBUG */
+
+/* Update the internal matrix state wrt its elements */
+extern RwMatrix *
+RwMatrixUpdate(RwMatrix * matrix);
+
+/* Update the internal matrix flags wrt its elements */
+extern RwMatrix *
+RwMatrixOptimize(RwMatrix * matrix,
+ const RwMatrixTolerance *
+ tolerance);
+
+extern RwReal
+_rwMatrixDeterminant(const RwMatrix * matrix);
+
+extern RwReal
+_rwMatrixNormalError(const RwMatrix * matrix);
+
+extern RwReal
+_rwMatrixOrthogonalError(const RwMatrix * matrix);
+
+extern RwReal
+_rwMatrixIdentityError(const RwMatrix * matrix);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* Compatibility macros */
+
+#define rwMatrixSetOptimizations(optimizeFlags) \
+ _rwMatrixSetOptimizations(optimizeFlags)
+
+#define rwMatrixSetMultFn(multMat) \
+ _rwMatrixSetMultFn(multMat)
+
+#define rwMatrixOpen(instance, offset, size) \
+ _rwMatrixOpen(instance, offset, size)
+
+#define rwMatrixClose(instance, offset, size) \
+ _rwMatrixClose(instance, offset, size)
+
+/* Initialisation/deinitialisation */
+#define rwMatrixInitialize(m, t) \
+MACRO_START \
+{ \
+ rwMatrixSetFlags((m), (t)); \
+} \
+MACRO_STOP
+
+#define rwMatrixIsNormal(_matrix, _epsilon) \
+ ( (_epsilon) >= _rwMatrixNormalError(_matrix) )
+
+#define rwMatrixIsOrthogonal(_matrix, _epsilon) \
+ ( (_epsilon) >= _rwMatrixOrthogonalError(_matrix) )
+
+#define rwMatrixIsOrthonormal(_matrix, _epsilon) \
+ ( rwMatrixIsNormal(_matrix, _epsilon) && \
+ rwMatrixIsOrthogonal(_matrix, _epsilon) )
+
+#define rwMatrixIsOrthonormalPositive(_matrix, _epsilon) \
+ ( rwMatrixIsOrthonormal(_matrix, _epsilon) && \
+( (((RwReal)1) - (_epsilon)) <= _rwMatrixDeterminant(_matrix) ) )
+
+#define rwMatrixIsIdentity(_matrix, _epsilon) \
+ ( (_epsilon) >= _rwMatrixIdentityError(_matrix) )
+
+#define rwMatrixValidFlags(_matrix, _epsilon) \
+ ( (_matrix) && /* valid pointer */ \
+ ( ( !( rwMatrixGetFlags(_matrix) & /* not flagged as identity */ \
+ rwMATRIXINTERNALIDENTITY) ) || /* .. or actually is */ \
+ rwMatrixIsIdentity(_matrix, _epsilon)) && \
+ ( ( !( rwMatrixGetFlags(_matrix) & /* not flagged as normal */ \
+ rwMATRIXTYPENORMAL) ) || /* ... or actually is */ \
+ rwMatrixIsNormal(_matrix, _epsilon)) && \
+ ( ( !( rwMatrixGetFlags(_matrix) & /* not flagged as orthogonal */ \
+ rwMATRIXTYPEORTHOGANAL) ) || /* ... or actually is */ \
+ rwMatrixIsOrthogonal(_matrix, _epsilon)) )
+
+#define rwMat01Det(_mAA) \
+ ( (_mAA) )
+
+#define rwMat02Det(_mAA, _mAB, \
+ _mBA, _mBB) \
+ ( (_mAA) * rwMat01Det(_mBB) \
+ - (_mAB) * rwMat01Det(_mBA) \
+ )
+
+#define rwMat03Det(_mAA, _mAB, _mAC, \
+ _mBA, _mBB, _mBC, \
+ _mCA, _mCB, _mCC) \
+ ( (_mAA) * rwMat02Det(_mBB, _mBC, \
+ _mCB, _mCC) \
+ - (_mAB) * rwMat02Det(_mBA, _mBC, \
+ _mCA, _mCC) \
+ + (_mAC) * rwMat02Det(_mBA, _mBB, \
+ _mCA, _mCB) \
+ )
+
+#define rwMat04Det(_mAA, _mAB, _mAC, _mAD, \
+ _mBA, _mBB, _mBC, _mBD, \
+ _mCA, _mCB, _mCC, _mCD, \
+ _mDA, _mDB, _mDC, _mDD) \
+ ( (_mAA) * rwMat03Det(_mBB, _mBC, _mBD, \
+ _mCB, _mCC, _mCD, \
+ _mDB, _mDC, _mDD) \
+ - (_mAB) * rwMat03Det(_mBA, _mBC, _mBD, \
+ _mCA, _mCC, _mCD, \
+ _mDA, _mDC, _mDD) \
+ + (_mAC) * rwMat03Det(_mBA, _mBB, _mBD, \
+ _mCA, _mCB, _mCD, \
+ _mDA, _mDB, _mDD) \
+ - (_mAD) * rwMat03Det(_mBA, _mBB, _mBC, \
+ _mCA, _mCB, _mCC, \
+ _mDA, _mDB, _mDC) \
+ )
+
+
+#define rwMat02Inv(_rAA, _rAB, \
+ _rBA, _rBB) \
+ _mAA, _mAB, \
+ _mBA, _mBB) \
+MACRO_START \
+{ \
+ RwSplitBits determinant; \
+ \
+ (_rAA) = rwMat01Det(_mBB); \
+ (_rAB) = -rwMat01Det(_mAB); \
+ \
+ determinant.nReal = ( (_rAA) * (_mAA) + \
+ (_rAB) * (_mBA) ); \
+ \
+ \
+ { \
+ const RwReal normalize = ( (determinant.nInt != 0)? \
+ (((RwReal)1)/determinant.nReal): \
+ ((RwReal)1) ); \
+ \
+ (_rAA) *= normalize; \
+ (_rAB) *= normalize; \
+ \
+ (_rBA) = -rwMat01Det(_mBA) * normalize; \
+ (_rBB) = rwMat01Det(_mAA) * normalize; \
+ } \
+} \
+MACRO_STOP
+
+#define rwMat03Inv(_rAA, _rAB, _rAC, \
+ _rBA, _rBB, _rBC, \
+ _rCA, _rCB, _rCC, \
+ _mAA, _mAB, _mAC, \
+ _mBA, _mBB, _mBC, \
+ _mCA, _mCB, _mCC) \
+MACRO_START \
+{ \
+ RwSplitBits determinant; \
+ \
+ (_rAA)= rwMat02Det(_mBB, _mBC, \
+ _mCB, _mCC); \
+ (_rAB)= -rwMat02Det(_mAB, _mAC, \
+ _mCB, _mCC); \
+ (_rAC)= rwMat02Det(_mAB, _mAC, \
+ _mBB, _mBC); \
+ \
+ determinant.nReal = ( (_rAA) * (_mAA) + \
+ (_rAB) * (_mBA) + \
+ (_rAC) * (_mCA) ); \
+ \
+ { \
+ const RwReal normalize = ( (determinant.nInt != 0)? \
+ (((RwReal)1)/determinant.nReal): \
+ ((RwReal)1) ); \
+ (_rAA) *= normalize; \
+ (_rAB) *= normalize; \
+ (_rAC) *= normalize; \
+ \
+ (_rBA)= -rwMat02Det(_mBA, _mBC, \
+ _mCA, _mCC) * normalize ; \
+ (_rBB)= rwMat02Det(_mAA, _mAC, \
+ _mCA, _mCC) * normalize ; \
+ (_rBC)= -rwMat02Det(_mAA, _mAC, \
+ _mBA, _mBC) * normalize ; \
+ \
+ (_rCA)= rwMat02Det(_mBA, _mBB, \
+ _mCA, _mCB) * normalize ; \
+ (_rCB)= -rwMat02Det(_mAA, _mAB, \
+ _mCA, _mCB) * normalize ; \
+ (_rCC)= rwMat02Det(_mAA, _mAB, \
+ _mBA, _mBB) * normalize ; \
+ } \
+ \
+} \
+MACRO_STOP
+
+#define rwMat04Inv(_rAA, _rAB, _rAC, _rAD, \
+ _rBA, _rBB, _rBC, _rBD, \
+ _rCA, _rCB, _rCC, _rCD, \
+ _rDA, _rDB, _rDC, _rDD, \
+ _mAA, _mAB, _mAC, _mAD, \
+ _mBA, _mBB, _mBC, _mBD, \
+ _mCA, _mCB, _mCC, _mCD, \
+ _mDA, _mDB, _mDC, _mDD) \
+MACRO_START \
+{ \
+ RwSplitBits determinant; \
+ \
+ (_rAA)= rwMat03Det(_mBB, _mBC, _mBD, \
+ _mCB, _mCC, _mCD, \
+ _mDB, _mDC, _mDD); \
+ (_rAB)= -rwMat03Det(_mAB, _mAC, _mAD, \
+ _mCB, _mCC, _mCD, \
+ _mDB, _mDC, _mDD); \
+ (_rAC)= rwMat03Det(_mAB, _mAC, _mAD, \
+ _mBB, _mBC, _mBD, \
+ _mDB, _mDC, _mDD); \
+ (_rAD)= -rwMat03Det(_mAB, _mAC, _mAD, \
+ _mBB, _mBC, _mBD, \
+ _mCB, _mCC, _mCD); \
+ \
+ determinant.nReal = ( (_rAA) * (_mAA) + \
+ (_rAB) * (_mBA) + \
+ (_rAC) * (_mCA) + \
+ (_rAD) * (_mDA) ); \
+ \
+ { \
+ const RwReal normalize = ( (determinant.nInt != 0)? \
+ (((RwReal)1)/determinant.nReal): \
+ ((RwReal)1) ); \
+ \
+ (_rAA) *= normalize; \
+ (_rAB) *= normalize; \
+ (_rAC) *= normalize; \
+ (_rAD) *= normalize; \
+ \
+ (_rBA)= -rwMat03Det(_mBA, _mBC, _mBD, \
+ _mCA, _mCC, _mCD, \
+ _mDA, _mDC, _mDD) * normalize ; \
+ (_rBB)= rwMat03Det(_mAA, _mAC, _mAD, \
+ _mCA, _mCC, _mCD, \
+ _mDA, _mDC, _mDD) * normalize ; \
+ (_rBC)= -rwMat03Det(_mAA, _mAC, _mAD, \
+ _mBA, _mBC, _mBD, \
+ _mDA, _mDC, _mDD) * normalize ; \
+ (_rBD)= rwMat03Det(_mAA, _mAC, _mAD, \
+ _mBA, _mBC, _mBD, \
+ _mCA, _mCC, _mCD) * normalize ; \
+ \
+ (_rCA)= rwMat03Det(_mBA, _mBB, _mBD, \
+ _mCA, _mCB, _mCD, \
+ _mDA, _mDB, _mDD) * normalize ; \
+ (_rCB)= -rwMat03Det(_mAA, _mAB, _mAD, \
+ _mCA, _mCB, _mCD, \
+ _mDA, _mDB, _mDD) * normalize ; \
+ (_rCC)= rwMat03Det(_mAA, _mAB, _mAD, \
+ _mBA, _mBB, _mBD, \
+ _mDA, _mDB, _mDD) * normalize ; \
+ (_rCD)= -rwMat03Det(_mAA, _mAB, _mAD, \
+ _mBA, _mBB, _mBD, \
+ _mCA, _mCB, _mCD) * normalize ; \
+ \
+ (_rDA)= -rwMat03Det(_mBA, _mBB, _mBC, \
+ _mCA, _mCB, _mCC, \
+ _mDA, _mDB, _mDC) * normalize ; \
+ (_rDB)= rwMat03Det(_mAA, _mAB, _mAC, \
+ _mCA, _mCB, _mCC, \
+ _mDA, _mDB, _mDC) * normalize ; \
+ (_rDC)= -rwMat03Det(_mAA, _mAB, _mAC, \
+ _mBA, _mBB, _mBC, \
+ _mDA, _mDB, _mDC) * normalize ; \
+ (_rDD)= rwMat03Det(_mAA, _mAB, _mAC, \
+ _mBA, _mBB, _mBC, \
+ _mCA, _mCB, _mCC) * normalize ; \
+ } \
+} \
+MACRO_STOP
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/drvmodel.h ---*/
+#ifndef D3D8_DRVMODEL_H
+#define D3D8_DRVMODEL_H
+
+#if (defined(__ICL))
+/* Avoid voluminous
+ * 'warning #344: typedef name has already been declared (with same type)'
+ * warnings from MS include files
+ */
+#pragma warning( disable : 344 )
+#endif /* (defined(__ICL)) */
+
+
+#include <windows.h>
+
+#if (defined(RWDEBUG))
+#if (defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC))
+#define _CRTDBG_MAP_ALLOC
+#endif /* defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) */
+#include <crtdbg.h>
+#define ERR_WRAP(A) (_rwRePrintErrorDDD3D((A), __FILE__, __LINE__))
+#endif /* (defined(RWDEBUG)) */
+
+#if (!defined(ERR_WRAP))
+#define ERR_WRAP(A) (A)
+#endif /* (!defined(ERR_WRAP)) */
+
+/****************************************************************************
+ Defines
+ */
+
+/* Set true depth information (for fogging, eg) */
+#define RwIm2DVertexSetCameraX(vert, camx) /* Nothing */
+#define RwIm2DVertexSetCameraY(vert, camy) /* Nothing */
+#define RwIm2DVertexSetCameraZ(vert, camz) /* Nothing */
+
+#define RwIm2DVertexSetRecipCameraZ(vert, recipz) ((vert)->rhw = recipz)
+
+#define RwIm2DVertexGetCameraX(vert) (cause an error)
+#define RwIm2DVertexGetCameraY(vert) (cause an error)
+#define RwIm2DVertexGetCameraZ(vert) (cause an error)
+#define RwIm2DVertexGetRecipCameraZ(vert) ((vert)->rhw)
+
+/* Set screen space coordinates in a device vertex */
+#define RwIm2DVertexSetScreenX(vert, scrnx) ((vert)->x = (scrnx))
+#define RwIm2DVertexSetScreenY(vert, scrny) ((vert)->y = (scrny))
+#define RwIm2DVertexSetScreenZ(vert, scrnz) ((vert)->z = (scrnz))
+#define RwIm2DVertexGetScreenX(vert) ((vert)->x)
+#define RwIm2DVertexGetScreenY(vert) ((vert)->y)
+#define RwIm2DVertexGetScreenZ(vert) ((vert)->z)
+
+/* Set texture coordinates in a device vertex */
+#define RwIm2DVertexSetU(vert, texU, recipz) ((vert)->u = (texU))
+#define RwIm2DVertexSetV(vert, texV, recipz) ((vert)->v = (texV))
+#define RwIm2DVertexGetU(vert) ((vert)->u)
+#define RwIm2DVertexGetV(vert) ((vert)->v)
+
+/* Modify the luminance stuff */
+#define RwIm2DVertexSetRealRGBA(vert, red, green, blue, alpha) \
+ ((vert)->emissiveColor = \
+ (((RwFastRealToUInt32(alpha)) << 24) | \
+ ((RwFastRealToUInt32(red)) << 16) | \
+ ((RwFastRealToUInt32(green)) << 8) | \
+ ((RwFastRealToUInt32(blue)))))
+
+#define RwIm2DVertexSetIntRGBA(vert, red, green, blue, alpha) \
+ ((vert)->emissiveColor = \
+ ((((RwUInt32)(alpha)) << 24) | \
+ (((RwUInt32)(red)) << 16) | \
+ (((RwUInt32)(green)) << 8) | \
+ (((RwUInt32)(blue)))))
+
+#define RwIm2DVertexGetRed(vert) \
+ (((vert)->emissiveColor >> 16) & 0xFF)
+
+#define RwIm2DVertexGetGreen(vert) \
+ (((vert)->emissiveColor >> 8) & 0xFF)
+
+#define RwIm2DVertexGetBlue(vert) \
+ ((vert)->emissiveColor & 0xFF)
+
+#define RwIm2DVertexGetAlpha(vert) \
+ (((vert)->emissiveColor >> 24) & 0xFF)
+
+#define RwIm2DVertexCopyRGBA(dst, src) \
+ ((dst)->emissiveColor = (src)->emissiveColor)
+
+/* Clipper stuff */
+
+#define RwIm2DVertexClipRGBA(o, i, n, f) \
+MACRO_START \
+{ \
+ const RwInt32 _factor = \
+ (RwFastRealToUInt32(i * (RwReal)(255))) & 255; \
+ \
+ (o)->emissiveColor = \
+ (((((RwIm2DVertexGetAlpha(f) - RwIm2DVertexGetAlpha(n)) * \
+ _factor) >> 8) + RwIm2DVertexGetAlpha(n)) << 24) | \
+ (((((RwIm2DVertexGetRed(f) - RwIm2DVertexGetRed(n)) * \
+ _factor) >> 8) + RwIm2DVertexGetRed(n)) << 16) | \
+ (((((RwIm2DVertexGetGreen(f) - RwIm2DVertexGetGreen(n)) * \
+ _factor) >> 8) + RwIm2DVertexGetGreen(n)) << 8) | \
+ (((((RwIm2DVertexGetBlue(f) - RwIm2DVertexGetBlue(n)) * \
+ _factor) >> 8) + RwIm2DVertexGetBlue(n))); \
+} \
+MACRO_STOP
+
+/* LEGACY-SUPPORT macros */
+#define RWIM2DVERTEXSetCameraX(vert, camx) RwIm2DVertexSetCameraX(vert, camx)
+#define RWIM2DVERTEXSetCameraY(vert, camy) RwIm2DVertexSetCameraY(vert, camy)
+#define RWIM2DVERTEXSetCameraZ(vert, camz) RwIm2DVertexSetCameraZ(vert, camz)
+#define RWIM2DVERTEXSetRecipCameraZ(vert, recipz) \
+ RwIm2DVertexSetRecipCameraZ(vert, recipz)
+#define RWIM2DVERTEXGetCameraX(vert) RwIm2DVertexGetCameraX(vert)
+#define RWIM2DVERTEXGetCameraY(vert) RwIm2DVertexGetCameraY(vert)
+#define RWIM2DVERTEXGetCameraZ(vert) RwIm2DVertexGetCameraZ(vert)
+#define RWIM2DVERTEXGetRecipCameraZ(vert) RwIm2DVertexGetRecipCameraZ(vert)
+#define RWIM2DVERTEXSetScreenX(vert, scrnx) RwIm2DVertexSetScreenX(vert, scrnx)
+#define RWIM2DVERTEXSetScreenY(vert, scrny) RwIm2DVertexSetScreenY(vert, scrny)
+#define RWIM2DVERTEXSetScreenZ(vert, scrnz) RwIm2DVertexSetScreenZ(vert, scrnz)
+#define RWIM2DVERTEXGetScreenX(vert) RwIm2DVertexGetScreenX(vert)
+#define RWIM2DVERTEXGetScreenY(vert) RwIm2DVertexGetScreenY(vert)
+#define RWIM2DVERTEXGetScreenZ(vert) RwIm2DVertexGetScreenZ(vert)
+#define RWIM2DVERTEXSetU(vert, u, recipz) RwIm2DVertexSetU(vert, u, recipz)
+#define RWIM2DVERTEXSetV(vert, v, recipz) RwIm2DVertexSetV(vert, v, recipz)
+#define RWIM2DVERTEXGetU(vert) RwIm2DVertexGetU(vert)
+#define RWIM2DVERTEXGetV(vert) RwIm2DVertexGetV(vert)
+#define RWIM2DVERTEXSetRealRGBA(vert, red, green, blue, alpha) \
+ RwIm2DVertexSetRealRGBA(vert, red, green, blue, alpha)
+#define RWIM2DVERTEXSetIntRGBA(vert, red, green, blue, alpha) \
+ RwIm2DVertexSetIntRGBA(vert, red, green, blue, alpha)
+#define RWIM2DVERTEXGetRed(vert) RwIm2DVertexGetRed(vert)
+#define RWIM2DVERTEXGetGreen(vert) RwIm2DVertexGetGreen(vert)
+#define RWIM2DVERTEXGetBlue(vert) RwIm2DVertexGetBlue(vert)
+#define RWIM2DVERTEXGetAlpha(vert) RwIm2DVertexGetAlpha(vert)
+#define RWIM2DVERTEXCopyRGBA(dst, src) RwIm2DVertexCopyRGBA(dst, src)
+#define RWIM2DVERTEXClipRGBA(o, i, n, f) RwIm2DVertexClipRGBA(o, i, n, f)
+
+/****************************************************************************
+ Global Types
+ */
+
+/* We use RwD3D8Vertex to drive the hardware in 2D mode */
+
+/**
+ * \ingroup rwcoredriverd3d8
+ * \typedef RwD3D8Vertex
+ * D3D8 vertex structure definition for 2D geometry
+ */
+typedef struct RwD3D8Vertex RwD3D8Vertex;
+/**
+ * \ingroup rwcoredriverd3d8
+ * \struct RwD3D8Vertex
+ * D3D8 vertex structure definition for 2D geometry
+ */
+struct RwD3D8Vertex
+{
+ RwReal x; /**< Screen X */
+ RwReal y; /**< Screen Y */
+ RwReal z; /**< Screen Z */
+ RwReal rhw; /**< Reciprocal of homogeneous W */
+
+ RwUInt32 emissiveColor; /**< Vertex color */
+
+ RwReal u; /**< Texture coordinate U */
+ RwReal v; /**< Texture coordinate V */
+};
+
+/* Define types used */
+
+/**
+ * \ingroup rwcoredriverd3d8
+ * \typedef RwIm2DVertex
+ * Typedef for a RenderWare Graphics Immediate Mode 2D Vertex
+ */
+typedef RwD3D8Vertex RwIm2DVertex;
+
+/* LEGACY-SUPPORT macro */
+/**
+ * \ingroup rwcoredriverd3d8
+ * \def RWIM2DVERTEX
+ * RWIM2DVERTEX is a legacy macro for RwIm2DVertex
+ */
+#define RWIM2DVERTEX RwIm2DVertex
+
+/**
+ * \ingroup rwcoredriverd3d8
+ * \typedef RxVertexIndex
+ *
+ * Typedef for a RenderWare Graphics PowerPipe Immediate
+ * Mode Vertex
+ */
+typedef RwUInt16 RxVertexIndex;
+
+/**
+ * \ingroup rwcoredriverd3d8
+ * \typedef RwImVertexIndex
+ * Typedef for a RenderWare Graphics Immediate Mode Vertex.
+ */
+typedef RxVertexIndex RwImVertexIndex;
+
+/* LEGACY-SUPPORT macro */
+/**
+ * \ingroup rwcoredriverd3d8
+ * \def RWIMVERTEXINDEX
+ * RWIMVERTEXINDEX is a legacy macro for RwImVertexIndex
+ */
+#define RWIMVERTEXINDEX RwImVertexIndex
+
+/**
+ * \ingroup rwcoredriverd3d8
+ * \struct RwD3D8Metrics
+ * Structure containing metrics counters
+ */
+typedef struct
+{
+ RwUInt32 numRenderStateChanges; /**< Number of Render States changed */
+ RwUInt32 numTextureStageStateChanges; /**< Number of Texture Stage States changed */
+ RwUInt32 numMaterialChanges; /**< Number of Material changes */
+ RwUInt32 numLightsChanged; /**< Number of Lights changed */
+}
+RwD3D8Metrics;
+
+#endif /* D3D8_DRVMODEL_H */
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bavector.h ---*/
+
+/*
+ * Typedef for pointer to Vector multiplication by Matrix function
+ */
+
+typedef RwV3d *(*rwVectorMultFn) (RwV3d * pointsOut,
+ const RwV3d * pointsIn,
+ RwInt32 numPoints,
+ const RwMatrix * matrix);
+
+
+/* If sqrt is overloaded for this platform, we will remove
+ * all the sqrt table stuff from the build entirely
+ * currently applies to SKY2 and XBOX - IDBS [2/11/2001]
+ * [and, if using the intel compiler version 400 or above,
+ * we will use the single-precision float "sqrtf" under
+ * D3D7, D3D8, OpenGL or SoftRas] */
+#if (defined(rwSqrtMacro))
+#define RWNOSQRTTABLE
+#endif /* (defined(rwSqrtMacro)) */
+#if (defined(rwInvSqrtMacro))
+#define RWNOINVSQRTTABLE
+#endif /* (defined(rwSqrtMacro)) */
+
+#if (!defined(rwSqrtMacro))
+#define rwSqrtMacro(_root, _input) \
+ ( *(_root) = _rwSqrt(_input) )
+#endif /* (!defined(rwSqrtMacro)) */
+
+#if (!defined(rwInvSqrtMacro))
+#define rwInvSqrtMacro(_recip, _input) \
+ ( *(_recip) = _rwInvSqrt(_input) )
+#endif /* (!defined(rwInvSqrtMacro)) */
+
+#if (!defined(rwSqrtInvSqrtMacro))
+#define rwSqrtInvSqrtMacro(_root, _recip, _input) \
+MACRO_START \
+{ \
+ RwReal _tmp = _input; \
+ rwSqrt((_root), _tmp); \
+ rwInvSqrt((_recip), _tmp); \
+} \
+MACRO_STOP
+#endif /* (!defined(rwSqrtInvSqrtMacro)) */
+
+/* Vector operations Macros */
+
+#if (!defined(RwV2dAssignMacro))
+#define RwV2dAssignMacro(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RwV2dAssignMacro)) */
+
+#define RwV2dAddMacro(o, a, b) \
+MACRO_START \
+{ \
+ (o)->x = (((a)->x) + ( (b)->x)); \
+ (o)->y = (((a)->y) + ( (b)->y)); \
+} \
+MACRO_STOP
+
+#define RwV2dSubMacro(o, a, b) \
+MACRO_START \
+{ \
+ (o)->x = (((a)->x) - ( (b)->x)); \
+ (o)->y = (((a)->y) - ( (b)->y)); \
+} \
+MACRO_STOP
+
+#define RwV2dScaleMacro(o, i, s) \
+MACRO_START \
+{ \
+ (o)->x = (((i)->x) * ( (s))); \
+ (o)->y = (((i)->y) * ( (s))); \
+} \
+MACRO_STOP
+
+#define RwV2dDotProductMacro(a,b) \
+ (( ((((a)->x) * ( (b)->x))) + \
+ ( (((a)->y) * ( (b)->y))))) \
+
+#define _rwV2dNormalizeMacro(_result, _out, _in) \
+MACRO_START \
+{ \
+ RwReal length2 = RwV2dDotProductMacro((_in), (_in)); \
+ rwInvSqrtMacro(&(_result), length2); \
+ RwV2dScaleMacro((_out), (_in), (_result)); \
+} \
+MACRO_STOP
+
+#define RwV2dNormalizeMacro(_result, _out, _in) \
+MACRO_START \
+{ \
+ RwReal length2 = RwV2dDotProductMacro((_in), (_in)); \
+ RwReal recip; \
+ \
+ rwSqrtInvSqrtMacro(&(_result), &recip, length2); \
+ RwV2dScaleMacro((_out), (_in), recip); \
+} \
+MACRO_STOP
+
+#define RwV2dLengthMacro(_result, _in) \
+MACRO_START \
+{ \
+ (_result) = RwV2dDotProductMacro(_in, _in); \
+ rwSqrtMacro(&(_result), (_result)); \
+} \
+MACRO_STOP
+
+#define RwV2dLineNormalMacro(_o, _a, _b) \
+MACRO_START \
+{ \
+ RwReal recip; \
+ \
+ (_o)->y = (((_b)->x) - ( (_a)->x)); \
+ (_o)->x = (((_a)->y) - ( (_b)->y)); \
+ _rwV2dNormalizeMacro(recip, _o,_o); \
+} \
+MACRO_STOP
+
+#define RwV2dPerpMacro(o, a) \
+MACRO_START \
+{ \
+ (o)->x = -(a)->y; \
+ (o)->y = (a)->x; \
+} \
+MACRO_STOP
+
+/* RwV3d */
+
+#if (!defined(RwV3dAssignMacro))
+#define RwV3dAssignMacro(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RwV3dAssignMacro)) */
+
+
+#define RwV3dAddMacro(o, a, b) \
+MACRO_START \
+{ \
+ (o)->x = (((a)->x) + ( (b)->x)); \
+ (o)->y = (((a)->y) + ( (b)->y)); \
+ (o)->z = (((a)->z) + ( (b)->z)); \
+} \
+MACRO_STOP
+
+#define RwV3dSubMacro(o, a, b) \
+MACRO_START \
+{ \
+ (o)->x = (((a)->x) - ( (b)->x)); \
+ (o)->y = (((a)->y) - ( (b)->y)); \
+ (o)->z = (((a)->z) - ( (b)->z)); \
+} \
+MACRO_STOP
+
+#define RwV3dScaleMacro(o, a, s) \
+MACRO_START \
+{ \
+ (o)->x = (((a)->x) * ( (s))); \
+ (o)->y = (((a)->y) * ( (s))); \
+ (o)->z = (((a)->z) * ( (s))); \
+} \
+MACRO_STOP
+
+#define RwV3dIncrementScaledMacro(o, a, s) \
+MACRO_START \
+{ \
+ (o)->x += (((a)->x) * ( (s))); \
+ (o)->y += (((a)->y) * ( (s))); \
+ (o)->z += (((a)->z) * ( (s))); \
+} \
+MACRO_STOP
+
+#define RwV3dNegateMacro(o, a) \
+MACRO_START \
+{ \
+ (o)->x = -(a)->x; \
+ (o)->y = -(a)->y; \
+ (o)->z = -(a)->z; \
+} \
+MACRO_STOP
+
+#define RwV3dDotProductMacro(a, b) \
+ ((((( (((a)->x) * ((b)->x))) + \
+ ( (((a)->y) * ((b)->y))))) + \
+ ( (((a)->z) * ((b)->z))))) \
+
+#define RwV3dCrossProductMacro(o, a, b) \
+MACRO_START \
+{ \
+ (o)->x = \
+ (( (((a)->y) * ( (b)->z))) - \
+ ( (((a)->z) * ( (b)->y)))); \
+ (o)->y = \
+ (( (((a)->z) * ( (b)->x))) - \
+ ( (((a)->x) * ( (b)->z)))); \
+ (o)->z = \
+ (( (((a)->x) * ( (b)->y))) - \
+ ( (((a)->y) * ( (b)->x)))); \
+} \
+MACRO_STOP
+
+#define _rwV3dNormalizeMacro(_result, _out, _in) \
+MACRO_START \
+{ \
+ RwReal length2 = RwV3dDotProductMacro(_in, _in); \
+ rwInvSqrtMacro(&(_result), length2); \
+ RwV3dScaleMacro(_out, _in, _result); \
+} \
+MACRO_STOP
+
+#define RwV3dNormalizeMacro(_result, _out, _in) \
+MACRO_START \
+{ \
+ RwReal length2 = RwV3dDotProductMacro((_in), (_in)); \
+ RwReal recip; \
+ \
+ rwSqrtInvSqrtMacro(&(_result), &recip, length2); \
+ RwV3dScaleMacro((_out), (_in), recip); \
+} \
+MACRO_STOP
+
+#define RwV3dLengthMacro(_result, _in) \
+MACRO_START \
+{ \
+ (_result) = RwV3dDotProductMacro(_in, _in); \
+ rwSqrtMacro(&(_result), _result); \
+} \
+MACRO_STOP
+
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+
+#define RwV2dAssign(o, a) RwV2dAssignMacro(o, a)
+#define RwV2dAdd(o, a, b) RwV2dAddMacro(o, a, b)
+#define RwV2dSub(o, a, b) RwV2dSubMacro(o, a, b)
+#define RwV2dLineNormal(_o, _a, _b) RwV2dLineNormalMacro(_o, _a, _b)
+#define RwV2dScale(o, i, s) RwV2dScaleMacro(o, i, s)
+#define RwV2dDotProduct(a,b) RwV2dDotProductMacro(a,b)
+#define RwV2dPerp(o, a) RwV2dPerpMacro(o, a)
+#define RwV3dAssign(o, a) RwV3dAssignMacro(o, a)
+#define RwV3dAdd(o, a, b) RwV3dAddMacro(o, a, b)
+#define RwV3dSub(o, a, b) RwV3dSubMacro(o, a, b)
+#define RwV3dScale(o, a, s) RwV3dScaleMacro(o, a, s)
+#define RwV3dIncrementScaled(o, a, s) RwV3dIncrementScaledMacro(o, a, s)
+#define RwV3dNegate(o, a) RwV3dNegateMacro(o, a)
+#define RwV3dDotProduct(a, b) RwV3dDotProductMacro(a, b)
+#define RwV3dCrossProduct(o, a, b) RwV3dCrossProductMacro(o, a, b)
+
+#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */
+
+#define RWRAD2DEG(_x) ((_x) * (((RwReal)180)/(rwPI)))
+
+#if (!defined(rw4OVERPISQ))
+#define rw4OVERPISQ ( ((RwReal)4) / ( rwPI * rwPI ))
+#endif /* (!defined(rw4OVERPISQ)) */
+
+#if (!defined(rwPI3))
+#define rwPI3 (rwPI * (RwReal)3)
+#endif /* (!defined(rwPI3)) */
+
+#if (!defined(rwPI3OVER2))
+#define rwPI3OVER2 ( rwPI3 / (RwReal)2 )
+#endif /* (!defined(rwPI3OVER2)) */
+
+#if (!defined(rwPI3OVER8))
+#define rwPI3OVER8 (rwPI3 / (RwReal)8 )
+#endif /* (!defined(rwPI3OVER8)) */
+
+#define RwQuadSin(_x) \
+ ( rw4OVERPISQ * \
+ ( ( (_x) < 0 ) ? \
+ ( ( rwPI + (_x) ) * (_x) ) : \
+ ( ( rwPI - (_x) ) * (_x) ) ) )
+
+#define RwQuadASin(_result, _s) \
+ ( rwPIOVER2 * ( ((_s)<0) ? \
+ ( rwSqrtMacro((_result), 1.0f + (_s)) - 1 ) : \
+ ( 1 - rwSqrtMacro((_result), 1.0f - (_s)) ) ) )
+
+#define RwQuadCos(_x) \
+ ( rw4OVERPISQ * \
+ ( ( (_x) < -rwPIOVER2 ) ? \
+ ( ( -rwPI3OVER2 - (_x) ) * ( -rwPIOVER2 - (_x) ) ) : \
+ ( ( (_x) < rwPIOVER2) ? \
+ ( ( rwPIOVER2 + (_x) ) * ( rwPIOVER2 - (_x) ) ) : \
+ ( ( rwPIOVER2 - (_x) ) * ( rwPI3OVER2 - (_x) ) ) ) ) )
+
+#define RwQuadACos(_result, _c) \
+ ( rwPIOVER2 * ( ((_c)<0) ? \
+ (2.0f - rwSqrtMacro((_result), 1.0f + (_c))): \
+ rwSqrtMacro((_result), 1.0f - (_c))) )
+
+#define RwQuadTan(_x) \
+ ( rwPI3 * (_x) / ( rwPI * rwPI - (_x) * (_x) * 4.0f ) )
+
+#define RwQuadATan(_result, _t) \
+ ( ( rwSqrtMacro((_result), (rwPI3OVER8 * rwPI3OVER8) + \
+ (_t) * (_t) * (rwPIOVER2 * rwPIOVER2) ) - rwPI3OVER8 ) \
+ / ( _t) )
+
+#define RwQuadATan2(_result, _s, _c) \
+ ( ( rwSqrtMacro((_result), (_c) * (_c) * (rwPI3OVER8 * rwPI3OVER8) + \
+ (_s) * (_s) * (rwPIOVER2 * rwPIOVER2) ) \
+ - (_c) * rwPI3OVER8 ) / ( _s) )
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Other useful stuff */
+
+extern RwReal RwV3dNormalize(RwV3d * out, const RwV3d * in);
+extern RwReal RwV3dLength(const RwV3d * in);
+
+extern RwReal RwV2dLength(const RwV2d * in);
+extern RwReal RwV2dNormalize(RwV2d * out, const RwV2d * in);
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+
+extern void RwV2dAssign(RwV2d * out,
+ const RwV2d * ina);
+extern void RwV2dAdd(RwV2d * out,
+ const RwV2d * ina, const RwV2d * inb);
+extern void RwV2dLineNormal(RwV2d * out,
+ const RwV2d * ina, const RwV2d * inb);
+extern void RwV2dSub(RwV2d * out,
+ const RwV2d * ina, const RwV2d * inb);
+extern void RwV2dPerp(RwV2d * out, const RwV2d * in);
+extern void RwV2dScale(RwV2d * out,
+ const RwV2d * in, RwReal scalar);
+extern RwReal RwV2dDotProduct(const RwV2d * ina, const RwV2d * inb);
+
+extern void RwV3dAssign(RwV3d * out,
+ const RwV3d * ina);
+extern void RwV3dAdd(RwV3d * out,
+ const RwV3d * ina, const RwV3d * inb);
+extern void RwV3dSub(RwV3d * out,
+ const RwV3d * ina, const RwV3d * inb);
+extern void RwV3dScale(RwV3d * out,
+ const RwV3d * in, RwReal scalar);
+extern void RwV3dIncrementScaled(RwV3d * out,
+ const RwV3d * in, RwReal scalar);
+extern void RwV3dNegate(RwV3d * out, const RwV3d * in);
+extern RwReal RwV3dDotProduct(const RwV3d * ina, const RwV3d * inb);
+extern void RwV3dCrossProduct(RwV3d * out,
+ const RwV3d * ina, const RwV3d * inb);
+
+#endif /* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */
+
+/* Transform points/vectors */
+extern RwV3d *RwV3dTransformPoints(RwV3d * pointsOut,
+ const RwV3d * pointsIn,
+ RwInt32 numPoints,
+ const RwMatrix * matrix);
+extern RwV3d *RwV3dTransformVectors(RwV3d * vectorsOut,
+ const RwV3d * vectorsIn,
+ RwInt32 numPoints,
+ const RwMatrix * matrix);
+
+/* SPI */
+
+#if (!defined(RWNOSQRTTABLE))
+extern RwReal _rwSqrt(const RwReal num);
+#endif /* (!defined(RWNOSQRTTABLE)) */
+#if (!defined(RWNOINVSQRTTABLE))
+extern RwReal _rwInvSqrt(const RwReal num);
+#endif /* (!defined(RWNOINVSQRTTABLE)) */
+
+extern RwReal _rwV3dNormalize(RwV3d * out, const RwV3d * in);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define rwVectorOpen(instance, offset, size) \
+ _rwVectorOpen(instance, offset, size)
+
+#define rwVectorClose(instance, offset, size) \
+ _rwVectorClose(instance, offset, size)
+
+#define rwVectorSetMultFn(multPoint,multVector) \
+ _rwVectorSetMultFn(multPoint,multVector)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/balist.h ---*/
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct RwSList RwSList;
+struct RwSList
+{
+ RwUInt8 *listElements;
+ RwInt32 numElementsFilled;
+ RwInt32 numElementsAlloced;
+ RwInt32 entrySize;
+};
+
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* SList functions */
+extern RwSList *_rwSListCreate(RwInt32 size);
+extern RwBool _rwSListDestroy(RwSList *sList);
+extern RwBool _rwSListDestroyArray(RwUInt8 *array);
+extern void _rwSListDestroyEndEntries(RwSList *sList, RwInt32 amount);
+extern RwBool _rwSListDestroyEntry(RwSList *sList, RwInt32 entry);
+extern void _rwSListEmpty(RwSList *sList);
+extern void *_rwSListGetArray(RwSList *sList);
+extern void *_rwSListGetEntry(RwSList *sList, RwInt32 entry);
+extern void *_rwSListGetNewEntry(RwSList *sList);
+extern void *_rwSListGetNewEntries(RwSList *sList, RwInt32 entry);
+extern RwInt32 _rwSListGetNumEntries(const RwSList *sList);
+extern RwBool _rwSListReleaseArray(RwSList *sList);
+extern void *_rwSListToArray(RwSList *sList);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* Comparibility macros */
+
+#define rwSListCreate(size) \
+ _rwSListCreate(size)
+#define rwSListDestroy(sList) \
+ _rwSListDestroy(sList)
+#define rwSListDestroyArray(array) \
+ _rwSListDestroyArray(array)
+#define rwSListDestroyEndEntries(sList, amount) \
+ _rwSListDestroyEndEntries(sList, amount)
+#define rwSListDestroyEntry(sList, entry) \
+ _rwSListDestroyEntry(sList, entry)
+#define rwSListEmpty(sList) \
+ _rwSListEmpty(sList)
+#define rwSListGetArray(sList) \
+ _rwSListGetArray(sList)
+#define rwSListGetEntry(sList, entry) \
+ _rwSListGetEntry(sList, entry)
+#define rwSListGetNewEntry(sList) \
+ _rwSListGetNewEntry(sList)
+#define rwSListGetNewEntries(sList, entry) \
+ _rwSListGetNewEntries(sList, entry)
+#define rwSListGetNumEntries(sList) \
+ _rwSListGetNumEntries(sList)
+#define rwSListReleaseArray(sList) \
+ _rwSListReleaseArray(sList)
+#define rwSListToArray(sList) \
+ _rwSListToArray(sList)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/baimmedi.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+ Immediate mode interface V2.0
+
+ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+
+/**
+ * \ingroup datatypes
+ * RwRenderState
+ * This type represents the various render states that
+ * can be set using the API function \ref RwRenderStateSet. This function also
+ * takes a render state value or pointer to an object depending on the type.
+ * For render states that are toggles, the value should be TRUE to switch the
+ * state on and FALSE to turn it off.
+ *
+ * Note that many of these render states may not be supported on certain
+ * platforms. The \ref RwRenderStateSet functions will return FALSE in such cases.
+ */
+enum RwRenderState
+{
+ rwRENDERSTATENARENDERSTATE = 0,
+ rwRENDERSTATETEXTURERASTER, /**<Raster to texture with. \ref RwRenderStateSet
+ * takes a pointer to an \ref RwRaster */
+ rwRENDERSTATETEXTUREADDRESS, /**<\ref RwTextureAddressMode: wrap, clamp, mirror or border */
+ rwRENDERSTATETEXTUREADDRESSU, /**<\ref RwTextureAddressMode in u only */
+ rwRENDERSTATETEXTUREADDRESSV, /**<\ref RwTextureAddressMode in v only */
+ rwRENDERSTATETEXTUREPERSPECTIVE, /**<Perspective correction on/off */
+ rwRENDERSTATEZTESTENABLE, /**<Z-buffer test on/off */
+ rwRENDERSTATESHADEMODE, /**<\ref RwShadeMode: flat or gouraud shading */
+ rwRENDERSTATEZWRITEENABLE, /**<Z-buffer write on/off */
+ rwRENDERSTATETEXTUREFILTER, /**<\ref RwTextureFilterMode: point sample, bilinear, trilinear, etc */
+ rwRENDERSTATESRCBLEND, /**<Source alpha \ref RwBlendFunction: src alpha, 1-src alpha, etc */
+ rwRENDERSTATEDESTBLEND, /**<Destination alpha \ref RwBlendFunction */
+ rwRENDERSTATEVERTEXALPHAENABLE, /**<Vertex alpha transparency on/off */
+ rwRENDERSTATEBORDERCOLOR, /**<Border color for \ref RwTextureAddressMode rwTEXTUREADDRESSBORDER.
+ * The value should be a packed RwUInt32 in ARGB form. The macro
+ * RWRGBALONG(r, g, b, a) may be used to construct this using 8-bit
+ * color components. */
+ rwRENDERSTATEFOGENABLE, /**<Fogging on/off (all polygons will be fogged) */
+ rwRENDERSTATEFOGCOLOR, /**<Color used for fogging. The value should be a packed RwUInt32
+ * in ARGB form. The macro RWRGBALONG(r, g, b, a) may be used to
+ * construct this using 8-bit color components */
+ rwRENDERSTATEFOGTYPE, /**<Sets \ref RwFogType, the type of fogging to use */
+ rwRENDERSTATEFOGDENSITY, /**<Select the fog density for \ref RwFogType of rwFOGTYPEEXPONENTIAL
+ * or rwFOGTYPEEXPONENTIAL2. The value should be a pointer to
+ * an RwReal in the range 0 to 1. */
+ rwRENDERSTATEFOGTABLE, /**<Install a 256 entry fog table placed between fog distance and far
+ * clip-plane */
+ rwRENDERSTATEALPHAPRIMITIVEBUFFER, /**<Render transparent alpha polygons last - on/off. \e Not \e supported
+ * \e on \e any \e platform.*/
+ rwRENDERSTATECULLMODE, /**<Sets \ref RwCullMode, for selecting face culling. */
+ rwRENDERSTATESTENCILENABLE, /**< TRUE to enable stenciling, or FALSE to disable stenciling.
+ * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only. */
+ rwRENDERSTATESTENCILFAIL, /**< Stencil test operator for the fail case.
+ * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */
+ rwRENDERSTATESTENCILZFAIL, /**< Stencil operation to perform if the stencil test passes
+ * and the depth test (z-test) fails.
+ * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */
+ rwRENDERSTATESTENCILPASS, /**< Stencil operation to perform if both the stencil and the
+ * depth (z) tests pass.
+ * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */
+ rwRENDERSTATESTENCILFUNCTION, /**< Comparison function for the stencil test.
+ * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */
+ rwRENDERSTATESTENCILFUNCTIONREF, /**< Integer reference value for the stencil test.
+ * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */
+ rwRENDERSTATESTENCILFUNCTIONMASK, /**< Mask applied to the reference value and each stencil buffer
+ * entry to determine the significant bits for the stencil test.
+ * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */
+ rwRENDERSTATESTENCILFUNCTIONWRITEMASK, /**< Write mask applied to values written into the stencil buffer.
+ * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */
+
+ rwRENDERSTATEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwRenderState RwRenderState;
+
+
+/**
+ * \ingroup datatypes
+ * RwShadeMode
+ * This type represents the options available for setting the
+ * rwRENDERSTATESHADEMODE render state */
+enum RwShadeMode
+{
+ rwSHADEMODENASHADEMODE = 0, /**<Invalid shading mode */
+ rwSHADEMODEFLAT, /**<Flat shading */
+ rwSHADEMODEGOURAUD, /**<Gouraud shading */
+ rwSHADEMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwShadeMode RwShadeMode;
+
+
+/**
+ * \ingroup datatypes
+ * RwTextureFilterMode
+ * This type represents the options available for texture
+ * filtering (see API functions \ref RwTextureSetFilterMode and \ref RwRenderStateSet)*/
+enum RwTextureFilterMode
+{
+ rwFILTERNAFILTERMODE = 0, /**<Invalid filter mode */
+ rwFILTERNEAREST, /**<Point sampled */
+ rwFILTERLINEAR, /**<Bilinear */
+ rwFILTERMIPNEAREST, /**<Point sampled per pixel mip map */
+ rwFILTERMIPLINEAR, /**<Bilinear per pixel mipmap */
+ rwFILTERLINEARMIPNEAREST, /**<MipMap interp point sampled */
+ rwFILTERLINEARMIPLINEAR, /**<Trilinear */
+ rwTEXTUREFILTERMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwTextureFilterMode RwTextureFilterMode;
+
+
+/**
+ * \ingroup datatypes
+ * RwFogType
+ * This type represents the options available to the
+ * rwRENDERSTATEFOGTYPE render state (see \ref RwRenderState);*/
+enum RwFogType
+{
+ rwFOGTYPENAFOGTYPE = 0, /**<Invalid fog type */
+ rwFOGTYPELINEAR, /**<Linear fog */
+ rwFOGTYPEEXPONENTIAL, /**<Exponential fog */
+ rwFOGTYPEEXPONENTIAL2, /**<Exponential^2 fog */
+ rwFOGTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwFogType RwFogType;
+
+
+/**
+ * \ingroup datatypes
+ * RwBlendFunction
+ * This type represents the options available
+ * to the rwRENDERSTATESRCBLEND and rwRENDERSTATEDESTBLEND render states
+ * (see \ref RwRenderState). In the following description,
+ * a subscript s refers to a source value while subscript d refers to a
+ * destination value.*/
+enum RwBlendFunction
+{
+ rwBLENDNABLEND = 0, /**<Invalid blend mode */
+ rwBLENDZERO, /**<(0, 0, 0, 0 ) */
+ rwBLENDONE, /**<(1, 1, 1, 1 ) */
+ rwBLENDSRCCOLOR, /**<(Rs, Gs, Bs, As ) */
+ rwBLENDINVSRCCOLOR, /**<(1-Rs, 1-Gs, 1-Bs, 1-As) */
+ rwBLENDSRCALPHA, /**<(As, As, As, As ) */
+ rwBLENDINVSRCALPHA, /**<(1-As, 1-As, 1-As, 1-As) */
+ rwBLENDDESTALPHA, /**<(Ad, Ad, Ad, Ad ) */
+ rwBLENDINVDESTALPHA, /**<(1-Ad, 1-Ad, 1-Ad, 1-Ad) */
+ rwBLENDDESTCOLOR, /**<(Rd, Gd, Bd, Ad ) */
+ rwBLENDINVDESTCOLOR, /**<(1-Rd, 1-Gd, 1-Bd, 1-Ad) */
+ rwBLENDSRCALPHASAT, /**<(f, f, f, 1 ) f = min (As, 1-Ad) */
+ rwBLENDFUNCTIONFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwBlendFunction RwBlendFunction;
+
+
+/**
+ * \ingroup datatypes
+ * RwTextureAddressMode
+ * This type represents the options available for
+ * applying textures to polygons (see API functions \ref RwTextureSetAddressing
+ * and \ref RwRenderStateSet, and the \ref RwRenderState type) */
+enum RwTextureAddressMode
+{
+ rwTEXTUREADDRESSNATEXTUREADDRESS = 0, /**<Invalid addressing mode */
+ rwTEXTUREADDRESSWRAP, /**<UV wraps (tiles) */
+ rwTEXTUREADDRESSMIRROR, /**<Alternate UV is flipped */
+ rwTEXTUREADDRESSCLAMP, /**<UV is clamped to 0-1 */
+ rwTEXTUREADDRESSBORDER, /**<Border colour takes effect outside of 0-1 */
+ rwTEXTUREADDRESSMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwTextureAddressMode RwTextureAddressMode;
+
+/**
+ * \ingroup datatypes
+ * RwStencilOperation
+ * This type represents the stencil operations to perform
+ * based on the results of the
+ * \ref rwRENDERSTATESTENCILFAIL, \ref rwRENDERSTATESTENCILZFAIL
+ * and \ref rwRENDERSTATESTENCILPASS tests.
+ */
+enum RwStencilOperation
+{
+ rwSTENCILOPERATIONNASTENCILOPERATION = 0,
+ rwSTENCILOPERATIONKEEP, /* Do not update the entry in the stencil buffer */
+ rwSTENCILOPERATIONZERO, /* Set the stencil-buffer entry to 0 */
+ rwSTENCILOPERATIONREPLACE, /* Replace the stencil-buffer entry with reference value */
+ rwSTENCILOPERATIONINCRSAT, /* Increment the stencil-buffer entry, clamping to the maximum value */
+ rwSTENCILOPERATIONDECRSAT, /* Decrement the stencil-buffer entry, clamping to zero */
+ rwSTENCILOPERATIONINVERT, /* Invert the bits in the stencil-buffer entry */
+ rwSTENCILOPERATIONINCR, /* Increment the stencil-buffer entry, wrapping to zero if the new value exceeds the maximum value */
+ rwSTENCILOPERATIONDECR, /* Decrement the stencil-buffer entry, wrapping to the maximum value if the new value is less than zero */
+ rwSTENCILOPERATIONFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwStencilOperation RwStencilOperation;
+
+/**
+ * \ingroup datatypes
+ * RwStencilFunction
+ * This type represents the options available for
+ * the comparison function for the stencil test \ref rwRENDERSTATESTENCILFUNCTION.
+ */
+enum RwStencilFunction
+{
+ rwSTENCILFUNCTIONNASTENCILFUNCTION = 0,
+ rwSTENCILFUNCTIONNEVER, /* Always fail the test */
+ rwSTENCILFUNCTIONLESS, /* Accept the new pixel if its value is less than the value of the current pixel */
+ rwSTENCILFUNCTIONEQUAL, /* Accept the new pixel if its value equals the value of the current pixel */
+ rwSTENCILFUNCTIONLESSEQUAL, /* Accept the new pixel if its value is less than or equal to the value of the current pixel */
+ rwSTENCILFUNCTIONGREATER, /* Accept the new pixel if its value is greater than the value of the current pixel */
+ rwSTENCILFUNCTIONNOTEQUAL, /* Accept the new pixel if its value does not equal the value of the current pixel */
+ rwSTENCILFUNCTIONGREATEREQUAL, /* Accept the new pixel if its value is greater than or equal to the value of the current pixel */
+ rwSTENCILFUNCTIONALWAYS, /* Always pass the test */
+ rwSTENCILFUNCTIONFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwStencilFunction RwStencilFunction;
+
+/**
+ * \ingroup datatypes
+ * RwCullMode
+ * This type represents the options available for culling polygons during rendering.
+ * and \ref RwRenderStateSet, and the \ref RwRenderState type) */
+enum RwCullMode
+{
+ rwCULLMODENACULLMODE = 0,
+ rwCULLMODECULLNONE, /**< Both front and back-facing triangles are drawn. */
+ rwCULLMODECULLBACK, /**< Just front-facing triangles are drawn */
+ rwCULLMODECULLFRONT, /**< Just rear-facing triangles are drawn */
+
+ rwCULLMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwCullMode RwCullMode;
+
+/**
+ * \ingroup datatypes
+ * RwPrimitiveType
+ * This type represents the different types of indexed
+ * line and indexed triangle primitives that are available when rendering 2D
+ * and 3D immediate mode objects (see API functions \ref RwIm2DRenderIndexedPrimitive,
+ * \ref RwIm2DRenderPrimitive, \ref RwIm3DRenderIndexedPrimitive and \ref RwIm3DRenderPrimitive).
+ * Indices are into a vertex list and must be defined in a counter-clockwise order
+ * (as seen from the camera) to be visible.*/
+enum RwPrimitiveType
+{
+ rwPRIMTYPENAPRIMTYPE = 0, /**<Invalid primative type */
+ rwPRIMTYPELINELIST = 1, /**<Unconnected line segments, each line is specified by
+ * both its start and end index, independently of other lines
+ * (for example, 3 segments specified as 0-1, 2-3, 4-5) */
+ rwPRIMTYPEPOLYLINE = 2, /**<Connected line segments, each line's start index
+ * (except the first) is specified by the index of the end of
+ * the previous segment (for example, 3 segments specified as
+ * 0-1, 1-2, 2-3) */
+ rwPRIMTYPETRILIST = 3, /**<Unconnected triangles: each triangle is specified by
+ * three indices, independently of other triangles (for example,
+ * 3 triangles specified as 0-1-2, 3-4-5, 6-7-8) */
+ rwPRIMTYPETRISTRIP = 4, /**<Connected triangles sharing an edge with, at most, one
+ * other forming a series (for example, 3 triangles specified
+ * as 0-2-1, 1-2-3-, 2-4-3) */
+ rwPRIMTYPETRIFAN = 5 , /**<Connected triangles sharing an edge with, at most,
+ * two others forming a fan (for example, 3 triangles specified
+ * as 0-2-1, 0-3-2, 0-4-3) */
+ rwPRIMTYPEPOINTLIST = 6, /**<Points 1, 2, 3, etc. This is not
+ * supported by the default RenderWare
+ * immediate or retained-mode pipelines
+ * (except on PlayStation 2), it is intended
+ * for use by user-created pipelines */
+ rwPRIMITIVETYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwPrimitiveType RwPrimitiveType;
+
+
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Expose Z buffer range */
+extern RwReal RwIm2DGetNearScreenZ(void);
+extern RwReal RwIm2DGetFarScreenZ(void);
+
+extern RwBool RwRenderStateGet(RwRenderState state, void *value);
+extern RwBool RwRenderStateSet(RwRenderState state, void *value);
+
+extern RwBool RwIm2DRenderLine(RwIm2DVertex *vertices, RwInt32 numVertices, RwInt32 vert1, RwInt32 vert2);
+extern RwBool RwIm2DRenderTriangle(RwIm2DVertex *vertices, RwInt32 numVertices,
+ RwInt32 vert1, RwInt32 vert2, RwInt32 vert3 );
+extern RwBool RwIm2DRenderPrimitive(RwPrimitiveType primType, RwIm2DVertex *vertices, RwInt32 numVertices);
+extern RwBool RwIm2DRenderIndexedPrimitive(RwPrimitiveType primType, RwIm2DVertex *vertices, RwInt32 numVertices,
+ RwImVertexIndex *indices, RwInt32 numIndices);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/badevice.h ---*/
+/***************************************************************************/
+/************************* System Requests *********************************/
+/***************************************************************************/
+
+/* Device controls:
+ *
+ * rwDEVICESYSTEMOPEN(NULL, RwEngineOpenParams *openParams, 0)
+ * rwDEVICESYSTEMCLOSE(NULL, NULL, 0)
+ * rwDEVICESYSTEMSTART(NULL, NULL, 0)
+ * rwDEVICESYSTEMSTOP(NULL, NULL, 0)
+ * rwDEVICESYSTEMREGISTER(RwDevice *coreDeviceBlock, RwMemoryFunctions *memFuncs, 0)
+ * rwDEVICESYSTEMGETNUMMODES(RwInt32 *numModes, NULL, 0)
+ * rwDEVICESYSTEMGETMODEINFO(RwVideoMode *modeinfo, NULL, RwInt32 modeNum)
+ * rwDEVICESYSTEMUSEMODE(NULL, NULL, RwInt32 modeNum)
+ * rwDEVICESYSTEMFOCUS(NULL, NULL, RwBool gainFocus)
+ * rwDEVICESYSTEMINITPIPELINE(NULL, NULL, 0)
+ * rwDEVICESYSTEMGETMODE(RwInt32 *curMode, NULL, 0)
+ * rwDEVICESYSTEMSTANDARDS(RwStandardFunc *fnPtrArray, NULL, RwInt32 arraySize)
+ * rwDEVICESYSTEMGETTEXMEMSIZE(RwInt32 *texMemSizeOut, NULL, 0)
+ * rwDEVICESYSTEMGETNUMSUBSYSTEMS(RwInt32 *numSubSystemsOut, NULL, 0)
+ * rwDEVICESYSTEMGETSUBSYSTEMINFO(RwSubSystemInfo *subSystemInfo, NULL, RwInt32 subSystemNum)
+ * rwDEVICESYSTEMGETCURRENTSUBSYSTEM(RwInt32 *curSubSystem, NULL, 0)
+ * rwDEVICESYSTEMSETSUBSYSTEM(NULL, NULL, RwInt32 subSystemNum)
+ * rwDEVICESYSTEMFINALIZESTART(NULL, NULL, 0)
+ * rwDEVICESYSTEMINITIATESTOP(NULL, NULL, 0)
+ * rwDEVICESYSTEMRXPIPELINEREQUESTPIPE(RxPipeline **pipelineRef, NULL, RwInt32 pipeType)
+ * rwDEVICESYSTEMDD - start of device specific controls
+ */
+
+#define rwPIPETYPEMATERIAL 0
+#define rwPIPETYPEWORLDSECTORINSTANCE 1
+#define rwPIPETYPEATOMICINSTANCE 2
+
+enum RwCoreDeviceSystemFn
+{
+ rwDEVICESYSTEMOPEN = 0x00,
+ rwDEVICESYSTEMCLOSE,
+ rwDEVICESYSTEMSTART,
+ rwDEVICESYSTEMSTOP,
+ rwDEVICESYSTEMREGISTER,
+ rwDEVICESYSTEMGETNUMMODES,
+ rwDEVICESYSTEMGETMODEINFO,
+ rwDEVICESYSTEMUSEMODE,
+ rwDEVICESYSTEMFOCUS,
+ rwDEVICESYSTEMINITPIPELINE,
+ rwDEVICESYSTEMGETMODE,
+ rwDEVICESYSTEMSTANDARDS,
+ rwDEVICESYSTEMGETTEXMEMSIZE,
+ rwDEVICESYSTEMGETNUMSUBSYSTEMS,
+ rwDEVICESYSTEMGETSUBSYSTEMINFO,
+ rwDEVICESYSTEMGETCURRENTSUBSYSTEM,
+ rwDEVICESYSTEMSETSUBSYSTEM,
+ rwDEVICESYSTEMFINALIZESTART,
+ rwDEVICESYSTEMINITIATESTOP,
+ rwDEVICESYSTEMGETMAXTEXTURESIZE,
+ rwDEVICESYSTEMRXPIPELINEREQUESTPIPE,
+ rwDEVICESYSTEMGETMETRICBLOCK,
+ rwDEVICESYSTEMDD = 0x1000,
+ rwCOREDEVICESYSTEMFNFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwCoreDeviceSystemFn RwCoreDeviceSystemFn;
+
+/******************************************************************************/
+/********************* Standard functions *************************************/
+/******************************************************************************/
+
+#define rwSTANDARDNASTANDARD 0
+#define rwSTANDARDCAMERABEGINUPDATE 1 /* Start 3d camera update */
+#define rwSTANDARDRGBTOPIXEL 2 /* For an RGB value return a pixel value */
+#define rwSTANDARDPIXELTORGB 3 /* For a pixel value returns a RGB value */
+#define rwSTANDARDRASTERCREATE 4 /* Create an raster */
+#define rwSTANDARDRASTERDESTROY 5 /* Raster destroy */
+#define rwSTANDARDIMAGEGETRASTER 6 /* Get image from a raster */
+#define rwSTANDARDRASTERSETIMAGE 7 /* Set raster from an image */
+#define rwSTANDARDTEXTURESETRASTER 8 /* Set texture's raster */
+#define rwSTANDARDIMAGEFINDRASTERFORMAT 9 /* Find a suitable raster format for an image */
+#define rwSTANDARDCAMERAENDUPDATE 10 /* End 3d camera update */
+#define rwSTANDARDSETRASTERCONTEXT 11 /* Start destination of 2d operations */
+#define rwSTANDARDRASTERSUBRASTER 12 /* Make a raster inside another raster */
+#define rwSTANDARDRASTERCLEARRECT 13 /* Clear a rectangle of the current dest raster */
+#define rwSTANDARDRASTERCLEAR 14 /* Clear the current dest raster */
+#define rwSTANDARDRASTERLOCK 15 /* Lock a raster to get it's pixels */
+#define rwSTANDARDRASTERUNLOCK 16 /* Unlock a raster to return it's pixels */
+#define rwSTANDARDRASTERRENDER 17 /* Render a raster (not scaled, but masked) */
+#define rwSTANDARDRASTERRENDERSCALED 18 /* Render a raster (scaled and masked) */
+#define rwSTANDARDRASTERRENDERFAST 19 /* Render a raster (not scaled or masked) */
+#define rwSTANDARDRASTERSHOWRASTER 20 /* Show a camera raster */
+#define rwSTANDARDCAMERACLEAR 21 /* Clear a camera's raster and/or Z raster */
+#define rwSTANDARDHINTRENDERF2B 22 /* Set hint for rendering direction in the world */
+#define rwSTANDARDRASTERLOCKPALETTE 23 /* Lock a raster to get it's palette */
+#define rwSTANDARDRASTERUNLOCKPALETTE 24 /* Unlock a raster to return it's palette */
+#define rwSTANDARDNATIVETEXTUREGETSIZE 25 /* Get size of native texture when written to a stream */
+#define rwSTANDARDNATIVETEXTUREREAD 26 /* Read native texture from the stream */
+#define rwSTANDARDNATIVETEXTUREWRITE 27 /* Write native texture to the stream */
+#define rwSTANDARDRASTERGETMIPLEVELS 28 /* Get the number of mip levels in a raster */
+#define rwSTANDARDNUMOFSTANDARD 29
+
+/****************************************************************************
+ Global Types
+ */
+
+/* Standard functions */
+typedef RwBool (*RwStandardFunc)(void *pOut,void *pInOut,RwInt32 nI);
+
+typedef struct RwEngineOpenParams RwEngineOpenParams;
+
+/**
+ * \ingroup datatypes
+ * \struct RwEngineOpenParams
+ * This type is used to specify device dependent parameters
+ * for use by the API function \ref RwEngineOpen.
+ * For a Windows application the displayID field
+ * should be set to the window's handle (of type HWND).
+ * For NULL and sky libraries displayID=0:
+ */
+struct RwEngineOpenParams
+{
+ void *displayID; /**< Display Identifier */
+};
+
+/* nOption is one of a list of possible System defines (see above) */
+typedef RwBool
+ (*RwSystemFunc)(RwInt32 nOption,
+ void *pOut,
+ void *pInOut,
+ RwInt32 nIn);
+
+/* Device block */
+typedef RwBool
+ (*RwRenderStateSetFunction)(RwRenderState nState,void *pParam);
+
+typedef RwBool
+ (*RwRenderStateGetFunction)(RwRenderState nState,void *pParam);
+
+typedef RwBool
+ (*RwIm2DRenderLineFunction)(RwIm2DVertex *vertices,
+ RwInt32 numVertices,
+ RwInt32 vert1,
+ RwInt32 vert2);
+
+typedef RwBool
+ (*RwIm2DRenderTriangleFunction)(RwIm2DVertex *vertices,
+ RwInt32 numVertices,
+ RwInt32 vert1,
+ RwInt32 vert2,
+ RwInt32 vert3);
+
+typedef RwBool
+ (*RwIm2DRenderPrimitiveFunction)(RwPrimitiveType primType,
+ RwIm2DVertex *vertices,
+ RwInt32 numVertices);
+
+typedef RwBool
+ (*RwIm2DRenderIndexedPrimitiveFunction)(RwPrimitiveType primType,
+ RwIm2DVertex *vertices,
+ RwInt32 numVertices,
+ RwImVertexIndex *indices,
+ RwInt32 numIndices);
+
+typedef RwBool
+ (*RwIm3DRenderLineFunction)(RwInt32 vert1,
+ RwInt32 vert2);
+
+typedef RwBool
+ (*RwIm3DRenderTriangleFunction)(RwInt32 vert1,
+ RwInt32 vert2,
+ RwInt32 vert3);
+
+typedef RwBool
+ (*RwIm3DRenderPrimitiveFunction)(RwPrimitiveType primType);
+
+typedef RwBool
+ (*RwIm3DRenderIndexedPrimitiveFunction)(RwPrimitiveType primtype,
+ RwImVertexIndex *indices,
+ RwInt32 numIndices);
+
+
+typedef struct RwDevice RwDevice;
+/**
+ * \ingroup datatypes
+ * \struct RwDevice
+ * Structure describing a display device
+ */
+struct RwDevice
+{
+ RwReal gammaCorrection; /**<Gamma correction */
+ RwSystemFunc fpSystem; /**< System handler */
+ RwReal zBufferNear; /**< Near Z buffer value */
+ RwReal zBufferFar; /**< Far Z buffer value */
+
+ /* Immediate mode functions */
+ RwRenderStateSetFunction fpRenderStateSet; /**< Internal Use */
+ RwRenderStateGetFunction fpRenderStateGet; /**< Internal Use */
+
+ /* Render functions */
+ RwIm2DRenderLineFunction fpIm2DRenderLine; /**< Internal Use */
+ RwIm2DRenderTriangleFunction fpIm2DRenderTriangle; /**< Internal Use */
+ RwIm2DRenderPrimitiveFunction fpIm2DRenderPrimitive; /**< Internal Use */
+ RwIm2DRenderIndexedPrimitiveFunction fpIm2DRenderIndexedPrimitive; /**< Internal Use */
+
+ RwIm3DRenderLineFunction fpIm3DRenderLine; /**< Internal Use */
+ RwIm3DRenderTriangleFunction fpIm3DRenderTriangle; /**< Internal Use */
+ RwIm3DRenderPrimitiveFunction fpIm3DRenderPrimitive; /**< Internal Use */
+ RwIm3DRenderIndexedPrimitiveFunction fpIm3DRenderIndexedPrimitive; /**< Internal Use */
+};
+
+typedef struct RwMetrics RwMetrics;
+/**
+ * \ingroup datatypes
+ * \struct RwMetrics
+ * This structure provides information about the performance
+ * of the application. The metrics are recorded only in the metrics
+ * libraries. To use metrics you should compile with the RWMETRICS
+ * preprocessor symbol defines, and link with the metrics libraries
+ * that ship with the SDK. The metrics are recorded on a per-frame
+ * basis. Each platform may provide additional information that
+ * is specific to that platform. Note that either the
+ * \ref numTextureUploads or \ref numResourceAllocs being non-zero can
+ * be considered as bad news and will indicate a significantly
+ * reduced rendering performance.
+ */
+struct RwMetrics
+{
+ RwUInt32 numTriangles; /**< Number of triangles processed */
+ RwUInt32 numProcTriangles; /**< Number of mesh triangles processed */
+ RwUInt32 numVertices; /**< Number of vertices processed */
+ RwUInt32 numTextureUploads; /**< Number of textures swapped */
+ RwUInt32 sizeTextureUploads; /**< Size of textures swapped */
+ RwUInt32 numResourceAllocs; /**< Number of resource blocks swapped */
+ void *devSpecificMetrics; /**< Device specific metrics */
+};
+
+#define SUBSYSTEMNAME_MAXLEN 80
+
+typedef struct RwSubSystemInfo RwSubSystemInfo;
+/**
+ * \ingroup datatypes
+ * \struct RwSubSystemInfo
+ * This type is used to represent information about a device.
+ * The only available field specifies a character string
+ * which identifies the subsystem
+ * (see API function \ref RwEngineGetSubSystemInfo). */
+struct RwSubSystemInfo
+{
+ RwChar name[SUBSYSTEMNAME_MAXLEN]; /**< Sub system string */
+};
+
+
+/* Video modes */
+/* These are flag bits which may be ORd */
+
+/**
+ * \ingroup datatypes
+ * RwVideoModeFlag
+ * These flags specify the type of display that RenderWare
+ * will use. The flags may be OR'd together to build composite modes.
+ * Note that not all modes are supported on all platforms.
+ */
+enum RwVideoModeFlag
+{
+ rwVIDEOMODEEXCLUSIVE = 0x1, /**<Exclusive (i.e. full-screen) */
+ rwVIDEOMODEINTERLACE = 0x2, /**<Interlaced */
+ rwVIDEOMODEFFINTERLACE = 0x4, /**<Flicker Free Interlaced */
+ rwVIDEOMODEFSAA0 = 0x8, /**< \if sky2
+ * Full-screen antialiasing mode 0
+ * \endif */
+ rwVIDEOMODEFSAA1 = 0x10, /**< \if sky2
+ * Full-screen antialiasing mode 1
+ * \endif */
+ rwVIDEOMODEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwVideoModeFlag RwVideoModeFlag;
+
+typedef struct RwVideoMode RwVideoMode;
+/**
+ * \ingroup datatypes
+ * \struct RwVideoMode
+ * This type represents a video mode available on a device specified
+ * by the frame buffer resolution (width and height) and depth,
+ * and a flag indicating whether the device has exclusive use of
+ * the mode (see API function \ref RwEngineGetVideoModeInfo): */
+struct RwVideoMode
+{
+ RwInt32 width; /**< Width */
+ RwInt32 height; /**< Height */
+ RwInt32 depth; /**< Depth */
+ RwVideoModeFlag flags; /**< Flags */
+};
+
+/**
+ * \ingroup datatypes
+ * RwEngineInitFlag
+ * Engine initialization flags. An application can use
+ * these to control the memory manager that RenderWare uses for dynamic
+ * memory management. By default RenderWare uses FreeLists. This is the
+ * preferred way of using RenderWare. If the application does not want
+ * RenderWare to use the memory manager, then the application can pass
+ * rwENGINEINITNOFREELISTS as the argument to \ref RwEngineInit and
+ * RenderWare will replace freelist calls to corresponding calls to
+ * RwMalloc and RwFree. This will result in more memory management
+ * related calls.
+ */
+enum RwEngineInitFlag
+{
+ rwENGINEINITFREELISTS = 0, /**<Use Freelists */
+ rwENGINEINITNOFREELISTS = 0x1, /**<Don't use Freelists */
+ rwENGINEINITFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwEngineInitFlag RwEngineInitFlag;
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Get the library binary version */
+extern RwInt32 RwEngineGetVersion(void);
+
+/* Sequence of events to get RenderWare up and running */
+extern RwBool RwEngineInit(RwMemoryFunctions *memFuncs, RwUInt32 initFlags, RwUInt32 resArenaSize);
+extern RwInt32 RwEngineRegisterPlugin(RwInt32 size, RwUInt32 pluginID,
+ RwPluginObjectConstructor initCB,
+ RwPluginObjectDestructor termCB);
+extern RwInt32 RwEngineGetPluginOffset(RwUInt32 pluginID);
+extern RwBool RwEngineOpen(RwEngineOpenParams *initParams);
+extern RwBool RwEngineStart(void);
+extern RwBool RwEngineStop(void);
+extern RwBool RwEngineClose(void);
+extern RwBool RwEngineTerm(void);
+
+/* Finding out about the rendering sub systems available */
+extern RwInt32 RwEngineGetNumSubSystems(void);
+extern RwSubSystemInfo *RwEngineGetSubSystemInfo(RwSubSystemInfo *subSystemInfo, RwInt32 subSystemIndex);
+extern RwInt32 RwEngineGetCurrentSubSystem(void);
+extern RwBool RwEngineSetSubSystem(RwInt32 subSystemIndex);
+
+/* Finding out about the modes available */
+extern RwInt32 RwEngineGetNumVideoModes(void);
+extern RwVideoMode *RwEngineGetVideoModeInfo(RwVideoMode *modeinfo, RwInt32 modeIndex);
+extern RwInt32 RwEngineGetCurrentVideoMode(void);
+extern RwBool RwEngineSetVideoMode(RwInt32 modeIndex);
+
+/* Finding out how much texture memory is available */
+extern RwInt32 RwEngineGetTextureMemorySize(void);
+extern RwInt32 RwEngineGetMaxTextureSize(void);
+
+/* Getting/Releasing the focus */
+extern RwBool RwEngineSetFocus(RwBool enable);
+
+/* Getting metrics */
+extern RwMetrics *RwEngineGetMetrics(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bafsys.h ---*/
+
+/****************************************************************************
+ Global Types
+ */
+
+/*
+ * \typedef rwFnFexist
+ * Returns TRUE if file with given name exists, FALSE if it doesn't.
+ */
+typedef RwBool (*rwFnFexist)(const RwChar *name);
+
+/*
+ * \typedef rwFnFopen
+ * Mimics ANSI C Standard Library fopen.
+ */
+typedef void *(*rwFnFopen)(const RwChar *name, const RwChar *mode);
+
+/*
+ * \typedef rwFnFclose
+ * Mimics ANSI C Standard Library fclose.
+ */
+typedef int (*rwFnFclose)(void *fptr);
+
+/*
+ * \typedef rwFnFread
+ * Mimics ANSI C Standard Library fread.
+ */
+typedef size_t (*rwFnFread)(void *addr, size_t size, size_t count, void *fptr);
+
+/*
+ * \typedef rwFnFwrite
+ * Mimics ANSI C Standard Library fwrite.
+ */
+typedef size_t (*rwFnFwrite)(const void *addr, size_t size, size_t count, void *fptr);
+
+/*
+ * \typedef rwFnFgets
+ * Mimics ANSI C Standard Library fgets.
+ */
+typedef RwChar *(*rwFnFgets)(RwChar *buffer, int maxLen, void *fptr);
+
+/*
+ * \typedef rwFnFputs
+ * Mimics ANSI C Standard Library fputs.
+ */
+typedef int (*rwFnFputs)(const RwChar *buffer, void *fptr);
+
+/*
+ * \typedef rwFnFeof
+ * Mimics ANSI C Standard Library feof.
+ */
+typedef int (*rwFnFeof)(void *fptr);
+
+/*
+ * \typedef rwFnFseek
+ * Mimics ANSI C Standard Library fseek.
+ */
+typedef int (*rwFnFseek)(void *fptr, long offset, int origin);
+
+/*
+ * \typedef rwFnFflush
+ * Mimics ANSI C Standard Library fflush.
+ */
+typedef int (*rwFnFflush)(void *fptr);
+
+/*
+ * \typedef rwFnFtell
+ * Mimics ANSI C Standard Library ftell.
+ */
+typedef int (*rwFnFtell)(void *fptr);
+
+
+/**
+ * \ingroup datatypes
+ * \typedef RwFileFunctions
+ * typedef for struct RwFileFunctions
+ */
+typedef struct RwFileFunctions RwFileFunctions;
+/**
+ * \ingroup datatypes
+ * \struct RwFileFunctions
+ * This type is used to specify the file access
+ * functions used by RenderWare. The default file system uses the standard
+ * ANSI functions. The application may install an alternative file system
+ * providing it complies with the ANSI interface -- see API
+ * function \ref RwOsGetFileInterface.
+ *
+ * The function types associated with this type are defined as follows
+ *
+ * \verbatim
+ RwBool (*rwFnFexist)(const RwChar *name)
+ void *(*rwFnFopen)(const RwChar *name, const RwChar *access)
+ int (*rwFnFclose)(void *fptr)
+ size_t (*rwFnFread)(void *addr, size_t size, size_t count, void *fptr)
+ size_t (*rwFnFwrite)(const void *addr, size_t size, size_t count,
+ void *fptr)
+ RwChar *(*rwFnFgets)(RwChar *buffer, int maxLen, void *fptr)
+ int (*rwFnFputs)(const RwChar *buffer, void *fptr)
+ int (*rwFnFeof)(void *fptr)
+ int (*rwFnFseek)(void *fptr, long offset, int origin)
+ int (*rwFnFflush)(void *fptr)
+ int (*rwFnFtell)(void *fptr)
+ \endverbatim
+ * Note the function argument lists are consistent with the ANSI
+ * standard file access interface:
+ */
+struct RwFileFunctions
+{
+ rwFnFexist rwfexist; /**< Pointer to fexist function */
+ rwFnFopen rwfopen; /**< Pointer to fopen function */
+ rwFnFclose rwfclose; /**< Pointer to fclose function */
+ rwFnFread rwfread; /**< Pointer to fread function */
+ rwFnFwrite rwfwrite; /**< Pointer to fwrite function */
+ rwFnFgets rwfgets; /**< Pointer to fgets function */
+ rwFnFputs rwfputs; /**< Pointer to puts function */
+ rwFnFeof rwfeof; /**< Pointer to feof function */
+ rwFnFseek rwfseek; /**< Pointer to fseek function */
+ rwFnFflush rwfflush; /**< Pointer to fflush function */
+ rwFnFtell rwftell; /**< Pointer to ftell function */
+};
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwFileFunctions *RwOsGetFileInterface(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/baerr.h ---*/
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct RwError RwError;
+/**
+ * \ingroup datatypes
+ * \struct RwError
+ * This type represents a RenderWare error specified by the
+ * ID of the plugin that the error was issued from (pluginID) and the error
+ * code itself (errorCode) (see API function \ref RwErrorGet).
+ * \param pluginID The ID of the plugin that issued the error.
+ * \param errorCode A value representing the error code.
+ */
+struct RwError
+{
+ RwInt32 pluginID; /**< Internal Use */
+ RwInt32 errorCode; /**< Internal Use */
+};
+
+#define RWECODE(a,b) a,
+
+/* common errors have the MSB set */
+
+enum RwErrorCodeCommon
+{
+ E_RW_NOERROR = (int)0x80000000L,
+#include "errcom.def"
+ E_RW_LASTERROR = RWFORCEENUMSIZEINT
+};
+typedef enum RwErrorCodeCommon RwErrorCodeCommon;
+
+#undef RWECODE
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwError *RwErrorGet(RwError *code);
+extern RwError *RwErrorSet(RwError *code);
+extern RwInt32 _rwerror(RwInt32 code, ...);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/badebug.h ---*/
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * RwDebugType
+ * This type represents the different types of debug and
+ * trace messages that can be sent to the currently installed debug handler
+ * (see API function \ref RwDebugSendMessage)*/
+enum RwDebugType
+{
+ rwNADEBUGTYPE = 0, /**<Invalid */
+ rwDEBUGASSERT, /**<Send an assert message */
+ rwDEBUGERROR, /**<Send an error message */
+ rwDEBUGMESSAGE, /**<Send an informational message */
+ rwDEBUGTRACE, /**<Send a trace message */
+ rwDEBUGTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwDebugType RwDebugType;
+
+/**
+ * \ingroup datatypes
+ * \ref RwDebugHandler
+ * This type represents the
+ * function called from \ref RwDebugSendMessage for sending a message to the
+ * RenderWare debug stream.
+ *
+ * \param type Type of debug message (assert, error, etc.).
+ *
+ * \param string Pointer to a string containing the error
+ * message.
+ *
+ * \see RwDebugSetHandler
+ */
+typedef void (*RwDebugHandler) (RwDebugType type,
+
+ const RwChar * string);
+
+#ifdef RWDEBUG
+
+#define RwDebugSendMessage(type, funcName, message) \
+ _rwDebugSendMessage(type, \
+ RWSTRING(__FILE__), \
+ __LINE__, \
+ funcName, \
+ message)
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Setting the debug message handler */
+extern RwDebugHandler RwDebugSetHandler(RwDebugHandler handler);
+extern void RwDebugSetTraceState(RwBool state);
+
+extern void _rwDebugSendMessage(RwDebugType type,
+ const RwChar * file,
+ const RwInt32 line,
+ const RwChar * funcName,
+ const RwChar * message);
+
+/* Sending a message */
+extern RwChar *_rwdberrcommon(RwInt32 code, ...);
+extern RwChar *_rwdbsprintf(const RwChar * format,
+ ...) __RWFORMAT__(printf, 1, 2);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#else /* RWDEBUG */
+
+#define RwDebugSetHandler(handler)
+#define RwDebugSetTraceState(state)
+#define RwDebugSendMessage(type, funcName, message)
+
+#if (!defined(RWREGSETDEBUGTRACE))
+#define RWREGSETDEBUGTRACE(_name) /* No op */
+#endif /* (!defined(RWREGSETDEBUGTRACE)) */
+
+#endif /* RWDEBUG */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/balibtyp.h ---*/
+/* Finding MSBs */
+
+#define RWBYTEFINDMSB(a) \
+ (_rwMsbBit[(a)]-1)
+
+#define RWWORDFINDMSB(a) \
+ (((a)&0xff00)?RWBYTEFINDMSB((a)>>8)+8: RWBYTEFINDMSB(a))
+
+#define RWLONGFINDMSB(a) \
+ (((a)&0xffff0000UL)?RWWORDFINDMSB((a)>>16)+16: RWWORDFINDMSB(a))
+
+/****************************************************************************
+ Defines
+ */
+
+/* macros used to access plugin data in objects */
+#define RWPLUGINOFFSET(_type, _base, _offset) \
+ ((_type *)((RwUInt8 *)(_base) + (_offset)))
+
+#define RWPLUGINOFFSETCONST(_type, _base, _offset) \
+ ((const _type *)((const RwUInt8 *)(_base) + (_offset)))
+
+/* macro used to access global data structure (the root type is RwGlobals) */
+#define RWSRCGLOBAL(variable) \
+ (((RwGlobals *)RwEngineInstance)->variable)
+
+#define RWASSERTISTYPE(_f, _t) \
+ RWASSERT((((const RwObject *)(_f))->type)==(_t))
+
+/****************************************************************************
+ Global Types
+ */
+
+enum RwEngineStatus
+{
+ rwENGINESTATUSIDLE = 0, /* This needs to be zero */
+ rwENGINESTATUSINITED = 1,
+ rwENGINESTATUSOPENED = 2,
+ rwENGINESTATUSSTARTED = 3,
+ rwENGINESTATUSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwEngineStatus RwEngineStatus;
+
+typedef struct RwGlobals RwGlobals;
+struct RwGlobals
+{
+#ifdef RWDEBUG
+ RwDebugHandler debugFunction; /* debug string handler */
+ void *debugFile; /* debug output file */
+ RwInt32 debugStackDepth; /* current depth of function stack */
+ RwBool debugTrace; /* is function tracing enabled */
+#endif
+
+ /* Current entities */
+ void *curCamera; /* Current camera */
+ void *curWorld; /* Current World */
+
+ /* Checking counters */
+ RwUInt16 renderFrame; /* Camera display count */
+ RwUInt16 lightFrame; /* Used to ensure each light is applied only once. */
+ RwUInt16 pad[2]; /* Longword align it again */
+
+ /* For the currently accessed device */
+ RwDevice dOpenDevice;
+
+ /* Standard renderers and functions */
+ RwStandardFunc stdFunc[rwSTANDARDNUMOFSTANDARD];
+
+ /* All of the frames which have been updated */
+ RwLinkList dirtyFrameList;
+
+ /* The file functions */
+ RwFileFunctions fileFuncs;
+
+ /* The string functions */
+ RwStringFunctions stringFuncs;
+
+ /* The memory allocation functions */
+ RwMemoryFunctions memoryFuncs;
+#ifdef RWDEBUG
+ RwBool freeListExtraDebug;
+#endif /* RWDEBUG */
+
+ /* virtual memory alloc/free functions */
+ RwMemoryAllocFn memoryAlloc;
+ RwMemoryFreeFn memoryFree;
+
+ RwMetrics *metrics;
+
+ /* Current engine status */
+ RwEngineStatus engineStatus;
+
+ /* Resource arena init size. */
+ RwUInt32 resArenaInitSize;
+};
+
+typedef struct RwModuleInfo RwModuleInfo;
+struct RwModuleInfo
+{
+ RwInt32 globalsOffset;
+ RwInt32 numInstances;
+};
+
+
+
+/****************************************************************************
+ Program wide globals
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+#ifdef RWGLOBALSIZE
+extern RwUInt32 ourGlobals[RWGLOBALSIZE / sizeof(RwUInt32)];
+#define RwEngineInstance ourGlobals
+#else /* RWGLOBALSIZE */
+extern void *RwEngineInstance;
+#endif /* RWGLOBALSIZE */
+
+extern RwInt8 _rwMsbBit[];
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/baresour.h ---*/
+
+#define RWRESOURCESGLOBAL(var) (RWPLUGINOFFSET(rwResourcesGlobals, \
+ RwEngineInstance, resourcesModule.globalsOffset)->var)
+
+/**
+ * \ingroup datatypes
+ * \typedef RwResEntry
+ * RwResEntry object. Instanced data block in resources arena.
+ * This should be considered an opaque
+ * type. Use the RwResEntry API functions to access.
+ */
+typedef struct RwResEntry RwResEntry;
+
+/**
+ * \ingroup datatypes
+ * \typedef RwResEntryDestroyNotify
+ * This type represents the function
+ * called from \ref RwResourcesFreeResEntry (and indirectly from
+ * \ref RwResourcesEmptyArena) immediately before the memory used by the
+ * specified resources entry is released.
+ *
+ * \param resEntry Pointer to the instanced data.
+ */
+typedef void (*RwResEntryDestroyNotify) (RwResEntry * resEntry);
+
+#if (!defined(DOXYGEN))
+struct RwResEntry
+{
+ RwLLLink link; /**< Node in the list of resource elements */
+ RwInt32 size; /**< Size of this node */
+ void *owner; /**< Owner of this node */
+ RwResEntry **ownerRef; /**< Pointer to pointer to this (enables de-alloc) */
+ RwResEntryDestroyNotify destroyNotify; /**< This is called right before destruction */
+};
+#endif /* (!defined(DOXYGEN)) */
+
+typedef struct rwResources rwResources;
+struct rwResources
+{
+ RwInt32 maxSize;
+ RwInt32 currentSize;
+ RwInt32 reusageSize;
+
+ void *memHeap;
+
+ RwLinkList entriesA;
+ RwLinkList entriesB;
+
+ RwLinkList *freeEntries;
+ RwLinkList *usedEntries;
+};
+
+typedef struct rwResourcesGlobals rwResourcesGlobals;
+struct rwResourcesGlobals
+{
+ rwResources res;
+};
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Setting the resources arena size */
+extern RwBool RwResourcesSetArenaSize(RwUInt32 size);
+extern RwInt32 RwResourcesGetArenaSize(void);
+extern RwInt32 RwResourcesGetArenaUsage(void);
+extern RwBool RwResourcesEmptyArena(void);
+
+/* Allocate */
+extern RwResEntry *RwResourcesAllocateResEntry(void *owner,
+ RwResEntry **ownerRef,
+ RwInt32 size,
+ RwResEntryDestroyNotify
+ destroyNotify);
+/* Deallocate */
+extern RwBool RwResourcesFreeResEntry(RwResEntry * entry);
+/* Mark all as unused */
+extern void _rwResourcesPurge(void);
+#if ((defined(RWDEBUG)) || (defined(RWSUPPRESSINLINE)))
+/* Mark as used */
+extern RwResEntry *RwResourcesUseResEntry(RwResEntry * entry);
+#endif /* ((defined(RWDEBUG)) || (defined(RWSUPPRESSINLINE))) */
+
+extern RwModuleInfo resourcesModule;
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#if ((!defined(RWDEBUG)) && (!defined(RWSUPPRESSINLINE)))
+#define RwResourcesUseResEntry(_ntry) \
+ ((((_ntry)->link.next)? \
+ (rwLinkListRemoveLLLink(&((_ntry)->link)), \
+ rwLinkListAddLLLink(RWRESOURCESGLOBAL(res.usedEntries), \
+ &((_ntry)->link))): \
+ NULL), \
+ (_ntry))
+#endif /* ((!defined(RWDEBUG)) && (!defined(RWSUPPRESSINLINE))) */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bacolor.h ---*/
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct RwRGBAReal RwRGBAReal;
+/**
+ * \ingroup datatypes
+ * \struct RwRGBAReal
+ * This structure represents a RGBA color which has
+ * components specified as real values.
+ *
+ * A color component of an RwRGBA with the value 255 generally corresponds
+ * to the associated component in an RwRGBAReal with the value 1.0f.
+ * However, any values can be substituted to denormalize/normalize
+ * RwRGBAReal and create different effects. For example, while light colors
+ * are expressed as normalized RGBA, interesting effects can be gained using
+ * larger values.
+ *
+ * It should also be noted that a color component of an RwRGBA with the
+ * value 0 generally corresponds to the associcated component in an
+ * RwRGBAReal with the value 0.0.
+ */
+struct RwRGBAReal
+{
+ RwReal red; /**< red component */
+ RwReal green; /**< green component */
+ RwReal blue; /**< blue component */
+ RwReal alpha; /**< alpha component */
+};
+
+#if (!defined(RwRGBARealAssign))
+#define RwRGBARealAssign(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RwRGBARealAssign)) */
+
+typedef struct RwRGBA RwRGBA;
+/**
+ * \ingroup datatypes
+ * \struct RwRGBA
+ * This structure represents a RGBA color
+ * which has integer components specified in the range 0 to 255. */
+struct RwRGBA
+{
+ RwUInt8 red; /**< red component */
+ RwUInt8 green; /**< green component */
+ RwUInt8 blue; /**< blue component */
+ RwUInt8 alpha; /**< alpha component */
+};
+
+#if (!defined(RwRGBAAssign))
+#define RwRGBAAssign(_target, _source) \
+ ( *(_target) = *(_source) )
+#endif /* (!defined(RwRGBAAssign)) */
+
+#define RwRGBARealAddMacro(o,a,b) \
+MACRO_START \
+{ \
+ (o)->red = (((a)->red) + ( (b)->red)); \
+ (o)->green = (((a)->green) + ( (b)->green)); \
+ (o)->blue = (((a)->blue) + ( (b)->blue)); \
+ (o)->alpha = (((a)->alpha) + ( (b)->alpha)); \
+} \
+MACRO_STOP
+
+#define RwRGBARealSubMacro(o,a,b) \
+MACRO_START \
+{ \
+ (o)->red = (((a)->red) - ( (b)->red)); \
+ (o)->green = (((a)->green) - ( (b)->green)); \
+ (o)->blue = (((a)->blue) - ( (b)->blue)); \
+ (o)->alpha = (((a)->alpha) - ( (b)->alpha)); \
+} \
+MACRO_STOP
+
+#define RwRGBARealScaleMacro(o,a,scale) \
+MACRO_START \
+{ \
+ (o)->red = (((a)->red) * ( scale)); \
+ (o)->green = (((a)->green) * ( scale)); \
+ (o)->blue = (((a)->blue) * ( scale)); \
+ (o)->alpha = (((a)->alpha) * ( scale)); \
+} \
+MACRO_STOP
+
+/* Conversion macros */
+#define RwRGBAFromRwRGBARealMacro(o, i) \
+MACRO_START \
+{ \
+ RwInt32 quantize; \
+ \
+ quantize = RwInt32FromRealMacro( ((i)->red * (RwReal)255.0) \
+ + (RwReal)0.5 ); \
+ (o)->red = (RwUInt8) quantize; \
+ quantize = RwInt32FromRealMacro( ((i)->green * (RwReal)255.0) \
+ + (RwReal)0.5 ); \
+ (o)->green = (RwUInt8) quantize; \
+ quantize = RwInt32FromRealMacro( ((i)->blue * (RwReal)255.0) \
+ + (RwReal)0.5 ); \
+ (o)->blue = (RwUInt8) quantize; \
+ quantize = RwInt32FromRealMacro( ((i)->alpha * (RwReal)255.0) \
+ + (RwReal)0.5 ); \
+ (o)->alpha = (RwUInt8) quantize; \
+ \
+} \
+MACRO_STOP
+
+#define RwRGBARealFromRwRGBAMacro(o, i) \
+MACRO_START \
+{ \
+ (o)->red = \
+ (((RwReal)(((i)->red))) * ( (RwReal)((1.0/255.0)))); \
+ (o)->green = \
+ (((RwReal)(((i)->green))) * ( (RwReal)((1.0/255.0)))); \
+ (o)->blue = \
+ (((RwReal)(((i)->blue))) * ( (RwReal)((1.0/255.0)))); \
+ (o)->alpha = \
+ (((RwReal)(((i)->alpha))) * ( (RwReal)((1.0/255.0)))); \
+} \
+MACRO_STOP
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+
+#define RwRGBARealAdd(o,a,b) \
+ RwRGBARealAddMacro(o,a,b)
+
+#define RwRGBARealSub(o,a,b) \
+ RwRGBARealSubMacro(o,a,b)
+
+#define RwRGBARealScale(o,a,scale) \
+ RwRGBARealScaleMacro(o,a,scale)
+
+#define RwRGBAFromRwRGBAReal(o, i) \
+ RwRGBAFromRwRGBARealMacro(o, i)
+
+#define RwRGBARealFromRwRGBA(o, i) \
+ RwRGBARealFromRwRGBAMacro(o, i)
+
+#else /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */
+
+/* Function versions for debug */
+extern void RwRGBARealAdd(RwRGBAReal *result,
+ const RwRGBAReal *source1,
+ const RwRGBAReal *source2);
+
+extern void RwRGBARealSub(RwRGBAReal *result,
+ const RwRGBAReal *source1,
+ const RwRGBAReal *source2);
+
+extern void RwRGBARealScale(RwRGBAReal *result,
+ const RwRGBAReal *source,
+ RwReal scalar);
+
+extern void RwRGBAFromRwRGBAReal(RwRGBA *result,
+ const RwRGBAReal *source);
+
+extern void RwRGBARealFromRwRGBA(RwRGBAReal *result,
+ RwRGBA *source);
+
+#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/babinmtx.h ---*/
+
+/****************************************************************************
+ Global types
+ */
+
+/* Matrix stream format */
+typedef struct rwStreamMatrix RwMatrixChunkInfo;
+typedef struct rwStreamMatrix rwStreamMatrix;
+struct rwStreamMatrix
+{
+ RwV3d right;
+ RwV3d up;
+ RwV3d at;
+ RwV3d pos;
+ RwInt32 type;
+};
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Matrix binary format */
+extern RwUInt32 RwMatrixStreamGetSize(const RwMatrix * matrix);
+extern RwMatrix *RwMatrixStreamRead(RwStream * stream,
+ RwMatrix * matrix);
+extern const RwMatrix *RwMatrixStreamWrite(const RwMatrix * matrix,
+ RwStream * stream);
+extern RwMatrixChunkInfo *RwMatrixChunkInfoRead(RwStream * stream,
+ RwMatrixChunkInfo *
+ matrixChunkInfo,
+ RwInt32 * bytesRead);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/babinary.h ---*/
+/****************************************************************************
+ Defines
+ */
+
+#ifndef rwCHUNKHEADERSIZE
+#define rwCHUNKHEADERSIZE (sizeof(RwUInt32)*3)
+#endif /* rwCHUNKHEADERSIZE */
+
+/* Compatibility macro */
+#define RwStreamWriteInt(_stream, _ints, _numBytes) \
+ RwStreamWriteInt32(_stream, _ints, _numBytes)
+
+#define RwStreamReadInt(_stream, _ints, _numBytes) \
+ RwStreamReadInt32(_stream, _ints, _numBytes)
+
+#define RwMemLittleEndian(_mem, _size) \
+ RwMemLittleEndian32(_mem, _size)
+
+#define RwMemNative(_mem, _size) \
+ RwMemNative32(_mem, _size)
+
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct RwChunkHeaderInfo RwChunkHeaderInfo;
+/**
+ * \ingroup datatypes
+ * \struct RwChunkHeaderInfo
+ * Holds data for a chunk header read from a
+ * stream with \ref RwStreamReadChunkHeaderInfo. */
+struct RwChunkHeaderInfo
+{
+ RwUInt32 type; /**< chunk ID - see \ref RwStreamFindChunk */
+ RwUInt32 length; /**< length of the chunk data in bytes */
+ RwUInt32 version; /**< version of the chunk data.
+ * See \ref RwEngineGetVersion. */
+ RwUInt32 buildNum; /**< build number of the RenderWare libraries
+ * previously used to stream out the data */
+ RwBool isComplex; /**< Internal Use */
+};
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/* Chunk header stuff */
+extern RwBool RwStreamFindChunk(RwStream *stream, RwUInt32 type,
+ RwUInt32 *lengthOut, RwUInt32 *versionOut);
+
+#define RwStreamWriteChunkHeader(stream, type, size) \
+ _rwStreamWriteVersionedChunkHeader( \
+ stream, type, size, rwLIBRARYCURRENTVERSION, RWBUILDNUMBER)
+
+extern RwStream *_rwStreamWriteVersionedChunkHeader(RwStream *stream,
+ RwInt32 type,
+ RwInt32 size,
+ RwUInt32 version,
+ RwUInt32 buildNum);
+
+extern RwStream *RwStreamWriteReal(RwStream *stream, const RwReal *reals,
+ RwUInt32 numBytes);
+extern RwStream *RwStreamWriteInt32(RwStream *stream, const RwInt32 *ints,
+ RwUInt32 numBytes);
+extern RwStream *RwStreamWriteInt16(RwStream *stream, const RwInt16 *ints,
+ RwUInt32 numBytes);
+
+extern RwStream *RwStreamReadReal(RwStream *stream, RwReal *reals,
+ RwUInt32 numBytes);
+extern RwStream *RwStreamReadInt32(RwStream *stream, RwInt32 *ints,
+ RwUInt32 numBytes);
+extern RwStream *RwStreamReadInt16(RwStream *stream, RwInt16 *ints,
+ RwUInt32 numBytes);
+
+/* Binary Portability Functions */
+extern void *RwMemLittleEndian16(void *mem, RwUInt32 size);
+extern void *RwMemLittleEndian32(void *mem, RwUInt32 size);
+extern void *RwMemNative16(void *mem, RwUInt32 size);
+extern void *RwMemNative32(void *mem, RwUInt32 size);
+extern void *RwMemRealToFloat32(void *mem, RwUInt32 size);
+extern void *RwMemFloat32ToReal(void *mem, RwUInt32 size);
+
+extern RwStream *
+RwStreamReadChunkHeaderInfo(RwStream *stream, RwChunkHeaderInfo *chunkHeaderInfo);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* RWPLCORE_H */
diff --git a/src/SurfaceTable.cpp b/src/SurfaceTable.cpp
index e9ef459a..107734e4 100644
--- a/src/SurfaceTable.cpp
+++ b/src/SurfaceTable.cpp
@@ -1,7 +1,11 @@
#include "common.h"
#include "patcher.h"
+#include "Weather.h"
+#include "Collision.h"
#include "SurfaceTable.h"
+float (*CSurfaceTable::ms_aAdhesiveLimitTable)[NUMADHESIVEGROUPS] = (float (*)[NUMADHESIVEGROUPS])0x8E29D4;
+
int
CSurfaceTable::GetAdhesionGroup(uint8 surfaceType)
{
@@ -42,3 +46,52 @@ CSurfaceTable::GetAdhesionGroup(uint8 surfaceType)
default: return ADHESIVE_ROAD;
}
}
+
+float
+CSurfaceTable::GetWetMultiplier(uint8 surfaceType)
+{
+ switch(surfaceType){
+ case SURFACE_0:
+ case SURFACE_1:
+ case SURFACE_4:
+ case SURFACE_5:
+ case SURFACE_8:
+ case SURFACE_20:
+ case SURFACE_21:
+ case SURFACE_22:
+ case SURFACE_25:
+ case SURFACE_30:
+ case SURFACE_31:
+ return 1.0f - CWeather::WetRoads*0.25f;
+
+ case SURFACE_2:
+ case SURFACE_6:
+ case SURFACE_7:
+ case SURFACE_9:
+ case SURFACE_10:
+ case SURFACE_11:
+ case SURFACE_12:
+ case SURFACE_13:
+ case SURFACE_14:
+ case SURFACE_15:
+ case SURFACE_16:
+ case SURFACE_17:
+ case SURFACE_23:
+ case SURFACE_24:
+ case SURFACE_26:
+ case SURFACE_27:
+ case SURFACE_28:
+ case SURFACE_29:
+ case SURFACE_32:
+ return 1.0f - CWeather::WetRoads*0.4f;
+
+ default:
+ return 1.0f;
+ }
+}
+
+float
+CSurfaceTable::GetAdhesiveLimit(CColPoint &colpoint)
+{
+ return ms_aAdhesiveLimitTable[GetAdhesionGroup(colpoint.surfaceB)][GetAdhesionGroup(colpoint.surfaceA)];
+}
diff --git a/src/SurfaceTable.h b/src/SurfaceTable.h
index 556a6e04..f1ef3002 100644
--- a/src/SurfaceTable.h
+++ b/src/SurfaceTable.h
@@ -92,8 +92,14 @@ enum
NUMADHESIVEGROUPS
};
+struct CColPoint;
+
class CSurfaceTable
{
+// static float ms_aAdhesiveLimitTable[NUMADHESIVEGROUPS][NUMADHESIVEGROUPS];
+ static float (*ms_aAdhesiveLimitTable)[NUMADHESIVEGROUPS];
public:
static int GetAdhesionGroup(uint8 surfaceType);
+ static float GetWetMultiplier(uint8 surfaceType);
+ static float GetAdhesiveLimit(CColPoint &colpoint);
};
diff --git a/src/audio/DMAudio.cpp b/src/audio/DMAudio.cpp
new file mode 100644
index 00000000..cc8d4e8b
--- /dev/null
+++ b/src/audio/DMAudio.cpp
@@ -0,0 +1,5 @@
+#include "common.h"
+#include "patcher.h"
+#include "DMAudio.h"
+
+WRAPPER void cDMAudio::ReportCollision(CEntity *A, CEntity *B, uint8 surfA, uint8 surfB, float impulse, float speed) { EAXJMP(0x161684); }
diff --git a/src/audio/DMAudio.h b/src/audio/DMAudio.h
new file mode 100644
index 00000000..8d49be27
--- /dev/null
+++ b/src/audio/DMAudio.h
@@ -0,0 +1,9 @@
+#pragma once
+
+class CEntity;
+
+class cDMAudio
+{
+public:
+ static void ReportCollision(CEntity *A, CEntity *B, uint8 surfA, uint8 surfB, float impulse, float speed);
+};
diff --git a/src/control/CarCtrl.cpp b/src/control/CarCtrl.cpp
new file mode 100644
index 00000000..54491cd2
--- /dev/null
+++ b/src/control/CarCtrl.cpp
@@ -0,0 +1,5 @@
+#include "common.h"
+#include "patcher.h"
+#include "CarCtrl.h"
+
+WRAPPER void CCarCtrl::SwitchVehicleToRealPhysics(CVehicle*) { EAXJMP(0x41F7F0); } \ No newline at end of file
diff --git a/src/control/CarCtrl.h b/src/control/CarCtrl.h
new file mode 100644
index 00000000..fbe36f28
--- /dev/null
+++ b/src/control/CarCtrl.h
@@ -0,0 +1,9 @@
+#pragma once
+
+class CVehicle;
+
+class CCarCtrl
+{
+public:
+ static void SwitchVehicleToRealPhysics(CVehicle*);
+};
diff --git a/src/entities/Physical.cpp b/src/entities/Physical.cpp
index c528444e..947ac47c 100644
--- a/src/entities/Physical.cpp
+++ b/src/entities/Physical.cpp
@@ -10,6 +10,8 @@
#include "ParticleObject.h"
#include "Particle.h"
#include "SurfaceTable.h"
+#include "CarCtrl.h"
+#include "DMAudio.h"
#include "Physical.h"
void
@@ -171,6 +173,145 @@ CPhysical::RemoveFromMovingList(void)
}
}
+void
+CPhysical::SetDamagedPieceRecord(uint16 piece, float impulse, CEntity *entity, CVector dir)
+{
+ m_nCollisionPieceType = piece;
+ m_fCollisionImpulse = impulse;
+ m_pCollidingEntity = entity;
+ entity->RegisterReference(&m_pCollidingEntity);
+ m_vecCollisionDirection = dir;
+}
+
+void
+CPhysical::AddCollisionRecord(CEntity *ent)
+{
+ AddCollisionRecord_Treadable(ent);
+ this->bHasCollided = true;
+ ent->bHasCollided = true;
+ if(IsVehicle() && ent->IsVehicle()){
+ if(((CVehicle*)this)->m_nAlarmState == -1)
+ ((CVehicle*)this)->m_nAlarmState = 15000;
+ if(((CVehicle*)ent)->m_nAlarmState == -1)
+ ((CVehicle*)ent)->m_nAlarmState = 15000;
+ }
+ if(bUseCollisionRecords){
+ int i;
+ for(i = 0; i < m_nCollisionRecords; i++)
+ if(m_aCollisionRecords[i] == ent)
+ return;
+ if(m_nCollisionRecords < PHYSICAL_MAX_COLLISIONRECORDS)
+ m_aCollisionRecords[m_nCollisionRecords++] = ent;
+ m_nLastTimeCollided = CTimer::GetTimeInMilliseconds();
+ }
+}
+
+void
+CPhysical::AddCollisionRecord_Treadable(CEntity *ent)
+{
+ if(ent->IsBuilding() && ((CBuilding*)ent)->GetIsATreadable()){
+ CTreadable *t = (CTreadable*)ent;
+ if(t->m_nodeIndicesPeds[0] >= 0 ||
+ t->m_nodeIndicesPeds[1] >= 0 ||
+ t->m_nodeIndicesPeds[2] >= 0 ||
+ t->m_nodeIndicesPeds[3] >= 0)
+ m_pedTreadable = t;
+ if(t->m_nodeIndicesCars[0] >= 0 ||
+ t->m_nodeIndicesCars[1] >= 0 ||
+ t->m_nodeIndicesCars[2] >= 0 ||
+ t->m_nodeIndicesCars[3] >= 0)
+ m_carTreadable = t;
+ }
+}
+
+bool
+CPhysical::GetHasCollidedWith(CEntity *ent)
+{
+ int i;
+ if(bUseCollisionRecords)
+ for(i = 0; i < m_nCollisionRecords; i++)
+ if(m_aCollisionRecords[i] == ent)
+ return true;
+ return false;
+}
+
+void
+CPhysical::RemoveRefsToEntity(CEntity *ent)
+{
+ int i, j;
+
+ for(i = 0; i < m_nCollisionRecords; i++){
+ if(m_aCollisionRecords[i] == ent){
+ for(j = i; j < m_nCollisionRecords-1; j++)
+ m_aCollisionRecords[j] = m_aCollisionRecords[j+1];
+ m_nCollisionRecords--;
+ }
+ }
+}
+
+int32
+CPhysical::ProcessEntityCollision(CEntity *ent, CColPoint *colpoints)
+{
+ int32 numSpheres = CCollision::ProcessColModels(
+ GetMatrix(), *CModelInfo::GetModelInfo(GetModelIndex())->GetColModel(),
+ ent->GetMatrix(), *CModelInfo::GetModelInfo(ent->GetModelIndex())->GetColModel(),
+ colpoints,
+ nil, nil); // No Lines allowed!
+ if(numSpheres > 0){
+ AddCollisionRecord(ent);
+ if(!ent->IsBuilding()) // Can't this catch dummies too?
+ ((CPhysical*)ent)->AddCollisionRecord(this);
+ if(ent->IsBuilding() || ent->bIsStatic)
+ this->bHasHitWall = true;
+ }
+ return numSpheres;
+}
+
+void
+CPhysical::ProcessControl(void)
+{
+ if(!IsPed())
+ m_phy_flagA8 = false;
+ bHasContacted = false;
+ bIsInSafePosition = false;
+ bWasPostponed = false;
+ bHasHitWall = false;
+
+ if(m_status == STATUS_SIMPLE)
+ return;
+
+ m_nCollisionRecords = 0;
+ bHasCollided = false;
+ m_nCollisionPieceType = 0;
+ m_fCollisionImpulse = 0.0f;
+ m_pCollidingEntity = nil;
+
+ if(!bIsStuck){
+ if(IsObject() ||
+ IsPed() && !bPedPhysics){
+ m_vecMoveSpeedAvg = (m_vecMoveSpeedAvg + m_vecMoveSpeed)/2.0f;
+ m_vecTurnSpeedAvg = (m_vecTurnSpeedAvg + m_vecTurnSpeed)/2.0f;
+ float step = CTimer::GetTimeStep() * 0.003;
+ if(m_vecMoveSpeedAvg.MagnitudeSqr() < step*step &&
+ m_vecTurnSpeedAvg.MagnitudeSqr() < step*step){
+ m_nStaticFrames++;
+ if(m_nStaticFrames > 10){
+ m_nStaticFrames = 10;
+ bIsStatic = true;
+ m_vecMoveSpeed = CVector(0.0f, 0.0f, 0.0f);
+ m_vecTurnSpeed = CVector(0.0f, 0.0f, 0.0f);
+ m_vecMoveFriction = m_vecMoveSpeed;
+ m_vecTurnFriction = m_vecTurnSpeed;
+ return;
+ }
+ }else
+ m_nStaticFrames = 0;
+ }
+ }
+ ApplyGravity();
+ ApplyFriction();
+ ApplyAirResistance();
+}
/*
* Some quantities (german in parens):
@@ -245,8 +386,8 @@ CPhysical::ApplySpringCollision(float f1, CVector &v, CVector &p, float f2, floa
return;
float step = min(CTimer::GetTimeStep(), 3.0f);
float strength = -0.008f*m_fMass*2.0f*step * f1 * (1.0f-f2) * f3;
- ApplyMoveForce(v.x*strength, v.y*strength, v.z*strength);
- ApplyTurnForce(v.x*strength, v.y*strength, v.z*strength, p.x, p.y, p.z);
+ ApplyMoveForce(v*strength);
+ ApplyTurnForce(v*strength, p);
}
void
@@ -798,58 +939,6 @@ CPhysical::ApplyFriction(float adhesiveLimit, CColPoint &colpoint)
// ProcessCollisionSectorList
// ProcessShiftSectorList
-void
-CPhysical::AddCollisionRecord(CEntity *ent)
-{
- AddCollisionRecord_Treadable(ent);
- this->bHasCollided = true;
- ent->bHasCollided = true;
- if(IsVehicle() && ent->IsVehicle()){
- if(((CVehicle*)this)->m_nAlarmState == -1)
- ((CVehicle*)this)->m_nAlarmState = 15000;
- if(((CVehicle*)ent)->m_nAlarmState == -1)
- ((CVehicle*)ent)->m_nAlarmState = 15000;
- }
- if(bUseCollisionRecords){
- int i;
- for(i = 0; i < m_nCollisionRecords; i++)
- if(m_aCollisionRecords[i] == ent)
- return;
- if(m_nCollisionRecords < PHYSICAL_MAX_COLLISIONRECORDS)
- m_aCollisionRecords[m_nCollisionRecords++] = ent;
- m_nLastTimeCollided = CTimer::GetTimeInMilliseconds();
- }
-}
-
-void
-CPhysical::AddCollisionRecord_Treadable(CEntity *ent)
-{
- if(ent->IsBuilding() && ((CBuilding*)ent)->GetIsATreadable()){
- CTreadable *t = (CTreadable*)ent;
- if(t->m_nodeIndicesPeds[0] >= 0 ||
- t->m_nodeIndicesPeds[1] >= 0 ||
- t->m_nodeIndicesPeds[2] >= 0 ||
- t->m_nodeIndicesPeds[3] >= 0)
- m_pedTreadable = t;
- if(t->m_nodeIndicesCars[0] >= 0 ||
- t->m_nodeIndicesCars[1] >= 0 ||
- t->m_nodeIndicesCars[2] >= 0 ||
- t->m_nodeIndicesCars[3] >= 0)
- m_carTreadable = t;
- }
-}
-
-bool
-CPhysical::GetHasCollidedWith(CEntity *ent)
-{
- int i;
- if(bUseCollisionRecords)
- for(i = 0; i < m_nCollisionRecords; i++)
- if(m_aCollisionRecords[i] == ent)
- return true;
- return false;
-}
-
bool
CPhysical::ProcessShiftSectorList(CPtrList *lists)
{
@@ -1012,65 +1101,181 @@ CPhysical::ProcessShiftSectorList(CPtrList *lists)
return true;
}
-void
-CPhysical::ProcessControl(void)
+bool
+CPhysical::ProcessCollisionSectorList_SimpleCar(CPtrList *lists)
{
- if(!IsPed())
- m_phy_flagA8 = false;
- bHasContacted = false;
- bIsInSafePosition = false;
- bWasPostponed = false;
- bHasHitWall = false;
+ static CColPoint aColPoints[32];
+ float radius;
+ CVector center;
+ int listtype;
+ CPhysical *A, *B;
+ int numCollisions;
+ int i;
+ float impulseA = -1.0f;
+ float impulseB = -1.0f;
- if(m_status == STATUS_SIMPLE)
- return;
+ A = (CPhysical*)this;
- m_nCollisionRecords = 0;
- bHasCollided = false;
- m_nCollisionPieceType = 0;
- m_fCollisionImpulse = 0.0f;
- m_pCollidingEntity = nil;
+ radius = A->GetBoundRadius();
+ A->GetBoundCentre(center);
- if(!bIsStuck){
- if(IsObject() ||
- IsPed() && !bPedPhysics){
- m_vecMoveSpeedAvg = (m_vecMoveSpeedAvg + m_vecMoveSpeed)/2.0f;
- m_vecTurnSpeedAvg = (m_vecTurnSpeedAvg + m_vecTurnSpeed)/2.0f;
- float step = CTimer::GetTimeStep() * 0.003;
- if(m_vecMoveSpeedAvg.MagnitudeSqr() < step*step &&
- m_vecTurnSpeedAvg.MagnitudeSqr() < step*step){
- m_nStaticFrames++;
- if(m_nStaticFrames > 10){
- m_nStaticFrames = 10;
- bIsStatic = true;
- m_vecMoveSpeed = CVector(0.0f, 0.0f, 0.0f);
- m_vecTurnSpeed = CVector(0.0f, 0.0f, 0.0f);
- m_vecMoveFriction = m_vecMoveSpeed;
- m_vecTurnFriction = m_vecTurnSpeed;
- return;
- }
- }else
- m_nStaticFrames = 0;
+ for(listtype = 3; listtype >= 0; listtype--){
+ // Go through vehicles and objects
+ CPtrList *list;
+ switch(listtype){
+ case 0: list = &lists[ENTITYLIST_VEHICLES]; break;
+ case 1: list = &lists[ENTITYLIST_VEHICLES_OVERLAP]; break;
+ case 2: list = &lists[ENTITYLIST_OBJECTS]; break;
+ case 3: list = &lists[ENTITYLIST_OBJECTS_OVERLAP]; break;
+ }
+
+ // Find first collision in list
+ CPtrNode *listnode;
+ for(listnode = list->first; listnode; listnode = listnode->next){
+ B = (CPhysical*)listnode->item;
+ if(B != A &&
+ B->m_scanCode != CWorld::GetCurrentScanCode() &&
+ B->bUsesCollision &&
+ B->GetIsTouching(center, radius)){
+ B->m_scanCode = CWorld::GetCurrentScanCode();
+ numCollisions = A->ProcessEntityCollision(B, aColPoints);
+ if(numCollisions > 0)
+ goto collision;
+ }
}
}
- ApplyGravity();
- ApplyFriction();
- ApplyAirResistance();
+ // no collision
+ return false;
+
+collision:
+
+ if(A->bHasContacted && B->bHasContacted){
+ for(i = 0; i < numCollisions; i++){
+ if(!A->ApplyCollision(B, aColPoints[i], impulseA, impulseB))
+ continue;
+
+ if(impulseA > A->m_fCollisionImpulse)
+ A->SetDamagedPieceRecord(aColPoints[i].pieceA, impulseA, B, aColPoints[i].normal);
+
+ if(impulseB > B->m_fCollisionImpulse)
+ A->SetDamagedPieceRecord(aColPoints[i].pieceB, impulseB, A, aColPoints[i].normal);
+
+ float turnSpeedDiff = (B->m_vecTurnSpeed - A->m_vecTurnSpeed).MagnitudeSqr();
+ float moveSpeedDiff = (B->m_vecMoveSpeed - A->m_vecMoveSpeed).MagnitudeSqr();
+
+ cDMAudio::ReportCollision(A, B, aColPoints[i].surfaceA, aColPoints[i].surfaceB, impulseA, max(turnSpeedDiff, moveSpeedDiff));
+ }
+ }else if(A->bHasContacted){
+ CVector savedMoveFriction = A->m_vecMoveFriction;
+ CVector savedTurnFriction = A->m_vecTurnFriction;
+ A->m_vecMoveFriction = CVector(0.0f, 0.0f, 0.0f);
+ A->m_vecTurnFriction = CVector(0.0f, 0.0f, 0.0f);
+ A->bHasContacted = false;
+
+ for(i = 0; i < numCollisions; i++){
+ if(!A->ApplyCollision(B, aColPoints[i], impulseA, impulseB))
+ continue;
+
+ if(impulseA > A->m_fCollisionImpulse)
+ A->SetDamagedPieceRecord(aColPoints[i].pieceA, impulseA, B, aColPoints[i].normal);
+
+ if(impulseB > B->m_fCollisionImpulse)
+ A->SetDamagedPieceRecord(aColPoints[i].pieceB, impulseB, A, aColPoints[i].normal);
+
+ float turnSpeedDiff = (B->m_vecTurnSpeed - A->m_vecTurnSpeed).MagnitudeSqr();
+ float moveSpeedDiff = (B->m_vecMoveSpeed - A->m_vecMoveSpeed).MagnitudeSqr();
+
+ cDMAudio::ReportCollision(A, B, aColPoints[i].surfaceA, aColPoints[i].surfaceB, impulseA, max(turnSpeedDiff, moveSpeedDiff));
+
+ if(A->ApplyFriction(B, CSurfaceTable::GetAdhesiveLimit(aColPoints[i])/numCollisions, aColPoints[i])){
+ A->bHasContacted = true;
+ B->bHasContacted = true;
+ }
+ }
+
+ if(!A->bHasContacted){
+ A->bHasContacted = true;
+ A->m_vecMoveFriction = savedMoveFriction;
+ A->m_vecTurnFriction = savedTurnFriction;
+ }
+ }else if(B->bHasContacted){
+ CVector savedMoveFriction = B->m_vecMoveFriction;
+ CVector savedTurnFriction = B->m_vecTurnFriction;
+ B->m_vecMoveFriction = CVector(0.0f, 0.0f, 0.0f);
+ B->m_vecTurnFriction = CVector(0.0f, 0.0f, 0.0f);
+ B->bHasContacted = false;
+
+ for(i = 0; i < numCollisions; i++){
+ if(!A->ApplyCollision(B, aColPoints[i], impulseA, impulseB))
+ continue;
+
+ if(impulseA > A->m_fCollisionImpulse)
+ A->SetDamagedPieceRecord(aColPoints[i].pieceA, impulseA, B, aColPoints[i].normal);
+
+ if(impulseB > B->m_fCollisionImpulse)
+ A->SetDamagedPieceRecord(aColPoints[i].pieceB, impulseB, A, aColPoints[i].normal);
+
+ float turnSpeedDiff = (B->m_vecTurnSpeed - A->m_vecTurnSpeed).MagnitudeSqr();
+ float moveSpeedDiff = (B->m_vecMoveSpeed - A->m_vecMoveSpeed).MagnitudeSqr();
+
+ cDMAudio::ReportCollision(A, B, aColPoints[i].surfaceA, aColPoints[i].surfaceB, impulseA, max(turnSpeedDiff, moveSpeedDiff));
+
+ if(A->ApplyFriction(B, CSurfaceTable::GetAdhesiveLimit(aColPoints[i])/numCollisions, aColPoints[i])){
+ A->bHasContacted = true;
+ B->bHasContacted = true;
+ }
+ }
+
+ if(!B->bHasContacted){
+ B->bHasContacted = true;
+ B->m_vecMoveFriction = savedMoveFriction;
+ B->m_vecTurnFriction = savedTurnFriction;
+ }
+ }else{
+ for(i = 0; i < numCollisions; i++){
+ if(!A->ApplyCollision(B, aColPoints[i], impulseA, impulseB))
+ continue;
+
+ if(impulseA > A->m_fCollisionImpulse)
+ A->SetDamagedPieceRecord(aColPoints[i].pieceA, impulseA, B, aColPoints[i].normal);
+
+ if(impulseB > B->m_fCollisionImpulse)
+ A->SetDamagedPieceRecord(aColPoints[i].pieceB, impulseB, A, aColPoints[i].normal);
+
+ float turnSpeedDiff = (B->m_vecTurnSpeed - A->m_vecTurnSpeed).MagnitudeSqr();
+ float moveSpeedDiff = (B->m_vecMoveSpeed - A->m_vecMoveSpeed).MagnitudeSqr();
+
+ cDMAudio::ReportCollision(A, B, aColPoints[i].surfaceA, aColPoints[i].surfaceB, impulseA, max(turnSpeedDiff, moveSpeedDiff));
+
+ if(A->ApplyFriction(B, CSurfaceTable::GetAdhesiveLimit(aColPoints[i])/numCollisions, aColPoints[i])){
+ A->bHasContacted = true;
+ B->bHasContacted = true;
+ }
+ }
+ }
+
+ if(B->m_status == STATUS_SIMPLE){
+ B->m_status = STATUS_PHYSICS;
+ if(B->IsVehicle())
+ CCarCtrl::SwitchVehicleToRealPhysics((CVehicle*)B);
+ }
+
+ return true;
}
+
STARTPATCHES
InjectHook(0x4951F0, &CPhysical::Add_, PATCH_JUMP);
InjectHook(0x4954B0, &CPhysical::Remove_, PATCH_JUMP);
InjectHook(0x495540, &CPhysical::RemoveAndAdd, PATCH_JUMP);
InjectHook(0x495F10, &CPhysical::ProcessControl_, PATCH_JUMP);
+ InjectHook(0x49F790, &CPhysical::ProcessEntityCollision_, PATCH_JUMP);
InjectHook(0x4958F0, &CPhysical::AddToMovingList, PATCH_JUMP);
InjectHook(0x495940, &CPhysical::RemoveFromMovingList, PATCH_JUMP);
-
InjectHook(0x497180, &CPhysical::AddCollisionRecord, PATCH_JUMP);
InjectHook(0x4970C0, &CPhysical::AddCollisionRecord_Treadable, PATCH_JUMP);
InjectHook(0x497240, &CPhysical::GetHasCollidedWith, PATCH_JUMP);
-
- InjectHook(0x49DA10, &CPhysical::ProcessShiftSectorList, PATCH_JUMP);
+ InjectHook(0x49F820, &CPhysical::RemoveRefsToEntity, PATCH_JUMP);
#define F3 float, float, float
InjectHook(0x495B10, &CPhysical::ApplyMoveSpeed, PATCH_JUMP);
@@ -1088,4 +1293,7 @@ STARTPATCHES
InjectHook(0x4992A0, &CPhysical::ApplyCollisionAlt, PATCH_JUMP);
InjectHook(0x499BE0, (bool (CPhysical::*)(float, CColPoint&))&CPhysical::ApplyFriction, PATCH_JUMP);
InjectHook(0x49A180, (bool (CPhysical::*)(CPhysical*, float, CColPoint&))&CPhysical::ApplyFriction, PATCH_JUMP);
+
+ InjectHook(0x49DA10, &CPhysical::ProcessShiftSectorList, PATCH_JUMP);
+ InjectHook(0x49E790, &CPhysical::ProcessCollisionSectorList_SimpleCar, PATCH_JUMP);
ENDPATCHES
diff --git a/src/entities/Physical.h b/src/entities/Physical.h
index 9867c33c..574238ab 100644
--- a/src/entities/Physical.h
+++ b/src/entities/Physical.h
@@ -82,6 +82,11 @@ public:
void RemoveAndAdd(void);
void AddToMovingList(void);
void RemoveFromMovingList(void);
+ void SetDamagedPieceRecord(uint16 piece, float impulse, CEntity *entity, CVector dir);
+ void AddCollisionRecord(CEntity *ent);
+ void AddCollisionRecord_Treadable(CEntity *ent);
+ bool GetHasCollidedWith(CEntity *ent);
+ void RemoveRefsToEntity(CEntity *ent);
// get speed of point p relative to entity center
CVector GetSpeed(const CVector &r);
@@ -126,16 +131,14 @@ public:
bool ApplyFriction(CPhysical *B, float adhesiveLimit, CColPoint &colpoint);
bool ApplyFriction(float adhesiveLimit, CColPoint &colpoint);
- void AddCollisionRecord(CEntity *ent);
- void AddCollisionRecord_Treadable(CEntity *ent);
- bool GetHasCollidedWith(CEntity *ent);
-
bool ProcessShiftSectorList(CPtrList *ptrlists);
+ bool ProcessCollisionSectorList_SimpleCar(CPtrList *lists);
// to make patching virtual functions possible
void Add_(void) { CPhysical::Add(); }
void Remove_(void) { CPhysical::Remove(); }
CRect GetBoundRect_(void) { return CPhysical::GetBoundRect(); }
void ProcessControl_(void) { CPhysical::ProcessControl(); }
+ int32 ProcessEntityCollision_(CEntity *ent, CColPoint *point) { return CPhysical::ProcessEntityCollision(ent, point); }
};
static_assert(sizeof(CPhysical) == 0x128, "CPhysical: error");