components/scene/ImageComponent.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            ImageComponent.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Component wrapper for drawing 2d images.
//
// License:         Copyright (C) 2009 Michael Bartsch and Contributors
//
//                  This program is free software: you can redistribute it
//                  and/or modify it under the terms of the zlib/libpng License.
//                  See main.cpp for conditions of distribution and use.
//
// /////////////////////////////////////////////////////////////////////////////

// Include files
#include "ImageComponent.h"
#include "../../core/GameManager.h"


// ImageComponent class
// ImageComponent constructor (default)
ImageComponent::ImageComponent(Entity *parent)
: EntityComponent(parent), mTexture(NULL), mPosition(vector2di(0, 0)),
 mSourceRect(rect<s32>(0, 0, 0, 0)), mClipRect(rect<s32>(0, 0, 0, 0)),
 mColor(SColor(255, 255, 255, 255)), mAlphaColor(SColor(255, 255, 255, 255)), mVisible(true),
 mUseAlphaColor(false)
{
    init();
}

// ImageComponent constructor.
ImageComponent::ImageComponent(Entity *parent, const std::string &fileName,
                               const vector2di &position, const rect<s32> &sourceRect,
                               const rect<s32> &clipRect, const SColor &color,
                               const SColor &alphaColor, bool useAlphaColor)
: EntityComponent(parent), mPosition(position), mSourceRect(sourceRect), mClipRect(clipRect),
  mColor(color), mAlphaColor(alphaColor), mVisible(true), mUseAlphaColor(useAlphaColor)
{
    init();
    setTexture(fileName);
}

// ImageComponent constructor.
ImageComponent::ImageComponent(Entity *parent, ITexture *texture,
                               const vector2di &position, const rect<s32> &sourceRect,
                               const rect<s32> &clipRect, const SColor &color,
                               const SColor &alphaColor, bool useAlphaColor)
: EntityComponent(parent), mPosition(position), mSourceRect(sourceRect), mClipRect(clipRect),
  mColor(color), mAlphaColor(alphaColor), mVisible(true), mUseAlphaColor(useAlphaColor)
{
    init();
    setTexture(texture);
}


// ImageComponent deconstructor.
ImageComponent::~ImageComponent()
{
    if(mTexture)
      mTexture->drop();
}

// Common initialisation method.
void ImageComponent::init()
{
    // Set misc. variables.
    mName = "ImageComponent";

    // Register events.
    pParent->connectEventSignal("onRender", this, &ImageComponent::onRender);
    pParent->connectEventSignal("onPause", this, &ImageComponent::onPause);
    pParent->connectEventSignal("onUnPause", this, &ImageComponent::onUnPause);
}

// Gets the alpha color.
const SColor& ImageComponent::getAlphaColor() const
{
    return mAlphaColor;
}

// Gets the clipping rectangle.
const rect<s32>& ImageComponent::getClipRect() const
{
    return mClipRect;
}

// Gets the color with which the image is drawn.
const SColor& ImageComponent::getColor() const
{
    return mColor;
}

// Gets the upper left 2d screen position where the image will be drawn.
const vector2di& ImageComponent::getPosition() const
{
    return mPosition;
}

// Gets the source rectangle in the image
const rect<s32>& ImageComponent::getSourceRect() const
{
    return mSourceRect;
}

// Gets the texture associated with this component.
const ITexture* ImageComponent::getTexture() const
{
    return mTexture;
}

// Returns whether the alpha color is used.
bool ImageComponent::getUseAlphaColor() const
{
    return mUseAlphaColor;
}

// Sets the alpha color of the image.
void ImageComponent::setAlphaColor(const SColor &color)
{
    if(mTexture)
      GameManager::Instance()->getDriver()->makeColorKeyTexture(mTexture, color);

    mAlphaColor = color;
}

// Sets where the image is clipped to.
void ImageComponent::setClipRect(const rect<s32> &rectangle)
{
    mClipRect = rectangle;
}

// Sets the color with which the image is drawn.
void ImageComponent::setColor(const SColor &color)
{
    mColor = color;
}

// Sets the upper left 2d screen position where the image will be drawn.
void ImageComponent::setPosition(const vector2di &position)
{
    mPosition = position;
}

// Sets the source rectangle in the image
void ImageComponent::setSourceRect(const rect<s32> &rectangle)
{
    mSourceRect = rectangle;
}

// Loads a texture from the given file and sets it as the texture to be drawn.
void ImageComponent::setTexture(const std::string &fileName)
{
    // Drop reference to previous texture.
    if(mTexture)
      mTexture->drop();

    // Set up variables.
    AssetGroup *assets = pParent->getAssetGroup();
    ITexture *texture = 0;

    // Retrieve pointer to the texture.
    if(assets != NULL)
    {
        // Unsubscribe from previous asset.
        assets->disconnectEventSignal(std::string("textures/") + mTextureFileName, this);

        // Get texture.
        TextureProcessor *processor = static_cast<TextureProcessor*>
                                      (assets->getAssetProcessor("textures"));
        texture = processor->getTexture(fileName);

        if(texture)
        {
           assets->connectEventSignal(std::string("textures/") + fileName, this,
                                        &ImageComponent::onTexture);
           mTextureFileName = fileName;
        }
    }

    else
      texture = GameManager::Instance()->getDriver()->getTexture(fileName.c_str());

    // Set texture.
    mTexture = texture;

    if(mTexture)
    {
       GameManager::Instance()->getDriver()->makeColorKeyTexture(mTexture, mAlphaColor);
       mTexture->grab();
    }
}

// Sets the texture which should be drawn.
void ImageComponent::setTexture(ITexture *texture)
{
    // Drop reference to previous texture.
    if(mTexture)
      mTexture->drop();

    // Check if we need to unsubscribe from an asset group texture.
    AssetGroup *assets = pParent->getAssetGroup();

    if(assets != NULL)
    {
       assets->disconnectEventSignal(std::string("textures/") + mTextureFileName, this);
       mTextureFileName = "";
    }

    // Set texture.
    mTexture = texture;

    if(mTexture)
    {
       GameManager::Instance()->getDriver()->makeColorKeyTexture(mTexture, mAlphaColor);
       mTexture->grab();
    }
}

// Sets whether the alpha color should be used.
void ImageComponent::setUseAlphaColor(bool value)
{
    mUseAlphaColor = value;
}


// Event functions
// Updates the component if the parent is rendered.
void ImageComponent::onRender(void *p)
{
    if(mTexture && mVisible)
    {
       IVideoDriver *driver = GameManager::Instance()->getDriver();
       driver->draw2DImage(mTexture, mPosition, mSourceRect, &mClipRect, mColor, mUseAlphaColor);
    }
}

// Pauses the component if the parent is paused.
void ImageComponent::onPause(void *p)
{
    mWasVisible = mVisible;
}

// Unpauses the component if the parent is unpaused.
void ImageComponent::onUnPause(void *p)
{
    mVisible = mWasVisible;
}

// Responds to changes of the texture attached to this component.
void ImageComponent::onTexture(void *p)
{
    // Get pointer to the new texture.
    ITexture *texture = reinterpret_cast<ITexture*>(p);

    // Drop reference to previous texture.
    if(mTexture)  // Technically unneeded, but rather safe than sorry.
      mTexture->drop();

    // Set new texture.
    mTexture = texture;

    // Get reference to the new texture.
    if(mTexture)
      mTexture->grab();
}

// Parses for a ImageComponent.
bool ImageComponent::parseXML(IXMLReader *file, Entity *entity)
{
   // Forward declaration.
   ImageComponent *component = NULL;

   // Are we dealing with a ImageComponent?
   if(file->getNodeType() == io::EXN_ELEMENT)
   {
      if(stringw("ImageComponent") == file->getNodeName())
      {
          // Initialise the component.
          component = new ImageComponent(entity);
      }
   }

   if(component == NULL)
     return false;

   // Continue parsing the file.
   while(file->read())
   {
       switch(file->getNodeType())
       {
          case io::EXN_ELEMENT:

             // <alphaColor>
             if(stringw("alphaColor") == file->getNodeName())
             {
                component->setAlphaColor( SColor(file->getAttributeValueAsInt(L"a"),
                                                file->getAttributeValueAsInt(L"r"),
                                                file->getAttributeValueAsInt(L"g"),
                                                file->getAttributeValueAsInt(L"b")) );
             }

             // <clipRect>
             else if(stringw("clipRect") == file->getNodeName())
             {
                rect<s32> clipRect = rect<s32>( file->getAttributeValueAsInt(L"x1"),
                                                file->getAttributeValueAsInt(L"y1"),
                                                file->getAttributeValueAsInt(L"x2"),
                                                file->getAttributeValueAsInt(L"y2") );

                component->setClipRect(clipRect);
             }

             // <color>
             else if(stringw("color") == file->getNodeName())
             {
                component->setColor( SColor(file->getAttributeValueAsInt(L"a"),
                                            file->getAttributeValueAsInt(L"r"),
                                            file->getAttributeValueAsInt(L"g"),
                                            file->getAttributeValueAsInt(L"b")) );
             }

             // <position>
             else if(stringw("position") == file->getNodeName())
             {
                component->setPosition(vector2di(file->getAttributeValueAsInt(L"x"),
                                                 file->getAttributeValueAsInt(L"y")) );
             }

             // <sourceRect>
             else if(stringw("sourceRect") == file->getNodeName())
             {
                rect<s32> sourceRect = rect<s32>( file->getAttributeValueAsInt(L"x1"),
                                                  file->getAttributeValueAsInt(L"y1"),
                                                  file->getAttributeValueAsInt(L"x2"),
                                                  file->getAttributeValueAsInt(L"y2") );

                component->setSourceRect(sourceRect);
             }

             // <texture>
             else if(stringw("texture") == file->getNodeName())
             {
                 stringc fileName = file->getAttributeValue(L"fileName");
                 component->setTexture(fileName.c_str());
             }

             // <useAlphaColor>
             else if(stringw("useAlphaColor") == file->getNodeName())
             {
                stringc value = file->getAttributeValue(L"value");
                component->setUseAlphaColor( (value == "true") ? true : false );
             }


             break;

          case io::EXN_ELEMENT_END:

             // </ImageComponent>
             if(stringw("ImageComponent") == file->getNodeName())
               return true;

             break;

         default:

            break;
        }

   }

   // The code should never get here.
   return false;
}

// End of File

---