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), mAlphaColor(SColor(255, 255, 255, 255)), mClipRect(NULL),
  mColor(SColor(255, 255, 255, 255)), mPosition(vector2di(0, 0)),
  mSourceRect(rect<s32>(0, 0, 0, 0)), mVisible(true), mUseAlphaColor(false)
{
    // Get a pointer to sub-systems of the Game Manager.
    EventManager *pEventMgr = GameManager::Instance()->getEventManager();

    // Set misc. variables.
    mName = "ImageComponent";

    // Register events.
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onRender",
                                  this, &ImageComponent::onRender);
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onPause",
                                  this, &ImageComponent::onPause);
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onUnPause",
                                  this, &ImageComponent::onUnPause);
}

// ImageComponent constructor.
ImageComponent::ImageComponent(Entity *parent, const std::string &fileName,
                               const vector2di &position, const rect<s32> &sourceRect,
                               rect<s32> *clipRect, const SColor &color,
                               const SColor &alphaColor, bool useAlphaColor)
: EntityComponent(parent), mAlphaColor(alphaColor), mClipRect(clipRect), mColor(color),
  mPosition(position), mSourceRect(sourceRect), mVisible(true), mUseAlphaColor(useAlphaColor)
{
    // Get a pointer to sub-systems of the Game Manager.
    EventManager *pEventMgr = GameManager::Instance()->getEventManager();

    // Load the texture/
    mTexture = GameManager::Instance()->getDriver()->getTexture(fileName.c_str());

    // Set misc. variables.
    mName = "ImageComponent";

    // Register events.
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onRender",
                                  this, &ImageComponent::onRender);
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onPause",
                                  this, &ImageComponent::onPause);
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onUnPause",
                                  this, &ImageComponent::onUnPause);
}

// ImageComponent constructor.
ImageComponent::ImageComponent(Entity *parent, ITexture *texture,
                               const vector2di &position, const rect<s32> &sourceRect,
                               rect<s32> *clipRect, const SColor &color,
                               const SColor &alphaColor, bool useAlphaColor)
: EntityComponent(parent), mAlphaColor(alphaColor), mClipRect(clipRect), mColor(color),
  mPosition(position), mSourceRect(sourceRect), mVisible(true), mUseAlphaColor(useAlphaColor)
{
    // Get a pointer to sub-systems of the Game Manager.
    EventManager *pEventMgr = GameManager::Instance()->getEventManager();

    // Load the texture/
    mTexture = texture;

    // Set misc. variables.
    mName = "ImageComponent";

    // Register events.
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onRender",
                                  this, &ImageComponent::onRender);
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onPause",
                                  this, &ImageComponent::onPause);
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onUnPause",
                                  this, &ImageComponent::onUnPause);
}


// ImageComponent deconstructor.
ImageComponent::~ImageComponent()
{
}

// AngelScript: Will be used to instanciate objects of this class.
ImageComponent* ImageComponent::refFactory(Entity *parent)
{
    return new ImageComponent(parent);
}

// 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(rect<s32> *rectangle)
{
    if(mClipRect != NULL)
    {
       delete mClipRect;
       mClipRect = NULL;
    }

    if(rectangle != NULL)
      mClipRect = new rect<s32>(*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)
{
    mTexture = GameManager::Instance()->getDriver()->getTexture(fileName.c_str());

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

// Sets the texture which should be drawn.
void ImageComponent::setTexture(ITexture *texture)
{
    mTexture = texture;

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

// 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;
}


// ImageComponent Angelscript binding.
void bindImageComponent(asIScriptEngine *engine)
{
    // Forward declarations.
    int r;

    // Bind ImageComponent class.
    r = engine->RegisterObjectType("ImageComponent", sizeof(ImageComponent), asOBJ_REF); assert(r >= 0);

    // Bind inherited functions.
    bindEntityComponentBase<ImageComponent>(engine, "ImageComponent");

    // Set ImageComponent behaviour.
    r = engine->RegisterGlobalBehaviour(asBEHAVE_REF_CAST, "ImageComponent@ f(EntityComponent @)",
                                        asFUNCTION((asRefCast<EntityComponent,ImageComponent>)), asCALL_CDECL); assert( r >= 0 );
    r = engine->RegisterGlobalBehaviour(asBEHAVE_IMPLICIT_REF_CAST, "EntityComponent@ f(ImageComponent @)",
                                        asFUNCTION((asRefCast<ImageComponent,EntityComponent>)), asCALL_CDECL); assert( r >= 0 );

    r = engine->RegisterObjectBehaviour("ImageComponent", asBEHAVE_FACTORY, "ImageComponent@ f(Entity @)",
                                        asFUNCTION(ImageComponent::refFactory), asCALL_CDECL); assert(r >= 0);

    // Bind ImageComponent class functions.
    r = engine->RegisterObjectMethod("ImageComponent", "void setAlphaColor(const SColor &in)",
                                     asMETHOD(ImageComponent, setAlphaColor), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "void setClipRect(const recti &in)",
                                     asMETHOD(ImageComponent, setClipRect), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "void setColor(const SColor &in)",
                                     asMETHOD(ImageComponent, setColor), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "void setPosition(vector2di &in)",
                                     asMETHOD(ImageComponent, setPosition), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "void setSourceRect(const recti &in)",
                                     asMETHOD(ImageComponent, setSourceRect), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "void setTexture(const string&)",
                                     asMETHODPR(ImageComponent, setTexture, (const std::string&), void),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "void setUseAlphaColor(bool)",
                                     asMETHOD(ImageComponent, setUseAlphaColor), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("ImageComponent", "const SColor& getAlphaColor()",
                                     asMETHOD(ImageComponent, getAlphaColor), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "const recti& getClipRect()",
                                     asMETHOD(ImageComponent, getClipRect), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "const SColor& getColor()",
                                     asMETHOD(ImageComponent, getColor), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "const vector2di& getPosition()",
                                     asMETHOD(ImageComponent, getPosition), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "const recti& getSourceRect()",
                                     asMETHOD(ImageComponent, getSourceRect), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("ImageComponent", "bool getUseAlphaColor()",
                                     asMETHOD(ImageComponent, getUseAlphaColor), asCALL_THISCALL); assert(r >= 0);
}

// End of File

---