//-----------------------------------------------------------------------------
CPUTResult CPUTAssetSet::LoadAssetSet(std::string name, int numSystemMaterials, std::string *pSystemMaterialNames)
{
CPUTResult result = CPUT_SUCCESS;
// if not found, load the set file
CPUTConfigFile ConfigFile;
result = ConfigFile.LoadFile(name);
if( !CPUTSUCCESS(result) )
{
return result;
}
// ASSERT( CPUTSUCCESS(result), "Failed loading set file '" + name + "'." );
mAssetCount = ConfigFile.BlockCount() + 1; // Add one for the implied root node
mppAssetList = new CPUTRenderNode*[mAssetCount];
mppAssetList[0] = mpRootNode;
mpRootNode->AddRef();
CPUTAssetLibrary *pAssetLibrary = (CPUTAssetLibrary*)CPUTAssetLibrary::GetAssetLibrary();
CPUTAnimation *pDefaultAnimation = NULL;
for(UINT ii=0; ii<mAssetCount-1; ii++) // Note: -1 because we added one for the root node (we don't load it)
{
CPUTConfigBlock *pBlock = ConfigFile.GetBlock(ii);
ASSERT(pBlock != NULL, "Cannot find block");
if( !pBlock )
{
return CPUT_ERROR_PARAMETER_BLOCK_NOT_FOUND;
}
std::string nodeType = pBlock->GetValueByName("type")->ValueAsString();
CPUTRenderNode *pParentNode = NULL;
// TODO: use Get*() instead of Load*() ?
std::string name = pBlock->GetValueByName("name")->ValueAsString();
int parentIndex;
CPUTRenderNode *pNode = NULL;
if(0==nodeType.compare("null"))
{
pNode = pNode = CPUTNullNode::Create();
result = ((CPUTNullNode*)pNode)->LoadNullNode(pBlock, &parentIndex);
pParentNode = mppAssetList[parentIndex+1];
std::string &parentPrefix = pParentNode->GetPrefix();
std::string prefix = parentPrefix;
prefix.append(".");
prefix.append(name);
pNode->SetPrefix(prefix);
// pNode->SetPrefix( parentPrefix + "." + name );
pAssetLibrary->AddNullNode("", parentPrefix + name, "", (CPUTNullNode*)pNode);
// Add this null's name to our prefix
// Append this null's name to our parent's prefix
pNode->SetParent( pParentNode );
pParentNode->AddChild( pNode );
}
else if(0==nodeType.compare("model"))
{
CPUTConfigEntry *pValue = pBlock->GetValueByName( "instance" );
CPUTModel *pModel = CPUTModel::Create();
if( pValue == &CPUTConfigEntry::sNullConfigValue )
{
// Not found. So, not an instance.
pModel->LoadModel(pBlock, &parentIndex, NULL, numSystemMaterials, pSystemMaterialNames);
}
else
{
int instance = pValue->ValueAsInt();
// If the current node is an instance of itself then it has no "master" model
if(ii == instance)
{
// TODO: create instance model object
pModel->LoadModel(pBlock, &parentIndex, NULL, numSystemMaterials, pSystemMaterialNames);
}
else
{
pModel->LoadModel(pBlock, &parentIndex, (CPUTModel*)mppAssetList[instance+1], numSystemMaterials, pSystemMaterialNames);
}
}
pParentNode = mppAssetList[parentIndex+1];
pModel->SetParent( pParentNode );
pParentNode->AddChild( pModel );
std::string &parentPrefix = pParentNode->GetPrefix();
pModel->SetPrefix( parentPrefix );
pAssetLibrary->AddModel(name, parentPrefix, "", pModel);
pModel->UpdateBoundsWorldSpace();
#ifdef SUPPORT_DRAWING_BOUNDING_BOXES
// Create a mesh for rendering the bounding box
// TODO: There is definitely a better way to do this. But, want to see the bounding boxes!
pModel->CreateBoundingBoxMesh();
#endif
pNode = pModel;
}
else if(0==nodeType.compare("light"))
{
pNode = CPUTLight::Create();
((CPUTLight*)pNode)->LoadLight(pBlock, &parentIndex);
pParentNode = mppAssetList[parentIndex+1]; // +1 because we added a root node to the start
pNode->SetParent( pParentNode );
pParentNode->AddChild( pNode );
std::string &parentPrefix = pParentNode->GetPrefix();
pNode->SetPrefix( parentPrefix );
pAssetLibrary->AddLight(name, parentPrefix, "", (CPUTLight*)pNode);
}
else if(0==nodeType.compare("camera"))
{
pNode = CPUTCamera::Create(CPUT_PERSPECTIVE);
((CPUTCamera*)pNode)->LoadCamera(pBlock, &parentIndex);
pParentNode = mppAssetList[parentIndex+1]; // +1 because we added a root node to the start
pNode->SetParent( pParentNode );
pParentNode->AddChild( pNode );
std::string &parentPrefix = pParentNode->GetPrefix();
pNode->SetPrefix( parentPrefix );
pAssetLibrary->AddCamera(name, parentPrefix, "", (CPUTCamera*)pNode);
if( !mpFirstCamera ) { mpFirstCamera = (CPUTCamera*)pNode; mpFirstCamera->AddRef();}
++mCameraCount;
}
else
{
ASSERT(0,"Unsupported node type '" + nodeType + "'.");
}
CPUTConfigEntry *pAnimValue = pBlock->GetValueByName( "Animation0" );
//int autoPlayAnimationIndex = pBlock->GetValueByName( "DefaultAnimation" );
for(int i = 1; pAnimValue != &CPUTConfigEntry::sNullConfigValue; ++i )
{
CPUTAnimation *pCurrentAnimation = pAssetLibrary->GetAnimation(pAnimValue->ValueAsString());
//First Animation will be default for now
if(pCurrentAnimation != NULL && i == 1 /*autoPlayAnimationIndex*/)
{
pDefaultAnimation = pCurrentAnimation ;
pCurrentAnimation->AddRef();
}
std::stringstream animName;
animName << "Animation" << i;
pAnimValue = pBlock->GetValueByName(animName.str());
pNode->mAnimationList.push_back(pCurrentAnimation);
}
// Add the node to our asset list (i.e., the linear list, not the hierarchical)
mppAssetList[ii+1] = pNode;
// Don't AddRef.Creating it set the refcount to 1. We add it to the list, and then we're done with it.
// Net effect is 0 (+1 to add to list, and -1 because we're done with it)
// pNode->AddRef();
}
//Set the default animation to the current Asset Set
if(pDefaultAnimation != NULL && mAssetCount > 1)
{
//Apply Animation to root of the setfile
mppAssetList[1]->SetAnimation(pDefaultAnimation);
}
SAFE_RELEASE(pDefaultAnimation);
return result;
}
//-----------------------------------------------------------------------------
CPUTResult CPUTAssetSetDX11::LoadAssetSet(cString name)
{
CPUTResult result = CPUT_SUCCESS;
// if not found, load the set file
CPUTConfigFile ConfigFile;
result = ConfigFile.LoadFile(name);
#if 1
if( !CPUTSUCCESS(result) )
{
return result;
}
// ASSERT( CPUTSUCCESS(result), _L("Failed loading set file '") + name + _L("'.") );
mAssetCount = ConfigFile.BlockCount() + 1; // Add one for the implied root node
// mAssetCount = min(2, mAssetCount); // Add one for the implied root node
mppAssetList = new CPUTRenderNode*[mAssetCount];
mppAssetList[0] = mpRootNode;
mpRootNode->AddRef();
CPUTAssetLibraryDX11 *pAssetLibrary = (CPUTAssetLibraryDX11*)CPUTAssetLibrary::GetAssetLibrary();
for(UINT ii=0; ii<mAssetCount-1; ii++) // Note: -1 because we added one for the root node (we don't load it)
{
CPUTConfigBlock *pBlock = ConfigFile.GetBlock(ii);
int assetIndex = pBlock->GetNameValue();
cString nodeType = pBlock->GetValueByName(_L("type"))->ValueAsString();
CPUTRenderNode *pParentNode = NULL;
// TODO: use Get*() instead of Load*() ?
cString name = pBlock->GetValueByName(_L("name"))->ValueAsString();
int parentIndex;
CPUTRenderNode *pNode;
if(0==nodeType.compare(_L("null")))
{
pNode = pNode = new CPUTNullNode();
result = ((CPUTNullNode*)pNode)->LoadNullNode(pBlock, &parentIndex);
pParentNode = mppAssetList[parentIndex+1];
cString &parentPrefix = pParentNode->GetPrefix();
pNode->SetPrefix( parentPrefix + _L(".") + name );
pAssetLibrary->AddNullNode(parentPrefix + name, (CPUTNullNode*)pNode);
// Add this null's name to our prefix
// Append this null's name to our parent's prefix
pNode->SetParent( pParentNode );
pParentNode->AddChild( pNode );
}
else if(0==nodeType.compare(_L("model")))
{
CPUTConfigEntry *pValue = pBlock->GetValueByName( _L("instance") );
CPUTModelDX11 *pModel = new CPUTModelDX11();
if( pValue == &CPUTConfigEntry::sNullConfigValue )
{
// Not found. So, not an instance.
pModel->LoadModel(pBlock, &parentIndex, NULL);
}
else
{
int instance = pValue->ValueAsInt();
pModel->LoadModel(pBlock, &parentIndex, (CPUTModel*)mppAssetList[instance+1]);
}
pParentNode = mppAssetList[parentIndex+1];
pModel->SetParent( pParentNode );
pParentNode->AddChild( pModel );
cString &parentPrefix = pParentNode->GetPrefix();
pModel->SetPrefix( parentPrefix );
pAssetLibrary->AddModel(parentPrefix + name, pModel);
pModel->UpdateBoundsWorldSpace();
#ifdef SUPPORT_DRAWING_BOUNDING_BOXES
// Create a mesh for rendering the bounding box
// TODO: There is definitely a better way to do this. But, want to see the bounding boxes!
pModel->CreateBoundingBoxMesh();
#endif
pNode = pModel;
}
else if(0==nodeType.compare(_L("light")))
{
pNode = new CPUTLight();
((CPUTLight*)pNode)->LoadLight(pBlock, &parentIndex);
pParentNode = mppAssetList[parentIndex+1]; // +1 because we added a root node to the start
pNode->SetParent( pParentNode );
pParentNode->AddChild( pNode );
cString &parentPrefix = pParentNode->GetPrefix();
pNode->SetPrefix( parentPrefix );
pAssetLibrary->AddLight(parentPrefix + name, (CPUTLight*)pNode);
}
else if(0==nodeType.compare(_L("camera")))
{
pNode = new CPUTCamera();
((CPUTCamera*)pNode)->LoadCamera(pBlock, &parentIndex);
pParentNode = mppAssetList[parentIndex+1]; // +1 because we added a root node to the start
pNode->SetParent( pParentNode );
pParentNode->AddChild( pNode );
cString &parentPrefix = pParentNode->GetPrefix();
pNode->SetPrefix( parentPrefix );
pAssetLibrary->AddCamera(parentPrefix + name, (CPUTCamera*)pNode);
if( !mpFirstCamera ) { mpFirstCamera = (CPUTCamera*)pNode; mpFirstCamera->AddRef();}
++mCameraCount;
}
else
{
ASSERT(0,_L("Unsupported node type '") + nodeType + _L("'."));
}
// Add the node to our asset list (i.e., the linear list, not the hierarchical)
mppAssetList[ii+1] = pNode;
// Don't AddRef.Creating it set the refcount to 1. We add it to the list, and then we're done with it.
// Net effect is 0 (+1 to add to list, and -1 because we're done with it)
// pNode->AddRef();
}
#endif
HEAPCHECK
return result;
}
bool CPUTGUIElement::Load(CPUTConfigBlock* pBlock, int* pParent)
{
CPUTConfigEntry* pEntry = NULL;
pEntry = pBlock->GetValueByName(NAME);
if (pEntry->IsValid())
mName= pEntry->ValueAsString();
pEntry = pBlock->GetValueByName(PARENT);
if(pEntry->IsValid())
*pParent = pEntry->ValueAsInt();
pEntry = pBlock->GetValueByName(WIDTH);
if(pEntry->IsValid())
mWidth = pEntry->ValueAsInt();
pEntry = pBlock->GetValueByName(HEIGHT);
if(pEntry->IsValid())
mHeight = pEntry->ValueAsInt();
pEntry = pBlock->GetValueByName(POS_X);
if(pEntry->IsValid())
mRelX = pEntry->ValueAsInt();
pEntry = pBlock->GetValueByName(POS_Y);
if(pEntry->IsValid())
mRelY = pEntry->ValueAsInt();
pEntry = pBlock->GetValueByName(PARENT_RELATIVE);
if(pEntry->IsValid())
mParentRelative = pEntry->ValueAsBool();
pEntry = pBlock->GetValueByName(VISIBLE);
if(pEntry->IsValid())
mVisible = pEntry->ValueAsBool();
pEntry = pBlock->GetValueByName(FOREGROUND_COLOR);
if(pEntry->IsValid())
{
pEntry->ValueAsFloatArray((float*)&mForegroundColor, 4);
mForegroundHighlightColor = mForegroundColor;
}
pEntry = pBlock->GetValueByName(BACKGROUND_COLOR);
if(pEntry->IsValid())
{
pEntry->ValueAsFloatArray((float*)&mBackgroundColor, 4);
mBackgroundHighlightColor = mBackgroundColor;
}
pEntry = pBlock->GetValueByName(FOREGROUND_HIGHLIGHT_COLOR);
if(pEntry->IsValid())
pEntry->ValueAsFloatArray((float*)&mForegroundHighlightColor, 4);
pEntry = pBlock->GetValueByName(BACKGROUND_HIGHLIGHT_COLOR);
if(pEntry->IsValid())
pEntry->ValueAsFloatArray((float*)&mBackgroundHighlightColor, 4);
pEntry = pBlock->GetValueByName(MATERIAL);
if(pEntry->IsValid())
{
cString materialName = pEntry->ValueAsString();
mpSprite = CPUTSprite::CreateSprite(0.0, 0.0, 1.0, 1.0, materialName);
}
pEntry = pBlock->GetValueByName(TEXT_MATERIAL);
if(pEntry->IsValid())
{
cString materialName = pEntry->ValueAsString();
mpTextMaterial = CPUTAssetLibrary::GetAssetLibrary()->GetMaterial(materialName);
}
const cString FONT = _L("font");
pEntry = pBlock->GetValueByName(FONT);
if(pEntry->IsValid())
{
cString fontName;
pEntry->ValueAsString(&fontName);
mpFont = (CPUTFont*)CPUTAssetLibrary::GetAssetLibrary()->GetFontByName(fontName);
if(mpFont == NULL)
{
DEBUG_PRINT(_L("Failed to load font: %s"), fontName.c_str());
}
}
pEntry = pBlock->GetValueByName(TEXT);
cString string;
if(pEntry->IsValid())
{
pEntry->ValueAsString(&string);
SetText(string);
}
pEntry = pBlock->GetValueByName(HIGHLIGHT);
if(pEntry->IsValid())
{
mHighlighted = pEntry->ValueAsBool();
}
pEntry = pBlock->GetValueByName(MOUSE_CLICK);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mClick.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(MOUSE_UP);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mUp.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(MOUSE_DOWN);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mDown.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(MOUSE_OUT);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mOut.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(MOUSE_IN);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mIn.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(HOTKEY);
if(pEntry->IsValid())
{
cString key;
pEntry->ValueAsString(&key);
mHotkey = MapKey(key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(HOTKEY_UP);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mKeyUp.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(HOTKEY_DOWN);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mKeyDown.key);
mEventHandler = true;
}
mParentMatrix = float4x4Translation((float)mPosX, (float)mPosY, 0.0);
return true;
}