mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 04:34:48 +00:00
555 lines
16 KiB
C++
555 lines
16 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.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|
|
// Arcane-FX for MIT Licensed Open Source version of Torque 3D from GarageGames
|
|
// Copyright (C) 2015 Faust Logic, Inc.
|
|
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|
|
|
|
#ifndef _TERRDATA_H_
|
|
#define _TERRDATA_H_
|
|
|
|
#ifndef _MPOINT3_H_
|
|
#include "math/mPoint3.h"
|
|
#endif
|
|
#ifndef _SCENEOBJECT_H_
|
|
#include "scene/sceneObject.h"
|
|
#endif
|
|
#ifndef __RESOURCE_H__
|
|
#include "core/resource.h"
|
|
#endif
|
|
#ifndef _RENDERPASSMANAGER_H_
|
|
#include "renderInstance/renderPassManager.h"
|
|
#endif
|
|
#ifndef _TSIGNAL_H_
|
|
#include "core/util/tSignal.h"
|
|
#endif
|
|
#ifndef _TERRFILE_H_
|
|
#include "terrain/terrFile.h"
|
|
#endif
|
|
#ifndef _GFXPRIMITIVEBUFFER_H_
|
|
#include "gfx/gfxPrimitiveBuffer.h"
|
|
#endif
|
|
|
|
#ifndef _ASSET_PTR_H_
|
|
#include "assets/assetPtr.h"
|
|
#endif
|
|
#ifndef TERRAINASSET_H
|
|
#include "T3D/assets/TerrainAsset.h"
|
|
#endif
|
|
#ifndef _CONVEX_H_
|
|
#include "collision/convex.h"
|
|
#endif
|
|
|
|
class GBitmap;
|
|
class TerrainBlock;
|
|
class TerrCell;
|
|
class PhysicsBody;
|
|
class TerrainCellMaterial;
|
|
|
|
class TerrainBlock : public SceneObject
|
|
{
|
|
typedef SceneObject Parent;
|
|
|
|
friend class TerrainEditor;
|
|
friend class TerrainCellMaterial;
|
|
|
|
protected:
|
|
|
|
enum
|
|
{
|
|
TransformMask = Parent::NextFreeMask,
|
|
FileMask = Parent::NextFreeMask << 1,
|
|
SizeMask = Parent::NextFreeMask << 2,
|
|
MaterialMask = Parent::NextFreeMask << 3,
|
|
HeightMapChangeMask = Parent::NextFreeMask << 4,
|
|
MiscMask = Parent::NextFreeMask << 5,
|
|
|
|
NextFreeMask = Parent::NextFreeMask << 6,
|
|
};
|
|
|
|
public:
|
|
|
|
enum BaseTexFormat
|
|
{
|
|
NONE, DDS, PNG
|
|
};
|
|
|
|
static const char* formatToExtension(BaseTexFormat format)
|
|
{
|
|
switch (format)
|
|
{
|
|
case DDS:
|
|
return "dds";
|
|
case PNG:
|
|
return "png";
|
|
default:
|
|
return "";
|
|
}
|
|
};
|
|
|
|
protected:
|
|
|
|
Box3F mBounds;
|
|
|
|
///
|
|
GBitmap *mLightMap;
|
|
|
|
/// The lightmap dimensions in pixels.
|
|
U32 mLightMapSize;
|
|
|
|
/// The lightmap texture.
|
|
GFXTexHandle mLightMapTex;
|
|
|
|
/// The terrain data file.
|
|
Resource<TerrainFile> mFile;
|
|
|
|
/// The TerrainFile CRC sent from the server.
|
|
U32 mCRC;
|
|
|
|
///
|
|
StringTableEntry mTerrFileName;
|
|
|
|
AssetPtr<TerrainAsset> mTerrainAsset;
|
|
StringTableEntry mTerrainAssetId;
|
|
|
|
/// The maximum detail distance found in the material list.
|
|
F32 mMaxDetailDistance;
|
|
|
|
///
|
|
Vector<GFXTexHandle> mBaseTextures;
|
|
|
|
GFXTextureArrayHandle mDetailTextureArray;
|
|
GFXTextureArrayHandle mMacroTextureArray;
|
|
GFXTextureArrayHandle mNormalTextureArray;
|
|
GFXTextureArrayHandle mOrmTextureArray;
|
|
|
|
///
|
|
GFXTexHandle mLayerTex;
|
|
|
|
/// The shader used to generate the base texture map.
|
|
GFXShaderRef mBaseShader;
|
|
|
|
///
|
|
GFXStateBlockRef mBaseShaderSB;
|
|
|
|
///
|
|
GFXShaderConstBufferRef mBaseShaderConsts;
|
|
|
|
///
|
|
GFXShaderConstHandle *mBaseTexScaleConst;
|
|
GFXShaderConstHandle *mBaseTexIdConst;
|
|
GFXShaderConstHandle *mBaseLayerSizeConst;
|
|
|
|
///
|
|
GFXTextureTargetRef mBaseTarget;
|
|
|
|
/// The base texture.
|
|
GFXTexHandle mBaseTex;
|
|
|
|
///
|
|
bool mDetailsDirty;
|
|
|
|
///
|
|
bool mLayerTexDirty;
|
|
|
|
/// The desired size for the base texture.
|
|
U32 mBaseTexSize;
|
|
|
|
BaseTexFormat mBaseTexFormat;
|
|
|
|
///
|
|
TerrCell *mCell;
|
|
|
|
/// The shared base material which is used to render
|
|
/// cells that are outside the detail map range.
|
|
TerrainCellMaterial *mBaseMaterial;
|
|
|
|
/// A dummy material only used for shadow
|
|
/// material generation.
|
|
BaseMatInstance *mDefaultMatInst;
|
|
|
|
F32 mSquareSize;
|
|
|
|
PhysicsBody *mPhysicsRep;
|
|
|
|
U32 mScreenError;
|
|
|
|
/// The shared primitive buffer used in rendering.
|
|
GFXPrimitiveBufferHandle mPrimBuffer;
|
|
|
|
/// The cells used in the last render pass
|
|
/// when doing debug rendering.
|
|
/// @see _renderDebug
|
|
Vector<TerrCell*> mDebugCells;
|
|
|
|
/// Set to enable debug rendering of the terrain. It
|
|
/// is exposed to the console via $terrain::debugRender.
|
|
static bool smDebugRender;
|
|
|
|
/// Allows the terrain to cast shadows onto itself and other objects.
|
|
bool mCastShadows;
|
|
|
|
/// A global LOD scale used to tweak the default
|
|
/// terrain screen error value.
|
|
static F32 smLODScale;
|
|
|
|
/// A global detail scale used to tweak the
|
|
/// material detail distances.
|
|
static F32 smDetailScale;
|
|
|
|
/// True if the zoning needs to be recalculated for the terrain.
|
|
bool mZoningDirty;
|
|
|
|
/// Holds the generated convex list stuff for this terrain
|
|
Convex mTerrainConvexList;
|
|
|
|
String _getBaseTexCacheFileName() const;
|
|
|
|
void _rebuildQuadtree();
|
|
|
|
void _updatePhysics();
|
|
|
|
void _renderBlock( SceneRenderState *state );
|
|
void _renderDebug( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat );
|
|
|
|
/// The callback used to get texture events.
|
|
/// @see GFXTextureManager::addEventDelegate
|
|
void _onTextureEvent( GFXTexCallbackCode code );
|
|
|
|
/// Used to release terrain materials when
|
|
/// the material manager flushes them.
|
|
/// @see MaterialManager::getFlushSignal
|
|
void _onFlushMaterials();
|
|
|
|
///
|
|
bool _initBaseShader();
|
|
|
|
///
|
|
void _updateMaterials();
|
|
|
|
///
|
|
void _updateBaseTexture( bool writeToCache );
|
|
|
|
void _updateLayerTexture();
|
|
|
|
void _updateBounds();
|
|
|
|
void _onZoningChanged( SceneZoneSpaceManager *zoneManager );
|
|
|
|
void _updateZoning();
|
|
|
|
// Protected fields
|
|
static bool _setTerrainFile( void *obj, const char *index, const char *data );
|
|
static bool _setTerrainAsset(void* obj, const char* index, const char* data);
|
|
static bool _setSquareSize( void *obj, const char *index, const char *data );
|
|
static bool _setBaseTexSize(void *obj, const char *index, const char *data);
|
|
static bool _setBaseTexFormat(void *obj, const char *index, const char *data);
|
|
static bool _setLightMapSize( void *obj, const char *index, const char *data );
|
|
|
|
public:
|
|
|
|
enum
|
|
{
|
|
LightmapUpdate = BIT(0),
|
|
HeightmapUpdate = BIT(1),
|
|
LayersUpdate = BIT(2),
|
|
EmptyUpdate = BIT(3)
|
|
};
|
|
|
|
static Signal<void(U32,TerrainBlock*,const Point2I& ,const Point2I&)> smUpdateSignal;
|
|
|
|
///
|
|
bool import( const GBitmap &heightMap,
|
|
F32 heightScale,
|
|
F32 metersPerPixel,
|
|
const Vector<U8> &layerMap,
|
|
const Vector<String> &materials,
|
|
bool flipYAxis = true );
|
|
|
|
#ifdef TORQUE_TOOLS
|
|
bool exportHeightMap( const UTF8 *filePath, const String &format ) const;
|
|
bool exportLayerMaps( const UTF8 *filePrefix, const String &format ) const;
|
|
#endif
|
|
|
|
public:
|
|
|
|
TerrainBlock();
|
|
virtual ~TerrainBlock();
|
|
|
|
U32 getCRC() const { return(mCRC); }
|
|
|
|
Resource<TerrainFile> getFile() const { return mFile; };
|
|
|
|
bool onAdd() override;
|
|
void onRemove() override;
|
|
|
|
void onEditorEnable() override;
|
|
void onEditorDisable() override;
|
|
|
|
/// Adds a new material as the top layer or
|
|
/// inserts it at the specified index.
|
|
void addMaterial( const String &name, U32 insertAt = -1 );
|
|
|
|
/// Removes the material at the index.
|
|
void removeMaterial( U32 index );
|
|
|
|
/// Updates the material at the index.
|
|
void updateMaterial( U32 index, const String &name );
|
|
|
|
/// Deletes all the materials on the terrain.
|
|
void deleteAllMaterials();
|
|
|
|
void setMaterialsDirty() { mDetailsDirty = true; };
|
|
|
|
//void setMaterialName( U32 index, const String &name );
|
|
|
|
/// Accessors and mutators for TerrainMaterialUndoAction.
|
|
/// @{
|
|
const Vector<TerrainMaterial*>& getMaterials() const { return mFile->mMaterials; }
|
|
const Vector<U8>& getLayerMap() const { return mFile->mLayerMap; }
|
|
void setMaterials( const Vector<TerrainMaterial*> &materials ) { mFile->mMaterials = materials; }
|
|
void setLayerMap( const Vector<U8> &layers ) { mFile->mLayerMap = layers; }
|
|
/// @}
|
|
|
|
TerrainMaterial* getMaterial( U32 index ) const;
|
|
|
|
const char* getMaterialName( U32 index ) const;
|
|
|
|
U32 getMaterialCount() const;
|
|
|
|
GFXTextureArrayHandle getDetailTextureArray() const { return mDetailTextureArray; }
|
|
GFXTextureArrayHandle getMacroTextureArray() const { return mMacroTextureArray; }
|
|
GFXTextureArrayHandle getNormalTextureArray() const { return mNormalTextureArray; }
|
|
GFXTextureArrayHandle getOrmTextureArray() const { return mOrmTextureArray; }
|
|
|
|
//BaseMatInstance* getMaterialInst( U32 x, U32 y );
|
|
|
|
void setHeight( const Point2I &pos, F32 height );
|
|
F32 getHeight( const Point2I &pos );
|
|
|
|
// Performs an update to the selected range of the terrain
|
|
// grid including the collision and rendering structures.
|
|
void updateGrid( const Point2I &minPt,
|
|
const Point2I &maxPt,
|
|
bool updateClient = false );
|
|
|
|
void updateGridMaterials( const Point2I &minPt, const Point2I &maxPt );
|
|
|
|
Point2I getGridPos( const Point3F &worldPos ) const;
|
|
|
|
/// This returns true and the terrain z height for
|
|
/// a 2d position in the terrains object space.
|
|
///
|
|
/// If the terrain at that point is within an empty block
|
|
/// or the 2d position is outside of the terrain area then
|
|
/// it returns false.
|
|
///
|
|
bool getHeight( const Point2F &pos, F32 *height ) const;
|
|
|
|
void getMinMaxHeight( F32 *minHeight, F32 *maxHeight ) const;
|
|
|
|
/// This returns true and the terrain normal for a
|
|
/// 2d position in the terrains object space.
|
|
///
|
|
/// If the terrain at that point is within an empty block
|
|
/// or the 2d position is outside of the terrain area then
|
|
/// it returns false.
|
|
///
|
|
bool getNormal( const Point2F &pos,
|
|
Point3F *normal,
|
|
bool normalize = true,
|
|
bool skipEmpty = true ) const;
|
|
|
|
/// This returns true and the smoothed terrain normal
|
|
// for a 2d position in the terrains object space.
|
|
///
|
|
/// If the terrain at that point is within an empty block
|
|
/// or the 2d position is outside of the terrain area then
|
|
/// it returns false.
|
|
///
|
|
bool getSmoothNormal( const Point2F &pos,
|
|
Point3F *normal,
|
|
bool normalize = true,
|
|
bool skipEmpty = true ) const;
|
|
|
|
/// This returns true and the terrain normal and z height
|
|
/// for a 2d position in the terrains object space.
|
|
///
|
|
/// If the terrain at that point is within an empty block
|
|
/// or the 2d position is outside of the terrain area then
|
|
/// it returns false.
|
|
///
|
|
bool getNormalAndHeight( const Point2F &pos,
|
|
Point3F *normal,
|
|
F32 *height,
|
|
bool normalize = true ) const;
|
|
|
|
/// This returns true and the terrain normal, z height, and
|
|
/// material name for a 2d position in the terrains object
|
|
/// space.
|
|
///
|
|
/// If the terrain at that point is within an empty block
|
|
/// or the 2d position is outside of the terrain area then
|
|
/// it returns false.
|
|
///
|
|
bool getNormalHeightMaterial( const Point2F &pos,
|
|
Point3F *normal,
|
|
F32 *height,
|
|
StringTableEntry &matName ) const;
|
|
|
|
// only the editor currently uses this method - should always be using a ray to collide with
|
|
bool collideBox( const Point3F &start, const Point3F &end, RayInfo* info ) override
|
|
{
|
|
return castRay( start, end, info );
|
|
}
|
|
|
|
///
|
|
void setLightMap( GBitmap *newLightMap );
|
|
|
|
/// Fills the lightmap with white.
|
|
void clearLightMap();
|
|
|
|
/// Retuns the dimensions of the light map.
|
|
U32 getLightMapSize() const { return mLightMapSize; }
|
|
|
|
const GBitmap* getLightMap() const { return mLightMap; }
|
|
|
|
GBitmap* getLightMap() { return mLightMap; }
|
|
|
|
///
|
|
GFXTextureObject* getLightMapTex();
|
|
|
|
public:
|
|
|
|
bool setFile( const FileName& terrFileName );
|
|
|
|
void setFile(const Resource<TerrainFile>& file);
|
|
|
|
bool setTerrainAsset(const StringTableEntry terrainAssetId);
|
|
|
|
bool save(const char* filename);
|
|
bool saveAsset();
|
|
|
|
F32 getSquareSize() const { return mSquareSize; }
|
|
|
|
/// Returns the dimensions of the terrain in world space.
|
|
F32 getWorldBlockSize() const { return mSquareSize * (F32)mFile->mSize; }
|
|
|
|
/// Retuns the dimensions of the terrain in samples.
|
|
U32 getBlockSize() const { return mFile->mSize; }
|
|
|
|
U32 getScreenError() const { return smLODScale * mScreenError; }
|
|
|
|
// SceneObject
|
|
void setTransform( const MatrixF &mat ) override;
|
|
void setScale( const VectorF &scale ) 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 castRay(const Point3F &start, const Point3F &end, RayInfo* info) override;
|
|
bool castRayI(const Point3F &start, const Point3F &end, RayInfo* info, bool emptyCollide);
|
|
|
|
bool castRayBlock( const Point3F &pStart,
|
|
const Point3F &pEnd,
|
|
const Point2I &blockPos,
|
|
U32 level,
|
|
F32 invDeltaX,
|
|
F32 invDeltaY,
|
|
F32 startT,
|
|
F32 endT,
|
|
RayInfo *info,
|
|
bool collideEmpty );
|
|
|
|
const StringTableEntry getTerrainFile() const { return mTerrFileName; }
|
|
|
|
void postLight(Vector<TerrainBlock *> &terrBlocks) {};
|
|
|
|
|
|
DECLARE_CONOBJECT(TerrainBlock);
|
|
DECLARE_CATEGORY("Environment \t BackGround");
|
|
static void initPersistFields();
|
|
U32 packUpdate (NetConnection *conn, U32 mask, BitStream *stream) override;
|
|
void unpackUpdate(NetConnection *conn, BitStream *stream) override;
|
|
void inspectPostApply() override;
|
|
|
|
void getUtilizedAssets(Vector<StringTableEntry>* usedAssetsList) override;
|
|
|
|
const StringTableEntry getTerrain() const
|
|
{
|
|
if (mTerrainAsset && (mTerrainAsset->getTerrainFilePath() != StringTable->EmptyString()))
|
|
return mTerrainAsset->getTerrainFilePath();
|
|
else if (mTerrainAssetId != StringTable->EmptyString())
|
|
return mTerrainAssetId;
|
|
else if (mTerrFileName != StringTable->EmptyString())
|
|
return mTerrFileName;
|
|
else
|
|
return StringTable->EmptyString();
|
|
}
|
|
|
|
const StringTableEntry getTerrainAssetId() const
|
|
{
|
|
if (mTerrainAssetId != StringTable->EmptyString())
|
|
return mTerrainAssetId;
|
|
else
|
|
return StringTable->EmptyString();
|
|
}
|
|
|
|
bool _setTerrain(StringTableEntry terrain)
|
|
{
|
|
if (terrain == StringTable->EmptyString())
|
|
return false;
|
|
|
|
if (AssetDatabase.isDeclaredAsset(terrain))
|
|
setTerrainAsset(terrain);
|
|
else
|
|
mTerrFileName = terrain;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool renameTerrainMaterial(StringTableEntry oldMatName, StringTableEntry newMatName);
|
|
S32 getTerrainMaterialCount() {
|
|
if (mFile)
|
|
return mFile->mMaterials.size();
|
|
return 0;
|
|
}
|
|
|
|
StringTableEntry getTerrainMaterialName(S32 index) {
|
|
if (mFile)
|
|
return mFile->mMaterials[index]->getInternalName();
|
|
|
|
return StringTable->EmptyString();
|
|
}
|
|
protected:
|
|
bool mUpdateBasetex;
|
|
bool mIgnoreZodiacs;
|
|
U16* zode_primBuffer;
|
|
void deleteZodiacPrimitiveBuffer();
|
|
public:
|
|
const U16* getZodiacPrimitiveBuffer();
|
|
};
|
|
|
|
#endif // _TERRDATA_H_
|