SO3Engine/SO3Renderer/FlashControl.h

Go to the documentation of this file.

/*
This file is part of Hikari, a library that allows developers
to use Flash in their Ogre3D applications.

Copyright (C) 2008 Adam J. Simmons

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
/*********************************************************************************************
___ ___ .__ __                 .__ 
/   |   \|__|  | _______ _______|__|
/    ~    \  |  |/ /\__  \\_  __ \  |
\    Y    /  |    <  / __ \|  | \/  |
\___|_  /|__|__|_ \(____  /__|  |__|  v0.4
\/         \/     \/          


* Zed Games PC Development Team - Jaime Crespillo Vilchez (jcrespillo@zed.com)
* Build: 0.1 - Date: 13/10/2008
* Undocked version of Hikari Lib
* Brief: Implementation of IFlashControl for Ogre Engine
**********************************************************************************************/

#ifndef __FlashControl_H__
#define __FlashControl_H__

#include "Ogre.h"
#include "IFlashControl.h"
#include "OgreViewportOverlay.h"
#include "../SCOLBasic/SO3Std.h"

class FlashControl : public Hikari::IFlashControl, public Ogre::ManualResourceLoader
{
        friend class Hikari::Impl::FlashSite;
        friend class Hikari::Impl::FlashHandler;
        friend class Hikari::HikariManager;
public:

        bool usingAlphaHack;
        bool originalDepthWritting;
        // MS : Comp with 1.7
        Ogre::SceneBlendFactor sBlend;
        Ogre::SceneBlendFactor dBlend;
        bool isFirstInside;
        bool onMaterial;
        bool isFirstOutside;
        OgreViewportOverlay* overlay;
        SViewPort * currentViewport;
        SScene* currentScene;
        size_t texWidth, texHeight, texDepth, texPitch;
        string materialName;
  string textureName;
        bool isIgnoringTransparent;
        float transThreshold;

        //these were static in update function!!! --> causing buffers crashing when you work with many FlashControls
        int lastDirtyWidth;
        int lastDirtyHeight;

        typedef std::map<std::wstring, Hikari::FlashDelegate> DelegateMap;
        typedef DelegateMap::iterator DelegateIter;
        DelegateMap delegateMap;

        TexturePtr texture;
        TexturePtr oldTex;
        int _tec;
        int _pass;
        int _unit;
        TextureUnitState* texUnit;
  bool movieLoaded;

        FlashControl(const string& name, Viewport* viewport, int width, int height, const Hikari::Position& position, unsigned short zOrder);
        FlashControl(const string& name,SScene* scene,const string& _matName, int width, int height,int techID=0,int passID=0,int unitID = 0);
        ~FlashControl();

        inline void setZOrder(unsigned short zorder){
                if(overlay)
                overlay->getOverlay()->setZOrder(zorder);
        };
        inline unsigned short getZOrder(){
                if(overlay)
                return overlay->getOverlay()->getZOrder();
                else return 0; // Cannot return -1, return value is unsigned! if we do that, we return unsigned max value, or 65535!
        };
        inline int getRelativeX(int absX){
                if(overlay)
                return overlay->getRelativeX(absX);
                else return -1;
        };
        inline int getRelativeY(int absY){
                if(overlay)
                return overlay->getRelativeY(absY);
                else return -1;
        };
        inline bool EnableMode(int mode)
        {
                if(mode > SO3_FLASH_MAX)                        return false;                                   // test if the mode is valid

                scolFlags |= mode;                                                                                              // set the mode

                return true;
        }

        inline bool DisableMode(int mode)
        {
                if(mode > SO3_FLASH_MAX)                        return false;                                   // test if the mode is valid

                scolFlags &= (0xffffffff - mode);                                                               // set the mode

                return true;
        }
        // maybe we will need for keeping the access to the HIKARI object´s model
        /*inline unsigned short getPanelZOrder(){
        return overlay->getPanel()->getZOrder();
        };*/
        void createControl();
        void createMaterial();
        bool isPointOverMe(int screenX, int screenY);
        void invalidateTotally();
        void handleKeyEvent(UINT msg, WPARAM wParam, LPARAM lParam);
        void handleFlashCall(const std::wstring& xmlString);
        void update();
        void load(const string& movieFilename, Hikari::HikariManager* hikariMgr,int type);

        void play();

        void stop();

        void rewind();

        /*JOTA*/
        //      void setAViewportOverlay(AViewportOverlay* _overlay);

        void gotoFrame(long frameNum);

        void setLoop(bool shouldLoop);

        void setTransparent(bool isTransparent, bool useAlphaHack = false);

        void setQuality(short renderQuality);

        void setScaleMode(short scaleMode);

        void setDraggable(bool isDraggable);

        void setIgnoreTransparentPixels(bool shouldIgnore, float threshold = 0.04);

        const string & getName() const;

        const string & getMaterialName() const;

        void bind(const std::wstring& funcName, const Hikari::FlashDelegate& callback);

        void unbind(const std::wstring& funcName);

        Hikari::FlashValue callFunction(const std::wstring& funcName, const Hikari::Arguments& args = Hikari::Args());

        void hide();

        void show();

        bool getVisibility() const;

        void setOpacity(float opacity);

        void focus();

        void updateZOrder();

        void move(int deltaX, int deltaY);

        void getExtents(unsigned short &width, unsigned short &height) const;

        void getUVScale(float &uScale, float &vScale) const;

        void injectMouseMove(int xPos, int yPos, int btn);

        void injectMouseDown(int xPos, int yPos, int index);

        void injectMouseUp(int xPos, int yPos, int index);

        void injectMouseWheel(int relScroll, int xPos, int yPos);

        void loadResource(Resource* resource);

        void updateTexture();
        
        void applyTexture(string matname, int techidx = 0, int passidx = 0, int unitidx = 0);

  void restoreMaterial();

  bool isLoaded();
};

#endif