mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-19 20:24:49 +00:00
66f924ebd4
Updates groundCover to utilize TerrainMaterialAsset macros in place of straight StringTableEntry for type layers Fixes formatting for several asset types' inspector fields so they correctly call down into prompting the AssetBrowser being shown with correct field naming, thus allowing fields that are arrays to have the right index when setting the target variable Updates several asset helper macros to handle blank values for network traffic to actually be sent to client, thus allowing setting an asset to blank on the client, rather than only falling back
995 lines
32 KiB
C++
995 lines
32 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2013 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 _SHAPE_ASSET_H_
|
|
#include "ShapeAsset.h"
|
|
#endif
|
|
|
|
#ifndef _ASSET_MANAGER_H_
|
|
#include "assets/assetManager.h"
|
|
#endif
|
|
|
|
#ifndef _CONSOLETYPES_H_
|
|
#include "console/consoleTypes.h"
|
|
#endif
|
|
|
|
#ifndef _TAML_
|
|
#include "persistence/taml/taml.h"
|
|
#endif
|
|
|
|
#ifndef _ASSET_PTR_H_
|
|
#include "assets/assetPtr.h"
|
|
#endif
|
|
|
|
#include "core/resourceManager.h"
|
|
|
|
// Debug Profiling.
|
|
#include "platform/profiler.h"
|
|
#include "T3D/assets/assetImporter.h"
|
|
|
|
#ifdef TORQUE_TOOLS
|
|
#include "ts/tsLastDetail.h"
|
|
#endif
|
|
#include "util/imposterCapture.h"
|
|
|
|
#include "ts/tsShapeInstance.h"
|
|
#include "gfx/bitmap/imageUtils.h"
|
|
|
|
StringTableEntry ShapeAsset::smNoShapeAssetFallback = NULL;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
IMPLEMENT_CONOBJECT(ShapeAsset);
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// REFACTOR
|
|
//-----------------------------------------------------------------------------
|
|
|
|
IMPLEMENT_STRUCT(AssetPtr<ShapeAsset>, AssetPtrShapeAsset, , "")
|
|
END_IMPLEMENT_STRUCT
|
|
|
|
ConsoleType(ShapeAssetPtr, TypeShapeAssetPtr, AssetPtr<ShapeAsset>, ASSET_ID_FIELD_PREFIX)
|
|
|
|
|
|
ConsoleGetType(TypeShapeAssetPtr)
|
|
{
|
|
// Fetch asset Id.
|
|
return (*((AssetPtr<ShapeAsset>*)dptr)).getAssetId();
|
|
}
|
|
|
|
ConsoleSetType(TypeShapeAssetPtr)
|
|
{
|
|
// Was a single argument specified?
|
|
if (argc == 1)
|
|
{
|
|
// Yes, so fetch field value.
|
|
const char* pFieldValue = argv[0];
|
|
|
|
// Fetch asset pointer.
|
|
AssetPtr<ShapeAsset>* pAssetPtr = dynamic_cast<AssetPtr<ShapeAsset>*>((AssetPtrBase*)(dptr));
|
|
|
|
// Is the asset pointer the correct type?
|
|
if (pAssetPtr == NULL)
|
|
{
|
|
Con::warnf("(TypeShapeAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
|
|
return;
|
|
}
|
|
|
|
// Set asset.
|
|
pAssetPtr->setAssetId(pFieldValue);
|
|
|
|
return;
|
|
}
|
|
|
|
// Warn.
|
|
Con::warnf("(TypeShapeAssetPtr) - Cannot set multiple args to a single asset.");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ConsoleType(assetIdString, TypeShapeAssetId, const char*, ASSET_ID_FIELD_PREFIX)
|
|
|
|
ConsoleGetType(TypeShapeAssetId)
|
|
{
|
|
// Fetch asset Id.
|
|
return *((const char**)(dptr));
|
|
}
|
|
|
|
ConsoleSetType(TypeShapeAssetId)
|
|
{
|
|
// Was a single argument specified?
|
|
if (argc == 1)
|
|
{
|
|
// Yes, so fetch field value.
|
|
*((const char**)dptr) = StringTable->insert(argv[0]);
|
|
|
|
return;
|
|
}
|
|
|
|
// Warn.
|
|
Con::warnf("(TypeAssetId) - Cannot set multiple args to a single asset.");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// REFACTOR END
|
|
//-----------------------------------------------------------------------------
|
|
|
|
const String ShapeAsset::mErrCodeStrings[] =
|
|
{
|
|
"TooManyVerts",
|
|
"TooManyBones",
|
|
"MissingAnimatons",
|
|
"UnKnown"
|
|
};
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ShapeAsset::ShapeAsset()
|
|
{
|
|
mShapeFile = StringTable->EmptyString();
|
|
mConstructorFileName = StringTable->EmptyString();
|
|
|
|
mDiffuseImposterFileName = StringTable->EmptyString();
|
|
mNormalImposterFileName = StringTable->EmptyString();
|
|
|
|
|
|
mLoadedState = AssetErrCode::NotLoaded;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ShapeAsset::~ShapeAsset()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ShapeAsset::consoleInit()
|
|
{
|
|
Parent::consoleInit();
|
|
|
|
Con::addVariable("$Core::NoShapeAssetFallback", TypeString, &smNoShapeAssetFallback,
|
|
"The assetId of the shape to display when the requested shape asset is missing.\n"
|
|
"@ingroup GFX\n");
|
|
|
|
smNoShapeAssetFallback = StringTable->insert(Con::getVariable("$Core::NoShapeAssetFallback"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ShapeAsset::initPersistFields()
|
|
{
|
|
docsURL;
|
|
// Call parent.
|
|
Parent::initPersistFields();
|
|
|
|
addProtectedField("fileName", TypeAssetLooseFilePath, Offset(mShapeFile, ShapeAsset),
|
|
&setShapeFile, &getShapeFile, "Path to the shape file we want to render");
|
|
addProtectedField("constuctorFileName", TypeAssetLooseFilePath, Offset(mConstructorFileName, ShapeAsset),
|
|
&setShapeConstructorFile, &getShapeConstructorFile, "Path to the shape file we want to render");
|
|
|
|
addProtectedField("diffuseImposterFileName", TypeAssetLooseFilePath, Offset(mDiffuseImposterFileName, ShapeAsset),
|
|
&setDiffuseImposterFile, &getDiffuseImposterFile, "Path to the diffuse imposter file we want to render");
|
|
addProtectedField("normalImposterFileName", TypeAssetLooseFilePath, Offset(mNormalImposterFileName, ShapeAsset),
|
|
&setNormalImposterFile, &getNormalImposterFile, "Path to the normal imposter file we want to render");
|
|
|
|
}
|
|
|
|
void ShapeAsset::setDataField(StringTableEntry slotName, StringTableEntry array, StringTableEntry value)
|
|
{
|
|
Parent::setDataField(slotName, array, value);
|
|
|
|
//Now, if it's a material slot of some fashion, set it up
|
|
StringTableEntry matSlotName = StringTable->insert("materialAsset");
|
|
if (String(slotName).startsWith(matSlotName))
|
|
{
|
|
StringTableEntry matId = StringTable->insert(value);
|
|
|
|
mMaterialAssetIds.push_back(matId);
|
|
}
|
|
}
|
|
|
|
void ShapeAsset::initializeAsset()
|
|
{
|
|
// Call parent.
|
|
Parent::initializeAsset();
|
|
|
|
if (mShapeFile == StringTable->EmptyString())
|
|
return;
|
|
|
|
ResourceManager::get().getChangedSignal().notify(this, &ShapeAsset::_onResourceChanged);
|
|
|
|
//Ensure our path is expando'd if it isn't already
|
|
mShapeFile = getOwned() ? expandAssetFilePath(mShapeFile) : mShapeFile;
|
|
|
|
mConstructorFileName = getOwned() ? expandAssetFilePath(mConstructorFileName) : mConstructorFileName;
|
|
if (!Torque::FS::IsFile(mConstructorFileName))
|
|
Con::errorf("ShapeAsset::initializeAsset (%s) could not find %s!", getAssetName(), mConstructorFileName);
|
|
|
|
|
|
mDiffuseImposterFileName = getOwned() ? expandAssetFilePath(mDiffuseImposterFileName) : mDiffuseImposterFileName;
|
|
if (mDiffuseImposterFileName == StringTable->EmptyString())
|
|
{
|
|
String diffusePath = String(mShapeFile) + "_imposter.dds";
|
|
mDiffuseImposterFileName = StringTable->insert(diffusePath.c_str());
|
|
}
|
|
|
|
mNormalImposterFileName = getOwned() ? expandAssetFilePath(mNormalImposterFileName) : mNormalImposterFileName;
|
|
if (mNormalImposterFileName == StringTable->EmptyString())
|
|
{
|
|
String normalPath = String(mShapeFile) + "_imposter_normals.dds";
|
|
mNormalImposterFileName = StringTable->insert(normalPath.c_str());
|
|
}
|
|
}
|
|
|
|
void ShapeAsset::setShapeFile(const char* pShapeFile)
|
|
{
|
|
// Sanity!
|
|
AssertFatal(pShapeFile != NULL, "Cannot use a NULL shape file.");
|
|
|
|
// Fetch image file.
|
|
pShapeFile = StringTable->insert(pShapeFile, true);
|
|
|
|
// Ignore no change,
|
|
if (pShapeFile == mShapeFile)
|
|
return;
|
|
|
|
mShapeFile = getOwned() ? expandAssetFilePath(pShapeFile) : pShapeFile;
|
|
|
|
// Refresh the asset.
|
|
refreshAsset();
|
|
}
|
|
|
|
void ShapeAsset::setShapeConstructorFile(const char* pShapeConstructorFile)
|
|
{
|
|
// Sanity!
|
|
AssertFatal(pShapeConstructorFile != NULL, "Cannot use a NULL shape constructor file.");
|
|
|
|
// Fetch image file.
|
|
pShapeConstructorFile = StringTable->insert(pShapeConstructorFile, true);
|
|
|
|
// Ignore no change,
|
|
if (pShapeConstructorFile == mConstructorFileName)
|
|
return;
|
|
|
|
mConstructorFileName = getOwned() ? expandAssetFilePath(pShapeConstructorFile) : pShapeConstructorFile;
|
|
|
|
// Refresh the asset.
|
|
refreshAsset();
|
|
}
|
|
|
|
void ShapeAsset::setDiffuseImposterFile(const char* pImageFile)
|
|
{
|
|
// Sanity!
|
|
AssertFatal(pImageFile != NULL, "Cannot use a NULL image file.");
|
|
|
|
// Fetch image file.
|
|
pImageFile = StringTable->insert(pImageFile, true);
|
|
|
|
// Ignore no change,
|
|
if (pImageFile == mDiffuseImposterFileName)
|
|
return;
|
|
|
|
mDiffuseImposterFileName = getOwned() ? expandAssetFilePath(pImageFile) : pImageFile;
|
|
|
|
// Refresh the asset.
|
|
refreshAsset();
|
|
}
|
|
|
|
void ShapeAsset::setNormalImposterFile(const char* pImageFile)
|
|
{
|
|
// Sanity!
|
|
AssertFatal(pImageFile != NULL, "Cannot use a NULL image file.");
|
|
|
|
// Fetch image file.
|
|
pImageFile = StringTable->insert(pImageFile, true);
|
|
|
|
// Ignore no change,
|
|
if (pImageFile == mNormalImposterFileName)
|
|
return;
|
|
|
|
mNormalImposterFileName = getOwned() ? expandAssetFilePath(pImageFile) : pImageFile;
|
|
|
|
// Refresh the asset.
|
|
refreshAsset();
|
|
}
|
|
|
|
void ShapeAsset::_onResourceChanged(const Torque::Path &path)
|
|
{
|
|
if (path != Torque::Path(mShapeFile) )
|
|
return;
|
|
|
|
refreshAsset();
|
|
}
|
|
|
|
U32 ShapeAsset::load()
|
|
{
|
|
if (mLoadedState == AssetErrCode::Ok) return mLoadedState;
|
|
|
|
mMaterialAssets.clear();
|
|
mMaterialAssetIds.clear();
|
|
|
|
//First, load any material, animation, etc assets we may be referencing in our asset
|
|
// Find any asset dependencies.
|
|
AssetManager::typeAssetDependsOnHash::Iterator assetDependenciesItr = mpOwningAssetManager->getDependedOnAssets()->find(mpAssetDefinition->mAssetId);
|
|
|
|
// Does the asset have any dependencies?
|
|
if (assetDependenciesItr != mpOwningAssetManager->getDependedOnAssets()->end())
|
|
{
|
|
// Iterate all dependencies.
|
|
while (assetDependenciesItr != mpOwningAssetManager->getDependedOnAssets()->end() && assetDependenciesItr->key == mpAssetDefinition->mAssetId)
|
|
{
|
|
StringTableEntry assetType = mpOwningAssetManager->getAssetType(assetDependenciesItr->value);
|
|
|
|
if (assetType == StringTable->insert("MaterialAsset"))
|
|
{
|
|
mMaterialAssetIds.push_front(assetDependenciesItr->value);
|
|
|
|
//Force the asset to become initialized if it hasn't been already
|
|
AssetPtr<MaterialAsset> matAsset = assetDependenciesItr->value;
|
|
|
|
mMaterialAssets.push_front(matAsset);
|
|
}
|
|
else if (assetType == StringTable->insert("ShapeAnimationAsset"))
|
|
{
|
|
mAnimationAssetIds.push_back(assetDependenciesItr->value);
|
|
|
|
//Force the asset to become initialized if it hasn't been already
|
|
AssetPtr<ShapeAnimationAsset> animAsset = assetDependenciesItr->value;
|
|
|
|
mAnimationAssets.push_back(animAsset);
|
|
}
|
|
|
|
// Next dependency.
|
|
assetDependenciesItr++;
|
|
}
|
|
}
|
|
|
|
mShape = ResourceManager::get().load(mShapeFile);
|
|
|
|
if (!mShape)
|
|
{
|
|
mLoadedState = BadFileReference;
|
|
return mLoadedState; //if it failed to load, bail out
|
|
}
|
|
// Construct billboards if not done already
|
|
if (GFXDevice::devicePresent())
|
|
mShape->setupBillboardDetails(mShapeFile, mDiffuseImposterFileName, mNormalImposterFileName);
|
|
|
|
//If they exist, grab our imposters here and bind them to our shapeAsset
|
|
|
|
bool hasBlends = false;
|
|
|
|
//Now that we've successfully loaded our shape and have any materials and animations loaded
|
|
//we need to set up the animations we're using on our shape
|
|
for (S32 i = mAnimationAssets.size()-1; i >= 0; --i)
|
|
{
|
|
String srcName = mAnimationAssets[i]->getAnimationName();
|
|
String srcPath(mAnimationAssets[i]->getAnimationFilename());
|
|
//SplitSequencePathAndName(srcPath, srcName);
|
|
|
|
if (!mShape->addSequence(srcPath, mAnimationAssets[i]->getAssetId(), srcName, srcName,
|
|
mAnimationAssets[i]->getStartFrame(), mAnimationAssets[i]->getEndFrame(), mAnimationAssets[i]->getPadRotation(), mAnimationAssets[i]->getPadTransforms()))
|
|
{
|
|
mLoadedState = MissingAnimatons;
|
|
return mLoadedState;
|
|
}
|
|
if (mAnimationAssets[i]->isBlend())
|
|
hasBlends = true;
|
|
}
|
|
|
|
//if any of our animations are blends, set those up now
|
|
if (hasBlends)
|
|
{
|
|
for (U32 i=0; i < mAnimationAssets.size(); ++i)
|
|
{
|
|
if (mAnimationAssets[i]->isBlend() && mAnimationAssets[i]->getBlendAnimationName() != StringTable->EmptyString())
|
|
{
|
|
//gotta do a bit of logic here.
|
|
//First, we need to make sure the anim asset we depend on for our blend is loaded
|
|
AssetPtr<ShapeAnimationAsset> blendAnimAsset = mAnimationAssets[i]->getBlendAnimationName();
|
|
|
|
U32 assetStatus = ShapeAnimationAsset::getAssetErrCode(blendAnimAsset);
|
|
if (assetStatus != AssetBase::Ok)
|
|
{
|
|
Con::errorf("ShapeAsset::initializeAsset - Unable to acquire reference animation asset %s for asset %s to blend!", mAnimationAssets[i]->getBlendAnimationName(), mAnimationAssets[i]->getAssetName());
|
|
{
|
|
mLoadedState = MissingAnimatons;
|
|
return mLoadedState;
|
|
}
|
|
}
|
|
|
|
String refAnimName = blendAnimAsset->getAnimationName();
|
|
if (!mShape->setSequenceBlend(mAnimationAssets[i]->getAnimationName(), true, blendAnimAsset->getAnimationName(), mAnimationAssets[i]->getBlendFrame()))
|
|
{
|
|
Con::errorf("ShapeAnimationAsset::initializeAsset - Unable to set animation clip %s for asset %s to blend!", mAnimationAssets[i]->getAnimationName(), mAnimationAssets[i]->getAssetName());
|
|
{
|
|
mLoadedState = MissingAnimatons;
|
|
return mLoadedState;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mLoadedState = Ok;
|
|
|
|
return mLoadedState;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//Utility function to 'fill out' bindings and resources with a matching asset if one exists
|
|
U32 ShapeAsset::getAssetByFilename(StringTableEntry fileName, AssetPtr<ShapeAsset>* shapeAsset)
|
|
{
|
|
AssetQuery query;
|
|
S32 foundAssetcount = AssetDatabase.findAssetLooseFile(&query, fileName);
|
|
if (foundAssetcount == 0)
|
|
{
|
|
//Didn't work, so have us fall back to a placeholder asset
|
|
shapeAsset->setAssetId(ShapeAsset::smNoShapeAssetFallback);
|
|
|
|
if (shapeAsset->isNull())
|
|
{
|
|
//Well that's bad, loading the fallback failed.
|
|
Con::warnf("ShapeAsset::getAssetByFilename - Finding of asset associated with file %s failed with no fallback asset", fileName);
|
|
return AssetErrCode::Failed;
|
|
}
|
|
|
|
//handle noshape not being loaded itself
|
|
if ((*shapeAsset)->mLoadedState == BadFileReference)
|
|
{
|
|
Con::warnf("ShapeAsset::getAssetByFilename - Finding of associated with file %s failed, and fallback asset reported error of Bad File Reference.", fileName);
|
|
return AssetErrCode::BadFileReference;
|
|
}
|
|
|
|
Con::warnf("ShapeAsset::getAssetByFilename - Finding of associated with file %s failed, utilizing fallback asset", fileName);
|
|
|
|
(*shapeAsset)->mLoadedState = AssetErrCode::UsingFallback;
|
|
return AssetErrCode::UsingFallback;
|
|
}
|
|
else
|
|
{
|
|
//acquire and bind the asset, and return it out
|
|
shapeAsset->setAssetId(query.mAssetList[0]);
|
|
return (*shapeAsset)->mLoadedState;
|
|
}
|
|
}
|
|
|
|
StringTableEntry ShapeAsset::getAssetIdByFilename(StringTableEntry fileName)
|
|
{
|
|
if (fileName == StringTable->EmptyString())
|
|
return StringTable->EmptyString();
|
|
|
|
StringTableEntry shapeAssetId = ShapeAsset::smNoShapeAssetFallback;
|
|
|
|
AssetQuery query;
|
|
S32 foundAssetcount = AssetDatabase.findAssetLooseFile(&query, fileName);
|
|
if (foundAssetcount != 0)
|
|
{
|
|
//acquire and bind the asset, and return it out
|
|
shapeAssetId = query.mAssetList[0];
|
|
}
|
|
else
|
|
{
|
|
foundAssetcount = AssetDatabase.findAssetType(&query, "ShapeAsset");
|
|
if (foundAssetcount != 0)
|
|
{
|
|
// loop all image assets and see if we can find one
|
|
// using the same image file/named target.
|
|
for (auto shapeAsset : query.mAssetList)
|
|
{
|
|
AssetPtr<ShapeAsset> temp = shapeAsset;
|
|
if (temp.notNull())
|
|
{
|
|
if (temp->getShapeFile() == fileName)
|
|
{
|
|
return shapeAsset;
|
|
}
|
|
else
|
|
{
|
|
Torque::Path temp1 = temp->getShapeFile();
|
|
Torque::Path temp2 = fileName;
|
|
|
|
if (temp1.getPath() == temp2.getPath() && temp1.getFileName() == temp2.getFileName())
|
|
{
|
|
return shapeAsset;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AssetPtr<ShapeAsset> shapeAsset = shapeAssetId; //ensures the fallback is loaded
|
|
}
|
|
}
|
|
|
|
return shapeAssetId;
|
|
}
|
|
|
|
U32 ShapeAsset::getAssetById(StringTableEntry assetId, AssetPtr<ShapeAsset>* shapeAsset)
|
|
{
|
|
(*shapeAsset) = assetId;
|
|
|
|
if (shapeAsset->notNull())
|
|
{
|
|
return (*shapeAsset)->mLoadedState;
|
|
}
|
|
else
|
|
{
|
|
//Didn't work, so have us fall back to a placeholder asset
|
|
shapeAsset->setAssetId(ShapeAsset::smNoShapeAssetFallback);
|
|
|
|
if (shapeAsset->isNull())
|
|
{
|
|
//Well that's bad, loading the fallback failed.
|
|
Con::warnf("ShapeAsset::getAssetById - Finding of asset with id %s failed with no fallback asset", assetId);
|
|
return AssetErrCode::Failed;
|
|
}
|
|
|
|
//handle noshape not being loaded itself
|
|
if ((*shapeAsset)->mLoadedState == BadFileReference)
|
|
{
|
|
Con::warnf("ShapeAsset::getAssetById - Finding of asset with id %s failed, and fallback asset reported error of Bad File Reference.", assetId);
|
|
return AssetErrCode::BadFileReference;
|
|
}
|
|
|
|
Con::warnf("ShapeAsset::getAssetById - Finding of asset with id %s failed, utilizing fallback asset", assetId);
|
|
|
|
(*shapeAsset)->mLoadedState = AssetErrCode::UsingFallback;
|
|
return AssetErrCode::UsingFallback;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
void ShapeAsset::copyTo(SimObject* object)
|
|
{
|
|
// Call to parent.
|
|
Parent::copyTo(object);
|
|
}
|
|
|
|
void ShapeAsset::onAssetRefresh(void)
|
|
{
|
|
// Ignore if not yet added to the sim.
|
|
if (!isProperlyAdded())
|
|
return;
|
|
|
|
if (mShapeFile == StringTable->EmptyString())
|
|
return;
|
|
|
|
// Call parent.
|
|
Parent::onAssetRefresh();
|
|
|
|
load();
|
|
}
|
|
|
|
void ShapeAsset::onTamlPreWrite(void)
|
|
{
|
|
// Call parent.
|
|
Parent::onTamlPreWrite();
|
|
|
|
// ensure paths are collapsed.
|
|
mShapeFile = collapseAssetFilePath(mShapeFile);
|
|
mConstructorFileName = collapseAssetFilePath(mConstructorFileName);
|
|
mDiffuseImposterFileName = collapseAssetFilePath(mDiffuseImposterFileName);
|
|
mNormalImposterFileName = collapseAssetFilePath(mNormalImposterFileName);
|
|
}
|
|
|
|
void ShapeAsset::onTamlPostWrite(void)
|
|
{
|
|
// Call parent.
|
|
Parent::onTamlPostWrite();
|
|
|
|
// ensure paths are expanded.
|
|
mShapeFile = expandAssetFilePath(mShapeFile);
|
|
mConstructorFileName = expandAssetFilePath(mConstructorFileName);
|
|
mDiffuseImposterFileName = expandAssetFilePath(mDiffuseImposterFileName);
|
|
mNormalImposterFileName = expandAssetFilePath(mNormalImposterFileName);
|
|
}
|
|
|
|
void ShapeAsset::SplitSequencePathAndName(String& srcPath, String& srcName)
|
|
{
|
|
srcName = "";
|
|
|
|
// Determine if there is a sequence name at the end of the source string, and
|
|
// if so, split the filename from the sequence name
|
|
S32 split = srcPath.find(' ', 0, String::Right);
|
|
S32 split2 = srcPath.find('\t', 0, String::Right);
|
|
if ((split == String::NPos) || (split2 > split))
|
|
split = split2;
|
|
if (split != String::NPos)
|
|
{
|
|
split2 = split + 1;
|
|
while ((srcPath[split2] != '\0') && dIsspace(srcPath[split2]))
|
|
split2++;
|
|
|
|
// now 'split' is at the end of the path, and 'split2' is at the start of the sequence name
|
|
srcName = srcPath.substr(split2);
|
|
srcPath = srcPath.erase(split, srcPath.length() - split);
|
|
}
|
|
}
|
|
|
|
ShapeAnimationAsset* ShapeAsset::getAnimation(S32 index)
|
|
{
|
|
if (index < mAnimationAssets.size())
|
|
{
|
|
return mAnimationAssets[index];
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
#ifdef TORQUE_TOOLS
|
|
const char* ShapeAsset::generateCachedPreviewImage(S32 resolution, String overrideMaterial)
|
|
{
|
|
if (!mShape)
|
|
return "";
|
|
|
|
// We're gonna render... make sure we can.
|
|
bool sceneBegun = GFX->canCurrentlyRender();
|
|
if (!sceneBegun)
|
|
GFX->beginScene();
|
|
|
|
// We need to create our own instance to render with.
|
|
TSShapeInstance* shape = new TSShapeInstance(mShape, true);
|
|
|
|
if (overrideMaterial.isNotEmpty())
|
|
{
|
|
Material *tMat = dynamic_cast<Material*>(Sim::findObject(overrideMaterial));
|
|
if (tMat)
|
|
shape->reSkin(tMat->mMapTo, mShape->materialList->getMaterialName(0));
|
|
}
|
|
// Animate the shape once.
|
|
shape->animate(0);
|
|
|
|
GBitmap* imposter = NULL;
|
|
GBitmap* imposterNrml = NULL;
|
|
|
|
ImposterCapture* imposterCap = new ImposterCapture();
|
|
|
|
static const MatrixF topXfm(EulerF(-M_PI_F / 2.0f, 0, 0));
|
|
static const MatrixF bottomXfm(EulerF(M_PI_F / 2.0f, 0, 0));
|
|
|
|
MatrixF angMat;
|
|
|
|
PROFILE_START(ShapeAsset_generateCachedPreviewImage);
|
|
|
|
//dMemset(destBmp.getWritableBits(mip), 0, destBmp.getWidth(mip) * destBmp.getHeight(mip) * GFXFormat_getByteSize(format));
|
|
|
|
F32 rotX = -(mDegToRad(60.0) - 0.5f * M_PI_F);
|
|
F32 rotZ = -(mDegToRad(45.0) - 0.5f * M_PI_F);
|
|
|
|
// We capture the images in a particular order which must
|
|
// match the order expected by the imposter renderer.
|
|
|
|
imposterCap->begin(shape, 0, resolution, mShape->mRadius, mShape->center);
|
|
|
|
angMat.mul(MatrixF(EulerF(rotX, 0, 0)),
|
|
MatrixF(EulerF(0, 0, rotZ)));
|
|
|
|
imposterCap->capture(angMat, &imposter, &imposterNrml);
|
|
|
|
imposterCap->end();
|
|
|
|
PROFILE_END(); // ShapeAsset_generateCachedPreviewImage
|
|
|
|
delete imposterCap;
|
|
delete shape;
|
|
|
|
String dumpPath = String(mShapeFile) + ".png";
|
|
|
|
char* returnBuffer = Con::getReturnBuffer(128);
|
|
dSprintf(returnBuffer, 128, "%s", dumpPath.c_str());
|
|
|
|
imposter->writeBitmap("png", dumpPath);
|
|
|
|
delete imposter;
|
|
delete imposterNrml;
|
|
|
|
// If we did a begin then end it now.
|
|
if (!sceneBegun)
|
|
GFX->endScene();
|
|
|
|
return returnBuffer;
|
|
}
|
|
#endif
|
|
|
|
DefineEngineMethod(ShapeAsset, getMaterialCount, S32, (), ,
|
|
"Gets the number of materials for this shape asset.\n"
|
|
"@return Material count.\n")
|
|
{
|
|
return object->getMaterialCount();
|
|
}
|
|
|
|
DefineEngineMethod(ShapeAsset, getAnimationCount, S32, (), ,
|
|
"Gets the number of animations for this shape asset.\n"
|
|
"@return Animation count.\n")
|
|
{
|
|
return object->getAnimationCount();
|
|
}
|
|
|
|
DefineEngineMethod(ShapeAsset, getAnimation, ShapeAnimationAsset*, (S32 index), (0),
|
|
"Gets a particular shape animation asset for this shape.\n"
|
|
"@param animation asset index.\n"
|
|
"@return Shape Animation Asset.\n")
|
|
{
|
|
return object->getAnimation(index);
|
|
}
|
|
|
|
DefineEngineMethod(ShapeAsset, getShapePath, const char*, (), ,
|
|
"Gets the shape's file path\n"
|
|
"@return The filename of the shape file")
|
|
{
|
|
return object->getShapeFile();
|
|
}
|
|
|
|
DefineEngineMethod(ShapeAsset, getShapeConstructorFilePath, const char*, (), ,
|
|
"Gets the shape's constructor file.\n"
|
|
"@return The filename of the shape constructor file")
|
|
{
|
|
return object->getShapeConstructorFile();
|
|
}
|
|
|
|
DefineEngineMethod(ShapeAsset, getStatusString, String, (), , "get status string")\
|
|
{
|
|
return ShapeAsset::getAssetErrstrn(object->getStatus());
|
|
}
|
|
|
|
#ifdef TORQUE_TOOLS
|
|
DefineEngineMethod(ShapeAsset, generateCachedPreviewImage, const char*, (S32 resolution, const char* overrideMaterialName), (256, ""),
|
|
"Generates a baked preview image of the given shapeAsset. Only really used for generating Asset Browser icons.\n"
|
|
"@param resolution Optional field for what resolution to bake the preview image at. Must be pow2\n"
|
|
"@param overrideMaterialName Optional field for overriding the material used when rendering the shape for the bake.")
|
|
{
|
|
object->load();
|
|
return object->generateCachedPreviewImage(resolution, overrideMaterialName);
|
|
}
|
|
|
|
DefineEngineStaticMethod(ShapeAsset, getAssetIdByFilename, const char*, (const char* filePath), (""),
|
|
"Queries the Asset Database to see if any asset exists that is associated with the provided file path.\n"
|
|
"@return The AssetId of the associated asset, if any.")
|
|
{
|
|
return ShapeAsset::getAssetIdByFilename(StringTable->insert(filePath));
|
|
}
|
|
#endif
|
|
|
|
#ifdef TORQUE_TOOLS
|
|
//-----------------------------------------------------------------------------
|
|
// GuiInspectorTypeAssetId
|
|
//-----------------------------------------------------------------------------
|
|
|
|
IMPLEMENT_CONOBJECT(GuiInspectorTypeShapeAssetPtr);
|
|
|
|
ConsoleDocClass(GuiInspectorTypeShapeAssetPtr,
|
|
"@brief Inspector field type for Shapes\n\n"
|
|
"Editor use only.\n\n"
|
|
"@internal"
|
|
);
|
|
|
|
void GuiInspectorTypeShapeAssetPtr::consoleInit()
|
|
{
|
|
Parent::consoleInit();
|
|
|
|
ConsoleBaseType::getType(TypeShapeAssetPtr)->setInspectorFieldType("GuiInspectorTypeShapeAssetPtr");
|
|
}
|
|
|
|
GuiControl* GuiInspectorTypeShapeAssetPtr::constructEditControl()
|
|
{
|
|
// Create base filename edit controls
|
|
GuiControl* retCtrl = Parent::constructEditControl();
|
|
if (retCtrl == NULL)
|
|
return retCtrl;
|
|
|
|
// Change filespec
|
|
char szBuffer[512];
|
|
|
|
const char* previewImage;
|
|
|
|
if (mInspector->getInspectObject() != nullptr)
|
|
{
|
|
StringBuilder varNameStr;
|
|
varNameStr.append(mCaption);
|
|
if (mFieldArrayIndex != nullptr)
|
|
{
|
|
varNameStr.append("[");
|
|
varNameStr.append(mFieldArrayIndex);
|
|
varNameStr.append("]");
|
|
}
|
|
|
|
dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"ShapeAsset\", \"AssetBrowser.changeAsset\", %s, \"%s\");",
|
|
mInspector->getIdString(), varNameStr.end().c_str());
|
|
mBrowseButton->setField("Command", szBuffer);
|
|
|
|
setDataField(StringTable->insert("targetObject"), NULL, mInspector->getInspectObject()->getIdString());
|
|
|
|
previewImage = mInspector->getInspectObject()->getDataField(varNameStr.end().c_str(), NULL);
|
|
}
|
|
else
|
|
{
|
|
//if we don't have a target object, we'll be manipulating the desination value directly
|
|
dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"ShapeAsset\", \"AssetBrowser.changeAsset\", %s, \"%s\");",
|
|
mInspector->getIdString(), mVariableName);
|
|
mBrowseButton->setField("Command", szBuffer);
|
|
|
|
previewImage = Con::getVariable(mVariableName);
|
|
}
|
|
|
|
mLabel = new GuiTextCtrl();
|
|
mLabel->registerObject();
|
|
mLabel->setControlProfile(mProfile);
|
|
mLabel->setText(mCaption);
|
|
addObject(mLabel);
|
|
|
|
//
|
|
GuiTextEditCtrl* editTextCtrl = static_cast<GuiTextEditCtrl*>(retCtrl);
|
|
GuiControlProfile* toolEditProfile;
|
|
if (Sim::findObject("ToolsGuiTextEditProfile", toolEditProfile))
|
|
editTextCtrl->setControlProfile(toolEditProfile);
|
|
|
|
GuiControlProfile* toolDefaultProfile = nullptr;
|
|
Sim::findObject("ToolsGuiDefaultProfile", toolDefaultProfile);
|
|
|
|
//
|
|
mPreviewImage = new GuiBitmapCtrl();
|
|
mPreviewImage->registerObject();
|
|
|
|
if (toolDefaultProfile)
|
|
mPreviewImage->setControlProfile(toolDefaultProfile);
|
|
|
|
updatePreviewImage();
|
|
|
|
addObject(mPreviewImage);
|
|
|
|
//
|
|
mPreviewBorderButton = new GuiBitmapButtonCtrl();
|
|
mPreviewBorderButton->registerObject();
|
|
|
|
if (toolDefaultProfile)
|
|
mPreviewBorderButton->setControlProfile(toolDefaultProfile);
|
|
|
|
mPreviewBorderButton->_setBitmap(StringTable->insert("ToolsModule:cubemapBtnBorder_n_image"));
|
|
|
|
mPreviewBorderButton->setField("Command", szBuffer); //clicking the preview does the same thing as the edit button, for simplicity
|
|
addObject(mPreviewBorderButton);
|
|
|
|
//
|
|
// Create "Open in Editor" button
|
|
mEditButton = new GuiBitmapButtonCtrl();
|
|
|
|
dSprintf(szBuffer, sizeof(szBuffer), "ShapeEditorPlugin.openShapeAssetId(%d.getText());", retCtrl->getId());
|
|
mEditButton->setField("Command", szBuffer);
|
|
|
|
mEditButton->setText("Edit");
|
|
mEditButton->setSizing(horizResizeLeft, vertResizeAspectTop);
|
|
|
|
mEditButton->setDataField(StringTable->insert("Profile"), NULL, "ToolsGuiButtonProfile");
|
|
mEditButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
|
|
mEditButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
|
|
mEditButton->setDataField(StringTable->insert("tooltip"), NULL, "Open this asset in the Shape Editor");
|
|
|
|
mEditButton->registerObject();
|
|
addObject(mEditButton);
|
|
|
|
//
|
|
mUseHeightOverride = true;
|
|
mHeightOverride = 72;
|
|
|
|
return retCtrl;
|
|
}
|
|
|
|
bool GuiInspectorTypeShapeAssetPtr::updateRects()
|
|
{
|
|
S32 rowSize = 18;
|
|
S32 dividerPos, dividerMargin;
|
|
mInspector->getDivider(dividerPos, dividerMargin);
|
|
Point2I fieldExtent = getExtent();
|
|
Point2I fieldPos = getPosition();
|
|
|
|
mEditCtrlRect.set(0, 0, fieldExtent.x, fieldExtent.y);
|
|
mLabel->resize(Point2I(mProfile->mTextOffset.x, 0), Point2I(fieldExtent.x, rowSize));
|
|
|
|
RectI previewRect = RectI(Point2I(mProfile->mTextOffset.x, rowSize), Point2I(50, 50));
|
|
mPreviewBorderButton->resize(previewRect.point, previewRect.extent);
|
|
mPreviewImage->resize(previewRect.point, previewRect.extent);
|
|
|
|
S32 editPos = previewRect.point.x + previewRect.extent.x + 10;
|
|
mEdit->resize(Point2I(editPos, rowSize * 1.5), Point2I(fieldExtent.x - editPos - 5, rowSize));
|
|
|
|
mEditButton->resize(Point2I(fieldExtent.x - 105, previewRect.point.y + previewRect.extent.y - rowSize), Point2I(100, rowSize));
|
|
|
|
mBrowseButton->setHidden(true);
|
|
|
|
return true;
|
|
}
|
|
|
|
void GuiInspectorTypeShapeAssetPtr::updateValue()
|
|
{
|
|
Parent::updateValue();
|
|
|
|
updatePreviewImage();
|
|
}
|
|
|
|
void GuiInspectorTypeShapeAssetPtr::updatePreviewImage()
|
|
{
|
|
const char* previewImage;
|
|
if (mInspector->getInspectObject() != nullptr)
|
|
previewImage = mInspector->getInspectObject()->getDataField(mCaption, NULL);
|
|
else
|
|
previewImage = Con::getVariable(mVariableName);
|
|
|
|
//if what we're working with isn't even a valid asset, don't present like we found a good one
|
|
if (!AssetDatabase.isDeclaredAsset(previewImage))
|
|
{
|
|
mPreviewImage->_setBitmap(StringTable->EmptyString());
|
|
return;
|
|
}
|
|
|
|
String shpPreviewAssetId = String(previewImage) + "_PreviewImage";
|
|
shpPreviewAssetId.replace(":", "_");
|
|
shpPreviewAssetId = "ToolsModule:" + shpPreviewAssetId;
|
|
if (AssetDatabase.isDeclaredAsset(shpPreviewAssetId.c_str()))
|
|
{
|
|
mPreviewImage->setBitmap(StringTable->insert(shpPreviewAssetId.c_str()));
|
|
}
|
|
|
|
if (mPreviewImage->getBitmapAsset().isNull())
|
|
mPreviewImage->_setBitmap(StringTable->insert("ToolsModule:genericAssetIcon_image"));
|
|
}
|
|
|
|
void GuiInspectorTypeShapeAssetPtr::setPreviewImage(StringTableEntry assetId)
|
|
{
|
|
//if what we're working with isn't even a valid asset, don't present like we found a good one
|
|
if (!AssetDatabase.isDeclaredAsset(assetId))
|
|
{
|
|
mPreviewImage->_setBitmap(StringTable->EmptyString());
|
|
return;
|
|
}
|
|
|
|
String shpPreviewAssetId = String(assetId) + "_PreviewImage";
|
|
shpPreviewAssetId.replace(":", "_");
|
|
shpPreviewAssetId = "ToolsModule:" + shpPreviewAssetId;
|
|
if (AssetDatabase.isDeclaredAsset(shpPreviewAssetId.c_str()))
|
|
{
|
|
mPreviewImage->setBitmap(StringTable->insert(shpPreviewAssetId.c_str()));
|
|
}
|
|
|
|
if (mPreviewImage->getBitmapAsset().isNull())
|
|
mPreviewImage->_setBitmap(StringTable->insert("ToolsModule:genericAssetIcon_image"));
|
|
}
|
|
|
|
IMPLEMENT_CONOBJECT(GuiInspectorTypeShapeAssetId);
|
|
|
|
ConsoleDocClass(GuiInspectorTypeShapeAssetId,
|
|
"@brief Inspector field type for Shapes\n\n"
|
|
"Editor use only.\n\n"
|
|
"@internal"
|
|
);
|
|
|
|
void GuiInspectorTypeShapeAssetId::consoleInit()
|
|
{
|
|
Parent::consoleInit();
|
|
|
|
ConsoleBaseType::getType(TypeShapeAssetId)->setInspectorFieldType("GuiInspectorTypeShapeAssetId");
|
|
}
|
|
#endif
|