diff options
Diffstat (limited to 'rwsdk/include/d3d8')
97 files changed, 57459 insertions, 0 deletions
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 permission 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 */ |