mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 04:34:48 +00:00
308 lines
8.6 KiB
C++
308 lines
8.6 KiB
C++
//-----------------------------------------------------------------------------
|
|
// 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.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef _CONVEXSHAPE_H_
|
|
#define _CONVEXSHAPE_H_
|
|
|
|
#ifndef _SCENEOBJECT_H_
|
|
#include "scene/sceneObject.h"
|
|
#endif
|
|
#ifndef _GFXVERTEXBUFFER_H_
|
|
#include "gfx/gfxVertexBuffer.h"
|
|
#endif
|
|
#ifndef _GFXPRIMITIVEBUFFER_H_
|
|
#include "gfx/gfxPrimitiveBuffer.h"
|
|
#endif
|
|
#ifndef _CONVEX_H_
|
|
#include "collision/convex.h"
|
|
#endif
|
|
|
|
#include "T3D/assets/MaterialAsset.h"
|
|
|
|
class ConvexShape;
|
|
|
|
// Crap name, but whatcha gonna do.
|
|
class ConvexShapeCollisionConvex : public Convex
|
|
{
|
|
typedef Convex Parent;
|
|
friend class ConvexShape;
|
|
|
|
protected:
|
|
|
|
ConvexShape *pShape;
|
|
|
|
public:
|
|
|
|
ConvexShapeCollisionConvex() { pShape = NULL; mType = ConvexShapeCollisionConvexType; }
|
|
|
|
ConvexShapeCollisionConvex( const ConvexShapeCollisionConvex& cv ) {
|
|
mType = ConvexShapeCollisionConvexType;
|
|
mObject = cv.mObject;
|
|
pShape = cv.pShape;
|
|
}
|
|
|
|
Point3F support(const VectorF& vec) const override;
|
|
void getFeatures(const MatrixF& mat,const VectorF& n, ConvexFeature* cf) override;
|
|
void getPolyList(AbstractPolyList* list) override;
|
|
};
|
|
|
|
|
|
GFXDeclareVertexFormat( ConvexVert )
|
|
{
|
|
Point3F point;
|
|
GFXVertexColor color;
|
|
Point3F normal;
|
|
Point3F tangent;
|
|
Point2F texCoord;
|
|
};
|
|
|
|
class PhysicsBody;
|
|
|
|
|
|
class ConvexShape : public SceneObject
|
|
{
|
|
typedef SceneObject Parent;
|
|
friend class GuiConvexEditorCtrl;
|
|
friend class GuiConvexEditorUndoAction;
|
|
friend class ConvexShapeCollisionConvex;
|
|
|
|
public:
|
|
|
|
enum NetBits {
|
|
TransformMask = Parent::NextFreeMask,
|
|
UpdateMask = Parent::NextFreeMask << 1,
|
|
NextFreeMask = Parent::NextFreeMask << 2
|
|
};
|
|
|
|
// Declaring these structs directly within ConvexShape to prevent
|
|
// the otherwise excessively deep scoping we had.
|
|
// eg. ConvexShape::Face::Triangle ...
|
|
|
|
// Define our vertex format here so we don't have to
|
|
// change it in multiple spots later
|
|
typedef GFXVertexPNTTB VertexType;
|
|
|
|
struct Edge
|
|
{
|
|
U32 p0;
|
|
U32 p1;
|
|
};
|
|
|
|
struct Triangle
|
|
{
|
|
U32 p0;
|
|
U32 p1;
|
|
U32 p2;
|
|
|
|
U32 operator []( U32 index ) const
|
|
{
|
|
AssertFatal( index >= 0 && index <= 2, "index out of range" );
|
|
return *( (&p0) + index );
|
|
}
|
|
};
|
|
|
|
struct Face
|
|
{
|
|
Vector< Edge > edges;
|
|
Vector< U32 > points;
|
|
Vector< U32 > winding;
|
|
Vector< Point2F > texcoords;
|
|
Vector< Triangle > triangles;
|
|
Point3F tangent;
|
|
Point3F normal;
|
|
Point3F centroid;
|
|
F32 area;
|
|
S32 id;
|
|
};
|
|
|
|
struct surfaceMaterial
|
|
{
|
|
// The name of the Material we will use for rendering
|
|
DECLARE_MATERIALASSET(surfaceMaterial, Material);
|
|
|
|
DECLARE_ASSET_SETGET(surfaceMaterial, Material);
|
|
|
|
// The actual Material instance
|
|
BaseMatInstance* materialInst;
|
|
|
|
surfaceMaterial()
|
|
{
|
|
INIT_ASSET(Material);
|
|
|
|
materialInst = NULL;
|
|
}
|
|
};
|
|
|
|
struct surfaceUV
|
|
{
|
|
S32 matID;
|
|
Point2F offset;
|
|
Point2F scale;
|
|
float zRot;
|
|
bool horzFlip;
|
|
bool vertFlip;
|
|
|
|
surfaceUV() : matID(0), offset(Point2F(0.0f, 0.0f)), scale(Point2F(1.0f, 1.0f)), zRot(0.0f), horzFlip(false), vertFlip(false) {}
|
|
};
|
|
|
|
struct surfaceBuffers
|
|
{
|
|
// The GFX vertex and primitive buffers
|
|
GFXVertexBufferHandle< VertexType > mVertexBuffer;
|
|
GFXPrimitiveBufferHandle mPrimitiveBuffer;
|
|
|
|
U32 mVertCount;
|
|
U32 mPrimCount;
|
|
};
|
|
|
|
struct Geometry
|
|
{
|
|
void generate(const Vector< PlaneF > &planes, const Vector< Point3F > &tangents, const Vector< surfaceMaterial > surfaceTextures, const Vector< Point2F > texOffset, const Vector< Point2F > texScale, const Vector< bool > horzFlip, const Vector< bool > vertFlip);
|
|
|
|
Vector< Point3F > points;
|
|
Vector< Face > faces;
|
|
};
|
|
|
|
static bool smRenderEdges;
|
|
|
|
// To prevent bitpack overflows.
|
|
// This is only indirectly enforced by trucation when serializing.
|
|
static const S32 smMaxSurfaces = 100;
|
|
|
|
public:
|
|
|
|
ConvexShape();
|
|
virtual ~ConvexShape();
|
|
|
|
DECLARE_CONOBJECT( ConvexShape );
|
|
DECLARE_CATEGORY("Object \t Simple");
|
|
|
|
// ConsoleObject
|
|
static void initPersistFields();
|
|
|
|
// SimObject
|
|
void inspectPostApply() override;
|
|
bool onAdd() override;
|
|
void onRemove() override;
|
|
void writeFields(Stream &stream, U32 tabStop) override;
|
|
bool writeField( StringTableEntry fieldname, const char *value ) override;
|
|
|
|
// NetObject
|
|
U32 packUpdate( NetConnection *conn, U32 mask, BitStream *stream ) override;
|
|
void unpackUpdate( NetConnection *conn, BitStream *stream ) override;
|
|
|
|
// SceneObject
|
|
void onScaleChanged() override;
|
|
void setTransform( const MatrixF &mat ) override;
|
|
void prepRenderImage( SceneRenderState *state ) override;
|
|
void buildConvex( const Box3F &box, Convex *convex ) override;
|
|
bool buildPolyList( PolyListContext context, AbstractPolyList *polyList, const Box3F &box, const SphereF &sphere ) override;
|
|
bool buildExportPolyList(ColladaUtils::ExportData* exportData, const Box3F &box, const SphereF &) override;
|
|
bool castRay( const Point3F &start, const Point3F &end, RayInfo *info ) override;
|
|
bool collideBox( const Point3F &start, const Point3F &end, RayInfo *info ) override;
|
|
|
|
|
|
void updateBounds( bool recenter );
|
|
void recenter();
|
|
|
|
/// Geometry access.
|
|
/// @{
|
|
|
|
MatrixF getSurfaceWorldMat( S32 faceid, bool scaled = false ) const;
|
|
void cullEmptyPlanes( Vector< U32 > *removedPlanes );
|
|
void exportToCollada();
|
|
void resizePlanes( const Point3F &size );
|
|
void getSurfaceLineList( S32 surfId, Vector< Point3F > &lineList );
|
|
Geometry& getGeometry() { return mGeometry; }
|
|
Vector<MatrixF>& getSurfaces() { return mSurfaces; }
|
|
void getSurfaceTriangles( S32 surfId, Vector< Point3F > *outPoints, Vector< Point2F > *outCoords, bool worldSpace );
|
|
|
|
/// @}
|
|
|
|
/// Geometry Visualization.
|
|
/// @{
|
|
|
|
void renderFaceEdges( S32 faceid, const ColorI &color = ColorI::WHITE, F32 lineWidth = 1.0f );
|
|
|
|
/// @}
|
|
|
|
String getMaterialName() { return mMaterialName; }
|
|
|
|
protected:
|
|
|
|
void _updateMaterial();
|
|
void _updateGeometry( bool updateCollision = false );
|
|
void _updateCollision();
|
|
void _export( OptimizedPolyList *plist, const Box3F &box, const SphereF &sphere );
|
|
|
|
void _renderDebug( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *mat );
|
|
|
|
static S32 QSORT_CALLBACK _comparePlaneDist( const void *a, const void *b );
|
|
|
|
static bool protectedSetSurface( void *object, const char *index, const char *data );
|
|
|
|
static bool protectedSetSurfaceTexture( void *object, const char *index, const char *data );
|
|
static bool protectedSetSurfaceUV(void *object, const char *index, const char *data);
|
|
|
|
protected:
|
|
|
|
DECLARE_MATERIALASSET(ConvexShape, Material);
|
|
DECLARE_ASSET_SETGET(ConvexShape, Material);
|
|
|
|
// The actual Material instance
|
|
BaseMatInstance* mMaterialInst;
|
|
|
|
// The GFX vertex and primitive buffers
|
|
/*GFXVertexBufferHandle< VertexType > mVertexBuffer;
|
|
GFXPrimitiveBufferHandle mPrimitiveBuffer;
|
|
|
|
U32 mVertCount;
|
|
U32 mPrimCount;*/
|
|
|
|
Geometry mGeometry;
|
|
|
|
Vector< PlaneF > mPlanes;
|
|
|
|
Vector< MatrixF > mSurfaces;
|
|
|
|
Vector< Point3F > mFaceCenters;
|
|
|
|
//this is mostly for storage purposes, so we can save the texture mods
|
|
Vector< surfaceMaterial > mSurfaceTextures;
|
|
Vector< surfaceUV > mSurfaceUVs;
|
|
Vector< surfaceBuffers > mSurfaceBuffers;
|
|
|
|
Convex *mConvexList;
|
|
|
|
PhysicsBody *mPhysicsRep;
|
|
|
|
/// Geometry visualization
|
|
/// @{
|
|
|
|
F32 mNormalLength;
|
|
|
|
/// @}
|
|
|
|
};
|
|
|
|
#endif // _CONVEXSHAPE_H_
|