Serious-Engine/Sources/Engine/Math/Object3D_CSG.cpp
2016-03-11 18:20:51 -06:00

688 lines
22 KiB
C++

/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "stdh.h"
#include <Engine/Math/Object3D.h>
#include <Engine/Templates/BSP_internal.h>
#include <Engine/Templates/DynamicArray.cpp>
/*
* CSG operation table action.
*/
enum CSGAction {
CSGA_WallA1, // wall of sector A1
CSGA_WallA1_2, // wall of sector A1 second part
CSGA_PortalA1A2, // portal between A1 and A2
CSGA_PortalA1A2_2, // portal between A1 and A2 second part
CSGA_PortalA1B1B1A1, // two portals: A1-B1 and B1-A1
CSGA_WallB1, // wall of sector B1
CSGA_PortalB1B2, // portal between B1 and B2
CSGA_Remove, // this polygon is removed
CSGA_Proceed, // this polygon proceeds with testing
};
/*
* CSG operation table.
*/
struct CSGOperationTable {
enum CSGAction cot_WallA1InsideB1, cot_WallA1OutsideB, cot_WallA1OnB1BorderInside, cot_WallA1OnB1BorderOutside;
enum CSGAction cot_PortalA1A2InsideB1, cot_PortalA1A2OutsideB, cot_PortalA1A2OnB1BorderInside, cot_PortalA1A2OnB1BorderOutside;
};
/*
NOTE: In following tables, the operations for object B have A and B sectors reversed.
That is because tables are always interpreted as being for object A, therefore
when using it for B, sector B means 'sector of other object' that is in fact sector A
and vice versa.
For readable tables see "CSG.doc".
*/
/*
* CSG operation tables for 'add rooms'.
*/
static struct CSGOperationTable csgotAddRoomsA = {
CSGA_PortalA1B1B1A1, CSGA_WallA1, CSGA_WallA1, CSGA_PortalA1B1B1A1,
CSGA_PortalA1A2, CSGA_PortalA1A2, CSGA_PortalA1A2, CSGA_PortalA1A2,
};
static struct CSGOperationTable csgotAddRoomsB = {
CSGA_Remove, CSGA_WallA1, CSGA_Remove, CSGA_Remove,
CSGA_Remove, CSGA_PortalA1A2, CSGA_Remove, CSGA_Remove,
};
/*
* CSG operation tables for 'add material'.
*/
static struct CSGOperationTable csgotAddMaterialA = {
CSGA_WallA1, CSGA_Remove, CSGA_Remove, CSGA_Remove,
CSGA_PortalA1A2, CSGA_Remove, CSGA_Remove, CSGA_Remove,
};
static struct CSGOperationTable csgotAddMaterialB = {
CSGA_WallB1, CSGA_Remove, CSGA_WallB1, CSGA_Proceed,
CSGA_Remove, CSGA_Remove, CSGA_Remove, CSGA_Remove,
};
static struct CSGOperationTable csgotAddMaterialReverseA = {
CSGA_WallA1, CSGA_Remove, CSGA_WallA1, CSGA_Remove,
CSGA_PortalA1A2, CSGA_Remove, CSGA_Remove, CSGA_Remove,
};
static struct CSGOperationTable csgotAddMaterialReverseB = {
CSGA_WallB1, CSGA_Remove, CSGA_Remove, CSGA_Proceed,
CSGA_Remove, CSGA_Remove, CSGA_Remove, CSGA_Remove,
};
/*
* CSG operation tables for 'split sectors'.
*/
static struct CSGOperationTable csgotSplitSectorsA = {
CSGA_WallB1, CSGA_WallA1, CSGA_WallB1, CSGA_WallA1,
CSGA_PortalB1B2, CSGA_PortalA1A2, CSGA_PortalB1B2, CSGA_PortalA1A2,
};
static struct CSGOperationTable csgotSplitSectorsB = {
CSGA_PortalA1B1B1A1, CSGA_Remove, CSGA_Remove, CSGA_Remove,
CSGA_Remove, CSGA_Remove, CSGA_Remove, CSGA_Remove,
};
/*
* CSG operation tables for 'join sectors'.
*/
static struct CSGOperationTable csgotJoinSectorsA = {
CSGA_Remove, CSGA_WallA1, CSGA_WallA1, CSGA_Remove,
CSGA_Remove, CSGA_PortalA1A2, CSGA_PortalA1A2, CSGA_Remove,
};
static struct CSGOperationTable csgotJoinSectorsB = {
CSGA_Remove, CSGA_WallB1, CSGA_Remove, CSGA_Remove,
CSGA_Remove, CSGA_PortalB1B2, CSGA_Remove, CSGA_Remove,
};
/*
* CSG operation tables for 'split polygons'.
*/
static struct CSGOperationTable csgotSplitPolygonsA = {
CSGA_WallA1_2, CSGA_WallA1, CSGA_WallA1_2, CSGA_WallA1,
CSGA_PortalA1A2_2, CSGA_PortalA1A2, CSGA_PortalA1A2_2, CSGA_PortalA1A2,
};
static struct CSGOperationTable csgotSplitPolygonsB = {
CSGA_Remove, CSGA_Remove, CSGA_Remove, CSGA_Remove,
CSGA_Remove, CSGA_Remove, CSGA_Remove, CSGA_Remove,
};
/*
* Create a new polygon that will be a piece of some split polygon.
*/
static inline CObjectPolygon *CreatePieceOfPolygon(
CObjectSector *poscSector,
const CObjectPolygon &opoOriginal,
BOOL bReversePlane)
{
// create new polygon
CObjectPolygon *popoPiece = poscSector->osc_aopoPolygons.New(1);
// if the plane should be reversed
if (bReversePlane) {
// create a new reversed plane
CObjectPlane *poplNew = poscSector->osc_aoplPlanes.New(1);
*poplNew = -*opoOriginal.opo_Plane;
popoPiece->opo_Plane = poplNew;
// otherwise
} else {
// create a new plane (not reversed)
CObjectPlane *poplNew = poscSector->osc_aoplPlanes.New(1);
*poplNew = *opoOriginal.opo_Plane;
popoPiece->opo_Plane = poplNew;
}
// create a new material
CObjectMaterial *pomtNew = poscSector->osc_aomtMaterials.New(1);
*pomtNew = *opoOriginal.opo_Material;
popoPiece->opo_Material = pomtNew;
// copy other attributes
popoPiece->opo_colorColor = opoOriginal.opo_colorColor;
memcpy(popoPiece->opo_amdMappings, opoOriginal.opo_amdMappings,
sizeof(opoOriginal.opo_amdMappings));
popoPiece->opo_ulFlags = opoOriginal.opo_ulFlags;
memcpy(popoPiece->opo_ubUserData, opoOriginal.opo_ubUserData, OPO_MAXUSERDATA);
return popoPiece;
}
/*
* A machine for doing CSG operations on an CObject3D object.
*/
class CObjectCSG {
public:
// pointers to sectors and polygons that is currently operating on
CObjectSector *oc_poscSectorA;
CObjectSector *oc_poscSectorB;
CObjectPolygon *oc_popoA;
CObjectPolygon *oc_popoWallA1;
CObjectPolygon *oc_popoWallA1_2;
CObjectPolygon *oc_popoPortalA1A2;
CObjectPolygon *oc_popoPortalA1A2_2;
CObjectPolygon *oc_popoPortalA1B1;
CObjectPolygon *oc_popoWallB1;
CObjectPolygon *oc_popoPortalB1A1;
CObjectPolygon *oc_popoPortalB1B2;
inline CObjectPolygon *GetWallA1(void);
inline CObjectPolygon *GetWallA1_2(void);
inline CObjectPolygon *GetPortalA1A2(void);
inline CObjectPolygon *GetPortalA1A2_2(void);
inline CObjectPolygon *GetPortalA1B1(void);
inline CObjectPolygon *GetWallB1(void);
inline CObjectPolygon *GetPortalB1A1(void);
inline CObjectPolygon *GetPortalB1B2(void);
BOOL oc_bCSGIngoringEnabled;
BOOL oc_bSkipObjectB;
// array for holding edges that proceed with testing
CDynamicArray<DOUBLEbspedge3D> oc_abedProceeding;
CObjectCSG(void) {
oc_bCSGIngoringEnabled = FALSE;
oc_bSkipObjectB = FALSE;
}
/* Add an entire array of BSP edges to some polygon according to action code. */
inline void AddEdgeArrayAccordingToAction(
CDynamicArray<DOUBLEbspedge3D> &abed,
enum CSGAction csga);
/* Fill array of bsp edges from array of polygon edges. */
void PolygonEdgesToBSPEdges(
CDynamicArray<CObjectPolygonEdge> &aope,
CDynamicArray<DOUBLEbspedge3D> &abed
);
public:
/* Perform CSG splitting of sectors in one operand using other operand. */
void DoCSGSplitting(
CObject3D &obResult,
CObject3D &obA,
INDEX iSectorOffsetA,
struct CSGOperationTable *pcsgotA,
CObject3D &obB,
INDEX iSectorOffsetB);
/* Perform CSG operation -- destroys both operands! */
void DoCSGOperation(
CObject3D &obResult,
CObject3D &obA,
CObject3D &obB,
struct CSGOperationTable *pcsgotA,
struct CSGOperationTable *pcsgotB);
};
CObjectPolygon *CObjectCSG::GetWallA1(void)
{
if (oc_popoWallA1==NULL) {
oc_popoWallA1 = CreatePieceOfPolygon(oc_poscSectorA, *oc_popoA, FALSE);
oc_popoWallA1->opo_ulFlags &= ~OPOF_PORTAL;
}
return oc_popoWallA1;
}
CObjectPolygon *CObjectCSG::GetWallA1_2(void)
{
if (oc_popoWallA1_2==NULL) {
oc_popoWallA1_2 = CreatePieceOfPolygon(oc_poscSectorA, *oc_popoA, FALSE);
oc_popoWallA1_2->opo_ulFlags &= ~OPOF_PORTAL;
}
return oc_popoWallA1_2;
}
CObjectPolygon *CObjectCSG::GetPortalA1A2(void)
{
if (oc_popoPortalA1A2==NULL) {
oc_popoPortalA1A2 = CreatePieceOfPolygon(oc_poscSectorA, *oc_popoA, FALSE);
oc_popoPortalA1A2->opo_ulFlags |= OPOF_PORTAL;
}
return oc_popoPortalA1A2;
}
CObjectPolygon *CObjectCSG::GetPortalA1A2_2(void)
{
if (oc_popoPortalA1A2_2==NULL) {
oc_popoPortalA1A2_2 = CreatePieceOfPolygon(oc_poscSectorA, *oc_popoA, FALSE);
oc_popoPortalA1A2_2->opo_ulFlags |= OPOF_PORTAL;
}
return oc_popoPortalA1A2_2;
}
CObjectPolygon *CObjectCSG::GetPortalA1B1(void)
{
if (oc_popoPortalA1B1==NULL) {
oc_popoPortalA1B1 = CreatePieceOfPolygon(oc_poscSectorA, *oc_popoA, FALSE);
oc_popoPortalA1B1->opo_ulFlags |= OPOF_PORTAL;
}
return oc_popoPortalA1B1;
}
CObjectPolygon *CObjectCSG::GetWallB1(void)
{
if (oc_popoWallB1==NULL) {
oc_popoWallB1 = CreatePieceOfPolygon(oc_poscSectorB, *oc_popoA, FALSE);
oc_popoWallB1->opo_ulFlags &= ~OPOF_PORTAL;
}
return oc_popoWallB1;
}
CObjectPolygon *CObjectCSG::GetPortalB1A1(void)
{
if (oc_popoPortalB1A1==NULL) {
oc_popoPortalB1A1 = CreatePieceOfPolygon(oc_poscSectorB, *oc_popoA, TRUE); // this one is reversed !
oc_popoPortalB1A1->opo_ulFlags |= OPOF_PORTAL;
}
return oc_popoPortalB1A1;
}
CObjectPolygon *CObjectCSG::GetPortalB1B2(void)
{
if (oc_popoPortalB1B2==NULL) {
oc_popoPortalB1B2 = CreatePieceOfPolygon(oc_poscSectorB, *oc_popoA, FALSE);
oc_popoPortalB1B2->opo_ulFlags |= OPOF_PORTAL;
}
return oc_popoPortalB1B2;
}
/*
* Fill array of bsp edges from array of polygon edges.
*/
void CObjectCSG::PolygonEdgesToBSPEdges(
CDynamicArray<CObjectPolygonEdge> &aope,
CDynamicArray<DOUBLEbspedge3D> &abed
)
{
aope.Lock();
abed.Lock();
// get number of edges in the polygon
INDEX ctEdges = aope.Count();
// create that much edges in array of bsp edges
abed.New(ctEdges);
// for each edge in polygon
for(INDEX iEdge=0; iEdge<ctEdges; iEdge++) {
const CObjectPolygonEdge &ope = aope[iEdge];
// if it is reversed
if (ope.ope_Backward) {
// add bsp edge with reverse vertices
abed[iEdge] = DOUBLEbspedge3D(*ope.ope_Edge->oed_Vertex1,
*ope.ope_Edge->oed_Vertex0, (ULONG)ope.ope_Edge);
// if it is not reversed
} else{
// add bsp edge with normal vertices
abed[iEdge] = DOUBLEbspedge3D(*ope.ope_Edge->oed_Vertex0,
*ope.ope_Edge->oed_Vertex1, (ULONG)ope.ope_Edge);
}
}
aope.Unlock();
abed.Unlock();
}
/*
* Add an entire array of BSP edges to some polygon according to action code.
*/
inline void CObjectCSG::AddEdgeArrayAccordingToAction(
CDynamicArray<DOUBLEbspedge3D> &abed,
enum CSGAction csga)
{
// if there are no edges to process
INDEX ctEdges = abed.Count();
if (ctEdges==0) {
// do nothing
return;
}
// if the action is Remove
if (csga==CSGA_Remove) {
// do nothing
return;
}
// if the action is Proceed
if (csga==CSGA_Proceed) {
// add entire array to array of proceeding edges
oc_abedProceeding.MoveArray(abed);
return;
}
// check the action code and find sector(s) and polygon(s) to add edges to
CObjectPolygon *popoNormal = NULL;
CObjectSector *poscNormal = NULL;
CObjectPolygon *popoReverse = NULL;
CObjectSector *poscReverse = NULL;
switch (csga) {
case CSGA_WallA1:
poscNormal = oc_poscSectorA;
popoNormal = GetWallA1();
break;
case CSGA_WallA1_2:
poscNormal = oc_poscSectorA;
popoNormal = GetWallA1_2();
break;
case CSGA_PortalA1A2_2:
poscNormal = oc_poscSectorA;
popoNormal = GetPortalA1A2_2();
break;
case CSGA_PortalA1A2:
poscNormal = oc_poscSectorA;
popoNormal = GetPortalA1A2();
break;
case CSGA_PortalA1B1B1A1:
poscNormal = oc_poscSectorA;
popoNormal = GetPortalA1B1();
poscReverse = oc_poscSectorB;
popoReverse = GetPortalB1A1();
break;
case CSGA_WallB1:
poscNormal = oc_poscSectorB;
popoNormal = GetWallB1();
break;
case CSGA_PortalB1B2:
poscNormal = oc_poscSectorB;
popoNormal = GetPortalB1B2();
break;
default:
ASSERTALWAYS("Unknown CSG action code");
}
// create needed number of vertices, edges and polygon edges
CObjectVertex *aovxNormal = NULL;
CObjectEdge *aoedNormal = NULL;
CObjectPolygonEdge *aopeNormal = NULL;
CObjectVertex *aovxReverse = NULL;
CObjectEdge *aoedReverse = NULL;
CObjectPolygonEdge *aopeReverse = NULL;
aovxNormal = poscNormal->osc_aovxVertices.New(2*ctEdges);
aoedNormal = poscNormal->osc_aoedEdges.New(ctEdges);
aopeNormal = popoNormal->opo_PolygonEdges.New(ctEdges);
if (poscReverse!=NULL) {
aovxReverse = poscReverse->osc_aovxVertices.New(2*ctEdges);
aoedReverse = poscReverse->osc_aoedEdges.New(ctEdges);
aopeReverse = popoReverse->opo_PolygonEdges.New(ctEdges);
}
abed.Lock();
// add all edges to normal polygon
{for(INDEX iEdge=0; iEdge<ctEdges; iEdge++) {
DOUBLEbspedge3D &bed = abed[iEdge];
aovxNormal[iEdge*2+0] = bed.bed_vVertex0;
aovxNormal[iEdge*2+1] = bed.bed_vVertex1;
aoedNormal[iEdge].oed_Vertex0 = &aovxNormal[iEdge*2+0];
aoedNormal[iEdge].oed_Vertex1 = &aovxNormal[iEdge*2+1];
aopeNormal[iEdge].ope_Backward = FALSE;
aopeNormal[iEdge].ope_Edge = &aoedNormal[iEdge];
}}
// if there is reverse polygon
if (poscReverse!=NULL) {
// add all edges to reverse polygon
{for(INDEX iEdge=0; iEdge<ctEdges; iEdge++) {
DOUBLEbspedge3D &bed = abed[iEdge];
aovxReverse[iEdge*2+0] = bed.bed_vVertex1;
aovxReverse[iEdge*2+1] = bed.bed_vVertex0;
aoedReverse[iEdge].oed_Vertex0 = &aovxReverse[iEdge*2+0];
aoedReverse[iEdge].oed_Vertex1 = &aovxReverse[iEdge*2+1];
aopeReverse[iEdge].ope_Backward = FALSE;
aopeReverse[iEdge].ope_Edge = &aoedReverse[iEdge];
}}
}
abed.Unlock();
}
/*
* Perform CSG splitting of sectors in one operand using other operand.
*/
void CObjectCSG::DoCSGSplitting(
CObject3D &obResult,
CObject3D &obA,
INDEX iSectorOffsetA,
struct CSGOperationTable *pcsgotA,
CObject3D &obB,
INDEX iSectorOffsetB)
{
obResult.ob_aoscSectors.Lock();
// for each sector in A
{FOREACHINDYNAMICARRAY(obA.ob_aoscSectors, CObjectSector, itoscA) {
// make sector reference in result
oc_poscSectorA = &obResult.ob_aoscSectors[iSectorOffsetA+itoscA->osc_Index];
// copy sector properties from operand A to result
oc_poscSectorA->osc_colColor = itoscA->osc_colColor;
oc_poscSectorA->osc_colAmbient = itoscA->osc_colAmbient;
oc_poscSectorA->osc_ulFlags[0] = itoscA->osc_ulFlags[0];
oc_poscSectorA->osc_ulFlags[1] = itoscA->osc_ulFlags[1];
oc_poscSectorA->osc_ulFlags[2] = itoscA->osc_ulFlags[2];
oc_poscSectorA->osc_strName = itoscA->osc_strName;
// for each of polygons in that sector
{FOREACHINDYNAMICARRAY(itoscA->osc_aopoPolygons, CObjectPolygon, itopoA) {
oc_popoA = itopoA;
// prepare appropriate actions for it
enum CSGAction csgaInside, csgaOutside, csgaBorderInside, csgaBorderOutside, csgaSkip;
if (itopoA->opo_ulFlags & OPOF_PORTAL) {
csgaInside = pcsgotA->cot_PortalA1A2InsideB1;
csgaOutside = pcsgotA->cot_PortalA1A2OutsideB;
csgaBorderInside = pcsgotA->cot_PortalA1A2OnB1BorderInside;
csgaBorderOutside = pcsgotA->cot_PortalA1A2OnB1BorderOutside;
csgaSkip = CSGA_PortalA1A2;
} else {
csgaInside = pcsgotA->cot_WallA1InsideB1;
csgaOutside = pcsgotA->cot_WallA1OutsideB;
csgaBorderInside = pcsgotA->cot_WallA1OnB1BorderInside;
csgaBorderOutside = pcsgotA->cot_WallA1OnB1BorderOutside;
csgaSkip = CSGA_WallA1;
}
// create temporary array for holding remaining edges
CDynamicArray<DOUBLEbspedge3D> abedRemaining;
// fill the array with edges from the polygon
PolygonEdgesToBSPEdges(itopoA->opo_PolygonEdges, abedRemaining);
// create wall A1 polygon
oc_popoWallA1 = NULL;
oc_popoWallA1_2 = NULL;
// create portal A1-A2 polygon
oc_popoPortalA1A2 = NULL;
oc_popoPortalA1A2_2 = NULL;
// if the polygon should be skipped
if (oc_bCSGIngoringEnabled && (itopoA->opo_ulFlags&OPOF_IGNOREDBYCSG)) {
// add entire polygon according to _skip_ action
AddEdgeArrayAccordingToAction(abedRemaining, csgaSkip);
// skip splitting
continue;
}
// for each sector in B
{FOREACHINDYNAMICARRAY(obB.ob_aoscSectors, CObjectSector, itoscB) {
// clear array of proceeding edges
oc_abedProceeding.Clear();
// make sector references in result
oc_poscSectorB = &obResult.ob_aoscSectors[iSectorOffsetB+itoscB->osc_Index];
// copy sector properties from operand B to result
oc_poscSectorB->osc_colColor = itoscB->osc_colColor;
oc_poscSectorB->osc_colAmbient = itoscB->osc_colAmbient;
oc_poscSectorB->osc_ulFlags[0] = itoscB->osc_ulFlags[0];
oc_poscSectorB->osc_ulFlags[1] = itoscB->osc_ulFlags[1];
oc_poscSectorB->osc_ulFlags[2] = itoscB->osc_ulFlags[2];
oc_poscSectorB->osc_strName = itoscB->osc_strName;
// create portal A1-B1 polygon
oc_popoPortalA1B1 = NULL;
// create portal B1-A1 polygon
oc_popoPortalB1A1 = NULL;
// create wall B1 polygon
oc_popoWallB1 = NULL;
// create portal B1-B2 polygon
oc_popoPortalB1B2 = NULL;
// create a bsp polygon from first temporary array
DOUBLEbsppolygon3D bpoA(*itopoA->opo_Plane, abedRemaining, (ULONG)itopoA->opo_Plane);
// create a BSP cutter for B's sector BSP and A's polygon
DOUBLEbspcutter3D bcCutter(bpoA, *itoscB->osc_BSPTree.bt_pbnRoot);
// optimize all parts of the polygon
DOUBLEbspedge3D::OptimizeBSPEdges(bcCutter.bc_abedInside);
DOUBLEbspedge3D::OptimizeBSPEdges(bcCutter.bc_abedBorderInside);
DOUBLEbspedge3D::OptimizeBSPEdges(bcCutter.bc_abedBorderOutside);
DOUBLEbspedge3D::OptimizeBSPEdges(bcCutter.bc_abedOutside);
// add all parts that are inside according to _inside_ action
AddEdgeArrayAccordingToAction(bcCutter.bc_abedInside, csgaInside);
// add all parts that are on border inside according to _on_border_inside_ action
AddEdgeArrayAccordingToAction(bcCutter.bc_abedBorderInside, csgaBorderInside);
// add all parts that are on border outside according to _on_border_outside_ action
AddEdgeArrayAccordingToAction(bcCutter.bc_abedBorderOutside, csgaBorderOutside);
// clear the temporary array
abedRemaining.Clear();
// move all parts that are outside or proceeding to the temporary array
abedRemaining.MoveArray(bcCutter.bc_abedOutside);
abedRemaining.MoveArray(oc_abedProceeding);
}}
// add all parts that are still remaining according to _outside_ action
AddEdgeArrayAccordingToAction(abedRemaining, csgaOutside);
}}
}}
obResult.ob_aoscSectors.Unlock();
}
/*
* Perform CSG operation -- destroys both operands!
*/
void CObjectCSG::DoCSGOperation(
CObject3D &obResult,
CObject3D &obA,
CObject3D &obB,
struct CSGOperationTable *pcsgotA,
struct CSGOperationTable *pcsgotB)
{
// remove current contents
obResult.Clear();
// create indices in operand sectors
obA.CreateSectorIndices();
obB.CreateSectorIndices();
// create sector BSP trees in both operands
obA.CreateSectorBSPs();
obB.CreateSectorBSPs();
// get number of sectors in operands
INDEX ctSectorsA = obA.ob_aoscSectors.Count();
INDEX ctSectorsB = obB.ob_aoscSectors.Count();
// create as much sectors in result as there is in both operands
obResult.ob_aoscSectors.New(ctSectorsA+ctSectorsB);
// do splitting of first operand using the second operand BSPs and first table
DoCSGSplitting(obResult, obA, 0, pcsgotA, obB, ctSectorsA);
// do splitting of second operand using the first operand BSPs and second table
if (!oc_bSkipObjectB) {
DoCSGSplitting(obResult, obB, ctSectorsA, pcsgotB, obA, 0);
}
}
/*
*** CSG operations -- they all destroy both operands! ***
*/
/*
* Add rooms.
*/
void CObject3D::CSGAddRooms(CObject3D &obA, CObject3D &obB)
{
// do CSG with 'add rooms' tables
CObjectCSG oc;
oc.DoCSGOperation(*this, obA, obB, &csgotAddRoomsA, &csgotAddRoomsB);
}
/*
* Add material from object B to object A. (B should have only one
* open sector and no closed sectors)
*/
void CObject3D::CSGAddMaterial(CObject3D &obA, CObject3D &obB)
{
// do CSG with 'add material' tables
CObjectCSG oc;
oc.DoCSGOperation(*this, obA, obB, &csgotAddMaterialA, &csgotAddMaterialB);
}
void CObject3D::CSGAddMaterialReverse(CObject3D &obA, CObject3D &obB)
{
// do CSG with 'add material' tables, but with reverse priorities
CObjectCSG oc;
oc.DoCSGOperation(*this, obA, obB, &csgotAddMaterialReverseA, &csgotAddMaterialReverseB);
}
/*
* Remove material of object B from object A. (B should have only one
* open sector and no closed sectors)
*/
void CObject3D::CSGRemoveMaterial(CObject3D &obA, CObject3D &obB)
{
// reverse the object B
obB.Inverse();
// do CSG with 'add rooms' tables, but with reversed priorities
CObjectCSG oc;
oc.DoCSGOperation(*this, obA, obB, &csgotAddRoomsB, &csgotAddRoomsA);
}
/*
* Split sectors of object A using object B. (B should have only one
* closed sector and no open sectors)
*/
void CObject3D::CSGSplitSectors(CObject3D &obA, CObject3D &obB)
{
// do CSG with 'split sectors' tables
CObjectCSG oc;
oc.DoCSGOperation(*this, obA, obB, &csgotSplitSectorsA, &csgotSplitSectorsB);
}
/* Join sectors of object A with sectors of object B. (both A and B should
have only one sector) */
void CObject3D::CSGJoinSectors(CObject3D &obA, CObject3D &obB)
{
// do CSG with 'join sectors' tables
CObjectCSG oc;
oc.DoCSGOperation(*this, obA, obB, &csgotJoinSectorsA, &csgotJoinSectorsB);
}
/* Split polygons of object A with sectors of object B. (both A and B should
have only one sector) */
void CObject3D::CSGSplitPolygons(CObject3D &obA, CObject3D &obB)
{
// do CSG with 'split polygons' tables
CObjectCSG oc;
oc.oc_bCSGIngoringEnabled = TRUE;
oc.oc_bSkipObjectB = TRUE;
oc.DoCSGOperation(*this, obA, obB, &csgotSplitPolygonsA, &csgotSplitPolygonsB);
}