| /* |
| * Project: VizKit |
| * Version: 2.3 |
| |
| * Date: 20090823 |
| * File: VisualAsset.cpp |
| * |
| */ |
| |
| /*************************************************************************** |
| |
| Copyright (c) 2004-2009 Heiko Wichmann (http://www.imagomat.de/vizkit) |
| |
| |
| This software is provided 'as-is', without any expressed or implied warranty. |
| In no event will the authors be held liable for any damages |
| arising from the use of this software. |
| |
| Permission is granted to anyone to use this software for any purpose, |
| including commercial applications, and to alter it and redistribute it |
| freely, subject to the following restrictions: |
| |
| 1. The origin of this software must not be misrepresented; |
| you must not claim that you wrote the original software. |
| If you use this software in a product, an acknowledgment |
| in the product documentation would be appreciated |
| but is not required. |
| |
| 2. Altered source versions must be plainly marked as such, |
| and must not be misrepresented as being the original software. |
| |
| 3. This notice may not be removed or altered from any source distribution. |
| |
| ***************************************************************************/ |
| |
| #include "VisualAsset.h" |
| #include "VisualItemIdentifier.h" |
| #include "VisualAnimationPackage.h" |
| #include "VisualAnimationQueue.h" |
| #include "VisualErrorHandling.h" |
| #include "VisualImage.h" |
| #include "VisualStageBox.h" |
| #include "VisualGraphics.h" |
| #include "VisualGraphicTypes.h" |
| #include "VisualVertex.h" |
| #include "VisualCamera.h" |
| |
| |
| using namespace VizKit; |
| |
| |
| VisualAsset::VisualAsset() { |
| image = NULL; |
| camera = NULL; |
| stageBox = NULL; |
| defaultVertexChainIdentifier = new VisualItemIdentifier; |
| rotationAngle = 0.0; |
| opacityValue = 1.0; |
| scaleFactor = 1.0; |
| init(); |
| } |
| |
| |
| VisualAsset::~VisualAsset() { |
| |
| VisualAnimationQueue::removeVisualAnimationsOfAsset(this); |
| |
| delete stageBox; |
| delete camera; |
| delete defaultVertexChainIdentifier; |
| if (image != NULL) { |
| delete image; |
| } |
| |
| } |
| |
| |
| VisualAsset::VisualAsset(const VisualAsset& other) : VisualObject(other) { |
| copy(other); |
| } |
| |
| |
| VisualAsset& VisualAsset::operator=(const VisualAsset& other) { |
| |
| if (this == &other) return *this; |
| |
| VisualObject::operator=(other); |
| |
| if (this->image != NULL) { |
| delete this->image; |
| } |
| delete this->stageBox; |
| delete this->camera; |
| delete this->defaultVertexChainIdentifier; |
| |
| this->copy(other); |
| |
| return *this; |
| } |
| |
| |
| bool VisualAsset::operator<(const VisualAsset& other) const { |
| return (this->VisualObject::getIdentifier() < other.VisualObject::getIdentifier()); |
| } |
| |
| |
| bool VisualAsset::operator==(const VisualAsset& other) const { |
| return (this->VisualObject::getIdentifier() == other.VisualObject::getIdentifier()); |
| } |
| |
| |
| bool VisualAsset::operator!=(const VisualAsset& other) const { |
| return !(*this == other); |
| } |
| |
| |
| VisualAsset* VisualAsset::clone(void) const { |
| return new VisualAsset(*this); |
| } |
| |
| |
| void VisualAsset::copy(const VisualAsset& other) { |
| |
| if (other.image != NULL) { |
| this->image = new VisualImage(*(other.image)); |
| } else { |
| this->image = NULL; |
| } |
| this->camera = new VisualCamera(*(other.camera)); |
| this->stageBox = new VisualStageBox(*(other.stageBox)); |
| |
| this->defaultVertexChainIdentifier = new VisualItemIdentifier(); |
| this->rotationAngle = other.rotationAngle; |
| this->opacityValue = other.opacityValue; |
| this->scaleFactor = other.scaleFactor; |
| |
| VisualAnimationQueue::copyAnimationsFromAssetToAsset(other, *this); |
| } |
| |
| |
| void VisualAsset::init() { |
| this->camera = new VisualCamera; |
| this->stageBox = new VisualStageBox(this); |
| this->setCamera(*this->camera); |
| } |
| |
| |
| VisualStageBox* VisualAsset::getBox() const { |
| return this->stageBox; |
| } |
| |
| |
| void VisualAsset::setCamera(const VisualCamera& cameraRef) { |
| *(this->camera) = cameraRef; |
| this->camera->activate(); |
| this->stageBox->setCoordDepth(cameraRef.getDepth()); |
| this->stageBox->update(); |
| } |
| |
| |
| VisualCamera& VisualAsset::getCamera(void) const { |
| return *(this->camera); |
| } |
| |
| |
| VisualStagePosition VisualAsset::getPosition() const { |
| return this->stageBox->getVisualStagePosition(); |
| } |
| |
| |
| void VisualAsset::setPosition(const VisualStagePosition& aPosition) { |
| this->stageBox->setVisualStagePosition(aPosition); |
| } |
| |
| |
| void VisualAsset::updateCoords() { |
| this->camera->activate(); |
| this->stageBox->update(); |
| } |
| |
| |
| void VisualAsset::setImage(const VisualImage& anImage) { |
| if (this->image != NULL) { |
| delete this->image; |
| this->image = NULL; |
| } |
| this->image = new VisualImage(anImage); |
| |
| this->stageBox->setContentPixelWidth(this->image->getWidth()); |
| this->stageBox->setContentPixelHeight(this->image->getHeight()); |
| |
| this->stageBox->initializeVertexChain(*(this->defaultVertexChainIdentifier)); |
| |
| VisualVertex* aVertex = NULL; |
| aVertex = this->stageBox->createVertex(0.0, 1.0, 0.0, 0.0, 1.0); |
| this->stageBox->addVertexToChain(*(this->defaultVertexChainIdentifier), aVertex); |
| |
| aVertex = this->stageBox->createVertex(0.0, 0.0, 0.0, 0.0, 0.0); |
| this->stageBox->addVertexToChain(*(this->defaultVertexChainIdentifier), aVertex); |
| |
| aVertex = this->stageBox->createVertex(1.0, 0.0, 0.0, 1.0, 0.0); |
| this->stageBox->addVertexToChain(*(this->defaultVertexChainIdentifier), aVertex); |
| |
| aVertex = this->stageBox->createVertex(1.0, 1.0, 0.0, 1.0, 1.0); |
| this->stageBox->addVertexToChain(*(this->defaultVertexChainIdentifier), aVertex); |
| } |
| |
| |
| bool VisualAsset::hasImage() const { |
| if (this->image == NULL) { |
| return false; |
| } |
| return true; |
| } |
| |
| |
| VisualImage* VisualAsset::getImage() const { |
| return this->image; |
| } |
| |
| |
| void VisualAsset::removeImage() { |
| if (this->image != NULL) { |
| delete this->image; |
| this->image = NULL; |
| this->stageBox->setContentPixelWidth(0); |
| this->stageBox->setContentPixelHeight(0); |
| } |
| } |
| |
| |
| void VisualAsset::draw(const VisualItemIdentifier& vertexChainName) const { |
| VertexChain* aVertexChain = this->stageBox->getVertexChain(vertexChainName); |
| this->doDraw(*aVertexChain); |
| } |
| |
| |
| void VisualAsset::draw() const { |
| size_t numberOfVertexChains = this->stageBox->getNumberOfVertexChains(); |
| bool defaultVertexChainFound = false; |
| for (size_t i = 0; i < numberOfVertexChains; i++) { |
| if (const_cast<VisualItemIdentifier&>(this->stageBox->getVertexChainIdentifier(i)) != *(this->defaultVertexChainIdentifier)) { |
| VertexChain* defaultVertexChain = this->stageBox->getVertexChain(i); |
| this->doDraw(*defaultVertexChain); |
| } else { |
| defaultVertexChainFound = true; |
| } |
| } |
| if (defaultVertexChainFound == true && numberOfVertexChains == 1) { |
| VertexChain* defaultVertexChain = this->stageBox->getVertexChain(*(this->defaultVertexChainIdentifier)); |
| this->doDraw(*defaultVertexChain); |
| } |
| } |
| |
| |
| void VisualAsset::doDraw(const VertexChain& aVertexChain) const { |
| this->camera->activate(); |
| this->stageBox->updateIfNeeded(); |
| VisualGraphics* theVisualGraphics = VisualGraphics::getInstance(); |
| theVisualGraphics->rotateMatrix(this->rotationAngle, 0.0, 1.0, 0.0); |
| if (this->image != NULL) { |
| this->image->draw(&aVertexChain, this->stageBox->getDebugMode()); |
| if (this->stageBox->getDebugMode() == true) { |
| theVisualGraphics->drawVertexChain(aVertexChain); |
| } |
| } else { |
| theVisualGraphics->drawVertexChain(aVertexChain); |
| } |
| |
| if (this->stageBox->getDebugMode() == true) { |
| theVisualGraphics->drawDebugVertexChain(aVertexChain, *(this->camera)); |
| this->drawBoxOutline(); |
| } |
| } |
| |
| |
| void VisualAsset::drawBoxOutline() const { |
| VertexColor yellow; |
| yellow.r = 1.0; |
| yellow.g = 1.0; |
| yellow.b = 0.0; |
| yellow.a = 1.0; |
| Coord coordPoint; |
| VisualVertex* aVertex = NULL; |
| // front |
| VertexChain* frontBoxChain = new VertexChain; |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| frontBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| frontBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| frontBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| frontBoxChain->push_back(aVertex); |
| // back |
| VertexChain* backBoxChain = new VertexChain; |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| backBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| backBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| backBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| backBoxChain->push_back(aVertex); |
| // left |
| VertexChain* leftBoxChain = new VertexChain; |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| leftBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| leftBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| leftBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| leftBoxChain->push_back(aVertex); |
| // right |
| VertexChain* rightBoxChain = new VertexChain; |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| rightBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| rightBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| rightBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| rightBoxChain->push_back(aVertex); |
| // top |
| VertexChain* topBoxChain = new VertexChain; |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| topBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| topBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| topBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getTopCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| topBoxChain->push_back(aVertex); |
| // bottom |
| VertexChain* bottomBoxChain = new VertexChain; |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| bottomBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getRightCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| bottomBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getBackPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| bottomBoxChain->push_back(aVertex); |
| coordPoint.x = this->stageBox->getLeftCoord(); |
| coordPoint.y = this->stageBox->getBottomCoord(); |
| coordPoint.z = this->stageBox->getFrontPosition(); |
| aVertex = new VisualVertex(coordPoint, yellow); |
| bottomBoxChain->push_back(aVertex); |
| |
| VisualGraphics* theVisualGraphics = VisualGraphics::getInstance(); |
| theVisualGraphics->drawVertexChain(*frontBoxChain); |
| theVisualGraphics->drawVertexChain(*backBoxChain); |
| theVisualGraphics->drawVertexChain(*leftBoxChain); |
| theVisualGraphics->drawVertexChain(*rightBoxChain); |
| theVisualGraphics->drawVertexChain(*topBoxChain); |
| theVisualGraphics->drawVertexChain(*bottomBoxChain); |
| |
| for (VertexChainIterator chainIt = frontBoxChain->begin(); chainIt != frontBoxChain->end(); chainIt++) { |
| delete *chainIt; |
| chainIt = frontBoxChain->erase(chainIt); |
| } |
| delete frontBoxChain; |
| for (VertexChainIterator chainIt = backBoxChain->begin(); chainIt != backBoxChain->end(); chainIt++) { |
| delete *chainIt; |
| chainIt = backBoxChain->erase(chainIt); |
| } |
| delete backBoxChain; |
| for (VertexChainIterator chainIt = leftBoxChain->begin(); chainIt != leftBoxChain->end(); chainIt++) { |
| delete *chainIt; |
| chainIt = leftBoxChain->erase(chainIt); |
| } |
| delete leftBoxChain; |
| for (VertexChainIterator chainIt = rightBoxChain->begin(); chainIt != rightBoxChain->end(); chainIt++) { |
| delete *chainIt; |
| chainIt = rightBoxChain->erase(chainIt); |
| } |
| delete rightBoxChain; |
| for (VertexChainIterator chainIt = topBoxChain->begin(); chainIt != topBoxChain->end(); chainIt++) { |
| delete *chainIt; |
| chainIt = topBoxChain->erase(chainIt); |
| } |
| delete topBoxChain; |
| for (VertexChainIterator chainIt = bottomBoxChain->begin(); chainIt != bottomBoxChain->end(); chainIt++) { |
| delete *chainIt; |
| chainIt = bottomBoxChain->erase(chainIt); |
| } |
| delete bottomBoxChain; |
| } |
| |
| |
| void VisualAsset::setScaleFactor(double aScaleFactor) { |
| this->scaleFactor = aScaleFactor; |
| this->stageBox->setScaleFactor(aScaleFactor); |
| } |
| |
| |
| double VisualAsset::getScaleFactor() const { |
| return this->scaleFactor; |
| } |
| |
| |
| void VisualAsset::setOpacityValue(double anOpacityValue) { |
| this->opacityValue = anOpacityValue; |
| this->stageBox->setOpacityValue(anOpacityValue); |
| } |
| |
| |
| double VisualAsset::getOpacityValue() const { |
| return this->opacityValue; |
| } |
| |
| |
| void VisualAsset::setRotationAngle(double aRotationAngle) { |
| this->rotationAngle = aRotationAngle; |
| } |
| |
| |
| double VisualAsset::getRotationAngle() const { |
| return this->rotationAngle; |
| } |
| |
| |
| void VisualAsset::setDebugMode(bool requestedDebugMode) { |
| this->stageBox->setDebugMode(requestedDebugMode); |
| } |
| |
| |
| bool VisualAsset::getDebugMode(void) { |
| return this->stageBox->getDebugMode(); |
| } |
| |
| |
| void VisualAsset::addAnimation(VisualAnimationComponent& anAnimation) { |
| anAnimation.preparePriorToAddingToAsset(*this); |
| VisualAnimationQueue::push(anAnimation, this->VisualObject::getIdentifier()); |
| } |
| |
| |
| void VisualAsset::removeAnimations(AnimatedProperty anAnimatedProperty) { |
| VisualAnimationQueue::removeVisualAnimationsWithOwnerIdentifier(this->VisualObject::getIdentifier(), anAnimatedProperty); |
| } |
| |
| |
| const VisualAnimationComponent* const VisualAsset::getAnimation(const AnimatedProperty& anAnimatedProperty) const { |
| return VisualAnimationQueue::getFirstVisualAnimation(this->VisualObject::getIdentifier(), anAnimatedProperty); |
| } |
| |
| |
| double VisualAsset::getCurrentAnimationValueOfProperty(const AnimatedProperty& anAnimatedProperty) const { |
| double currentValue = 0.0; |
| |
| switch (anAnimatedProperty) { |
| case kAnimatedSize: |
| currentValue = this->scaleFactor; |
| break; |
| case kAnimatedOpacity: |
| currentValue = this->opacityValue; |
| break; |
| case kAnimatedRotation: |
| currentValue = (this->rotationAngle / 360.0); |
| break; |
| case kUndefinedAnimatedProperty: |
| case kCustomAnimatedProperty: |
| // unknown |
| break; |
| default: |
| char errLog[256]; |
| sprintf(errLog, "unknown AnimatedProperty %d in file: %s (line: %d) [%s])", anAnimatedProperty, __FILE__, __LINE__, __FUNCTION__); |
| writeLog(errLog); |
| } |
| |
| return currentValue; |
| |
| } |
| |
| |
| void VisualAsset::updateLocation(double currPosition) { |
| VisualStagePosition position = VisualStageBox::tweenVisualStagePosition(this->startValueVisualStagePosition, this->stopValueVisualStagePosition, currPosition, *this->stageBox); |
| this->setPosition(position); |
| } |
| |
| |
| double VisualAsset::getCurrentAnimationValueForAnimatedLocation(const VisualStagePosition& startPosition, const VisualStagePosition& stopPosition) const { |
| VisualStagePosition currStagePosition = this->stageBox->getVisualStagePosition(); |
| return 0.0; |
| } |
| |
| |
| void VisualAsset::setStartValueVisualStagePosition(const VisualStagePosition& position) { |
| this->startValueVisualStagePosition = position; |
| } |
| |
| |
| void VisualAsset::setStopValueVisualStagePosition(const VisualStagePosition& position) { |
| this->stopValueVisualStagePosition = position; |
| } |
| |
| |
| void VisualAsset::animateOpacity(double currentPosition, void* userData) { |
| if (reinterpret_cast<VisualAsset*>(userData)->stageBox->getDebugMode() == true) { |
| printf("VisualAsset::animateOpacity: %f\n", currentPosition); |
| } |
| reinterpret_cast<VisualAsset*>(userData)->setOpacityValue(currentPosition); |
| } |
| |
| |
| void VisualAsset::animateRotation(double currentPosition, void* userData) { |
| double rotationAngle = currentPosition * 360.0; |
| reinterpret_cast<VisualAsset*>(userData)->setRotationAngle(rotationAngle); |
| } |
| |
| |
| void VisualAsset::animateScaleFactor(double currentPosition, void* userData) { |
| reinterpret_cast<VisualAsset*>(userData)->setScaleFactor(currentPosition); |
| } |
| |
| |
| void VisualAsset::animateLocation(double currentPosition, void* userData) { |
| reinterpret_cast<VisualAsset*>(userData)->updateLocation(currentPosition); |
| } |