TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-01-20 04:34:48 +00:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity
Torque3D/Engine/source/environment/meshRoad.h
AzaezelX fbcfe02098 clean up "Add" menubar categoes on the 3d object side via the following: 
SceneObject now defaults to a category of "misc"
getCategoryOfClass now checks parent classes for what categories they hold so that variants can inherit
categories are in one of a few rough groups and subgroups depending on actual mapper needs/usages
2023-11-08 20:42:47 -06:00

660 lines
19 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
// Arcane-FX for MIT Licensed Open Source version of Torque 3D from GarageGames
// Copyright (C) 2015 Faust Logic, Inc.
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
#ifndef _MESHROAD_H_
#define _MESHROAD_H_
#ifndef _SCENEOBJECT_H_
#include "scene/sceneObject.h"
#endif
#ifndef _GFXTEXTUREHANDLE_H_
#include "gfx/gfxTextureHandle.h"
#endif
#ifndef _GFXVERTEXBUFFER_H_
#include "gfx/gfxVertexBuffer.h"
#endif
#ifndef _GFXPRIMITIVEBUFFER_H_
#include "gfx/gfxPrimitiveBuffer.h"
#endif
#ifndef _CLIPPEDPOLYLIST_H_
#include "collision/clippedPolyList.h"
#endif
#ifndef _MATINSTANCE_H_
#include "materials/matInstance.h"
#endif
#ifndef _CONVEX_H_
#include "collision/convex.h"
#endif
#include "math/util/decomposePoly.h"
#include "T3D/assets/MaterialAsset.h"
//extern U32 gIdxArray[6][2][3];
struct MeshRoadHitSegment
{
U32 idx;
F32 t;
};
class MeshRoad;
class MeshRoadProfileNode
{
private:
Point3F mPos; // The position of the node. Only x and y are used.
bool mSmooth; // Is the node smoothed? Determines the normal at the node.
public:
MeshRoadProfileNode() { mSmooth = false; }
MeshRoadProfileNode(Point3F p) { mPos = p; mSmooth = false; }
void setPosition(F32 x, F32 y) { mPos.x = x; mPos.y = y; mPos.z = 0.0f; }
Point3F getPosition() { return mPos; }
void setSmoothing(bool isSmooth) { mSmooth = isSmooth; }
bool isSmooth() { return mSmooth; }
};
//-------------------------------------------------------------------------
// MeshRoadProfile Class
//-------------------------------------------------------------------------
class MeshRoadProfile
{
private:
friend class GuiMeshRoadEditorCtrl;
friend class MeshRoad;
friend class GuiMeshRoadEditorUndoAction;
protected:
MeshRoad* mRoad; // A pointer to the Road this profile belongs to
Vector<MeshRoadProfileNode> mNodes; // The list of nodes in the profile
Vector<VectorF> mNodeNormals; // The list of normals for each node
Vector<U8> mSegMtrls; // The list of segment materials
MatrixF mObjToSlice; // Transform profile from obj to slice space
MatrixF mSliceToObj; // Transform profile from slice to obj space
Point3F mStartPos; // Start position of profile in world space
decompPoly mCap; // The polygon that caps the ends
public:
MeshRoadProfile();
S32 clickOnLine(Point3F &p); // In profile space
void addPoint(U32 nodeId, Point3F &p); // In profile space
void removePoint(U32 nodeId);
void setNodePosition(U32 nodeId, Point3F pos); // In profile space
void toggleSmoothing(U32 nodeId);
void toggleSegMtrl(U32 seg); // Toggle between top, bottom, side
void generateNormals();
void generateEndCap(F32 width);
void setProfileDepth(F32 depth);
void setTransform(const MatrixF &mat, const Point3F &p); // Object to slice space transform
void getNodeWorldPos(U32 nodeId, Point3F &p); // Get node position in world space
void getNormToSlice(U32 normId, VectorF &n); // Get normal vector in slice space
void getNormWorldPos(U32 normId, Point3F &p); // Get normal end pos in world space
void worldToObj(Point3F &p); // Transform from world to obj space
void objToWorld(Point3F &p); // Transform from obj to world space
F32 getProfileLen();
F32 getNodePosPercent(U32 nodeId);
Vector<MeshRoadProfileNode> getNodes() { return mNodes; }
void resetProfile(F32 defaultDepth); // Reset profile to 2 default nodes
};
//-------------------------------------------------------------------------
// MeshRoadConvex Class
//-------------------------------------------------------------------------
class MeshRoadConvex : public Convex
{
typedef Convex Parent;
friend class MeshRoad;
protected:
MeshRoad *pRoad;
public:
U32 faceId;
U32 triangleId;
U32 segmentId;
Point3F verts[4];
PlaneF normal;
Box3F box;
public:
MeshRoadConvex():pRoad(NULL), faceId(0), triangleId(0), segmentId(0) { mType = MeshRoadConvexType; }
MeshRoadConvex( const MeshRoadConvex& cv ) {
mType = MeshRoadConvexType;
mObject = cv.mObject;
pRoad = cv.pRoad;
faceId = cv.faceId;
triangleId = cv.triangleId;
segmentId = cv.segmentId;
verts[0] = cv.verts[0];
verts[1] = cv.verts[1];
verts[2] = cv.verts[2];
verts[3] = cv.verts[3];
normal = cv.normal;
box = cv.box;
}
const MatrixF& getTransform() const;
Box3F getBoundingBox() const;
Box3F getBoundingBox(const MatrixF& mat, const Point3F& scale) const;
Point3F support(const VectorF& vec) const;
void getFeatures(const MatrixF& mat,const VectorF& n, ConvexFeature* cf);
void getPolyList(AbstractPolyList* list);
};
//-------------------------------------------------------------------------
// MeshRoadSplineNode Class
//-------------------------------------------------------------------------
class Path;
class TerrainBlock;
struct ObjectRenderInst;
class MeshRoadSplineNode
{
public:
MeshRoadSplineNode() :x(0.0f), y(0.0f), z(0.0f), width(0.0f), depth(0.0f) {}
F32 x;
F32 y;
F32 z;
F32 width;
F32 depth;
VectorF normal;
MeshRoadSplineNode& operator=(const MeshRoadSplineNode&);
MeshRoadSplineNode operator+(const MeshRoadSplineNode&) const;
MeshRoadSplineNode operator-(const MeshRoadSplineNode&) const;
MeshRoadSplineNode operator*(const F32) const;
F32 len();
Point3F getPosition() const { return Point3F(x,y,z); };
};
inline F32 MeshRoadSplineNode::len()
{
return mSqrt(F32(x*x + y*y + z*z));
}
inline MeshRoadSplineNode& MeshRoadSplineNode::operator=(const MeshRoadSplineNode &_node)
{
x = _node.x;
y = _node.y;
z = _node.z;
width = _node.width;
depth = _node.depth;
normal = _node.normal;
return *this;
}
inline MeshRoadSplineNode MeshRoadSplineNode::operator+(const MeshRoadSplineNode& _add) const
{
MeshRoadSplineNode result;
result.x = x + _add.x;
result.y = y + _add.y;
result.z = z + _add.z;
result.width = width + _add.width;
result.depth = depth + _add.depth;
result.normal = normal + _add.normal;
return result;
}
inline MeshRoadSplineNode MeshRoadSplineNode::operator-(const MeshRoadSplineNode& _rSub) const
{
MeshRoadSplineNode result;
result.x = x - _rSub.x;
result.y = y - _rSub.y;
result.z = z - _rSub.z;
result.width = width - _rSub.width;
result.depth = depth - _rSub.depth;
result.normal = normal - _rSub.normal;
return result;
}
inline MeshRoadSplineNode operator*(const F32 mul, const MeshRoadSplineNode& multiplicand)
{
return multiplicand * mul;
}
inline MeshRoadSplineNode MeshRoadSplineNode::operator*(const F32 _mul) const
{
MeshRoadSplineNode result;
result.x = x * _mul;
result.y = y * _mul;
result.z = z * _mul;
result.width = width * _mul;
result.depth = depth * _mul;
result.normal = normal * _mul;
return result;
}
//-------------------------------------------------------------------------
// Structures
//-------------------------------------------------------------------------
struct MeshRoadRenderBatch
{
U32 startSegmentIdx;
U32 endSegmentIdx;
U32 startVert;
U32 endVert;
U32 startIndex;
U32 endIndex;
U32 totalRows;
U32 indexCount;
U32 vertCount;
U32 triangleCount;
};
typedef Vector<MeshRoadRenderBatch> MeshRoadBatchVector;
struct MeshRoadNode
{
// The 3D position of the node
Point3F point;
// The width of the River at this node (meters)
F32 width;
// The depth of the River at this node (meters)
F32 depth;
VectorF normal;
};
typedef Vector<MeshRoadNode> MeshRoadNodeVector;
struct MeshRoadSlice
{
MeshRoadSlice()
{
p0.zero();
p1.zero();
p2.zero();
pb0.zero();
pb2.zero();
uvec.zero();
fvec.zero();
rvec.zero();
width = 0.0f;
depth = 0.0f;
normal.set(0,0,1);
texCoordV = 0.0f;
t = 0.0f;
parentNodeIdx = -1;
};
Point3F p0; // upper left
Point3F p1; // upper center
Point3F p2; // upper right
Point3F pb0; // bottom left
Point3F pb2; // bottom right
VectorF uvec;
VectorF fvec;
VectorF rvec;
F32 width;
F32 depth;
Point3F normal;
F32 t;
F32 texCoordV;
U32 parentNodeIdx;
Vector<Point3F> verts;
Vector<VectorF> norms;
};
typedef Vector<MeshRoadSlice> MeshRoadSliceVector;
//-------------------------------------------------------------------------
// MeshRoadSegment Class
//-------------------------------------------------------------------------
class MeshRoadSegment
{
public:
MeshRoadSegment();
MeshRoadSegment( MeshRoadSlice *rs0, MeshRoadSlice *rs1, const MatrixF &roadMat );
void set( MeshRoadSlice *rs0, MeshRoadSlice *rs1 );
F32 TexCoordStart() const { return slice0->texCoordV; }
F32 TexCoordEnd() const { return slice1->texCoordV; }
const Point3F& getP00() const { return slice0->p0; }
const Point3F& getP01() const { return slice1->p0; }
const Point3F& getP11() const { return slice1->p2; }
const Point3F& getP10() const { return slice0->p2; }
Point3F getSurfaceCenter() const { return ( slice0->p1 + slice1->p1 ) / 2.0f; }
Point3F getSurfaceNormal() const { return -mPlanes[4].getNormal(); }
bool intersectBox( const Box3F &bounds ) const;
bool containsPoint( const Point3F &pnt ) const;
F32 distanceToSurface( const Point3F &pnt ) const;
F32 length() const { return ( slice1->p1 - slice0->p1 ).len(); }
// Quick access to the segment's points
Point3F& operator[](U32);
const Point3F& operator[](U32) const;
Point3F& operator[](S32 i) { return operator[](U32(i)); }
const Point3F& operator[](S32 i ) const { return operator[](U32(i)); }
const Box3F& getWorldBounds() const { return worldbounds; }
MeshRoadSlice *slice0;
MeshRoadSlice *slice1;
protected:
PlaneF mPlanes[6];
U32 mPlaneCount;
U32 columns;
U32 rows;
U32 startVert;
U32 endVert;
U32 startIndex;
U32 endIndex;
U32 numVerts;
U32 numTriangles;
Box3F objectbounds;
Box3F worldbounds;
};
typedef Vector<MeshRoadSegment> MeshRoadSegmentVector;
inline Point3F& MeshRoadSegment::operator[](U32 index)
{
AssertFatal(index < 8, "MeshRoadSegment::operator[] - out of bounds array access!");
MeshRoadSlice *slice = NULL;
if ( index > 3 )
{
slice = slice1;
index -= 4;
}
else
{
slice = slice0;
}
if ( index == 0 )
return slice->p0;
if ( index == 1 )
return slice->p2;
if ( index == 2 )
return slice->pb0;
else //( index == 3 )
return slice->pb2;
}
inline const Point3F& MeshRoadSegment::operator[](U32 index) const
{
AssertFatal(index < 8, "MeshRoadSegment::operator[] - out of bounds array access!");
MeshRoadSlice *slice = NULL;
if ( index > 3 )
{
slice = slice1;
index -= 4;
}
else
{
slice = slice0;
}
if ( index == 0 )
return slice->p0;
if ( index == 1 )
return slice->p2;
if ( index == 2 )
return slice->pb0;
else// ( index == 3 )
return slice->pb2;
}
//------------------------------------------------------------------------------
// MeshRoad Class
//------------------------------------------------------------------------------
class PhysicsBody;
struct MeshRoadNodeList;
class MeshRoad : public SceneObject
{
private:
friend class GuiMeshRoadEditorCtrl;
friend class GuiMeshRoadEditorUndoAction;
friend class MeshRoadConvex;
friend class MeshRoadProfile;
typedef SceneObject Parent;
enum
{
MeshRoadMask = Parent::NextFreeMask,
NodeMask = Parent::NextFreeMask << 1,
RegenMask = Parent::NextFreeMask << 2,
InitialUpdateMask = Parent::NextFreeMask << 3,
SelectedMask = Parent::NextFreeMask << 4,
MaterialMask = Parent::NextFreeMask << 5,
ProfileMask = Parent::NextFreeMask << 6,
NextFreeMask = Parent::NextFreeMask << 7,
};
public:
MeshRoad();
~MeshRoad();
DECLARE_CONOBJECT(MeshRoad);
DECLARE_CATEGORY("Environment \t BackGround");
// ConObject.
static void initPersistFields();
static void consoleInit();
// SimObject
bool onAdd();
void onRemove();
void onEditorEnable();
void onEditorDisable();
void inspectPostApply();
void onStaticModified(const char* slotName, const char*newValue = NULL);
void writeFields(Stream &stream, U32 tabStop);
bool writeField( StringTableEntry fieldname, const char *value );
// NetObject
U32 packUpdate(NetConnection *, U32, BitStream *);
void unpackUpdate(NetConnection *, BitStream *);
// SceneObject
virtual void prepRenderImage( SceneRenderState* sceneState );
virtual void setTransform( const MatrixF &mat );
virtual void setScale( const VectorF &scale );
// SceneObject - Collision
virtual void buildConvex(const Box3F& box,Convex* convex);
virtual bool buildPolyList(PolyListContext context, AbstractPolyList* polyList, const Box3F &box, const SphereF &sphere);
virtual bool castRay(const Point3F &start, const Point3F &end, RayInfo* info);
virtual bool collideBox(const Point3F &start, const Point3F &end, RayInfo* info);
// MeshRoad
void regenerate();
void setBatchSize( U32 level );
void setTextureFile( StringTableEntry file );
void setTextureRepeat( F32 meters );
bool collideRay( const Point3F &origin, const Point3F &direction, U32 *nodeIdx = NULL, Point3F *collisionPnt = NULL );
bool buildSegmentPolyList( AbstractPolyList* polyList, U32 startSegIdx, U32 endSegIdx, bool capFront, bool capEnd );
void buildNodesFromList( MeshRoadNodeList* list );
U32 insertNode( const Point3F &pos, const F32 &width, const F32 &depth, const Point3F &normal, const U32 &idx );
U32 addNode( const Point3F &pos, const F32 &width, const F32 &depth, const Point3F &normal );
void deleteNode( U32 idx );
void setNode( const Point3F &pos, const F32 &width, const F32 &depth, const Point3F &normal, const U32 &idx );
const MeshRoadNode& getNode( U32 idx );
VectorF getNodeNormal( U32 idx );
void setNodeNormal( U32 idx, const VectorF &normal );
Point3F getNodePosition( U32 idx );
void setNodePosition( U32 idx, const Point3F &pos );
F32 getNodeWidth( U32 idx );
void setNodeWidth( U32 idx, F32 width );
F32 getNodeDepth( U32 idx );
void setNodeDepth( U32 idx, F32 depth );
MatrixF getNodeTransform( U32 idx );
void calcSliceTransform( U32 idx, MatrixF &mat );
bool isEndNode( U32 idx ) { return ( mNodes.size() > 0 && ( idx == 0 || idx == mNodes.size() - 1 ) ); }
U32 getSegmentCount() { return mSegments.size(); }
const MeshRoadSegment& getSegment( U32 idx ) { return mSegments[idx]; }
F32 getRoadLength() const;
static SimSet* getServerSet();
/// Protected 'Component' Field setter that will add a component to the list.
static bool addNodeFromField( void *object, const char *index, const char *data );
static bool addProfileNodeFromField(void *obj, const char *index, const char* data);
static bool smEditorOpen;
static bool smWireframe;
static bool smShowBatches;
static bool smShowSpline;
static bool smShowRoad;
static bool smShowRoadProfile;
static SimObjectPtr<SimSet> smServerMeshRoadSet;
protected:
void _initMaterial();
void _debugRender( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance* );
U32 _insertNode( const Point3F &pos, const F32 &width, const F32 &depth, const Point3F &normal, const U32 &idx );
U32 _addNode( const Point3F &pos, const F32 &width, const F32 &depth, const Point3F &normal );
void _regenerate();
void _generateSlices();
void _generateSegments();
void _generateVerts();
protected:
MeshRoadSliceVector mSlices;
MeshRoadNodeVector mNodes;
MeshRoadSegmentVector mSegments;
MeshRoadBatchVector mBatches;
static GFXStateBlockRef smWireframeSB;
enum {
Top = 0,
Bottom = 1,
Side = 2,
SurfaceCount = 3
};
GFXVertexBufferHandle<GFXVertexPNTT> mVB[SurfaceCount];
GFXPrimitiveBufferHandle mPB[SurfaceCount];
DECLARE_MATERIALASSET(MeshRoad, TopMaterial);
DECLARE_ASSET_NET_SETGET(MeshRoad, TopMaterial, MeshRoadMask);
DECLARE_MATERIALASSET(MeshRoad, BottomMaterial);
DECLARE_ASSET_NET_SETGET(MeshRoad, BottomMaterial, MeshRoadMask);
DECLARE_MATERIALASSET(MeshRoad, SideMaterial);
DECLARE_ASSET_NET_SETGET(MeshRoad, SideMaterial, MeshRoadMask);
//String mMaterialName[SurfaceCount];
SimObjectPtr<Material> mMaterial[SurfaceCount];
BaseMatInstance *mMatInst[SurfaceCount];
U32 mVertCount[SurfaceCount];
U32 mTriangleCount[SurfaceCount];
MeshRoadProfile mSideProfile;
// Fields.
F32 mTextureLength;
F32 mBreakAngle;
S32 mWidthSubdivisions;
// Collision and Physics.
Convex* mConvexList;
Vector<MeshRoadConvex*> mDebugConvex;
PhysicsBody *mPhysicsRep;
private:
static bool buildPolyList_TopSurfaceOnly;
public:
bool buildTopPolyList(PolyListContext, AbstractPolyList*);
};
#endif // _MESHROAD_H_
Reference in a new issue View git blame Copy permalink