Eagle517/tge
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
tge/tools/map2dif/exportGeometry.cc
Metario 9c6ff74f19 added everything
2017-04-17 06:17:10 -06:00

2395 lines
93 KiB
C++
Executable File
Raw Blame History

//-----------------------------------------------------------------------------
// Torque Game Engine
//
// Copyright (c) 2001 GarageGames.Com
//-----------------------------------------------------------------------------
// this define required for VC++ due to conflict with placement new in STL
#define __PLACEMENT_NEW_INLINE
#include <algorithm>
#include "map2dif/editGeometry.h"
#include "map2dif/entityTypes.h"
#include "map2dif/tokenizer.h"
#include "map2dif/csgBrush.h"
#include "map2dif/editInteriorRes.h"
#include "interior/interior.h"
#include "dgl/gBitmap.h"
#include "core/resManager.h"
#include "math/mMath.h"
#include "dgl/materialList.h"
#include "core/bitMatrix.h"
#include "interior/mirrorSubObject.h"
#include "interior/interiorResObjects.h"
#include "interior/forceField.h"
//------------------------------------------------------------------------------
enum PointClassification {
LEFT,
RIGHT,
BEYOND,
BEHIND,
BETWEEN,
ORIGIN,
DEST
};
PointClassification classify(const Point3D& start, const Point3D& end, const Point3D& normal, const Point3D& query)
{
Point3D edge = end - start;
Point3D test = query - start;
if (query == end)
return DEST;
if (query == start)
return ORIGIN;
Point3D edgeCopy = edge;
Point3D testCopy = test;
edgeCopy.normalize();
testCopy.normalize();
Point3D cross;
mCross(edgeCopy, testCopy, &cross);
if (cross.len() < 0.000001) {
// Colinear
F64 dot = mDot(edgeCopy, test);
if (dot < 0.0) {
return BEHIND;
} else {
F64 len0 = edge.len();
F64 len1 = test.len();
if (len0 > len1)
return BETWEEN;
else
return BEYOND;
}
} else {
// Not colinear, test against the normal to find out which side it's on...
F64 dot = mDot(cross, normal);
if (dot > 0.0)
return LEFT;
else
return RIGHT;
}
}
void EditGeometry::giftWrapPortal(Winding& winding, Portal* portal)
{
if (portal->windings.size() == 1) {
winding = portal->windings[0];
return;
}
Point3D newPoints[4];
F64 minOrthox = 1e12;
F64 maxOrthox = -1e12;
F64 minOrthoy = 1e12;
F64 maxOrthoy = -1e12;
for (U32 i = 0; i < portal->windings.size(); i++) {
for (U32 j = 0; j < portal->windings[i].numIndices; j++) {
const Point3D& rPoint = getPoint(portal->windings[i].indices[j]);
F64 dotx = mDot(portal->x, rPoint);
F64 doty = mDot(portal->y, rPoint);
if (dotx < minOrthox)
minOrthox = dotx;
if (dotx > maxOrthox)
maxOrthox = dotx;
if (doty < minOrthoy)
minOrthoy = doty;
if (doty > maxOrthoy)
maxOrthoy = doty;
}
}
AssertFatal(minOrthox != 1e12, "Screwed!");
AssertFatal(maxOrthox != -1e12, "Screwed!");
AssertFatal(minOrthoy != 1e12, "Screwed!");
AssertFatal(maxOrthoy != -1e12, "Screwed!");
const Point3D& ref = getPoint(portal->windings[0].indices[0]);
F64 refx = mDot(ref, portal->x);
F64 refy = mDot(ref, portal->y);
newPoints[0] = ref + (portal->x * (minOrthox - refx)) + (portal->y * (minOrthoy - refy));
newPoints[1] = ref + (portal->x * (minOrthox - refx)) + (portal->y * (maxOrthoy - refy));
newPoints[2] = ref + (portal->x * (maxOrthox - refx)) + (portal->y * (minOrthoy - refy));
newPoints[3] = ref + (portal->x * (maxOrthox - refx)) + (portal->y * (maxOrthoy - refy));
UniqueVector points;
points.pushBackUnique(insertPoint(newPoints[0]));
points.pushBackUnique(insertPoint(newPoints[1]));
points.pushBackUnique(insertPoint(newPoints[2]));
points.pushBackUnique(insertPoint(newPoints[3]));
Point3D cross;
const PlaneEQ& rPlane = getPlaneEQ(portal->planeEQIndex);
if (mFabs(rPlane.normal.z) < 0.99)
mCross(rPlane.normal, Point3D(0, 0, 1), &cross);
else
mCross(rPlane.normal, Point3D(0, 1, 0), &cross);
F64 minValue = 1e9;
S32 a = -1;
for (U32 i = 0; i < points.size(); i++) {
F64 dot = mDot(getPoint(points[i]), cross);
if (dot < minValue) {
minValue = dot;
a = i;
}
}
AssertFatal(a != -1, "Wtf!");
U32 n = points.size();
U32 storA = a;
points.push_back(points[a]);
winding.numIndices = 0;
for (U32 m = 0; m < n; m++) {
// Swap (p[a], p[m])
U32 temp = points[a];
points[a] = points[m];
points[m] = temp;
winding.indices[winding.numIndices++] = points[m];
AssertFatal(winding.numIndices <= 32, "Error, too many points in this winding!");
a = m + 1;
for (U32 i = m + 2; i <= n; i++) {
PointClassification c = classify(getPoint(points[m]), getPoint(points[a]), rPlane.normal, getPoint(points[i]));
if (c == LEFT || c == BEYOND)
a = i;
}
if (a == n)
break;
}
AssertFatal(winding.numIndices >= 3, "Error, bad portal generated!");
}
inline U16 createLeafIndex(U16 baseIndex,
bool isSolid)
{
AssertFatal(baseIndex <= 0x3fff, "out of range base index. Uh, oh... Talk to DMoore");
U16 baseRet;
if (isSolid)
baseRet = 0xC000;
else
baseRet = 0x8000;
return (baseRet | baseIndex);
}
inline U16 EditGeometry::remapPlaneIndex(S32 inPlaneIndex)
{
AssertFatal(inPlaneIndex >= 0 && inPlaneIndex < mPlaneEQs.size(), "Error, out of bounds plane index!");
AssertFatal(mPlaneRemaps[inPlaneIndex] != -1, "Error, this plane should have been exported, tell DMoore");
U16 ret = mPlaneRemaps[inPlaneIndex];
AssertFatal(ret < 32768, avar("Error, there are still to many dang planes! Tell DMoore: %d", ret));
ret |= (inPlaneIndex & 1) ? 0x8000 : 0;
return ret;
}
inline U16 EditGeometry::remapVehiclePlaneIndex(S32 inPlaneIndex, Interior* pRuntime)
{
const PlaneEQ& rPlane = getPlaneEQ(inPlaneIndex);
PlaneF newPlane;
newPlane.x = F32(rPlane.normal.x);
newPlane.y = F32(rPlane.normal.y);
newPlane.z = F32(rPlane.normal.z);
newPlane.d = F32(rPlane.dist) / mWorldEntity->mGeometryScale;
for (U32 i = 0; i < pRuntime->mVehiclePlanes.size(); i++)
{
if (pRuntime->mVehiclePlanes[i].x == newPlane.x &&
pRuntime->mVehiclePlanes[i].y == newPlane.y &&
pRuntime->mVehiclePlanes[i].z == newPlane.z &&
pRuntime->mVehiclePlanes[i].d == newPlane.d)
return i;
}
pRuntime->mVehiclePlanes.push_back(newPlane);
return (pRuntime->mVehiclePlanes.size() - 1);
}
inline U32 makeNullSurfaceIndex(U32 idx)
{
return idx | 0x80000000;
}
inline U32 makeVehicleNullSurfaceIndex(U32 idx)
{
return (idx | 0x80000000 | 0x40000000);
}
U16 EditGeometry::exportBSPToRuntime(Interior* pRuntime, EditBSPNode* pNode)
{
if (pNode->planeEQIndex == -1) {
if (pNode->isSolid == true) {
// solid node
pRuntime->mBSPSolidLeaves.increment();
Interior::IBSPLeafSolid& rRTLeaf = pRuntime->mBSPSolidLeaves.last();
// DMM Need to include a list of surfaces affected by this leaf
rRTLeaf.surfaceIndex = pRuntime->mSolidLeafSurfaces.size();
rRTLeaf.surfaceCount = 0;
U32 i;
for (i = 0; i < mSurfaces.size(); i++) {
Surface& rSurface = mSurfaces[i];
bool found = false;
for (U32 j = 0; j < rSurface.winding.numNodes; j++) {
if (rSurface.winding.solidNodes[j] == pNode->nodeId) {
found = true;
break;
}
}
if (found == true) {
pRuntime->mSolidLeafSurfaces.push_back(i);
rRTLeaf.surfaceCount++;
}
}
for (i = 0; i < mNullSurfaces.size(); i++) {
NullSurface& rNullSurface = mNullSurfaces[i];
bool found = false;
for (U32 j = 0; j < rNullSurface.winding.numNodes; j++) {
if (rNullSurface.winding.solidNodes[j] == pNode->nodeId) {
found = true;
break;
}
}
if (found == true) {
pRuntime->mSolidLeafSurfaces.push_back(makeNullSurfaceIndex(i));
rRTLeaf.surfaceCount++;
}
}
return createLeafIndex(pRuntime->mBSPSolidLeaves.size() - 1, true);
}
else {
if (mZones[pNode->zoneId]->active == false) {
return createLeafIndex(0x0FFF, false);
} else {
U32 actives = 0;
for (U32 i = 0; i < pNode->zoneId; i++)
if (mZones[i]->active)
actives++;
return createLeafIndex(actives, false);
}
//
// AssertFatal(pNode->zoneId < (0xFFFF & ~0xC000), "Error, this index is going to cause problems!");
// return createLeafIndex(pNode->zoneId, false);
}
}
else {
// Node
U16 retIndex = pRuntime->mBSPNodes.size();
pRuntime->mBSPNodes.increment();
Interior::IBSPNode& rRTNode = pRuntime->mBSPNodes.last();
rRTNode.planeIndex = remapPlaneIndex(pNode->planeEQIndex);
rRTNode.frontIndex = exportBSPToRuntime(pRuntime, pNode->pFront);
rRTNode.backIndex = exportBSPToRuntime(pRuntime, pNode->pBack);
return retIndex;
}
}
void EditGeometry::exportDMLToRuntime(Interior* pRuntime, Vector<char*>& textureNames)
{
AssertFatal(pRuntime->mMaterialList == NULL, "Error, material list already exists!");
Vector<char*> textureNamesCopy;
for (U32 i = 0; i < textureNames.size(); i++) {
U32 len = dStrlen(textureNames[i]) + dStrlen(mWorldEntity->mWadPrefix) + 1;
char* copyBuffer = new char[len];
dStrcpy(copyBuffer, mWorldEntity->mWadPrefix);
dStrcat(copyBuffer, textureNames[i]);
textureNamesCopy.push_back(copyBuffer);
}
pRuntime->mMaterialList = new MaterialList(textureNamesCopy.size(), (const char**)textureNamesCopy.address());
for (U32 i = 0; i < textureNamesCopy.size(); i++)
delete [] textureNamesCopy[i];
}
U32 EditGeometry::exportPointToRuntime(Interior* pRuntime, const U32 pointIndex)
{
for (U32 i = 0; i < mExportPointMap.size(); i++) {
if (mExportPointMap[i].originalIndex == pointIndex)
return mExportPointMap[i].runtimeIndex;
}
mExportPointMap.increment();
mExportPointMap.last().originalIndex = pointIndex;
mExportPointMap.last().runtimeIndex = pRuntime->mPoints.size();
const Point3D& rPoint = getPoint(pointIndex);
pRuntime->mPoints.increment();
pRuntime->mPoints.last().point.set(F32(rPoint.x) / mWorldEntity->mGeometryScale,
F32(rPoint.y) / mWorldEntity->mGeometryScale,
F32(rPoint.z) / mWorldEntity->mGeometryScale);
return mExportPointMap.last().runtimeIndex;
}
U32 EditGeometry::exportVehiclePointToRuntime(Interior* pRuntime, const U32 pointIndex)
{
for (U32 i = 0; i < mVehicleExportPointMap.size(); i++) {
if (mVehicleExportPointMap[i].originalIndex == pointIndex)
return mVehicleExportPointMap[i].runtimeIndex;
}
mVehicleExportPointMap.increment();
mVehicleExportPointMap.last().originalIndex = pointIndex;
mVehicleExportPointMap.last().runtimeIndex = pRuntime->mVehiclePoints.size();
const Point3D& rPoint = getPoint(pointIndex);
pRuntime->mVehiclePoints.increment();
pRuntime->mVehiclePoints.last().point.set(F32(rPoint.x) / mWorldEntity->mGeometryScale,
F32(rPoint.y) / mWorldEntity->mGeometryScale,
F32(rPoint.z) / mWorldEntity->mGeometryScale);
return mExportPointMap.last().runtimeIndex;
}
void EditGeometry::exportWindingToRuntime(Interior* pRuntime,
const Winding& rWinding)
{
Winding finalWinding;
finalWinding.numIndices = 0;
for (U32 i = 0; i < rWinding.numIndices; i++) {
finalWinding.indices[finalWinding.numIndices++] =
exportPointToRuntime(pRuntime, rWinding.indices[i]);
}
AssertFatal(finalWinding.numIndices == rWinding.numIndices, "Ah, crap. Paradox.");
pRuntime->mWindingIndices.increment();
pRuntime->mWindingIndices.last().windingStart = pRuntime->mWindings.size();
pRuntime->mWindingIndices.last().windingCount = finalWinding.numIndices;
for (U32 i = 0; i < finalWinding.numIndices; i++) {
pRuntime->mWindings.increment();
pRuntime->mWindings.last() = finalWinding.indices[i];
}
}
void EditGeometry::exportVehicleWindingToRuntime(Interior* pRuntime,
const Winding& rWinding)
{
Winding finalWinding;
finalWinding.numIndices = 0;
for (U32 i = 0; i < rWinding.numIndices; i++) {
finalWinding.indices[finalWinding.numIndices++] =
exportVehiclePointToRuntime(pRuntime, rWinding.indices[i]);
}
AssertFatal(finalWinding.numIndices == rWinding.numIndices, "Ah, crap. Paradox.");
pRuntime->mVehicleWindingIndices.increment();
pRuntime->mVehicleWindingIndices.last().windingStart = pRuntime->mVehicleWindings.size();
pRuntime->mVehicleWindingIndices.last().windingCount = finalWinding.numIndices;
for (U32 i = 0; i < finalWinding.numIndices; i++) {
pRuntime->mVehicleWindings.increment();
pRuntime->mVehicleWindings.last() = finalWinding.indices[i];
}
}
U32 EditGeometry::exportEmitStringToRuntime(Interior* pRuntime,
const U8* pString,
const U32 stringLen)
{
// Search for already included strings.
if (pRuntime->mConvexHullEmitStrings.size() > stringLen) {
for (S32 i = 0; i < pRuntime->mConvexHullEmitStrings.size() - stringLen; i++) {
if (dMemcmp(&pRuntime->mConvexHullEmitStrings[i], pString, stringLen) == 0)
return i;
}
}
// Insert the string
U32 insertPoint = pRuntime->mConvexHullEmitStrings.size();
if (pRuntime->mConvexHullEmitStrings.size() + stringLen >
pRuntime->mConvexHullEmitStrings.capacity()) {
if (pRuntime->mConvexHullEmitStrings.capacity() == 0)
pRuntime->mConvexHullEmitStrings.reserve(1);
pRuntime->mConvexHullEmitStrings.reserve(pRuntime->mConvexHullEmitStrings.capacity() * 2);
}
pRuntime->mConvexHullEmitStrings.setSize(pRuntime->mConvexHullEmitStrings.size() + stringLen);
dMemcpy(&pRuntime->mConvexHullEmitStrings[insertPoint],
pString, stringLen);
return insertPoint;
}
U32 EditGeometry::exportVehicleEmitStringToRuntime(Interior* pRuntime,
const U8* pString,
const U32 stringLen)
{
// Search for already included strings.
if (pRuntime->mVehicleConvexHullEmitStrings.size() > stringLen) {
for (S32 i = 0; i < pRuntime->mVehicleConvexHullEmitStrings.size() - stringLen; i++) {
if (dMemcmp(&pRuntime->mVehicleConvexHullEmitStrings[i], pString, stringLen) == 0)
return i;
}
}
// Insert the string
U32 insertPoint = pRuntime->mVehicleConvexHullEmitStrings.size();
if (pRuntime->mVehicleConvexHullEmitStrings.size() + stringLen >
pRuntime->mVehicleConvexHullEmitStrings.capacity()) {
if (pRuntime->mVehicleConvexHullEmitStrings.capacity() == 0)
pRuntime->mVehicleConvexHullEmitStrings.reserve(1);
pRuntime->mVehicleConvexHullEmitStrings.reserve(pRuntime->mVehicleConvexHullEmitStrings.capacity() * 2);
}
pRuntime->mVehicleConvexHullEmitStrings.setSize(pRuntime->mVehicleConvexHullEmitStrings.size() + stringLen);
dMemcpy(&pRuntime->mVehicleConvexHullEmitStrings[insertPoint],
pString, stringLen);
return insertPoint;
}
U16 EditGeometry::getMaterialIndex(const char* texName) const
{
for (U32 i = 0; i < mTextureNames.size(); i++) {
if (dStricmp(mTextureNames[i], texName) == 0)
return i;
}
return 0xFFFF;
}
//------------------------------------------------------------------------------
void EditGeometry::fillInLightmapInfo(Surface& rSurface)
{
AssertFatal(rSurface.textureIndex != 0, "Error, shouldn't get these here!");
//F32 lumelScale = mWorldEntity->sgGetLightingScale();
Point3D axises[3] = {
Point3D(1, 0, 0),
Point3D(0, 1, 0),
Point3D(0, 0, 1)
};
F64 bestDot = -1;
S32 bestIndex = -1;
for (U32 i = 0; i < 3; i++) {
F64 dot = mFabs(mDot(getPlaneEQ(rSurface.planeIndex).normal, axises[i]));
if (dot > bestDot) {
bestDot = dot;
bestIndex = i;
}
}
AssertFatal(bestIndex != -1 && bestDot > 0.0, "Paradox! Talk to DMoore");
S32 sc, tc;
if (axises[bestIndex].x != 0.0) {
sc = 1;
tc = 2;
} else if (axises[bestIndex].y != 0.0) {
sc = 0;
tc = 2;
} else {
sc = 0;
tc = 1;
}
F64 coords[MaxWindingPoints * 3];
for (U32 i = 0; i < rSurface.winding.numIndices; i++) {
coords[i * 3 + 0] = getPoint(rSurface.winding.indices[i]).x;
coords[i * 3 + 1] = getPoint(rSurface.winding.indices[i]).y;
coords[i * 3 + 2] = getPoint(rSurface.winding.indices[i]).z;
}
F64 minS = 1e10; S32 minSIndex = -1;
F64 maxS = -1e10; S32 maxSIndex = -1;
F64 minT = 1e10; S32 minTIndex = -1;
F64 maxT = -1e10; S32 maxTIndex = -1;
for (U32 i = 0; i < rSurface.winding.numIndices; i++) {
if (coords[i*3 + sc] < minS) {
minS = coords[i*3 + sc];
minSIndex = i;
}
if (coords[i*3 + sc] > maxS) {
maxS = coords[i*3 + sc];
maxSIndex = i;
}
if (coords[i*3 + tc] < minT) {
minT = coords[i*3 + tc];
minTIndex = i;
}
if (coords[i*3 + tc] > maxT) {
maxT = coords[i*3 + tc];
maxTIndex = i;
}
}
AssertFatal(minSIndex != -1 && maxSIndex != -1 && minTIndex != -1 && maxTIndex != -1, "Paradox!");
// Points in the lmap coord space that represent the bounds of the poly
F64 virtualMin[2], virtualMax[2], desiredStart[2], desiredEnd[2];
virtualMin[0] = coords[minSIndex*3 + sc];
virtualMin[1] = coords[minTIndex*3 + tc];
virtualMax[0] = coords[maxSIndex*3 + sc];
virtualMax[1] = coords[maxTIndex*3 + tc];
for (U32 i = 0; i < 2; i++) {
desiredStart[i] = virtualMin[i] / rSurface.sgLightingScale;
if (desiredStart[i] - mFloor(desiredStart[i]) < 0.5) {
desiredStart[i] = mFloor(desiredStart[i] - 1.0);
} else {
desiredStart[i] = mFloor(desiredStart[i]);
}
}
for (U32 i = 0; i < 2; i++) {
desiredEnd[i] = virtualMax[i] / rSurface.sgLightingScale;
if (mCeil(desiredEnd[i]) - desiredEnd[i] < 0.5) {
desiredEnd[i] = mCeil(desiredEnd[i] + 1.0);
} else {
desiredEnd[i] = mCeil(desiredEnd[i]);
}
}
// Make sure we don't lose precision to errant FP rounding. We now
// know how large the lm section should be...
rSurface.lMapDimX = U32(desiredEnd[0] - desiredStart[0] + 0.5);
rSurface.lMapDimY = U32(desiredEnd[1] - desiredStart[1] + 0.5);
AssertISV(rSurface.lMapDimX <= 256 && rSurface.lMapDimY <= 256, avar(
"Light map too large: %d x %d (where max is 256 x 256). Your have a brush that is too large, or your light map scale value may be too small.",
rSurface.lMapDimX, rSurface.lMapDimY));
AssertFatal(desiredEnd[0] > desiredStart[0] && desiredEnd[1] > desiredStart[1] &&
S32(rSurface.lMapDimX) > 0 && S32(rSurface.lMapDimY) > 0, "Aw, crap, a paradox. Please talk to DMoore");
desiredStart[0] *= rSurface.sgLightingScale;
desiredStart[1] *= rSurface.sgLightingScale;
desiredEnd[0] *= rSurface.sgLightingScale;
desiredEnd[1] *= rSurface.sgLightingScale;
for (U32 i = 0; i < 4; i++) {
rSurface.lmapTexGenX[i] = 0.0f;
rSurface.lmapTexGenY[i] = 0.0f;
}
rSurface.tempScale[0] = rSurface.tempScale[1] = 1.0 / rSurface.sgLightingScale;
rSurface.lmapTexGenX[sc] = F32(1.0 / rSurface.sgLightingScale);
rSurface.lmapTexGenX[3] = F32(-desiredStart[0] / rSurface.sgLightingScale);
rSurface.lmapTexGenY[tc] = F32(1.0 / rSurface.sgLightingScale);
rSurface.lmapTexGenY[3] = F32(-desiredStart[1] / rSurface.sgLightingScale);
if (rSurface.lMapDimX < rSurface.lMapDimY) {
// Always orient surfaces so that they lay down the long way...
rSurface.lmapTexGenSwapped = true;
U32 iTemp = rSurface.lMapDimX;
rSurface.lMapDimX = rSurface.lMapDimY;
rSurface.lMapDimY = iTemp;
F32 fTemp;
for (U32 i = 0; i < 4; i++) {
fTemp = rSurface.lmapTexGenX[i];
rSurface.lmapTexGenX[i] = rSurface.lmapTexGenY[i];
rSurface.lmapTexGenY[i] = fTemp;
}
} else {
rSurface.lmapTexGenSwapped = false;
}
rSurface.pNormalLMap = new GBitmap(rSurface.lMapDimX, rSurface.lMapDimY);
rSurface.pAlarmLMap = new GBitmap(rSurface.lMapDimX, rSurface.lMapDimY);
}
void EditGeometry::adjustLMapTexGen(Surface& rSurface)
{
//F32 lumelScale = rSurface.isInside ? mWorldEntity->mInsideLumelScale :
// mWorldEntity->mOutsideLumelScale;
F64 scaleX = 1.0 / F64(mLightmaps[rSurface.sheetIndex]->getWidth() * rSurface.sgLightingScale);
F64 scaleY = 1.0 / F64(mLightmaps[rSurface.sheetIndex]->getHeight() * rSurface.sgLightingScale);
U32 i;
for (i = 0; i < 4; i++) {
rSurface.lmapTexGenX[i] /= rSurface.tempScale[0];
rSurface.lmapTexGenY[i] /= rSurface.tempScale[1];
rSurface.lmapTexGenX[i] *= scaleX;
rSurface.lmapTexGenY[i] *= scaleY;
}
rSurface.lmapTexGenX[3] += F64(rSurface.offsetX) / F64(mLightmaps[rSurface.sheetIndex]->getWidth());
rSurface.lmapTexGenY[3] += F64(rSurface.offsetY) / F64(mLightmaps[rSurface.sheetIndex]->getHeight());
for (i = 0; i < 3; i++) {
rSurface.lmapTexGenX[i] *= mWorldEntity->mGeometryScale;
rSurface.lmapTexGenY[i] *= mWorldEntity->mGeometryScale;
}
}
void EditGeometry::dumpSurfaceToRuntime(Interior* pRuntime,
Surface& editSurface)
{
AssertFatal(editSurface.sheetIndex != 0xFFFFFFFF, "Error, shouldn't get these here!");
pRuntime->mSurfaces.increment();
pRuntime->mLMTexGenEQs.increment();
Interior::Surface& rSurface = pRuntime->mSurfaces.last();
Interior::TexGenPlanes& rLMPlanes = pRuntime->mLMTexGenEQs.last();
rSurface.planeIndex = remapPlaneIndex(editSurface.planeIndex);
rSurface.textureIndex = editSurface.textureIndex;
rLMPlanes.planeX.x = editSurface.lmapTexGenX[0];
rLMPlanes.planeX.y = editSurface.lmapTexGenX[1];
rLMPlanes.planeX.z = editSurface.lmapTexGenX[2];
rLMPlanes.planeX.d = editSurface.lmapTexGenX[3];
rLMPlanes.planeY.x = editSurface.lmapTexGenY[0];
rLMPlanes.planeY.y = editSurface.lmapTexGenY[1];
rLMPlanes.planeY.z = editSurface.lmapTexGenY[2];
rLMPlanes.planeY.d = editSurface.lmapTexGenY[3];
rSurface.texGenIndex = editSurface.texGenIndex;
// We used only runtime flags in the surface, so this is fine...
rSurface.surfaceFlags = editSurface.flags & Interior::SurfaceFlagMask;
rSurface.fanMask = editSurface.fanMask;
// Ok, this is an abuse, but it's easy. Export to the trifans,
// then steal the last one.
exportWindingToRuntime(pRuntime, editSurface.winding);
rSurface.windingStart = pRuntime->mWindingIndices.last().windingStart;
rSurface.windingCount = pRuntime->mWindingIndices.last().windingCount;
pRuntime->mWindingIndices.decrement();
AssertFatal(editSurface.lMapDimX < 256 && editSurface.lMapDimY < 256,
"Error, lightmap too large to fit into 8 bits!");
AssertFatal(editSurface.offsetX < 256 && editSurface.offsetY < 256,
"Error, lightmap too large to fit into 8 bits! (Plus, that's just plain wierd)");
rSurface.lightCount = editSurface.numLights;
rSurface.lightStateInfoStart = editSurface.stateDataStart;
rSurface.mapSizeX = editSurface.lMapDimX;
rSurface.mapSizeY = editSurface.lMapDimY;
rSurface.mapOffsetX = editSurface.offsetX;
rSurface.mapOffsetY = editSurface.offsetY;
}
void EditGeometry::dumpNullSurfaceToRuntime(Interior* pRuntime,
EditGeometry::NullSurface& editSurface)
{
pRuntime->mNullSurfaces.increment();
Interior::NullSurface& rSurface = pRuntime->mNullSurfaces.last();
rSurface.planeIndex = remapPlaneIndex(editSurface.planeIndex);
rSurface.surfaceFlags = editSurface.flags;
exportWindingToRuntime(pRuntime, editSurface.winding);
rSurface.windingStart = pRuntime->mWindingIndices.last().windingStart;
rSurface.windingCount = pRuntime->mWindingIndices.last().windingCount;
pRuntime->mWindingIndices.decrement();
}
void EditGeometry::dumpVehicleNullSurfaceToRuntime(Interior* pRuntime,
EditGeometry::NullSurface& editSurface)
{
pRuntime->mVehicleNullSurfaces.increment();
Interior::NullSurface& rSurface = pRuntime->mVehicleNullSurfaces.last();
rSurface.planeIndex = remapVehiclePlaneIndex(editSurface.planeIndex, pRuntime);
rSurface.surfaceFlags = editSurface.flags;
exportVehicleWindingToRuntime(pRuntime, editSurface.winding);
rSurface.windingStart = pRuntime->mVehicleWindingIndices.last().windingStart;
rSurface.windingCount = pRuntime->mVehicleWindingIndices.last().windingCount;
pRuntime->mVehicleWindingIndices.decrement();
}
void EditGeometry::dumpMirrorToRuntime(Interior* pRuntime,
MirrorSurfaceEntity* pEntity)
{
// Do we have _any_ windings?
if (pEntity->mRealZone == 0xFFFFFFFF)
return;
pRuntime->mSubObjects.push_back(new MirrorSubObject);
MirrorSubObject* pObject = static_cast<MirrorSubObject*>(pRuntime->mSubObjects.last());
pObject->mZone = pEntity->mRealZone;
pObject->mDetailLevel = mWorldEntity->mDetailNumber;
pObject->mAlphaLevel = pEntity->mAlphaLevel;
pObject->surfaceStart = 0xFFFFFFFF;
pObject->surfaceCount = 0;
// We know that our surfaces are marked with our zone key, and should be contiguous
// in the list of surfaces
for (U32 i = 0; i < mSurfaces.size(); i++) {
Surface& rSurface = mSurfaces[i];
if (rSurface.winding.zoneIds[0] == pEntity->mZoneKey) {
pObject->surfaceStart = i;
Point3D centroid(0, 0, 0);
for (U32 j = 0; j < rSurface.winding.numIndices; j++) {
centroid += getPoint(rSurface.winding.indices[j]);
}
centroid /= F64(rSurface.winding.numIndices) * mWorldEntity->mGeometryScale;
pObject->mCentroid.x = centroid.x;
pObject->mCentroid.y = centroid.y;
pObject->mCentroid.z = centroid.z;
break;
}
}
AssertFatal(pObject->surfaceStart != 0xFFFFFFFF, "Error, couldn't find our surface");
for (U32 i = pObject->surfaceStart; i < mSurfaces.size(); i++) {
Surface& rSurface = mSurfaces[i];
if (rSurface.winding.zoneIds[0] == pEntity->mZoneKey) {
pObject->surfaceCount++;
} else {
break;
}
}
}
void EditGeometry::dumpTriggerToRuntime(Interior* /*pRuntime*/,
InteriorResource* pResource,
TriggerEntity* pEntity)
{
AssertISV(mWorldEntity->mDetailNumber == 0, "Error, triggers only go on the 0 detail level!");
EditInteriorResource* pEditResource = dynamic_cast<EditInteriorResource*>(pResource);
InteriorResTrigger* pTrigger = new InteriorResTrigger();
dStrcpy(pTrigger->mName, pEntity->mName);
pTrigger->mDataBlock = StringTable->insert(pEntity->mDataBlock);
pTrigger->mPolyhedron = pEntity->triggerPolyhedron;
pTrigger->mOffset.x = pEntity->mOrigin.x;
pTrigger->mOffset.y = pEntity->mOrigin.y;
pTrigger->mOffset.z = pEntity->mOrigin.z;
pTrigger->mDictionary = pEntity->mDictionary;
pEditResource->insertTrigger(pTrigger);
}
void EditGeometry::dumpAISpecialToRuntime(Interior* /*pRuntime*/,
InteriorResource* pResource,
SpecialNodeEntity* pEntity)
{
AssertISV(mWorldEntity->mDetailNumber == 0, "Error, SpecialNodes only go on the 0 detail level!");
EditInteriorResource* pEditResource = dynamic_cast<EditInteriorResource*>(pResource);
AISpecialNode *pSpecialNode = new AISpecialNode();
pSpecialNode->mName = StringTable->insert(pEntity->mName);
pSpecialNode->mPos.x = (pEntity->mOrigin.x / mWorldEntity->mGeometryScale);
pSpecialNode->mPos.y = (pEntity->mOrigin.y / mWorldEntity->mGeometryScale);
pSpecialNode->mPos.z = (pEntity->mOrigin.z / mWorldEntity->mGeometryScale);
pEditResource->insertSpecialNode(pSpecialNode);
}
void EditGeometry::dumpGameEntityToRuntime(Interior* /*pRuntime*/,
InteriorResource* pResource,
GameEntity* pEntity)
{
AssertISV(mWorldEntity->mDetailNumber == 0, "Error, GameEntities only go on the 0 detail level!");
EditInteriorResource* pEditResource = dynamic_cast<EditInteriorResource*>(pResource);
ItrGameEntity *pGameEntity = new ItrGameEntity();
pGameEntity->mDataBlock = StringTable->insert(pEntity->mDatablock);
pGameEntity->mGameClass = StringTable->insert(pEntity->mGameClass);
pGameEntity->mDictionary = pEntity->mDictionary;
pGameEntity->mPos.x = (pEntity->mOrigin.x / mWorldEntity->mGeometryScale);
pGameEntity->mPos.y = (pEntity->mOrigin.y / mWorldEntity->mGeometryScale);
pGameEntity->mPos.z = (pEntity->mOrigin.z / mWorldEntity->mGeometryScale);
pEditResource->insertGameEntity(pGameEntity);
}
void EditGeometry::dumpDoorToRuntime(Interior* /*pRuntime*/,
InteriorResource* pResource,
DoorEntity* pEntity)
{
AssertISV(mWorldEntity->mDetailNumber == 0, "Error, doors only are on the 0 detail level!");
EditInteriorResource* pEditResource = dynamic_cast<EditInteriorResource*>(pResource);
if (pEntity->mInterior == NULL)
return;
// We need to set the following:
// Resource index (name will be patched in by morian later.
// Parent SO and Path indices (name patched in at runtime)
InteriorPathFollower* pChild = new InteriorPathFollower;
pEditResource->insertPathedChild(pChild);
pChild->mName = StringTable->insert(pEntity->mName);
pChild->mDataBlock = StringTable->insert(pEntity->mDataBlock);
pChild->mInteriorResIndex = pEditResource->insertSubObject(pEntity->mInterior);
pChild->mOffset.x = pEntity->mOrigin.x;
pChild->mOffset.y = pEntity->mOrigin.y;
pChild->mOffset.z = pEntity->mOrigin.z;
pChild->mDictionary = pEntity->mDictionary;
for(U32 i = 0; i < pEntity->mWayPoints.size(); i++)
pEntity->mWayPoints[i].pos /= mWorldEntity->mGeometryScale;
pChild->mWayPoints = pEntity->mWayPoints;
U32 curr = 0;
pChild->mTriggerIds = pEntity->mTriggerIds;
pEntity->mInterior = NULL;
}
void EditGeometry::dumpForceFieldToRuntime(Interior* /*pRuntime*/,
InteriorResource* pResource,
ForceFieldEntity* pEntity)
{
AssertISV(mWorldEntity->mDetailNumber == 0, "Error, force fields can only be on the 0 detail level!");
EditInteriorResource* pEditResource = dynamic_cast<EditInteriorResource*>(pResource);
if (pEntity->mInterior == NULL)
return;
// The process command for this object has created a nice interior object for us,
// let's copy out only the parts we want. Note that this is just about
// as non-optimal as you can imagine, but hey, it's easy and it works.
ForceField* pField = new ForceField;
pField->mBoundingBox = pEntity->mInterior->mBoundingBox;
pField->mBoundingSphere = pEntity->mInterior->mBoundingSphere;
pField->mPlanes = pEntity->mInterior->mPlanes;
pField->mPoints.setSize(pEntity->mInterior->mPoints.size());
for (U32 i = 0; i < pEntity->mInterior->mPoints.size(); i++)
pField->mPoints[i] = pEntity->mInterior->mPoints[i].point;
pField->mBSPNodes.setSize(pEntity->mInterior->mBSPNodes.size());
pField->mBSPSolidLeaves.setSize(pEntity->mInterior->mBSPSolidLeaves.size());
for (U32 i = 0; i < pEntity->mInterior->mBSPNodes.size(); i++) {
pField->mBSPNodes[i].planeIndex = pEntity->mInterior->mBSPNodes[i].planeIndex;
pField->mBSPNodes[i].frontIndex = pEntity->mInterior->mBSPNodes[i].frontIndex;
pField->mBSPNodes[i].backIndex = pEntity->mInterior->mBSPNodes[i].backIndex;
}
for (U32 i = 0; i < pEntity->mInterior->mBSPSolidLeaves.size(); i++) {
pField->mBSPSolidLeaves[i].surfaceIndex = pEntity->mInterior->mBSPSolidLeaves[i].surfaceIndex;
pField->mBSPSolidLeaves[i].surfaceCount = pEntity->mInterior->mBSPSolidLeaves[i].surfaceCount;
}
pField->mSolidLeafSurfaces = pEntity->mInterior->mSolidLeafSurfaces;
pField->mWindings = pEntity->mInterior->mWindings;
pField->mSurfaces.setSize(pEntity->mInterior->mSurfaces.size());
for (U32 i = 0; i < pEntity->mInterior->mSurfaces.size(); i++) {
pField->mSurfaces[i].windingStart = pEntity->mInterior->mSurfaces[i].windingStart;
pField->mSurfaces[i].fanMask = pEntity->mInterior->mSurfaces[i].fanMask;
pField->mSurfaces[i].planeIndex = pEntity->mInterior->mSurfaces[i].planeIndex;
pField->mSurfaces[i].windingCount = pEntity->mInterior->mSurfaces[i].windingCount;
pField->mSurfaces[i].surfaceFlags = pEntity->mInterior->mSurfaces[i].surfaceFlags;
}
pEditResource->insertField(pField);
pField->mName = StringTable->insert(pEntity->mName);
pField->mColor = pEntity->mColor;
U32 curr = 0;
while (pEntity->mTrigger[curr][0] != '\0')
pField->mTriggers.push_back(StringTable->insert(pEntity->mTrigger[curr++]));
}
void EditGeometry::createBoundingVolumes(Interior* pRuntime)
{
// Really slow. ah, well...
Box3F boundBox(Point3F(1e10, 1e10, 1e10), Point3F(-1e10, -1e10, -1e10), true);
Point3F centroid(0, 0, 0);
for (U32 i = 0; i < pRuntime->mPoints.size(); i++) {
boundBox.min.setMin(pRuntime->mPoints[i].point);
boundBox.max.setMax(pRuntime->mPoints[i].point);
centroid += pRuntime->mPoints[i].point;
}
centroid /= F32(pRuntime->mPoints.size());
F32 maxRSq = 0.0f;
for (U32 i = 0; i < pRuntime->mPoints.size(); i++) {
F32 lenSQ = (pRuntime->mPoints[i].point - centroid).lenSquared();
if (lenSQ > maxRSq)
maxRSq = lenSQ;
}
F32 r = mSqrt(maxRSq);
SphereF boundSphere(centroid, r);
pRuntime->mBoundingBox = boundBox;
pRuntime->mBoundingSphere = boundSphere;
}
void remapRecurse(EditBSPNode* node, Vector<S32>& remapVector, U32& currIndex)
{
if (node->planeEQIndex == -1)
return;
S32 planeIndex = node->planeEQIndex;
planeIndex &= ~1;
if (remapVector[planeIndex] == -1) {
remapVector[planeIndex] = currIndex;
remapVector[planeIndex | 1] = currIndex++;
}
remapRecurse(node->pFront, remapVector, currIndex);
remapRecurse(node->pBack, remapVector, currIndex);
}
void EditGeometry::exportPlanes(Interior* pRuntime)
{
// AssertFatal(false, avar("foeey: %d", mPlaneEQs.size()));
mPlaneRemaps.setSize(mPlaneEQs.size());
for (U32 i = 0; i < mPlaneEQs.size(); i++) {
mPlaneRemaps[i] = -1;
}
U32 currIndex = 0;
// Loop through all structures that have planeIndices.
// We'll be keeping only those planes that are actually used.
for (U32 i = 0; i < mSurfaces.size(); i++) {
S32 planeIndex = mSurfaces[i].planeIndex;
planeIndex &= ~1;
if (mPlaneRemaps[planeIndex] == -1) {
mPlaneRemaps[planeIndex] = currIndex;
mPlaneRemaps[planeIndex | 1] = currIndex++;
}
}
for (U32 i = 0; i < mNullSurfaces.size(); i++) {
S32 planeIndex = mNullSurfaces[i].planeIndex;
planeIndex &= ~1;
if (mPlaneRemaps[planeIndex] == -1) {
mPlaneRemaps[planeIndex] = currIndex;
mPlaneRemaps[planeIndex | 1] = currIndex++;
}
}
for (U32 i = 0; i < mPortals.size(); i++) {
S32 planeIndex = mPortals[i]->planeEQIndex;
planeIndex &= ~1;
if (mPlaneRemaps[planeIndex] == -1) {
mPlaneRemaps[planeIndex] = currIndex;
mPlaneRemaps[planeIndex | 1] = currIndex++;
}
}
for (U32 i = 0; i < mStructuralBrushes.size(); i++) {
CSGBrush* pBrush = mStructuralBrushes[i];
for (U32 j = 0; j < pBrush->mPlanes.size(); j++) {
S32 planeIndex = pBrush->mPlanes[j].planeEQIndex;
planeIndex &= ~1;
if (mPlaneRemaps[planeIndex] == -1) {
mPlaneRemaps[planeIndex] = currIndex;
mPlaneRemaps[planeIndex | 1] = currIndex++;
}
}
}
for (U32 i = 0; i < mDetailBrushes.size(); i++) {
CSGBrush* pBrush = mDetailBrushes[i];
for (U32 j = 0; j < pBrush->mPlanes.size(); j++) {
S32 planeIndex = pBrush->mPlanes[j].planeEQIndex;
planeIndex &= ~1;
if (mPlaneRemaps[planeIndex] == -1) {
mPlaneRemaps[planeIndex] = currIndex;
mPlaneRemaps[planeIndex | 1] = currIndex++;
}
}
}
remapRecurse(mBSPRoot, mPlaneRemaps, currIndex);
AssertFatal(currIndex < (1 << 16), "Error, too many unique planes, must be less than (1 << 16)");
pRuntime->mPlanes.setSize(currIndex);
for (U32 i = 0; i < mPlaneEQs.size(); i += 2) {
// Export if the remap vector is not -1
if (mPlaneRemaps[i] != -1) {
const PlaneEQ& rPlane = mPlaneEQs[i];
PlaneF& rRTPlane = pRuntime->mPlanes[mPlaneRemaps[i]];
rRTPlane.x = F32(rPlane.normal.x);
rRTPlane.y = F32(rPlane.normal.y);
rRTPlane.z = F32(rPlane.normal.z);
rRTPlane.d = F32(rPlane.dist) / mWorldEntity->mGeometryScale;
}
}
}
static S32 QSORT_CALLBACK cmpAnimatedLights(const void* a,const void* b)
{
const Interior::AnimatedLight* pLight1 = reinterpret_cast<const Interior::AnimatedLight*>(a);
const Interior::AnimatedLight* pLight2 = reinterpret_cast<const Interior::AnimatedLight*>(b);
if ((pLight1->flags & Interior::AnimationAmbient) == (pLight2->flags & Interior::AnimationAmbient)) {
return 0;
} else {
if (pLight1->flags & Interior::AnimationAmbient) {
// Light1 sorts to back
return 1;
} else {
return -1;
}
}
}
U32 EditGeometry::exportIntensityMap(Interior* pRuntime, GBitmap* bmp)
{
if (bmp == NULL)
return 0xFFFFFFFF;
AssertFatal(bmp->getFormat() == GBitmap::Intensity, avar("Error, wrong format! (%d)", bmp->getFormat()));
U32 retIndex = pRuntime->mStateDataBuffer.size();
pRuntime->mStateDataBuffer.setSize(retIndex + (bmp->getWidth() * bmp->getHeight()));
dMemcpy(&pRuntime->mStateDataBuffer[retIndex], bmp->getWritableBits(),
bmp->getWidth() * bmp->getHeight());
return retIndex;
}
//--------------------------------------------------------------------------
void EditGeometry::preprocessLighting()
{
for (U32 i = 0; i < mSurfaces.size(); i++)
mSurfaces[i].numLights = 0;
if (mAnimatedLights.size() == 0)
return;
// We have to make sure of the following:
// Each state has at least a NULL state data for each surface that ANY state
// affects.
// Each state data has the appropriate stateDataIndex
// Each surface has the appropriate stateDataIndex
//
BitVector surfacesAffected;
surfacesAffected.setSize(mSurfaces.size());
BitMatrix surfaceLightPairs(mSurfaces.size(), mAnimatedLights.size());
surfaceLightPairs.clearAllBits();
// First, make sure all the NULL states are filled in if necessary
for (U32 i = 0; i < mAnimatedLights.size(); i++) {
AnimatedLight* pLight = mAnimatedLights[i];
surfacesAffected.clear();
for (U32 j = 0; j < pLight->states.size(); j++) {
LightState* pState = pLight->states[j];
for (U32 k = 0; k < pState->stateData.size(); k++) {
if (pState->stateData[k].pLMap != NULL) {
surfacesAffected.set(pState->stateData[k].surfaceIndex);
surfaceLightPairs.setBit(pState->stateData[k].surfaceIndex, i);
}
}
}
// Now go back and fill in any missing states
for (U32 j = 0; j < pLight->states.size(); j++) {
LightState* pState = pLight->states[j];
for (U32 k = 0; k < mSurfaces.size(); k++) {
if (surfacesAffected.test(k)) {
// Need to make sure there is a state data for k in this state.
bool found = false;
for (U32 l = 0; l < pState->stateData.size(); l++) {
if (pState->stateData[l].surfaceIndex == k) {
found = true;
break;
}
}
if (found == false) {
pState->stateData.increment();
pState->stateData.last().pLMap = NULL;
pState->stateData.last().surfaceIndex = k;
pState->stateData.last().stateDataIndex = 0;
}
}
}
}
}
// Ok, we now have complete statedata information, mark the number of lights
// on all surfaces. This determines the start point for the statedata.
for (U32 i = 0; i < mSurfaces.size(); i++) {
for (U32 j = 0; j < mAnimatedLights.size(); j++) {
if (surfaceLightPairs.isSet(i, j))
mSurfaces[i].numLights++;
}
}
}
void EditGeometry::postProcessLighting(Interior* pRuntime)
{
if(!mSurfaces.size())
return;
BitVector surfacesAffected;
surfacesAffected.setSize(mSurfaces.size());
mSurfaces[0].stateDataStart = 0;
for (U32 i = 1; i < mSurfaces.size(); i++) {
mSurfaces[i].stateDataStart = mSurfaces[i-1].stateDataStart +
mSurfaces[i-1].numLights;
}
// OK, now, all surfaces are marked with the appropriate stateDataStart point,
// we need to zip through the lights again, and fill in the stateDataIndex field
// on the state data.
//
for (U32 i = 0; i < mAnimatedLights.size(); i++) {
AnimatedLight* pLight = mAnimatedLights[i];
surfacesAffected.clear();
for (U32 j = 0; j < pLight->states.size(); j++) {
for (U32 k = 0; k < pLight->states[j]->stateData.size(); k++) {
pLight->states[j]->stateData[k].stateDataIndex =
mSurfaces[pLight->states[j]->stateData[k].surfaceIndex].stateDataStart;
surfacesAffected.set(pLight->states[j]->stateData[k].surfaceIndex);
}
}
for (U32 j = 0; j < mSurfaces.size(); j++)
if (surfacesAffected.test(j))
mSurfaces[j].stateDataStart++;
}
// We clobbered the stateDataStart in the last pass, lets reset it...
mSurfaces[0].stateDataStart = 0;
for (U32 i = 1; i < mSurfaces.size(); i++) {
U32 correctStart = mSurfaces[i-1].stateDataStart +
mSurfaces[i-1].numLights;
AssertFatal(correctStart == mSurfaces[i].stateDataStart - mSurfaces[i].numLights, "Error, miscount somewhere");
mSurfaces[i].stateDataStart = correctStart;
}
// Finished!
pRuntime->mNumLightStateEntries += mSurfaces.last().stateDataStart + mSurfaces.last().numLights;
}
void EditGeometry::exportLightsToRuntime(Interior* pRuntime)
{
postProcessLighting(pRuntime);
for (U32 i = 0; i < mAnimatedLights.size(); i++) {
AnimatedLight* pLight = mAnimatedLights[i];
pRuntime->mAnimatedLights.increment();
Interior::AnimatedLight& rILight = pRuntime->mAnimatedLights.last();
rILight.nameIndex = pRuntime->mNameBuffer.size();
if (pLight->name == NULL) {
static U32 sUnnamedLight = 0;
pLight->name = new char[128];
dSprintf(pLight->name, 127, "UNNAMED_%d", sUnnamedLight++);
}
pRuntime->mNameBuffer.setSize(rILight.nameIndex + dStrlen(pLight->name) + 1);
dStrcpy(pRuntime->mNameBuffer.address() + rILight.nameIndex, pLight->name);
rILight.flags = pLight->type;
rILight.flags |= pLight->alarm ? Interior::AlarmLight : 0;
rILight.stateIndex = pRuntime->mLightStates.size();
rILight.stateCount = pLight->states.size();
pRuntime->mLightStates.setSize(rILight.stateIndex + rILight.stateCount);
F32 duration = 0.0f;
for (U32 j = 0; j < rILight.stateCount; j++) {
LightState* pState = pLight->states[j];
Interior::LightState& rIState = pRuntime->mLightStates[rILight.stateIndex + j];
rIState.red = pState->color.red;
rIState.green = pState->color.green;
rIState.blue = pState->color.blue;
rIState.activeTime = U32((duration * 1000.0f) + 0.5f);
// DMMFIX
rIState.dataIndex = pRuntime->mStateData.size();
rIState.dataCount = pState->stateData.size();
pRuntime->mStateData.setSize(rIState.dataIndex + rIState.dataCount);
for (U32 k = 0; k < rIState.dataCount; k++) {
Interior::LightStateData& rIStateData = pRuntime->mStateData[rIState.dataIndex + k];
StateData& rStateData = pState->stateData[k];
rIStateData.surfaceIndex = rStateData.surfaceIndex;
rIStateData.mapIndex = exportIntensityMap(pRuntime, rStateData.pLMap);
rIStateData.lightStateIndex = rStateData.stateDataIndex;
}
duration += pState->duration;
}
rILight.duration = U32((duration * 1000.0f) + 0.5f);
}
// Sort the interior lights so that the triggerables are first,
//
dQsort(pRuntime->mAnimatedLights.address(), // p
pRuntime->mAnimatedLights.size(), // nElem
sizeof(Interior::AnimatedLight), // w
cmpAnimatedLights); // cmp
}
//------------------------------------------------------------------------------
bool EditGeometry::exportToRuntime(Interior* pRuntime, InteriorResource* pResource)
{
mExportPointMap.clear();
pRuntime->mHasAlarmState = mHasAlarmState;
// The first thing to do is to export the planelist. Note that
// we're exporting only the forward facing planes. Negatives
// are indicated by the high bit being set on the index. From now
// on, we need to export planeIndices by calling convert...
//
exportPlanes(pRuntime);
// Next we export the BSP Tree. We'll need to call a recursive function
// for this.
U32 totalNodes = mNodeArena.mBuffers.size() * mNodeArena.arenaSize;
pRuntime->mBSPNodes.reserve(totalNodes);
pRuntime->mBSPSolidLeaves.reserve(totalNodes);
exportBSPToRuntime(pRuntime, mBSPRoot);
exportDMLToRuntime(pRuntime, mTextureNames);
// Now export the zones
for (U32 i = 0; i < mZones.size(); i++) {
if (mZones[i]->active == true) {
pRuntime->mZones.increment();
pRuntime->mZones.last().portalStart = pRuntime->mZonePortalList.size();
pRuntime->mZones.last().portalCount = mZones[i]->referencingPortals.size();
pRuntime->mZones.last().zoneId = i;
pRuntime->mZones.last().flags = mZones[i]->ambientLit ? 0 : Interior::ZoneInside;
for (U32 j = 0; j < mZones[i]->referencingPortals.size(); j++) {
pRuntime->mZonePortalList.increment();
pRuntime->mZonePortalList.last() = mZones[i]->referencingPortals[j];
}
}
}
// ...and the portals
for (U32 i = 0; i < mPortals.size(); i++) {
pRuntime->mPortals.increment();
pRuntime->mPortals.last().planeIndex = remapPlaneIndex(mPortals[i]->planeEQIndex);
pRuntime->mPortals.last().triFanStart = pRuntime->mWindingIndices.size();
if (mPortals[i]->windings.size() != 0)
pRuntime->mPortals.last().triFanCount = 1;
else
pRuntime->mPortals.last().triFanCount = 0;
pRuntime->mPortals.last().zoneFront = 0xFFFF;
pRuntime->mPortals.last().zoneBack = 0xFFFF;
for (U32 j = 0; j < pRuntime->mZones.size(); j++) {
if (pRuntime->mZones[j].zoneId == mPortals[i]->frontZone)
pRuntime->mPortals.last().zoneFront = j;
if (pRuntime->mZones[j].zoneId == mPortals[i]->backZone)
pRuntime->mPortals.last().zoneBack = j;
}
AssertFatal((mPortals[i]->frontZone == -1 && mPortals[i]->backZone == -1) ||
(pRuntime->mPortals.last().zoneFront != 0xFFFF && pRuntime->mPortals.last().zoneBack != 0xFFFF),
avar("Error, couldn't find the active zone corresponding to this portal! (%d, %d | %d, %d)",
mPortals[i]->frontZone,
mPortals[i]->backZone,
pRuntime->mPortals.last().zoneFront,
pRuntime->mPortals.last().zoneBack));
if (mPortals[i]->windings.size() != 0) {
Winding winding;
giftWrapPortal(winding, mPortals[i]);
exportWindingToRuntime(pRuntime, winding);
}
}
// Dump the animated lights.
exportLightsToRuntime(pRuntime);
// Dump the texgen
pRuntime->mTexGenEQs.setSize(mTexGenEQs.size());
for (U32 i = 0; i < mTexGenEQs.size(); i++) {
pRuntime->mTexGenEQs[i].planeX.x = mTexGenEQs[i].planeX.x * mWorldEntity->mGeometryScale;
pRuntime->mTexGenEQs[i].planeX.y = mTexGenEQs[i].planeX.y * mWorldEntity->mGeometryScale;
pRuntime->mTexGenEQs[i].planeX.z = mTexGenEQs[i].planeX.z * mWorldEntity->mGeometryScale;
pRuntime->mTexGenEQs[i].planeX.d = mTexGenEQs[i].planeX.d;
pRuntime->mTexGenEQs[i].planeY.x = mTexGenEQs[i].planeY.x * mWorldEntity->mGeometryScale;
pRuntime->mTexGenEQs[i].planeY.y = mTexGenEQs[i].planeY.y * mWorldEntity->mGeometryScale;
pRuntime->mTexGenEQs[i].planeY.z = mTexGenEQs[i].planeY.z * mWorldEntity->mGeometryScale;
pRuntime->mTexGenEQs[i].planeY.d = mTexGenEQs[i].planeY.d;
}
// ...and the surfaces
if (mSurfaces.size() != 0) {
for (U32 i = 0; i < mSurfaces.size(); i++) {
dumpSurfaceToRuntime(pRuntime, mSurfaces[i]);
AssertFatal(mSurfaces[i].sheetIndex < 0xFF, "Error, sheet index won't fit into 8 bits!");
pRuntime->mNormalLMapIndices.push_back(mSurfaces[i].sheetIndex);
pRuntime->mAlarmLMapIndices.push_back(mSurfaces[i].alarmSheetIndex);
}
}
// Dump any mirrors...
// Dump any triggers
// Dump any paths
// Dump any AISpecial Nodes
for (U32 i = 0; i < mEntities.size(); i++) {
if (dynamic_cast<MirrorSurfaceEntity*>(mEntities[i]) != NULL) {
dumpMirrorToRuntime(pRuntime, static_cast<MirrorSurfaceEntity*>(mEntities[i]));
}
else if (dynamic_cast<TriggerEntity*>(mEntities[i]) != NULL) {
dumpTriggerToRuntime(pRuntime, pResource,
static_cast<TriggerEntity*>(mEntities[i]));
}
else if (dynamic_cast<SpecialNodeEntity*>(mEntities[i]) != NULL) {
dumpAISpecialToRuntime(pRuntime, pResource,
static_cast<SpecialNodeEntity*>(mEntities[i]));
}
else if (dynamic_cast<GameEntity*>(mEntities[i]) != NULL) {
dumpGameEntityToRuntime(pRuntime, pResource,
static_cast<GameEntity*>(mEntities[i]));
}
}
// Dump doors (has to be after paths...
for (U32 i = 0; i < mEntities.size(); i++) {
if (dynamic_cast<DoorEntity*>(mEntities[i])) {
dumpDoorToRuntime(pRuntime, pResource, static_cast<DoorEntity*>(mEntities[i]));
}
else if (dynamic_cast<ForceFieldEntity*>(mEntities[i])) {
dumpForceFieldToRuntime(pRuntime, pResource, static_cast<ForceFieldEntity*>(mEntities[i]));
}
}
for (U32 i = 0; i < mNullSurfaces.size(); i++)
dumpNullSurfaceToRuntime(pRuntime, mNullSurfaces[i]);
for (U32 i = 0; i < mVehicleNullSurfaces.size(); i++)
dumpVehicleNullSurfaceToRuntime(pRuntime, mVehicleNullSurfaces[i]);
if (mSurfaces.size() != 0) {
for (U32 i = 0; i < pRuntime->mZones.size(); i++) {
pRuntime->mZones[i].surfaceStart = pRuntime->mZoneSurfaces.size();
pRuntime->mZones[i].surfaceCount = 0;
for (U32 j = 0; j < mSurfaces.size(); j++) {
if (mSurfaces[j].isMemberOfZone(pRuntime->mZones[i].zoneId)) {
pRuntime->mZoneSurfaces.push_back(j);
pRuntime->mZones[i].surfaceCount++;
}
}
}
} else {
for (U32 i = 0; i < pRuntime->mZones.size(); i++) {
pRuntime->mZones[i].surfaceStart = 0;
pRuntime->mZones[i].surfaceCount = 0;
}
}
// ...and the lightmaps
for (U32 i = 0; i < mLightmaps.size(); i++)
pRuntime->mLightmaps.push_back(new GBitmap(*mLightmaps[i]));
createBoundingVolumes(pRuntime);
pRuntime->mDetailLevel = mWorldEntity->mDetailNumber;
pRuntime->mMinPixels = mWorldEntity->mMinPixels;
// Build the interval trees and convex hulls for solid collisions...
if (mSpecialCollisionBrushes.size() == 0)
{
for (U32 i = 0; i < mStructuralBrushes.size(); i++)
exportHullToRuntime(pRuntime, mStructuralBrushes[i]);
for (U32 i = 0; i < mDetailBrushes.size(); i++)
exportHullToRuntime(pRuntime, mDetailBrushes[i]);
}
else
{
// Export the special hulls only...
for (U32 i = 0; i < mSpecialCollisionBrushes.size(); i++)
exportHullToRuntime(pRuntime, mSpecialCollisionBrushes[i]);
}
for (U32 i = 0; i< mVehicleCollisionBrushes.size(); i++)
{
exportVehicleHullToRuntime(pRuntime, mVehicleCollisionBrushes[i]);
}
exportHullBins(pRuntime);
// Export the ambient colors...
pRuntime->mBaseAmbient = mWorldEntity->mAmbientColor;
pRuntime->mAlarmAmbient = mWorldEntity->mEmergencyAmbientColor;
// Setup the point visibilities...
pRuntime->mPointVisibility.setSize(pRuntime->mPoints.size());
dMemset(pRuntime->mPointVisibility.address(), 0, pRuntime->mPointVisibility.size());
for (U32 i = 0; i < pRuntime->mSurfaces.size(); i++)
{
// Any point that is on an outside surface gets a 0xFF for right now...
for (U32 j = 0; j < pRuntime->mSurfaces[i].windingCount; j++)
{
pRuntime->mPointVisibility[pRuntime->mWindings[pRuntime->mSurfaces[i].windingStart + j]] = 0xFF;
}
}
// Setup the flags to keep the lightmaps if they have animated lights on them...
pRuntime->mLightmapKeep.setSize(pRuntime->mLightmaps.size());
for (U32 i = 0; i < pRuntime->mLightmapKeep.size(); i++)
pRuntime->mLightmapKeep[i] = false;
for (U32 i = 0; i < pRuntime->mStateData.size(); i++)
{
pRuntime->mLightmapKeep[pRuntime->mNormalLMapIndices[pRuntime->mStateData[i].surfaceIndex]] = true;
if (pRuntime->mHasAlarmState)
pRuntime->mLightmapKeep[pRuntime->mAlarmLMapIndices[pRuntime->mStateData[i].surfaceIndex]] = true;
}
return true;
}
struct PolySorted {
U32 numPoints;
S32* points;
U16 planeIndex;
};
int QSORT_CALLBACK cmpPointIndices(const void* p1, const void* p2)
{
const S32* pS321 = (const S32*)p1;
const S32* pS322 = (const S32*)p2;
return (*pS322) - (*pS321);
}
// God this sucks.
int QSORT_CALLBACK cmpPolySorted(const void* p1, const void* p2)
{
const PolySorted* pSorted1 = (const PolySorted*)p1;
const PolySorted* pSorted2 = (const PolySorted*)p2;
static S32 temp1[128];
static S32 temp2[128];
dMemcpy(temp1, pSorted1->points, sizeof(S32) * pSorted1->numPoints);
dMemcpy(temp2, pSorted2->points, sizeof(S32) * pSorted2->numPoints);
dQsort(temp1, pSorted1->numPoints, sizeof(S32), cmpPointIndices);
dQsort(temp2, pSorted2->numPoints, sizeof(S32), cmpPointIndices);
for (U32 i = 0; i < pSorted1->numPoints && i < pSorted2->numPoints; i++) {
if (temp1[i] != temp2[i])
return temp2[i] - temp1[i];
}
if (pSorted1->numPoints > pSorted2->numPoints)
return 1;
else if (pSorted2->numPoints > pSorted1->numPoints)
return -1;
else
return 0;
}
void EditGeometry::exportHullToRuntime(Interior* pRuntime, CSGBrush* brush)
{
S32** pWindingRemap = new S32*[brush->mPlanes.size()];
for (U32 i = 0; i < brush->mPlanes.size(); i++) {
pWindingRemap[i] = new S32[brush->mPlanes[i].winding.numIndices];
for (U32 j = 0; j < brush->mPlanes[i].winding.numIndices; j++)
pWindingRemap[i][j] = -1;
}
U32 numRemaps = 0;
// First, we remap the first winding
for (U32 i = 0; i < brush->mPlanes[0].winding.numIndices; i++)
pWindingRemap[0][i] = numRemaps++;
// Now, replace all of those indices in the other windings with the index of the
// remapped point
for (U32 i = 0; i < brush->mPlanes[0].winding.numIndices; i++) {
S32 remapIndex = brush->mPlanes[0].winding.indices[i];
S32 remapTo = i;
for (U32 j = 1; j < brush->mPlanes.size(); j++) {
for (U32 k = 0; k < brush->mPlanes[j].winding.numIndices; k++) {
if (brush->mPlanes[j].winding.indices[k] == remapIndex) {
pWindingRemap[j][k] = remapTo;
}
}
}
}
// Now, push the edge signature of the first winding onto our stack
Vector<U32> edgeSignatureStack;
for (U32 i = 0; i < brush->mPlanes[0].winding.numIndices; i++) {
S32 firstPoint = pWindingRemap[0][i];
S32 nextPoint = pWindingRemap[0][(i+1) % brush->mPlanes[0].winding.numIndices];
U32 edgeSignature = ((getMin(firstPoint, nextPoint) << 16) |
(getMax(firstPoint, nextPoint) << 0));
edgeSignatureStack.push_back(edgeSignature);
}
Vector<U32> polysLeft;
for (U32 i = 1; i < brush->mPlanes.size(); i++)
polysLeft.push_back(i);
U32 numFinds = 0;
while (edgeSignatureStack.empty() == false) {
// Find the winding with an edge signature that matches the first edge on the stack.
// we're guaranteed that this exists.
S32 polyIndex = -1;
for (U32 i = 0; i < polysLeft.size() && polyIndex == -1; i++) {
for (U32 j = 0; j < brush->mPlanes[polysLeft[i]].winding.numIndices && polyIndex == -1; j++) {
S32 firstPoint = pWindingRemap[polysLeft[i]][j];
S32 nextPoint = pWindingRemap[polysLeft[i]][(j+1) % brush->mPlanes[polysLeft[i]].winding.numIndices];
if (firstPoint == -1 || nextPoint == -1)
continue;
U32 edgeSignature = ((getMin(firstPoint, nextPoint) << 16) |
(getMax(firstPoint, nextPoint) << 0));
if (edgeSignature == edgeSignatureStack[0]) {
polyIndex = polysLeft[i];
polysLeft.erase(i);
break;
}
}
}
AssertFatal(polyIndex != -1, "Error, should have found that poly!");
// Ok, so now we know which poly is next, let's rotate it's winding until the edge
// we want is the first two indices in this poly
U32 warnCount = 0;
while (true) {
bool rotate = false;
S32 firstPoint = pWindingRemap[polyIndex][0];
S32 nextPoint = pWindingRemap[polyIndex][1];
if (firstPoint == -1 || nextPoint == -1) {
rotate = true;
} else {
U32 edgeSignature = ((getMin(firstPoint, nextPoint) << 16) |
(getMax(firstPoint, nextPoint) << 0));
if (edgeSignature != edgeSignatureStack[0])
rotate = true;
}
// OK, if we need to rotate, let's do that, otherwise, let's move on.
if (rotate == true) {
S32 stor = pWindingRemap[polyIndex][0];
dMemmove(&pWindingRemap[polyIndex][0], &pWindingRemap[polyIndex][1],
sizeof(S32) * (brush->mPlanes[polyIndex].winding.numIndices - 1));
pWindingRemap[polyIndex][brush->mPlanes[polyIndex].winding.numIndices - 1] = stor;
U32 storU = brush->mPlanes[polyIndex].winding.indices[0];
dMemmove(&brush->mPlanes[polyIndex].winding.indices[0],
&brush->mPlanes[polyIndex].winding.indices[1],
sizeof(U32) * (brush->mPlanes[polyIndex].winding.numIndices - 1));
brush->mPlanes[polyIndex].winding.indices[brush->mPlanes[polyIndex].winding.numIndices - 1] = storU;
} else {
break;
}
warnCount++;
AssertFatal(warnCount < 500, "Error, more rotations performed than possible");
}
// Ok. Now let's remap all the points necessary on this one
for (U32 i = 0; i < brush->mPlanes[polyIndex].winding.numIndices; i++) {
if (pWindingRemap[polyIndex][i] == -1) {
pWindingRemap[polyIndex][i] = numRemaps++;
// Now remap all the polys that contain that vertex as well (note that the
// zero poly is always fully remapped, so we can ignore it
S32 remapIndex = brush->mPlanes[polyIndex].winding.indices[i];
S32 remapTo = pWindingRemap[polyIndex][i];
for (U32 j = 1; j < brush->mPlanes.size(); j++) {
for (U32 k = 0; k < brush->mPlanes[j].winding.numIndices; k++) {
if (brush->mPlanes[j].winding.indices[k] == remapIndex) {
pWindingRemap[j][k] = remapTo;
}
}
}
}
}
// And push back the edge signatures for this winding, deleting any duplicates
for (U32 i = 0; i < brush->mPlanes[polyIndex].winding.numIndices; i++) {
S32 firstPoint = pWindingRemap[polyIndex][i];
S32 nextPoint = pWindingRemap[polyIndex][(i+1) % brush->mPlanes[polyIndex].winding.numIndices];
AssertFatal(firstPoint != -1 && nextPoint != -1, "Error, that's impossible!");
U32 edgeSignature = ((getMin(firstPoint, nextPoint) << 16) |
(getMax(firstPoint, nextPoint) << 0));
bool insert = true;
for (U32 j = 0; j < edgeSignatureStack.size(); j++) {
if (edgeSignatureStack[j] == edgeSignature) {
insert = false;
edgeSignatureStack.erase(j);
break;
}
}
if (insert == true)
edgeSignatureStack.push_back(edgeSignature);
}
numFinds++;
AssertFatal(numFinds <= brush->mPlanes.size(), avar("Error, too many damn finds (%d)!", brush->brushId));
}
// OK! At this point, none of the points should be uninserted, and everything is
// in canonical order. Let's whip through the remap arrays just to make sure. At
// the same time, we'll create the points array, which is a remap of indices in the
// remaps to the hullIndices.
Vector<U32> points;
points.setSize(numRemaps);
for (U32 i = 0; i < points.size(); i++)
points[i] = 0xFFFFFFFF;
for (U32 i = 0; i < brush->mPlanes.size(); i++) {
for (U32 j = 0; j < brush->mPlanes[i].winding.numIndices; j++) {
AssertFatal(pWindingRemap[i][j] != -1, "Error, there's an unremapped point here!");
if (points[pWindingRemap[i][j]] != 0xFFFFFFFF) {
AssertFatal(points[pWindingRemap[i][j]] == brush->mPlanes[i].winding.indices[j], "Error, bad remapping!");
} else {
points[pWindingRemap[i][j]] = brush->mPlanes[i].winding.indices[j];
}
}
}
for (U32 i = 0; i < points.size(); i++)
points[i] = exportPointToRuntime(pRuntime, points[i]);
pRuntime->mConvexHulls.increment();
pRuntime->mConvexHulls.last().hullStart = pRuntime->mHullIndices.size();
F32 minx = 1e8;
F32 miny = 1e8;
F32 minz = 1e8;
F32 maxx = -1e8;
F32 maxy = -1e8;
F32 maxz = -1e8;
for (U32 i = 0; i < points.size(); i++) {
pRuntime->mHullIndices.push_back(points[i]);
Point3F& rPoint = pRuntime->mPoints[points[i]].point;
if (rPoint.x < minx) minx = rPoint.x;
if (rPoint.x > maxx) maxx = rPoint.x;
if (rPoint.y < miny) miny = rPoint.y;
if (rPoint.y > maxy) maxy = rPoint.y;
if (rPoint.z < minz) minz = rPoint.z;
if (rPoint.z > maxz) maxz = rPoint.z;
}
pRuntime->mConvexHulls.last().hullCount = (pRuntime->mHullIndices.size() -
pRuntime->mConvexHulls.last().hullStart);
pRuntime->mConvexHulls.last().minX = minx;
pRuntime->mConvexHulls.last().maxX = maxx;
pRuntime->mConvexHulls.last().minY = miny;
pRuntime->mConvexHulls.last().maxY = maxy;
pRuntime->mConvexHulls.last().minZ = minz;
pRuntime->mConvexHulls.last().maxZ = maxz;
// We need a sorted array of poly objects in order to make these plane normals come
// out right.
PolySorted* pSortedPolys = new PolySorted[brush->mPlanes.size()];
for (U32 i = 0; i < brush->mPlanes.size(); i++) {
pSortedPolys[i].numPoints = brush->mPlanes[i].winding.numIndices;
pSortedPolys[i].points = pWindingRemap[i];
pSortedPolys[i].planeIndex = remapPlaneIndex(brush->mPlanes[i].planeEQIndex);
}
dQsort(pSortedPolys, brush->mPlanes.size(), sizeof(PolySorted), cmpPolySorted);
// Ok, now we have to construct an emit string for each vertex. This should be fairly
// straightforward, the procedure is: for each point:
// - find all polys that contain that point
// - find all points in those polys
// - find all edges " " "
// - enter the string
// The tricky bit is that we have to set up the emit indices to be relative to the
// hullindices.
for (U32 i = 0; i < points.size(); i++) {
static Vector<U32> emitPoints(128);
static Vector<U16> emitEdges(128);
static Vector<U32> emitPolys;
emitPoints.setSize(0);
emitEdges.setSize(0);
emitPolys.setSize(0);
for (U32 j = 0; j < brush->mPlanes.size(); j++) {
bool found = false;
for (U32 k = 0; k < pSortedPolys[j].numPoints; k++) {
if (pSortedPolys[j].points[k] == i) {
found = true;
break;
}
}
if (found) {
// Have to emit this poly...
for (U32 k = 0; k < pSortedPolys[j].numPoints; k++) {
emitPoints.push_back(pSortedPolys[j].points[k]);
S32 firstPoint = pSortedPolys[j].points[k];
S32 nextPoint = pSortedPolys[j].points[(k+1) % pSortedPolys[j].numPoints];
AssertFatal(firstPoint != -1 && nextPoint != -1, "Error, that's impossible!");
AssertFatal(firstPoint < 255 && nextPoint < 255, "Error, that's impossible!");
U16 edgeSignature = ((getMin(firstPoint, nextPoint) << 8) |
(getMax(firstPoint, nextPoint) << 0));
emitEdges.push_back(edgeSignature);
}
emitPolys.push_back(j);
}
}
// We also have to emit any polys that share the plane, but not necessarily the
// support point
for (U32 j = 0; j < brush->mPlanes.size(); j++) {
for (U32 k = 0; k < emitPolys.size(); k++) {
if (emitPolys[k] == j)
continue;
if (pSortedPolys[emitPolys[k]].planeIndex == pSortedPolys[j].planeIndex) {
// We may have to emit this as well...
bool found = false;
for (U32 l = 0; l < emitPolys.size(); l++) {
if (emitPolys[l] == j)
found = true;
}
if (!found) {
// Have to emit this poly...
for (U32 l = 0; l < pSortedPolys[j].numPoints; l++) {
emitPoints.push_back(pSortedPolys[j].points[l]);
S32 firstPoint = pSortedPolys[j].points[l];
S32 nextPoint = pSortedPolys[j].points[(l+1) % pSortedPolys[j].numPoints];
AssertFatal(firstPoint != -1 && nextPoint != -1, "Error, that's impossible!");
AssertFatal(firstPoint < 255 && nextPoint < 255, "Error, that's impossible!");
U16 edgeSignature = ((getMin(firstPoint, nextPoint) << 8) |
(getMax(firstPoint, nextPoint) << 0));
emitEdges.push_back(edgeSignature);
}
emitPolys.push_back(j);
}
}
}
}
AssertFatal(emitPoints.size() != 0 && emitEdges.size() != 0 && emitPolys.size() != 0,
"Error, should always emit something!");
std::sort(emitPoints.begin(), emitPoints.end());
U32* newend = std::unique(emitPoints.begin(), emitPoints.end());
emitPoints.setSize(newend - emitPoints.begin());
std::sort(emitPoints.begin(), emitPoints.end());
std::sort(emitEdges.begin(), emitEdges.end());
U16* newend16 = std::unique(emitEdges.begin(), emitEdges.end());
emitEdges.setSize(newend16 - emitEdges.begin());
std::sort(emitEdges.begin(), emitEdges.end());
// We need to transmute the edges to be relative to the points in the order of
// emission
for (U32 j = 0; j < emitEdges.size(); j++) {
U16 firstIndex = emitEdges[j] >> 8;
U16 nextIndex = emitEdges[j] & 0xFF;
U16 newFirst = 0xFFFF;
U16 newNext = 0xFFFF;
for (U32 k = 0; k < emitPoints.size(); k++) {
if (emitPoints[k] == firstIndex)
newFirst = k;
if (emitPoints[k] == nextIndex)
newNext = k;
}
AssertFatal(newFirst != 0xFFFF && newNext != 0xFFFF, "Error, bad edge!");
U16 newSignature = ((getMin(newFirst, newNext) << 8) |
(getMax(newFirst, newNext) << 0));
emitEdges[j] = newSignature;
}
// Emit string length is:
// 1 + NumPoints +
// 1 + (NumEdges * 2) +
// 1 + Sum_polys(1 + 1 + numVerts(poly))
U32 emitStringLen = 0;
emitStringLen += 1 + emitPoints.size();
emitStringLen += 1 + (emitEdges.size() * 2);
emitStringLen += 1;
for (U32 j = 0; j < emitPolys.size(); j++)
emitStringLen += 1 + 1 + pSortedPolys[emitPolys[j]].numPoints;
U8* emitString = new U8[emitStringLen];
U32 currPos = 0;
dMemset(emitString, 0, emitStringLen);
// First, dump the points
emitString[currPos++] = emitPoints.size();
for (U32 j = 0; j < emitPoints.size(); j++)
emitString[currPos++] = emitPoints[j];
// Now the edges
emitString[currPos++] = emitEdges.size();
for (U32 j = 0; j < emitEdges.size(); j++) {
U16 edgeP1 = emitEdges[j] >> 8;
U16 edgeP2 = emitEdges[j] & 0xFF;
emitString[currPos++] = edgeP1;
emitString[currPos++] = edgeP2;
}
// And the polys.
emitString[currPos++] = emitPolys.size();
for (U32 j = 0; j < emitPolys.size(); j++) {
// A poly is:
// vertex count
// plane index
// verts (relative)
emitString[currPos++] = pSortedPolys[emitPolys[j]].numPoints;
emitString[currPos++] = emitPolys[j];
for (U32 k = 0; k < pSortedPolys[emitPolys[j]].numPoints; k++) {
bool found = false;
for (U32 l = 0; l < emitPoints.size(); l++) {
if (emitPoints[l] == pSortedPolys[emitPolys[j]].points[k]) {
emitString[currPos++] = l;
found = true;
break;
}
}
AssertFatal(found, "Error, missed a point!");
}
}
AssertFatal(currPos == emitStringLen, "Error, miscalculation of string len!");
U32 emitStringExportedIndex = exportEmitStringToRuntime(pRuntime, emitString, emitStringLen);
pRuntime->mHullEmitStringIndices.push_back(emitStringExportedIndex);
AssertFatal(dMemcmp(&pRuntime->mConvexHullEmitStrings[emitStringExportedIndex], emitString, emitStringLen) == 0, "Bad exported string!");
delete [] emitString;
}
AssertFatal(pRuntime->mHullEmitStringIndices.size() == pRuntime->mHullIndices.size(), "Point/emitstring mismatch!");
pRuntime->mConvexHulls.last().planeStart = pRuntime->mHullPlaneIndices.size();
for (U32 i = 0; i < brush->mPlanes.size(); i++)
pRuntime->mHullPlaneIndices.push_back(pSortedPolys[i].planeIndex);
for (U32 i = 0; i < brush->mPlanes.size(); i++)
delete [] pWindingRemap[i];
delete [] pWindingRemap;
delete [] pSortedPolys;
// Now dump out the surfaces that were created by this hull that are still in
// the interior...
pRuntime->mConvexHulls.last().surfaceStart = pRuntime->mHullSurfaceIndices.size();
for (U32 i = 0; i < mSurfaces.size(); i++) {
if (mSurfaces[i].winding.brushId == brush->brushId) {
// Dump this surface
pRuntime->mHullSurfaceIndices.push_back(i);
}
}
for (U32 i = 0; i < mNullSurfaces.size(); i++) {
if (mNullSurfaces[i].winding.brushId == brush->brushId) {
// Dump this surface
pRuntime->mHullSurfaceIndices.push_back(makeNullSurfaceIndex(i));
}
}
pRuntime->mConvexHulls.last().surfaceCount = (pRuntime->mHullSurfaceIndices.size() -
pRuntime->mConvexHulls.last().surfaceStart);
}
void EditGeometry::exportVehicleHullToRuntime(Interior* pRuntime, CSGBrush* brush)
{
S32** pWindingRemap = new S32*[brush->mPlanes.size()];
for (U32 i = 0; i < brush->mPlanes.size(); i++) {
pWindingRemap[i] = new S32[brush->mPlanes[i].winding.numIndices];
for (U32 j = 0; j < brush->mPlanes[i].winding.numIndices; j++)
pWindingRemap[i][j] = -1;
}
U32 numRemaps = 0;
// First, we remap the first winding
for (U32 i = 0; i < brush->mPlanes[0].winding.numIndices; i++)
pWindingRemap[0][i] = numRemaps++;
// Now, replace all of those indices in the other windings with the index of the
// remapped point
for (U32 i = 0; i < brush->mPlanes[0].winding.numIndices; i++) {
S32 remapIndex = brush->mPlanes[0].winding.indices[i];
S32 remapTo = i;
for (U32 j = 1; j < brush->mPlanes.size(); j++) {
for (U32 k = 0; k < brush->mPlanes[j].winding.numIndices; k++) {
if (brush->mPlanes[j].winding.indices[k] == remapIndex) {
pWindingRemap[j][k] = remapTo;
}
}
}
}
// Now, push the edge signature of the first winding onto our stack
Vector<U32> edgeSignatureStack;
for (U32 i = 0; i < brush->mPlanes[0].winding.numIndices; i++) {
S32 firstPoint = pWindingRemap[0][i];
S32 nextPoint = pWindingRemap[0][(i+1) % brush->mPlanes[0].winding.numIndices];
U32 edgeSignature = (getMin(firstPoint, nextPoint) << 16) |
(getMax(firstPoint, nextPoint) << 0);
edgeSignatureStack.push_back(edgeSignature);
}
Vector<U32> polysLeft;
for (U32 i = 1; i < brush->mPlanes.size(); i++)
polysLeft.push_back(i);
U32 numFinds = 0;
while (edgeSignatureStack.empty() == false) {
// Find the winding with an edge signature that matches the first edge on the stack.
// we're guaranteed that this exists.
S32 polyIndex = -1;
for (U32 i = 0; i < polysLeft.size() && polyIndex == -1; i++) {
for (U32 j = 0; j < brush->mPlanes[polysLeft[i]].winding.numIndices && polyIndex == -1; j++) {
S32 firstPoint = pWindingRemap[polysLeft[i]][j];
S32 nextPoint = pWindingRemap[polysLeft[i]][(j+1) % brush->mPlanes[polysLeft[i]].winding.numIndices];
if (firstPoint == -1 || nextPoint == -1)
continue;
U32 edgeSignature = (getMin(firstPoint, nextPoint) << 16) |
(getMax(firstPoint, nextPoint) << 0);
if (edgeSignature == edgeSignatureStack[0]) {
polyIndex = polysLeft[i];
polysLeft.erase(i);
break;
}
}
}
AssertFatal(polyIndex != -1, "Error, should have found that poly!");
// Ok, so now we know which poly is next, let's rotate it's winding until the edge
// we want is the first two indices in this poly
U32 warnCount = 0;
while (true) {
bool rotate = false;
S32 firstPoint = pWindingRemap[polyIndex][0];
S32 nextPoint = pWindingRemap[polyIndex][1];
if (firstPoint == -1 || nextPoint == -1) {
rotate = true;
} else {
U32 edgeSignature = (getMin(firstPoint, nextPoint) << 16) |
(getMax(firstPoint, nextPoint) << 0);
if (edgeSignature != edgeSignatureStack[0])
rotate = true;
}
// OK, if we need to rotate, let's do that, otherwise, let's move on.
if (rotate == true) {
S32 stor = pWindingRemap[polyIndex][0];
dMemmove(&pWindingRemap[polyIndex][0], &pWindingRemap[polyIndex][1],
sizeof(S32) * (brush->mPlanes[polyIndex].winding.numIndices - 1));
pWindingRemap[polyIndex][brush->mPlanes[polyIndex].winding.numIndices - 1] = stor;
U32 storU = brush->mPlanes[polyIndex].winding.indices[0];
dMemmove(&brush->mPlanes[polyIndex].winding.indices[0],
&brush->mPlanes[polyIndex].winding.indices[1],
sizeof(U32) * (brush->mPlanes[polyIndex].winding.numIndices - 1));
brush->mPlanes[polyIndex].winding.indices[brush->mPlanes[polyIndex].winding.numIndices - 1] = storU;
} else {
break;
}
warnCount++;
AssertFatal(warnCount < 500, "Error, more rotations performed than possible");
}
// Ok. Now let's remap all the points necessary on this one
for (U32 i = 0; i < brush->mPlanes[polyIndex].winding.numIndices; i++) {
if (pWindingRemap[polyIndex][i] == -1) {
pWindingRemap[polyIndex][i] = numRemaps++;
// Now remap all the polys that contain that vertex as well (note that the
// zero poly is always fully remapped, so we can ignore it
S32 remapIndex = brush->mPlanes[polyIndex].winding.indices[i];
S32 remapTo = pWindingRemap[polyIndex][i];
for (U32 j = 1; j < brush->mPlanes.size(); j++) {
for (U32 k = 0; k < brush->mPlanes[j].winding.numIndices; k++) {
if (brush->mPlanes[j].winding.indices[k] == remapIndex) {
pWindingRemap[j][k] = remapTo;
}
}
}
}
}
// And push back the edge signatures for this winding, deleting any duplicates
for (U32 i = 0; i < brush->mPlanes[polyIndex].winding.numIndices; i++) {
S32 firstPoint = pWindingRemap[polyIndex][i];
S32 nextPoint = pWindingRemap[polyIndex][(i+1) % brush->mPlanes[polyIndex].winding.numIndices];
AssertFatal(firstPoint != -1 && nextPoint != -1, "Error, that's impossible!");
U32 edgeSignature = (getMin(firstPoint, nextPoint) << 16) |
(getMax(firstPoint, nextPoint) << 0);
bool insert = true;
for (U32 j = 0; j < edgeSignatureStack.size(); j++) {
if (edgeSignatureStack[j] == edgeSignature) {
insert = false;
edgeSignatureStack.erase(j);
break;
}
}
if (insert == true)
edgeSignatureStack.push_back(edgeSignature);
}
numFinds++;
AssertFatal(numFinds <= brush->mPlanes.size(), avar("Error, too many damn finds (%d)!", brush->brushId));
}
// OK! At this point, none of the points should be uninserted, and everything is
// in canonical order. Let's whip through the remap arrays just to make sure. At
// the same time, we'll create the points array, which is a remap of indices in the
// remaps to the hullIndices.
Vector<U32> points;
points.setSize(numRemaps);
for (U32 i = 0; i < points.size(); i++)
points[i] = 0xFFFFFFFF;
for (U32 i = 0; i < brush->mPlanes.size(); i++) {
for (U32 j = 0; j < brush->mPlanes[i].winding.numIndices; j++) {
AssertFatal(pWindingRemap[i][j] != -1, "Error, there's an unremapped point here!");
if (points[pWindingRemap[i][j]] != 0xFFFFFFFF) {
AssertFatal(points[pWindingRemap[i][j]] == brush->mPlanes[i].winding.indices[j], "Error, bad remapping!");
} else {
points[pWindingRemap[i][j]] = brush->mPlanes[i].winding.indices[j];
}
}
}
for (U32 i = 0; i < points.size(); i++)
points[i] = exportVehiclePointToRuntime(pRuntime, points[i]);
pRuntime->mVehicleConvexHulls.increment();
pRuntime->mVehicleConvexHulls.last().hullStart = pRuntime->mVehicleHullIndices.size();
F32 minx = 1e8;
F32 miny = 1e8;
F32 minz = 1e8;
F32 maxx = -1e8;
F32 maxy = -1e8;
F32 maxz = -1e8;
for (U32 i = 0; i < points.size(); i++) {
pRuntime->mVehicleHullIndices.push_back(points[i]);
Point3F& rPoint = pRuntime->mVehiclePoints[points[i]].point;
if (rPoint.x < minx) minx = rPoint.x;
if (rPoint.x > maxx) maxx = rPoint.x;
if (rPoint.y < miny) miny = rPoint.y;
if (rPoint.y > maxy) maxy = rPoint.y;
if (rPoint.z < minz) minz = rPoint.z;
if (rPoint.z > maxz) maxz = rPoint.z;
}
pRuntime->mVehicleConvexHulls.last().hullCount = (pRuntime->mVehicleHullIndices.size() -
pRuntime->mVehicleConvexHulls.last().hullStart);
pRuntime->mVehicleConvexHulls.last().minX = minx;
pRuntime->mVehicleConvexHulls.last().maxX = maxx;
pRuntime->mVehicleConvexHulls.last().minY = miny;
pRuntime->mVehicleConvexHulls.last().maxY = maxy;
pRuntime->mVehicleConvexHulls.last().minZ = minz;
pRuntime->mVehicleConvexHulls.last().maxZ = maxz;
// We need a sorted array of poly objects in order to make these plane normals come
// out right.
PolySorted* pSortedPolys = new PolySorted[brush->mPlanes.size()];
for (U32 i = 0; i < brush->mPlanes.size(); i++) {
pSortedPolys[i].numPoints = brush->mPlanes[i].winding.numIndices;
pSortedPolys[i].points = pWindingRemap[i];
pSortedPolys[i].planeIndex = remapVehiclePlaneIndex(brush->mPlanes[i].planeEQIndex, pRuntime);
}
dQsort(pSortedPolys, brush->mPlanes.size(), sizeof(PolySorted), cmpPolySorted);
// Ok, now we have to construct an emit string for each vertex. This should be fairly
// straightforward, the procedure is: for each point:
// - find all polys that contain that point
// - find all points in those polys
// - find all edges " " "
// - enter the string
// The tricky bit is that we have to set up the emit indices to be relative to the
// hullindices.
for (U32 i = 0; i < points.size(); i++) {
static Vector<U32> emitPoints(128);
static Vector<U16> emitEdges(128);
static Vector<U32> emitPolys;
emitPoints.setSize(0);
emitEdges.setSize(0);
emitPolys.setSize(0);
for (U32 j = 0; j < brush->mPlanes.size(); j++) {
bool found = false;
for (U32 k = 0; k < pSortedPolys[j].numPoints; k++) {
if (pSortedPolys[j].points[k] == i) {
found = true;
break;
}
}
if (found) {
// Have to emit this poly...
for (U32 k = 0; k < pSortedPolys[j].numPoints; k++) {
emitPoints.push_back(pSortedPolys[j].points[k]);
S32 firstPoint = pSortedPolys[j].points[k];
S32 nextPoint = pSortedPolys[j].points[(k+1) % pSortedPolys[j].numPoints];
AssertFatal(firstPoint != -1 && nextPoint != -1, "Error, that's impossible!");
AssertFatal(firstPoint < 255 && nextPoint < 255, "Error, that's impossible!");
U16 edgeSignature = (getMin(firstPoint, nextPoint) << 8) |
(getMax(firstPoint, nextPoint) << 0);
emitEdges.push_back(edgeSignature);
}
emitPolys.push_back(j);
}
}
// We also have to emit any polys that share the plane, but not necessarily the
// support point
for (U32 j = 0; j < brush->mPlanes.size(); j++) {
for (U32 k = 0; k < emitPolys.size(); k++) {
if (emitPolys[k] == j)
continue;
if (pSortedPolys[emitPolys[k]].planeIndex == pSortedPolys[j].planeIndex) {
// We may have to emit this as well...
bool found = false;
for (U32 l = 0; l < emitPolys.size(); l++) {
if (emitPolys[l] == j)
found = true;
}
if (!found) {
// Have to emit this poly...
for (U32 l = 0; l < pSortedPolys[j].numPoints; l++) {
emitPoints.push_back(pSortedPolys[j].points[l]);
S32 firstPoint = pSortedPolys[j].points[l];
S32 nextPoint = pSortedPolys[j].points[(l+1) % pSortedPolys[j].numPoints];
AssertFatal(firstPoint != -1 && nextPoint != -1, "Error, that's impossible!");
AssertFatal(firstPoint < 255 && nextPoint < 255, "Error, that's impossible!");
U16 edgeSignature = (getMin(firstPoint, nextPoint) << 8) |
(getMax(firstPoint, nextPoint) << 0);
emitEdges.push_back(edgeSignature);
}
emitPolys.push_back(j);
}
}
}
}
AssertFatal(emitPoints.size() != 0 && emitEdges.size() != 0 && emitPolys.size() != 0,
"Error, should always emit something!");
std::sort(emitPoints.begin(), emitPoints.end());
U32* newend = std::unique(emitPoints.begin(), emitPoints.end());
emitPoints.setSize(newend - emitPoints.begin());
std::sort(emitPoints.begin(), emitPoints.end());
std::sort(emitEdges.begin(), emitEdges.end());
U16* newend16 = std::unique(emitEdges.begin(), emitEdges.end());
emitEdges.setSize(newend16 - emitEdges.begin());
std::sort(emitEdges.begin(), emitEdges.end());
// We need to transmute the edges to be relative to the points in the order of
// emission
for (U32 j = 0; j < emitEdges.size(); j++) {
U16 firstIndex = emitEdges[j] >> 8;
U16 nextIndex = emitEdges[j] & 0xFF;
U16 newFirst = 0xFFFF;
U16 newNext = 0xFFFF;
for (U32 k = 0; k < emitPoints.size(); k++) {
if (emitPoints[k] == firstIndex)
newFirst = k;
if (emitPoints[k] == nextIndex)
newNext = k;
}
AssertFatal(newFirst != 0xFFFF && newNext != 0xFFFF, "Error, bad edge!");
U16 newSignature = (getMin(newFirst, newNext) << 8) |
(getMax(newFirst, newNext) << 0);
emitEdges[j] = newSignature;
}
// Emit string length is:
// 1 + NumPoints +
// 1 + (NumEdges * 2) +
// 1 + Sum_polys(1 + 1 + numVerts(poly))
U32 emitStringLen = 0;
emitStringLen += 1 + emitPoints.size();
emitStringLen += 1 + (emitEdges.size() * 2);
emitStringLen += 1;
for (U32 j = 0; j < emitPolys.size(); j++)
emitStringLen += 1 + 1 + pSortedPolys[emitPolys[j]].numPoints;
U8* emitString = new U8[emitStringLen];
U32 currPos = 0;
dMemset(emitString, 0, emitStringLen);
// First, dump the points
emitString[currPos++] = emitPoints.size();
for (U32 j = 0; j < emitPoints.size(); j++)
emitString[currPos++] = emitPoints[j];
// Now the edges
emitString[currPos++] = emitEdges.size();
for (U32 j = 0; j < emitEdges.size(); j++) {
U16 edgeP1 = emitEdges[j] >> 8;
U16 edgeP2 = emitEdges[j] & 0xFF;
emitString[currPos++] = edgeP1;
emitString[currPos++] = edgeP2;
}
// And the polys.
emitString[currPos++] = emitPolys.size();
for (U32 j = 0; j < emitPolys.size(); j++) {
// A poly is:
// vertex count
// plane index
// verts (relative)
emitString[currPos++] = pSortedPolys[emitPolys[j]].numPoints;
emitString[currPos++] = emitPolys[j];
for (U32 k = 0; k < pSortedPolys[emitPolys[j]].numPoints; k++) {
bool found = false;
for (U32 l = 0; l < emitPoints.size(); l++) {
if (emitPoints[l] == pSortedPolys[emitPolys[j]].points[k]) {
emitString[currPos++] = l;
found = true;
break;
}
}
AssertFatal(found, "Error, missed a point!");
}
}
AssertFatal(currPos == emitStringLen, "Error, miscalculation of string len!");
U32 emitStringExportedIndex = exportVehicleEmitStringToRuntime(pRuntime, emitString, emitStringLen);
pRuntime->mVehicleHullEmitStringIndices.push_back(emitStringExportedIndex);
AssertFatal(dMemcmp(&pRuntime->mVehicleConvexHullEmitStrings[emitStringExportedIndex], emitString, emitStringLen) == 0, "Bad exported string!");
delete [] emitString;
}
AssertFatal(pRuntime->mVehicleHullEmitStringIndices.size() == pRuntime->mVehicleHullIndices.size(),
"Point/emitstring mismatch!");
pRuntime->mVehicleConvexHulls.last().planeStart = pRuntime->mVehicleHullPlaneIndices.size();
for (U32 i = 0; i < brush->mPlanes.size(); i++)
pRuntime->mVehicleHullPlaneIndices.push_back(pSortedPolys[i].planeIndex);
for (U32 i = 0; i < brush->mPlanes.size(); i++)
delete [] pWindingRemap[i];
delete [] pWindingRemap;
delete [] pSortedPolys;
// Now dump out the surfaces that were created by this hull that are still in
// the interior...
pRuntime->mVehicleConvexHulls.last().surfaceStart = pRuntime->mVehicleHullSurfaceIndices.size();
for (U32 i = 0; i < mVehicleNullSurfaces.size(); i++) {
if (mVehicleNullSurfaces[i].winding.brushId == brush->brushId) {
// Dump this surface
pRuntime->mVehicleHullSurfaceIndices.push_back(makeVehicleNullSurfaceIndex(i));
}
}
pRuntime->mVehicleConvexHulls.last().surfaceCount = (pRuntime->mVehicleHullSurfaceIndices.size() -
pRuntime->mVehicleConvexHulls.last().surfaceStart);
}
void EditGeometry::exportHullBins(Interior* pRuntime)
{
pRuntime->mCoordBinMode = Interior::BinsXY;
for (U32 i = 0; i < Interior::NumCoordBins; i++) {
F32 minX = pRuntime->mBoundingBox.min.x;
F32 maxX = pRuntime->mBoundingBox.min.x;
minX += F32(i) * (pRuntime->mBoundingBox.len_x() / F32(Interior::NumCoordBins));
maxX += F32(i+1) * (pRuntime->mBoundingBox.len_x() / F32(Interior::NumCoordBins));
for (U32 j = 0; j < Interior::NumCoordBins; j++) {
F32 minY = pRuntime->mBoundingBox.min.y;
F32 maxY = pRuntime->mBoundingBox.min.y;
minY += F32(j) * (pRuntime->mBoundingBox.len_y() / F32(Interior::NumCoordBins));
maxY += F32(j+1) * (pRuntime->mBoundingBox.len_y() / F32(Interior::NumCoordBins));
// This isn't really the fastest way to do this, but it is convenient...
RectF binRect(Point2F(minX, minY), Point2F(maxX - minX, maxY - minY));
AssertFatal(binRect.isValidRect(), "Error, invalid rect for bin!");
U32 binIndex = (i * Interior::NumCoordBins) + j;
pRuntime->mCoordBins[binIndex].binStart = pRuntime->mCoordBinIndices.size();
for (U32 k = 0; k < pRuntime->mConvexHulls.size(); k++) {
const Interior::ConvexHull& rHull = pRuntime->mConvexHulls[k];
RectF hullRect(Point2F(rHull.minX, rHull.minY), Point2F(rHull.maxX - rHull.minX, rHull.maxY - rHull.minY));
AssertFatal(hullRect.isValidRect(), "Error, invalid rect for bin!");
if (binRect.overlaps(hullRect)) {
// Index k goes into bin [i][j]...
pRuntime->mCoordBinIndices.push_back(k);
}
}
pRuntime->mCoordBins[binIndex].binCount = (pRuntime->mCoordBinIndices.size() -
pRuntime->mCoordBins[binIndex].binStart);
}
}
}
Reference in New Issue View Git Blame Copy Permalink