Exemplo n.º 1
0
//-----------------------------------------------------------------------------
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;
}