diff options
66 files changed, 874 insertions, 874 deletions
diff --git a/engines/sword25/fmv/movieplayer.cpp b/engines/sword25/fmv/movieplayer.cpp index ea22cfd3db..fffefde5db 100644 --- a/engines/sword25/fmv/movieplayer.cpp +++ b/engines/sword25/fmv/movieplayer.cpp @@ -39,51 +39,51 @@ namespace Sword25 { #define BS_LOG_PREFIX "MOVIEPLAYER" BS_Service *BS_OggTheora_CreateObject(BS_Kernel *pKernel) { - return new BS_MoviePlayer(pKernel); + return new MoviePlayer(pKernel); } -BS_MoviePlayer::BS_MoviePlayer(BS_Kernel *pKernel) : BS_Service(pKernel) { +MoviePlayer::MoviePlayer(BS_Kernel *pKernel) : BS_Service(pKernel) { if (!_RegisterScriptBindings()) BS_LOG_ERRORLN("Script bindings could not be registered."); else BS_LOGLN("Script bindings registered."); } -bool BS_MoviePlayer::LoadMovie(const Common::String &Filename, unsigned int Z) { +bool MoviePlayer::LoadMovie(const Common::String &Filename, unsigned int Z) { return true; } -bool BS_MoviePlayer::UnloadMovie() { +bool MoviePlayer::UnloadMovie() { return true; } -bool BS_MoviePlayer::Play() { +bool MoviePlayer::Play() { return true; } -bool BS_MoviePlayer::Pause() { +bool MoviePlayer::Pause() { return true; } -void BS_MoviePlayer::Update() { +void MoviePlayer::Update() { } -bool BS_MoviePlayer::IsMovieLoaded() { +bool MoviePlayer::IsMovieLoaded() { return true; } -bool BS_MoviePlayer::IsPaused() { +bool MoviePlayer::IsPaused() { return true; } -float BS_MoviePlayer::GetScaleFactor() { +float MoviePlayer::GetScaleFactor() { return 1.0f; } -void BS_MoviePlayer::SetScaleFactor(float ScaleFactor) { +void MoviePlayer::SetScaleFactor(float ScaleFactor) { } -double BS_MoviePlayer::GetTime() { +double MoviePlayer::GetTime() { return 1.0; } diff --git a/engines/sword25/fmv/movieplayer.h b/engines/sword25/fmv/movieplayer.h index 08d0012388..ceb7c6dad9 100644 --- a/engines/sword25/fmv/movieplayer.h +++ b/engines/sword25/fmv/movieplayer.h @@ -48,14 +48,14 @@ namespace Sword25 { // Class definitions // ----------------------------------------------------------------------------- -class BS_MoviePlayer : public BS_Service { +class MoviePlayer : public BS_Service { public: // ----------------------------------------------------------------------------- // Constructor / Destructor // ----------------------------------------------------------------------------- - BS_MoviePlayer(BS_Kernel *pKernel); - ~BS_MoviePlayer() {}; + MoviePlayer(BS_Kernel *pKernel); + ~MoviePlayer() {}; // ----------------------------------------------------------------------------- // Abstract interface must be implemented by each Movie Player diff --git a/engines/sword25/fmv/movieplayer_script.cpp b/engines/sword25/fmv/movieplayer_script.cpp index 523cc2d4f3..dcf5cd334b 100644 --- a/engines/sword25/fmv/movieplayer_script.cpp +++ b/engines/sword25/fmv/movieplayer_script.cpp @@ -46,7 +46,7 @@ namespace Sword25 { int LoadMovie(lua_State *L) { - BS_MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); + MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); BS_ASSERT(FMVPtr); lua_pushbooleancpp(L, FMVPtr->LoadMovie(luaL_checkstring(L, 1), lua_gettop(L) == 2 ? static_cast<unsigned int>(luaL_checknumber(L, 2)) : 10)); @@ -57,7 +57,7 @@ int LoadMovie(lua_State *L) { // ------------------------------------------------------------------------- int UnloadMovie(lua_State *L) { - BS_MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); + MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); BS_ASSERT(FMVPtr); lua_pushbooleancpp(L, FMVPtr->UnloadMovie()); @@ -68,7 +68,7 @@ int UnloadMovie(lua_State *L) { // ------------------------------------------------------------------------- int Play(lua_State *L) { - BS_MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); + MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); BS_ASSERT(FMVPtr); lua_pushbooleancpp(L, FMVPtr->Play()); @@ -79,7 +79,7 @@ int Play(lua_State *L) { // ------------------------------------------------------------------------- int Pause(lua_State *L) { - BS_MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); + MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); BS_ASSERT(FMVPtr); lua_pushbooleancpp(L, FMVPtr->Pause()); @@ -90,7 +90,7 @@ int Pause(lua_State *L) { // ------------------------------------------------------------------------- int Update(lua_State *L) { - BS_MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); + MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); BS_ASSERT(FMVPtr); FMVPtr->Update(); @@ -101,7 +101,7 @@ int Update(lua_State *L) { // ------------------------------------------------------------------------- int IsMovieLoaded(lua_State *L) { - BS_MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); + MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); BS_ASSERT(FMVPtr); lua_pushbooleancpp(L, FMVPtr->IsMovieLoaded()); @@ -112,7 +112,7 @@ int IsMovieLoaded(lua_State *L) { // ------------------------------------------------------------------------- int IsPaused(lua_State *L) { - BS_MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); + MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); BS_ASSERT(FMVPtr); lua_pushbooleancpp(L, FMVPtr->IsPaused()); @@ -123,7 +123,7 @@ int IsPaused(lua_State *L) { // ------------------------------------------------------------------------- int GetScaleFactor(lua_State *L) { - BS_MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); + MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); BS_ASSERT(FMVPtr); lua_pushnumber(L, FMVPtr->GetScaleFactor()); @@ -134,7 +134,7 @@ int GetScaleFactor(lua_State *L) { // ------------------------------------------------------------------------- int SetScaleFactor(lua_State *L) { - BS_MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); + MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); BS_ASSERT(FMVPtr); FMVPtr->SetScaleFactor(static_cast<float>(luaL_checknumber(L, 1))); @@ -145,7 +145,7 @@ int SetScaleFactor(lua_State *L) { // ------------------------------------------------------------------------- int GetTime(lua_State *L) { - BS_MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); + MoviePlayer *FMVPtr = BS_Kernel::GetInstance()->GetFMV(); BS_ASSERT(FMVPtr); lua_pushnumber(L, FMVPtr->GetTime()); @@ -171,7 +171,7 @@ const luaL_reg LIBRARY_FUNCTIONS[] = { { 0, 0 } }; -bool BS_MoviePlayer::_RegisterScriptBindings() { +bool MoviePlayer::_RegisterScriptBindings() { BS_Kernel *pKernel = BS_Kernel::GetInstance(); BS_ASSERT(pKernel); BS_ScriptEngine *pScript = static_cast<BS_ScriptEngine *>(pKernel->GetService("script")); diff --git a/engines/sword25/gfx/animation.cpp b/engines/sword25/gfx/animation.cpp index 5101a8b732..7c4d05da73 100644 --- a/engines/sword25/gfx/animation.cpp +++ b/engines/sword25/gfx/animation.cpp @@ -56,8 +56,8 @@ namespace Sword25 { // Konstruktion / Destruktion // -------------------------- -BS_Animation::BS_Animation(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const Common::String &FileName) : - BS_TimedRenderObject(ParentPtr, BS_RenderObject::TYPE_ANIMATION) { +Animation::Animation(RenderObjectPtr<RenderObject> ParentPtr, const Common::String &FileName) : + TimedRenderObject(ParentPtr, RenderObject::TYPE_ANIMATION) { // Das BS_RenderObject konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden. if (!m_InitSuccess) return; @@ -74,8 +74,8 @@ BS_Animation::BS_Animation(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const // ----------------------------------------------------------------------------- -BS_Animation::BS_Animation(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const BS_AnimationTemplate &Template) : - BS_TimedRenderObject(ParentPtr, BS_RenderObject::TYPE_ANIMATION) { +Animation::Animation(RenderObjectPtr<RenderObject> ParentPtr, const AnimationTemplate &Template) : + TimedRenderObject(ParentPtr, RenderObject::TYPE_ANIMATION) { // Das BS_RenderObject konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden. if (!m_InitSuccess) return; @@ -84,7 +84,7 @@ BS_Animation::BS_Animation(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const // Vom negativen Fall ausgehen. m_InitSuccess = false; - m_AnimationTemplateHandle = BS_AnimationTemplate::Create(Template); + m_AnimationTemplateHandle = AnimationTemplate::Create(Template); // Erfolg signalisieren. m_InitSuccess = true; @@ -92,8 +92,8 @@ BS_Animation::BS_Animation(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const // ----------------------------------------------------------------------------- -BS_Animation::BS_Animation(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) : - BS_TimedRenderObject(ParentPtr, BS_RenderObject::TYPE_ANIMATION, Handle) { +Animation::Animation(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) : + TimedRenderObject(ParentPtr, RenderObject::TYPE_ANIMATION, Handle) { // Das BS_RenderObject konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden. if (!m_InitSuccess) return; @@ -105,11 +105,11 @@ BS_Animation::BS_Animation(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr< // ----------------------------------------------------------------------------- -void BS_Animation::InitializeAnimationResource(const Common::String &FileName) { +void Animation::InitializeAnimationResource(const Common::String &FileName) { // Die Resource wird für die gesamte Lebensdauer des Animations-Objektes gelockt. BS_Resource *ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(FileName); if (ResourcePtr && ResourcePtr->GetType() == BS_Resource::TYPE_ANIMATION) - m_AnimationResourcePtr = static_cast<BS_AnimationResource *>(ResourcePtr); + m_AnimationResourcePtr = static_cast<AnimationResource *>(ResourcePtr); else { BS_LOG_ERRORLN("The resource \"%s\" could not be requested. The Animation can't be created.", FileName.c_str()); return; @@ -121,7 +121,7 @@ void BS_Animation::InitializeAnimationResource(const Common::String &FileName) { // ----------------------------------------------------------------------------- -void BS_Animation::InitMembers() { +void Animation::InitMembers() { m_CurrentFrame = 0; m_CurrentFrameTime = 0; m_Direction = FORWARD; @@ -139,7 +139,7 @@ void BS_Animation::InitMembers() { // ----------------------------------------------------------------------------- -BS_Animation::~BS_Animation() { +Animation::~Animation() { if (GetAnimationDescription()) { Stop(); GetAnimationDescription()->Unlock(); @@ -155,7 +155,7 @@ BS_Animation::~BS_Animation() { // Steuermethoden // ----------------------------------------------------------------------------- -void BS_Animation::Play() { +void Animation::Play() { // Wenn die Animation zuvor komplett durchgelaufen ist, wird sie wieder von Anfang abgespielt if (m_Finished) Stop(); @@ -165,14 +165,14 @@ void BS_Animation::Play() { // ----------------------------------------------------------------------------- -void BS_Animation::Pause() { +void Animation::Pause() { m_Running = false; UnlockAllFrames(); } // ----------------------------------------------------------------------------- -void BS_Animation::Stop() { +void Animation::Stop() { m_CurrentFrame = 0; m_CurrentFrameTime = 0; m_Direction = FORWARD; @@ -181,8 +181,8 @@ void BS_Animation::Stop() { // ----------------------------------------------------------------------------- -void BS_Animation::SetFrame(unsigned int Nr) { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +void Animation::SetFrame(unsigned int Nr) { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); if (Nr >= animationDescriptionPtr->GetFrameCount()) { @@ -201,8 +201,8 @@ void BS_Animation::SetFrame(unsigned int Nr) { // Rendern // ----------------------------------------------------------------------------- -bool BS_Animation::DoRender() { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +bool Animation::DoRender() { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); BS_ASSERT(m_CurrentFrame < animationDescriptionPtr->GetFrameCount()); @@ -210,23 +210,23 @@ bool BS_Animation::DoRender() { BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(m_CurrentFrame).FileName); BS_ASSERT(pResource); BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP); - BS_BitmapResource *pBitmapResource = static_cast<BS_BitmapResource *>(pResource); + BitmapResource *pBitmapResource = static_cast<BitmapResource *>(pResource); // Framebufferobjekt holen - BS_GraphicEngine *pGfx = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); + GraphicEngine *pGfx = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); BS_ASSERT(pGfx); // Bitmap zeichnen bool Result; if (IsScalingAllowed() && (m_Width != pBitmapResource->GetWidth() || m_Height != pBitmapResource->GetHeight())) { Result = pBitmapResource->Blit(m_AbsoluteX, m_AbsoluteY, - (animationDescriptionPtr->GetFrame(m_CurrentFrame).FlipV ? BS_BitmapResource::FLIP_V : 0) | - (animationDescriptionPtr->GetFrame(m_CurrentFrame).FlipH ? BS_BitmapResource::FLIP_H : 0), + (animationDescriptionPtr->GetFrame(m_CurrentFrame).FlipV ? BitmapResource::FLIP_V : 0) | + (animationDescriptionPtr->GetFrame(m_CurrentFrame).FlipH ? BitmapResource::FLIP_H : 0), 0, m_ModulationColor, m_Width, m_Height); } else { Result = pBitmapResource->Blit(m_AbsoluteX, m_AbsoluteY, - (animationDescriptionPtr->GetFrame(m_CurrentFrame).FlipV ? BS_BitmapResource::FLIP_V : 0) | - (animationDescriptionPtr->GetFrame(m_CurrentFrame).FlipH ? BS_BitmapResource::FLIP_H : 0), + (animationDescriptionPtr->GetFrame(m_CurrentFrame).FlipV ? BitmapResource::FLIP_V : 0) | + (animationDescriptionPtr->GetFrame(m_CurrentFrame).FlipH ? BitmapResource::FLIP_H : 0), 0, m_ModulationColor, -1, -1); } @@ -240,8 +240,8 @@ bool BS_Animation::DoRender() { // Frame Notifikation // ----------------------------------------------------------------------------- -void BS_Animation::FrameNotification(int TimeElapsed) { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +void Animation::FrameNotification(int TimeElapsed) { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); BS_ASSERT(TimeElapsed >= 0); @@ -341,15 +341,15 @@ void BS_Animation::FrameNotification(int TimeElapsed) { // ----------------------------------------------------------------------------- -void BS_Animation::ComputeCurrentCharacteristics() { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +void Animation::ComputeCurrentCharacteristics() { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); - const BS_AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame); + const AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame); BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName); BS_ASSERT(pResource); BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP); - BS_BitmapResource *pBitmap = static_cast<BS_BitmapResource *>(pResource); + BitmapResource *pBitmap = static_cast<BitmapResource *>(pResource); // Größe des Bitmaps auf die Animation übertragen m_Width = static_cast<int>(pBitmap->GetWidth() * m_ScaleFactorX); @@ -359,16 +359,16 @@ void BS_Animation::ComputeCurrentCharacteristics() { int PosX = m_RelX + ComputeXModifier(); int PosY = m_RelY + ComputeYModifier(); - BS_RenderObject::SetPos(PosX, PosY); + RenderObject::SetPos(PosX, PosY); pBitmap->Release(); } // ----------------------------------------------------------------------------- -bool BS_Animation::LockAllFrames() { +bool Animation::LockAllFrames() { if (!m_FramesLocked) { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); for (unsigned int i = 0; i < animationDescriptionPtr->GetFrameCount(); ++i) { if (!BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(i).FileName)) { @@ -385,9 +385,9 @@ bool BS_Animation::LockAllFrames() { // ----------------------------------------------------------------------------- -bool BS_Animation::UnlockAllFrames() { +bool Animation::UnlockAllFrames() { if (m_FramesLocked) { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); for (unsigned int i = 0; i < animationDescriptionPtr->GetFrameCount(); ++i) { BS_Resource *pResource; @@ -411,48 +411,48 @@ bool BS_Animation::UnlockAllFrames() { // Getter // ----------------------------------------------------------------------------- -BS_Animation::ANIMATION_TYPES BS_Animation::GetAnimationType() const { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +Animation::ANIMATION_TYPES Animation::GetAnimationType() const { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); return animationDescriptionPtr->GetAnimationType(); } // ----------------------------------------------------------------------------- -int BS_Animation::GetFPS() const { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +int Animation::GetFPS() const { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); return animationDescriptionPtr->GetFPS(); } // ----------------------------------------------------------------------------- -int BS_Animation::GetFrameCount() const { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +int Animation::GetFrameCount() const { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); return animationDescriptionPtr->GetFrameCount(); } // ----------------------------------------------------------------------------- -bool BS_Animation::IsScalingAllowed() const { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +bool Animation::IsScalingAllowed() const { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); return animationDescriptionPtr->IsScalingAllowed(); } // ----------------------------------------------------------------------------- -bool BS_Animation::IsAlphaAllowed() const { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +bool Animation::IsAlphaAllowed() const { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); return animationDescriptionPtr->IsAlphaAllowed(); } // ----------------------------------------------------------------------------- -bool BS_Animation::IsColorModulationAllowed() const { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +bool Animation::IsColorModulationAllowed() const { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); return animationDescriptionPtr->IsColorModulationAllowed(); } @@ -461,7 +461,7 @@ bool BS_Animation::IsColorModulationAllowed() const { // Positionieren // ----------------------------------------------------------------------------- -void BS_Animation::SetPos(int RelX, int RelY) { +void Animation::SetPos(int RelX, int RelY) { m_RelX = RelX; m_RelY = RelY; @@ -470,7 +470,7 @@ void BS_Animation::SetPos(int RelX, int RelY) { // ----------------------------------------------------------------------------- -void BS_Animation::SetX(int RelX) { +void Animation::SetX(int RelX) { m_RelX = RelX; ComputeCurrentCharacteristics(); @@ -478,7 +478,7 @@ void BS_Animation::SetX(int RelX) { // ----------------------------------------------------------------------------- -void BS_Animation::SetY(int RelY) { +void Animation::SetY(int RelY) { m_RelY = RelY; ComputeCurrentCharacteristics(); @@ -488,8 +488,8 @@ void BS_Animation::SetY(int RelY) { // Darstellungsart festlegen // ----------------------------------------------------------------------------- -void BS_Animation::SetAlpha(int Alpha) { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +void Animation::SetAlpha(int Alpha) { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); if (!animationDescriptionPtr->IsAlphaAllowed()) { BS_LOG_WARNINGLN("Tried to set alpha value on an animation that does not support alpha. Call was ignored."); @@ -505,8 +505,8 @@ void BS_Animation::SetAlpha(int Alpha) { // ----------------------------------------------------------------------------- -void BS_Animation::SetModulationColor(unsigned int ModulationColor) { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +void Animation::SetModulationColor(unsigned int ModulationColor) { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); if (!animationDescriptionPtr->IsColorModulationAllowed()) { BS_LOG_WARNINGLN("Tried to set modulation color on an animation that does not support color modulation. Call was ignored"); @@ -522,15 +522,15 @@ void BS_Animation::SetModulationColor(unsigned int ModulationColor) { // ----------------------------------------------------------------------------- -void BS_Animation::SetScaleFactor(float ScaleFactor) { +void Animation::SetScaleFactor(float ScaleFactor) { SetScaleFactorX(ScaleFactor); SetScaleFactorY(ScaleFactor); } // ----------------------------------------------------------------------------- -void BS_Animation::SetScaleFactorX(float ScaleFactorX) { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +void Animation::SetScaleFactorX(float ScaleFactorX) { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); if (!animationDescriptionPtr->IsScalingAllowed()) { BS_LOG_WARNINGLN("Tried to set x scale factor on an animation that does not support scaling. Call was ignored"); @@ -547,8 +547,8 @@ void BS_Animation::SetScaleFactorX(float ScaleFactorX) { // ----------------------------------------------------------------------------- -void BS_Animation::SetScaleFactorY(float ScaleFactorY) { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +void Animation::SetScaleFactorY(float ScaleFactorY) { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); if (!animationDescriptionPtr->IsScalingAllowed()) { BS_LOG_WARNINGLN("Tried to set y scale factor on an animation that does not support scaling. Call was ignored"); @@ -565,47 +565,47 @@ void BS_Animation::SetScaleFactorY(float ScaleFactorY) { // ----------------------------------------------------------------------------- -const Common::String &BS_Animation::GetCurrentAction() const { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +const Common::String &Animation::GetCurrentAction() const { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); return animationDescriptionPtr->GetFrame(m_CurrentFrame).Action; } // ----------------------------------------------------------------------------- -int BS_Animation::GetX() const { +int Animation::GetX() const { return m_RelX; } // ----------------------------------------------------------------------------- -int BS_Animation::GetY() const { +int Animation::GetY() const { return m_RelY; } // ----------------------------------------------------------------------------- -int BS_Animation::GetAbsoluteX() const { +int Animation::GetAbsoluteX() const { return m_AbsoluteX + (m_RelX - m_X); } // ----------------------------------------------------------------------------- -int BS_Animation::GetAbsoluteY() const { +int Animation::GetAbsoluteY() const { return m_AbsoluteY + (m_RelY - m_Y); } // ----------------------------------------------------------------------------- -int BS_Animation::ComputeXModifier() const { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +int Animation::ComputeXModifier() const { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); - const BS_AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame); + const AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame); BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName); BS_ASSERT(pResource); BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP); - BS_BitmapResource *pBitmap = static_cast<BS_BitmapResource *>(pResource); + BitmapResource *pBitmap = static_cast<BitmapResource *>(pResource); int Result = CurFrame.FlipV ? - static_cast<int>((pBitmap->GetWidth() - 1 - CurFrame.HotspotX) * m_ScaleFactorX) : - static_cast<int>(CurFrame.HotspotX * m_ScaleFactorX); @@ -617,15 +617,15 @@ int BS_Animation::ComputeXModifier() const { // ----------------------------------------------------------------------------- -int BS_Animation::ComputeYModifier() const { - BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); +int Animation::ComputeYModifier() const { + AnimationDescription *animationDescriptionPtr = GetAnimationDescription(); BS_ASSERT(animationDescriptionPtr); - const BS_AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame); + const AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame); BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName); BS_ASSERT(pResource); BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP); - BS_BitmapResource *pBitmap = static_cast<BS_BitmapResource *>(pResource); + BitmapResource *pBitmap = static_cast<BitmapResource *>(pResource); int Result = CurFrame.FlipH ? - static_cast<int>((pBitmap->GetHeight() - 1 - CurFrame.HotspotY) * m_ScaleFactorY) : - static_cast<int>(CurFrame.HotspotY * m_ScaleFactorY); @@ -637,7 +637,7 @@ int BS_Animation::ComputeYModifier() const { // ----------------------------------------------------------------------------- -void BS_Animation::RegisterActionCallback(ANIMATION_CALLBACK Callback, unsigned int Data) { +void Animation::RegisterActionCallback(ANIMATION_CALLBACK Callback, unsigned int Data) { ANIMATION_CALLBACK_DATA CD; CD.Callback = Callback; CD.Data = Data; @@ -646,7 +646,7 @@ void BS_Animation::RegisterActionCallback(ANIMATION_CALLBACK Callback, unsigned // ----------------------------------------------------------------------------- -void BS_Animation::RegisterLoopPointCallback(ANIMATION_CALLBACK Callback, unsigned int Data) { +void Animation::RegisterLoopPointCallback(ANIMATION_CALLBACK Callback, unsigned int Data) { ANIMATION_CALLBACK_DATA CD; CD.Callback = Callback; CD.Data = Data; @@ -655,7 +655,7 @@ void BS_Animation::RegisterLoopPointCallback(ANIMATION_CALLBACK Callback, unsign // ----------------------------------------------------------------------------- -void BS_Animation::RegisterDeleteCallback(ANIMATION_CALLBACK Callback, unsigned int Data) { +void Animation::RegisterDeleteCallback(ANIMATION_CALLBACK Callback, unsigned int Data) { ANIMATION_CALLBACK_DATA CD; CD.Callback = Callback; CD.Data = Data; @@ -666,7 +666,7 @@ void BS_Animation::RegisterDeleteCallback(ANIMATION_CALLBACK Callback, unsigned // Persistenz // ----------------------------------------------------------------------------- -void BS_Animation::PersistCallbackVector(BS_OutputPersistenceBlock &Writer, const Common::Array<ANIMATION_CALLBACK_DATA> & Vector) { +void Animation::PersistCallbackVector(BS_OutputPersistenceBlock &Writer, const Common::Array<ANIMATION_CALLBACK_DATA> & Vector) { // Anzahl an Callbacks persistieren. Writer.Write(Vector.size()); @@ -682,7 +682,7 @@ void BS_Animation::PersistCallbackVector(BS_OutputPersistenceBlock &Writer, cons // ----------------------------------------------------------------------------- -void BS_Animation::UnpersistCallbackVector(BS_InputPersistenceBlock &Reader, Common::Array<ANIMATION_CALLBACK_DATA> & Vector) { +void Animation::UnpersistCallbackVector(BS_InputPersistenceBlock &Reader, Common::Array<ANIMATION_CALLBACK_DATA> & Vector) { // Callbackvector leeren. Vector.resize(0); @@ -706,10 +706,10 @@ void BS_Animation::UnpersistCallbackVector(BS_InputPersistenceBlock &Reader, Com // ----------------------------------------------------------------------------- -bool BS_Animation::Persist(BS_OutputPersistenceBlock &Writer) { +bool Animation::Persist(BS_OutputPersistenceBlock &Writer) { bool Result = true; - Result &= BS_RenderObject::Persist(Writer); + Result &= RenderObject::Persist(Writer); Writer.Write(m_RelX); Writer.Write(m_RelY); @@ -742,17 +742,17 @@ bool BS_Animation::Persist(BS_OutputPersistenceBlock &Writer) { PersistCallbackVector(Writer, m_ActionCallbacks); PersistCallbackVector(Writer, m_DeleteCallbacks); - Result &= BS_RenderObject::PersistChildren(Writer); + Result &= RenderObject::PersistChildren(Writer); return Result; } // ----------------------------------------------------------------------------- -bool BS_Animation::Unpersist(BS_InputPersistenceBlock &Reader) { +bool Animation::Unpersist(BS_InputPersistenceBlock &Reader) { bool Result = true; - Result &= BS_RenderObject::Unpersist(Reader); + Result &= RenderObject::Unpersist(Reader); Reader.Read(m_RelX); Reader.Read(m_RelY); @@ -787,16 +787,16 @@ bool BS_Animation::Unpersist(BS_InputPersistenceBlock &Reader) { UnpersistCallbackVector(Reader, m_ActionCallbacks); UnpersistCallbackVector(Reader, m_DeleteCallbacks); - Result &= BS_RenderObject::UnpersistChildren(Reader); + Result &= RenderObject::UnpersistChildren(Reader); return Reader.IsGood() && Result; } // ----------------------------------------------------------------------------- -BS_AnimationDescription *BS_Animation::GetAnimationDescription() const { +AnimationDescription *Animation::GetAnimationDescription() const { if (m_AnimationResourcePtr) return m_AnimationResourcePtr; - else return BS_AnimationTemplateRegistry::GetInstance().ResolveHandle(m_AnimationTemplateHandle); + else return AnimationTemplateRegistry::GetInstance().ResolveHandle(m_AnimationTemplateHandle); } } // End of namespace Sword25 diff --git a/engines/sword25/gfx/animation.h b/engines/sword25/gfx/animation.h index 93f450dce0..978b1ae151 100644 --- a/engines/sword25/gfx/animation.h +++ b/engines/sword25/gfx/animation.h @@ -48,18 +48,18 @@ namespace Sword25 { // Forward declarations class BS_Kernel; class BS_PackageManager; -class BS_AnimationResource; -class BS_AnimationTemplate; -class BS_AnimationDescription; +class AnimationResource; +class AnimationTemplate; +class AnimationDescription; class BS_InputPersistenceBlock; -class BS_Animation : public BS_TimedRenderObject { - friend class BS_RenderObject; +class Animation : public TimedRenderObject { + friend class RenderObject; private: - BS_Animation(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const Common::String &FileName); - BS_Animation(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const BS_AnimationTemplate &Template); - BS_Animation(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle); + Animation(RenderObjectPtr<RenderObject> ParentPtr, const Common::String &FileName); + Animation(RenderObjectPtr<RenderObject> ParentPtr, const AnimationTemplate &Template); + Animation(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle); public: enum ANIMATION_TYPES { @@ -68,7 +68,7 @@ public: AT_JOJO }; - virtual ~BS_Animation(); + virtual ~Animation(); void Play(); void Pause(); @@ -179,7 +179,7 @@ private: bool m_Running; bool m_Finished; DIRECTION m_Direction; - BS_AnimationResource *m_AnimationResourcePtr; + AnimationResource *m_AnimationResourcePtr; unsigned int m_AnimationTemplateHandle; bool m_FramesLocked; @@ -223,7 +223,7 @@ private: void InitMembers(); void PersistCallbackVector(BS_OutputPersistenceBlock &Writer, const Common::Array<ANIMATION_CALLBACK_DATA> & Vector); void UnpersistCallbackVector(BS_InputPersistenceBlock &Reader, Common::Array<ANIMATION_CALLBACK_DATA> & Vector); - BS_AnimationDescription *GetAnimationDescription() const; + AnimationDescription *GetAnimationDescription() const; void InitializeAnimationResource(const Common::String &FileName); }; diff --git a/engines/sword25/gfx/animationdescription.cpp b/engines/sword25/gfx/animationdescription.cpp index f8ed9b893c..44a9d8de06 100644 --- a/engines/sword25/gfx/animationdescription.cpp +++ b/engines/sword25/gfx/animationdescription.cpp @@ -46,7 +46,7 @@ namespace Sword25 { // Persistenz // ----------------------------------------------------------------------------- -bool BS_AnimationDescription::Persist(BS_OutputPersistenceBlock &Writer) { +bool AnimationDescription::Persist(BS_OutputPersistenceBlock &Writer) { Writer.Write(static_cast<unsigned int>(m_AnimationType)); Writer.Write(m_FPS); Writer.Write(m_MillisPerFrame); @@ -59,10 +59,10 @@ bool BS_AnimationDescription::Persist(BS_OutputPersistenceBlock &Writer) { // ----------------------------------------------------------------------------- -bool BS_AnimationDescription::Unpersist(BS_InputPersistenceBlock &Reader) { +bool AnimationDescription::Unpersist(BS_InputPersistenceBlock &Reader) { unsigned int AnimationType; Reader.Read(AnimationType); - m_AnimationType = static_cast<BS_Animation::ANIMATION_TYPES>(AnimationType); + m_AnimationType = static_cast<Animation::ANIMATION_TYPES>(AnimationType); Reader.Read(m_FPS); Reader.Read(m_MillisPerFrame); Reader.Read(m_ScalingAllowed); diff --git a/engines/sword25/gfx/animationdescription.h b/engines/sword25/gfx/animationdescription.h index e4c861d4e0..3ac441a767 100644 --- a/engines/sword25/gfx/animationdescription.h +++ b/engines/sword25/gfx/animationdescription.h @@ -49,10 +49,10 @@ namespace Sword25 { // Klassendefinition // ----------------------------------------------------------------------------- -class BS_AnimationDescription : public BS_Persistable { +class AnimationDescription : public BS_Persistable { protected: - BS_AnimationDescription() : - m_AnimationType(BS_Animation::AT_LOOP), + AnimationDescription() : + m_AnimationType(Animation::AT_LOOP), m_FPS(10), m_MillisPerFrame(0), m_ScalingAllowed(true), @@ -83,7 +83,7 @@ public: // Getter Methoden // ----------------------------------------------------------------------------- - BS_Animation::ANIMATION_TYPES GetAnimationType() const { + Animation::ANIMATION_TYPES GetAnimationType() const { return m_AnimationType; } int GetFPS() const { @@ -106,7 +106,7 @@ public: virtual bool Unpersist(BS_InputPersistenceBlock &Reader); protected: - BS_Animation::ANIMATION_TYPES m_AnimationType; + Animation::ANIMATION_TYPES m_AnimationType; int m_FPS; int m_MillisPerFrame; bool m_ScalingAllowed; diff --git a/engines/sword25/gfx/animationresource.cpp b/engines/sword25/gfx/animationresource.cpp index f492daa93c..c229463dfb 100644 --- a/engines/sword25/gfx/animationresource.cpp +++ b/engines/sword25/gfx/animationresource.cpp @@ -64,7 +64,7 @@ const int MAX_FPS = 200; // Construction / Destruction // ----------------------------------------------------------------------------- -BS_AnimationResource::BS_AnimationResource(const Common::String &FileName) : +AnimationResource::AnimationResource(const Common::String &FileName) : BS_Resource(FileName, BS_Resource::TYPE_ANIMATION), m_Valid(false) { // Pointer auf den Package-Manager bekommen @@ -166,7 +166,7 @@ BS_AnimationResource::BS_AnimationResource(const Common::String &FileName) : // Dokument-Parsermethoden // ----------------------------------------------------------------------------- -bool BS_AnimationResource::ParseAnimationTag(TiXmlElement &AnimationTag, int &FPS, BS_Animation::ANIMATION_TYPES &AnimationType) { +bool AnimationResource::ParseAnimationTag(TiXmlElement &AnimationTag, int &FPS, Animation::ANIMATION_TYPES &AnimationType) { // FPS einlesen const char *FPSString; if ((FPSString = AnimationTag.Attribute("fps"))) { @@ -183,11 +183,11 @@ bool BS_AnimationResource::ParseAnimationTag(TiXmlElement &AnimationTag, int &FP const char *LoopTypeString; if ((LoopTypeString = AnimationTag.Attribute("type"))) { if (strcmp(LoopTypeString, "oneshot") == 0) - AnimationType = BS_Animation::AT_ONESHOT; + AnimationType = Animation::AT_ONESHOT; else if (strcmp(LoopTypeString, "loop") == 0) - AnimationType = BS_Animation::AT_LOOP; + AnimationType = Animation::AT_LOOP; else if (strcmp(LoopTypeString, "jojo") == 0) - AnimationType = BS_Animation::AT_JOJO; + AnimationType = Animation::AT_JOJO; else BS_LOG_WARNINGLN("Illegal type value (\"%s\") in <animation> tag in \"%s\". Assuming default (\"loop\").", LoopTypeString, GetFileName().c_str()); @@ -198,7 +198,7 @@ bool BS_AnimationResource::ParseAnimationTag(TiXmlElement &AnimationTag, int &FP // ----------------------------------------------------------------------------- -bool BS_AnimationResource::ParseFrameTag(TiXmlElement &FrameTag, Frame &Frame_, BS_PackageManager &PackageManager) { +bool AnimationResource::ParseFrameTag(TiXmlElement &FrameTag, Frame &Frame_, BS_PackageManager &PackageManager) { const char *FileString = FrameTag.Attribute("file"); if (!FileString) { BS_LOG_ERRORLN("<frame> tag without file attribute occurred in \"%s\".", GetFileName().c_str()); @@ -258,12 +258,12 @@ bool BS_AnimationResource::ParseFrameTag(TiXmlElement &FrameTag, Frame &Frame_, // ----------------------------------------------------------------------------- -BS_AnimationResource::~BS_AnimationResource() { +AnimationResource::~AnimationResource() { } // ----------------------------------------------------------------------------- -bool BS_AnimationResource::PrecacheAllFrames() const { +bool AnimationResource::PrecacheAllFrames() const { Common::Array<Frame>::const_iterator Iter = m_Frames.begin(); for (; Iter != m_Frames.end(); ++Iter) { if (!BS_Kernel::GetInstance()->GetResourceManager()->PrecacheResource((*Iter).FileName)) { @@ -277,7 +277,7 @@ bool BS_AnimationResource::PrecacheAllFrames() const { // ----------------------------------------------------------------------------- -bool BS_AnimationResource::ComputeFeatures() { +bool AnimationResource::ComputeFeatures() { BS_ASSERT(m_Frames.size()); // Alle Features werden als vorhanden angenommen @@ -288,8 +288,8 @@ bool BS_AnimationResource::ComputeFeatures() { // Alle Frame durchgehen und alle Features deaktivieren, die auch nur von einem Frame nicht unterstützt werden. Common::Array<Frame>::const_iterator Iter = m_Frames.begin(); for (; Iter != m_Frames.end(); ++Iter) { - BS_BitmapResource *pBitmap; - if (!(pBitmap = static_cast<BS_BitmapResource *>(BS_Kernel::GetInstance()->GetResourceManager()->RequestResource((*Iter).FileName)))) { + BitmapResource *pBitmap; + if (!(pBitmap = static_cast<BitmapResource *>(BS_Kernel::GetInstance()->GetResourceManager()->RequestResource((*Iter).FileName)))) { BS_LOG_ERRORLN("Could not request \"%s\".", (*Iter).FileName.c_str()); return false; } diff --git a/engines/sword25/gfx/animationresource.h b/engines/sword25/gfx/animationresource.h index f67963e6f8..532aaa51ae 100644 --- a/engines/sword25/gfx/animationresource.h +++ b/engines/sword25/gfx/animationresource.h @@ -63,10 +63,10 @@ class BS_PackageManager; // Class Definition // ----------------------------------------------------------------------------- -class BS_AnimationResource : public BS_Resource, public BS_AnimationDescription { +class AnimationResource : public BS_Resource, public AnimationDescription { public: - BS_AnimationResource(const Common::String &FileName); - virtual ~BS_AnimationResource(); + AnimationResource(const Common::String &FileName); + virtual ~AnimationResource(); virtual const Frame &GetFrame(unsigned int Index) const { BS_ASSERT(Index < m_Frames.size()); @@ -79,7 +79,7 @@ public: Release(); } - BS_Animation::ANIMATION_TYPES GetAnimationType() const { + Animation::ANIMATION_TYPES GetAnimationType() const { return m_AnimationType; } int GetFPS() const { @@ -109,7 +109,7 @@ private: //@{ /** @name Dokument-Parser Methoden */ - bool ParseAnimationTag(TiXmlElement &AnimationTag, int &FPS, BS_Animation::ANIMATION_TYPES &AnimationType); + bool ParseAnimationTag(TiXmlElement &AnimationTag, int &FPS, Animation::ANIMATION_TYPES &AnimationType); bool ParseFrameTag(TiXmlElement &FrameTag, Frame &Frame, BS_PackageManager &PackageManager); //@} diff --git a/engines/sword25/gfx/animationtemplate.cpp b/engines/sword25/gfx/animationtemplate.cpp index dede871ece..c573d06b1e 100644 --- a/engines/sword25/gfx/animationtemplate.cpp +++ b/engines/sword25/gfx/animationtemplate.cpp @@ -53,11 +53,11 @@ namespace Sword25 { // Konstruktion / Destruktion // ----------------------------------------------------------------------------- -unsigned int BS_AnimationTemplate::Create(const Common::String &SourceAnimation) { - BS_AnimationTemplate *AnimationTemplatePtr = new BS_AnimationTemplate(SourceAnimation); +unsigned int AnimationTemplate::Create(const Common::String &SourceAnimation) { + AnimationTemplate *AnimationTemplatePtr = new AnimationTemplate(SourceAnimation); if (AnimationTemplatePtr->IsValid()) { - return BS_AnimationTemplateRegistry::GetInstance().ResolvePtr(AnimationTemplatePtr); + return AnimationTemplateRegistry::GetInstance().ResolvePtr(AnimationTemplatePtr); } else { delete AnimationTemplatePtr; return 0; @@ -66,11 +66,11 @@ unsigned int BS_AnimationTemplate::Create(const Common::String &SourceAnimation) // ----------------------------------------------------------------------------- -unsigned int BS_AnimationTemplate::Create(const BS_AnimationTemplate &Other) { - BS_AnimationTemplate *AnimationTemplatePtr = new BS_AnimationTemplate(Other); +unsigned int AnimationTemplate::Create(const AnimationTemplate &Other) { + AnimationTemplate *AnimationTemplatePtr = new AnimationTemplate(Other); if (AnimationTemplatePtr->IsValid()) { - return BS_AnimationTemplateRegistry::GetInstance().ResolvePtr(AnimationTemplatePtr); + return AnimationTemplateRegistry::GetInstance().ResolvePtr(AnimationTemplatePtr); } else { delete AnimationTemplatePtr; return 0; @@ -79,11 +79,11 @@ unsigned int BS_AnimationTemplate::Create(const BS_AnimationTemplate &Other) { // ----------------------------------------------------------------------------- -unsigned int BS_AnimationTemplate::Create(BS_InputPersistenceBlock &Reader, unsigned int Handle) { - BS_AnimationTemplate *AnimationTemplatePtr = new BS_AnimationTemplate(Reader, Handle); +unsigned int AnimationTemplate::Create(BS_InputPersistenceBlock &Reader, unsigned int Handle) { + AnimationTemplate *AnimationTemplatePtr = new AnimationTemplate(Reader, Handle); if (AnimationTemplatePtr->IsValid()) { - return BS_AnimationTemplateRegistry::GetInstance().ResolvePtr(AnimationTemplatePtr); + return AnimationTemplateRegistry::GetInstance().ResolvePtr(AnimationTemplatePtr); } else { delete AnimationTemplatePtr; return 0; @@ -92,9 +92,9 @@ unsigned int BS_AnimationTemplate::Create(BS_InputPersistenceBlock &Reader, unsi // ----------------------------------------------------------------------------- -BS_AnimationTemplate::BS_AnimationTemplate(const Common::String &SourceAnimation) { +AnimationTemplate::AnimationTemplate(const Common::String &SourceAnimation) { // Objekt registrieren. - BS_AnimationTemplateRegistry::GetInstance().RegisterObject(this); + AnimationTemplateRegistry::GetInstance().RegisterObject(this); m_Valid = false; @@ -107,9 +107,9 @@ BS_AnimationTemplate::BS_AnimationTemplate(const Common::String &SourceAnimation // ----------------------------------------------------------------------------- -BS_AnimationTemplate::BS_AnimationTemplate(const BS_AnimationTemplate &Other) { +AnimationTemplate::AnimationTemplate(const AnimationTemplate &Other) { // Objekt registrieren. - BS_AnimationTemplateRegistry::GetInstance().RegisterObject(this); + AnimationTemplateRegistry::GetInstance().RegisterObject(this); m_Valid = false; @@ -133,9 +133,9 @@ BS_AnimationTemplate::BS_AnimationTemplate(const BS_AnimationTemplate &Other) { // ----------------------------------------------------------------------------- -BS_AnimationTemplate::BS_AnimationTemplate(BS_InputPersistenceBlock &Reader, unsigned int Handle) { +AnimationTemplate::AnimationTemplate(BS_InputPersistenceBlock &Reader, unsigned int Handle) { // Objekt registrieren. - BS_AnimationTemplateRegistry::GetInstance().RegisterObject(this, Handle); + AnimationTemplateRegistry::GetInstance().RegisterObject(this, Handle); // Objekt laden. m_Valid = Unpersist(Reader); @@ -143,31 +143,31 @@ BS_AnimationTemplate::BS_AnimationTemplate(BS_InputPersistenceBlock &Reader, uns // ----------------------------------------------------------------------------- -BS_AnimationResource *BS_AnimationTemplate::RequestSourceAnimation(const Common::String &SourceAnimation) const { +AnimationResource *AnimationTemplate::RequestSourceAnimation(const Common::String &SourceAnimation) const { BS_ResourceManager *RMPtr = BS_Kernel::GetInstance()->GetResourceManager(); BS_Resource *ResourcePtr; if (NULL == (ResourcePtr = RMPtr->RequestResource(SourceAnimation)) || ResourcePtr->GetType() != BS_Resource::TYPE_ANIMATION) { BS_LOG_ERRORLN("The resource \"%s\" could not be requested or is has an invalid type. The animation template can't be created.", SourceAnimation.c_str()); return 0; } - return static_cast<BS_AnimationResource *>(ResourcePtr); + return static_cast<AnimationResource *>(ResourcePtr); } // ----------------------------------------------------------------------------- -BS_AnimationTemplate::~BS_AnimationTemplate() { +AnimationTemplate::~AnimationTemplate() { // Animations-Resource freigeben if (m_SourceAnimationPtr) { m_SourceAnimationPtr->Release(); } // Objekt deregistrieren - BS_AnimationTemplateRegistry::GetInstance().DeregisterObject(this); + AnimationTemplateRegistry::GetInstance().DeregisterObject(this); } // ----------------------------------------------------------------------------- -void BS_AnimationTemplate::AddFrame(int Index) { +void AnimationTemplate::AddFrame(int Index) { if (ValidateSourceIndex(Index)) { m_Frames.push_back(m_SourceAnimationPtr->GetFrame(Index)); } @@ -175,7 +175,7 @@ void BS_AnimationTemplate::AddFrame(int Index) { // ----------------------------------------------------------------------------- -void BS_AnimationTemplate::SetFrame(int DestIndex, int SrcIndex) { +void AnimationTemplate::SetFrame(int DestIndex, int SrcIndex) { if (ValidateDestIndex(DestIndex) && ValidateSourceIndex(SrcIndex)) { m_Frames[DestIndex] = m_SourceAnimationPtr->GetFrame(SrcIndex); } @@ -183,7 +183,7 @@ void BS_AnimationTemplate::SetFrame(int DestIndex, int SrcIndex) { // ----------------------------------------------------------------------------- -bool BS_AnimationTemplate::ValidateSourceIndex(unsigned int Index) const { +bool AnimationTemplate::ValidateSourceIndex(unsigned int Index) const { if (Index > m_SourceAnimationPtr->GetFrameCount()) { BS_LOG_WARNINGLN("Tried to insert a frame (\"%d\") that does not exist in the source animation (\"%s\"). Ignoring call.", Index, m_SourceAnimationPtr->GetFileName().c_str()); @@ -194,7 +194,7 @@ bool BS_AnimationTemplate::ValidateSourceIndex(unsigned int Index) const { // ----------------------------------------------------------------------------- -bool BS_AnimationTemplate::ValidateDestIndex(unsigned int Index) const { +bool AnimationTemplate::ValidateDestIndex(unsigned int Index) const { if (Index > m_Frames.size()) { BS_LOG_WARNINGLN("Tried to change a nonexistent frame (\"%d\") in a template animation. Ignoring call.", Index); @@ -205,18 +205,18 @@ bool BS_AnimationTemplate::ValidateDestIndex(unsigned int Index) const { // ----------------------------------------------------------------------------- -void BS_AnimationTemplate::SetFPS(int FPS) { +void AnimationTemplate::SetFPS(int FPS) { m_FPS = FPS; m_MillisPerFrame = 1000000 / m_FPS; } // ----------------------------------------------------------------------------- -bool BS_AnimationTemplate::Persist(BS_OutputPersistenceBlock &Writer) { +bool AnimationTemplate::Persist(BS_OutputPersistenceBlock &Writer) { bool Result = true; // Parent persistieren. - Result &= BS_AnimationDescription::Persist(Writer); + Result &= AnimationDescription::Persist(Writer); // Frameanzahl schreiben. Writer.Write(m_Frames.size()); @@ -242,11 +242,11 @@ bool BS_AnimationTemplate::Persist(BS_OutputPersistenceBlock &Writer) { // ----------------------------------------------------------------------------- -bool BS_AnimationTemplate::Unpersist(BS_InputPersistenceBlock &Reader) { +bool AnimationTemplate::Unpersist(BS_InputPersistenceBlock &Reader) { bool Result = true; // Parent wieder herstellen. - Result &= BS_AnimationDescription::Unpersist(Reader); + Result &= AnimationDescription::Unpersist(Reader); // Frameanzahl lesen. unsigned int FrameCount; diff --git a/engines/sword25/gfx/animationtemplate.h b/engines/sword25/gfx/animationtemplate.h index df94547411..63e09bc20a 100644 --- a/engines/sword25/gfx/animationtemplate.h +++ b/engines/sword25/gfx/animationtemplate.h @@ -53,26 +53,26 @@ namespace Sword25 { // Forward declarations // ----------------------------------------------------------------------------- -class BS_AnimationResource; +class AnimationResource; // ----------------------------------------------------------------------------- // Klassendefinition // ----------------------------------------------------------------------------- -class BS_AnimationTemplate : public BS_AnimationDescription { +class AnimationTemplate : public AnimationDescription { public: static unsigned int Create(const Common::String &SourceAnimation); - static unsigned int Create(const BS_AnimationTemplate &Other); + static unsigned int Create(const AnimationTemplate &Other); static unsigned int Create(BS_InputPersistenceBlock &Reader, unsigned int Handle); - BS_AnimationTemplate *ResolveHandle(unsigned int Handle) const; + AnimationTemplate *ResolveHandle(unsigned int Handle) const; private: - BS_AnimationTemplate(const Common::String &SourceAnimation); - BS_AnimationTemplate(const BS_AnimationTemplate &Other); - BS_AnimationTemplate(BS_InputPersistenceBlock &Reader, unsigned int Handle); + AnimationTemplate(const Common::String &SourceAnimation); + AnimationTemplate(const AnimationTemplate &Other); + AnimationTemplate(BS_InputPersistenceBlock &Reader, unsigned int Handle); public: - ~BS_AnimationTemplate(); + ~AnimationTemplate(); virtual const Frame &GetFrame(unsigned int Index) const { BS_ASSERT(Index < m_Frames.size()); @@ -109,7 +109,7 @@ public: @brief Setzt den Animationstyp. @param Type der Typ der Animation. Muss aus den enum BS_Animation::ANIMATION_TYPES sein. */ - void SetAnimationType(BS_Animation::ANIMATION_TYPES Type) { + void SetAnimationType(Animation::ANIMATION_TYPES Type) { m_AnimationType = Type; } @@ -124,10 +124,10 @@ public: private: Common::Array<Frame> m_Frames; - BS_AnimationResource *m_SourceAnimationPtr; + AnimationResource *m_SourceAnimationPtr; bool m_Valid; - BS_AnimationResource *RequestSourceAnimation(const Common::String &SourceAnimation) const; + AnimationResource *RequestSourceAnimation(const Common::String &SourceAnimation) const; bool ValidateSourceIndex(unsigned int Index) const; bool ValidateDestIndex(unsigned int Index) const; }; diff --git a/engines/sword25/gfx/animationtemplateregistry.cpp b/engines/sword25/gfx/animationtemplateregistry.cpp index be55381500..d15a1947e8 100644 --- a/engines/sword25/gfx/animationtemplateregistry.cpp +++ b/engines/sword25/gfx/animationtemplateregistry.cpp @@ -53,23 +53,23 @@ namespace Sword25 { // Implementation // ----------------------------------------------------------------------------- -std::auto_ptr<BS_AnimationTemplateRegistry> BS_AnimationTemplateRegistry::m_InstancePtr; +std::auto_ptr<AnimationTemplateRegistry> AnimationTemplateRegistry::m_InstancePtr; // ----------------------------------------------------------------------------- -void BS_AnimationTemplateRegistry::LogErrorLn(const char *Message) const { +void AnimationTemplateRegistry::LogErrorLn(const char *Message) const { BS_LOG_ERRORLN(Message); } // ----------------------------------------------------------------------------- -void BS_AnimationTemplateRegistry::LogWarningLn(const char *Message) const { +void AnimationTemplateRegistry::LogWarningLn(const char *Message) const { BS_LOG_WARNINGLN(Message); } // ----------------------------------------------------------------------------- -bool BS_AnimationTemplateRegistry::Persist(BS_OutputPersistenceBlock &Writer) { +bool AnimationTemplateRegistry::Persist(BS_OutputPersistenceBlock &Writer) { bool Result = true; // Das nächste zu vergebene Handle schreiben. @@ -95,7 +95,7 @@ bool BS_AnimationTemplateRegistry::Persist(BS_OutputPersistenceBlock &Writer) { // ----------------------------------------------------------------------------- -bool BS_AnimationTemplateRegistry::Unpersist(BS_InputPersistenceBlock &Reader) { +bool AnimationTemplateRegistry::Unpersist(BS_InputPersistenceBlock &Reader) { bool Result = true; // Das nächste zu vergebene Handle wieder herstellen. @@ -116,7 +116,7 @@ bool BS_AnimationTemplateRegistry::Unpersist(BS_InputPersistenceBlock &Reader) { Reader.Read(Handle); // BS_AnimationTemplate wieder herstellen. - Result &= (BS_AnimationTemplate::Create(Reader, Handle) != 0); + Result &= (AnimationTemplate::Create(Reader, Handle) != 0); } return Reader.IsGood() && Result; diff --git a/engines/sword25/gfx/animationtemplateregistry.h b/engines/sword25/gfx/animationtemplateregistry.h index 8769e457f3..b5947a8841 100644 --- a/engines/sword25/gfx/animationtemplateregistry.h +++ b/engines/sword25/gfx/animationtemplateregistry.h @@ -53,16 +53,16 @@ namespace Sword25 { // Forward Deklarationen // ----------------------------------------------------------------------------- -class BS_AnimationTemplate; +class AnimationTemplate; // ----------------------------------------------------------------------------- // Klassendeklaration // ----------------------------------------------------------------------------- -class BS_AnimationTemplateRegistry : public BS_ObjectRegistry<BS_AnimationTemplate>, public BS_Persistable { +class AnimationTemplateRegistry : public BS_ObjectRegistry<AnimationTemplate>, public BS_Persistable { public: - static BS_AnimationTemplateRegistry &GetInstance() { - if (!m_InstancePtr.get()) m_InstancePtr.reset(new BS_AnimationTemplateRegistry); + static AnimationTemplateRegistry &GetInstance() { + if (!m_InstancePtr.get()) m_InstancePtr.reset(new AnimationTemplateRegistry); return *m_InstancePtr.get(); } @@ -73,7 +73,7 @@ private: virtual void LogErrorLn(const char *Message) const; virtual void LogWarningLn(const char *Message) const; - static std::auto_ptr<BS_AnimationTemplateRegistry> m_InstancePtr; + static std::auto_ptr<AnimationTemplateRegistry> m_InstancePtr; }; } // End of namespace Sword25 diff --git a/engines/sword25/gfx/bitmap.cpp b/engines/sword25/gfx/bitmap.cpp index 534e28d78e..d5354d534d 100644 --- a/engines/sword25/gfx/bitmap.cpp +++ b/engines/sword25/gfx/bitmap.cpp @@ -52,8 +52,8 @@ namespace Sword25 { // Konstruktion / Destruktion // ----------------------------------------------------------------------------- -BS_Bitmap::BS_Bitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, TYPES Type, unsigned int Handle) : - BS_RenderObject(ParentPtr, Type, Handle), +Bitmap::Bitmap(RenderObjectPtr<RenderObject> ParentPtr, TYPES Type, unsigned int Handle) : + RenderObject(ParentPtr, Type, Handle), m_ModulationColor(0xffffffff), m_ScaleFactorX(1.0f), m_ScaleFactorY(1.0f), @@ -63,14 +63,14 @@ BS_Bitmap::BS_Bitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, TYPES Type, // ----------------------------------------------------------------------------- -BS_Bitmap::~BS_Bitmap() { +Bitmap::~Bitmap() { } // ----------------------------------------------------------------------------- // Darstellungsart festlegen // ----------------------------------------------------------------------------- -void BS_Bitmap::SetAlpha(int Alpha) { +void Bitmap::SetAlpha(int Alpha) { if (!IsAlphaAllowed()) { BS_LOG_WARNINGLN("Tried to set alpha value on a bitmap that does not support alpha blending. Call was ignored."); return; @@ -94,7 +94,7 @@ void BS_Bitmap::SetAlpha(int Alpha) { // ----------------------------------------------------------------------------- -void BS_Bitmap::SetModulationColor(unsigned int ModulationColor) { +void Bitmap::SetModulationColor(unsigned int ModulationColor) { if (!IsColorModulationAllowed()) { BS_LOG_WARNINGLN("Tried to set modulation color of a bitmap that does not support color modulation. Call was ignored."); return; @@ -109,14 +109,14 @@ void BS_Bitmap::SetModulationColor(unsigned int ModulationColor) { // ----------------------------------------------------------------------------- -void BS_Bitmap::SetScaleFactor(float ScaleFactor) { +void Bitmap::SetScaleFactor(float ScaleFactor) { SetScaleFactorX(ScaleFactor); SetScaleFactorY(ScaleFactor); } // ----------------------------------------------------------------------------- -void BS_Bitmap::SetScaleFactorX(float ScaleFactorX) { +void Bitmap::SetScaleFactorX(float ScaleFactorX) { if (!IsScalingAllowed()) { BS_LOG_WARNINGLN("Tried to set scale factor of a bitmap that does not support scaling. Call was ignored."); return; @@ -137,7 +137,7 @@ void BS_Bitmap::SetScaleFactorX(float ScaleFactorX) { // ----------------------------------------------------------------------------- -void BS_Bitmap::SetScaleFactorY(float ScaleFactorY) { +void Bitmap::SetScaleFactorY(float ScaleFactorY) { if (!IsScalingAllowed()) { BS_LOG_WARNINGLN("Tried to set scale factor of a bitmap that does not support scaling. Call was ignored."); return; @@ -158,14 +158,14 @@ void BS_Bitmap::SetScaleFactorY(float ScaleFactorY) { // ----------------------------------------------------------------------------- -void BS_Bitmap::SetFlipH(bool FlipH) { +void Bitmap::SetFlipH(bool FlipH) { m_FlipH = FlipH; ForceRefresh(); } // ----------------------------------------------------------------------------- -void BS_Bitmap::SetFlipV(bool FlipV) { +void Bitmap::SetFlipV(bool FlipV) { m_FlipV = FlipV; ForceRefresh(); } @@ -174,10 +174,10 @@ void BS_Bitmap::SetFlipV(bool FlipV) { // Persistenz // ----------------------------------------------------------------------------- -bool BS_Bitmap::Persist(BS_OutputPersistenceBlock &Writer) { +bool Bitmap::Persist(BS_OutputPersistenceBlock &Writer) { bool Result = true; - Result &= BS_RenderObject::Persist(Writer); + Result &= RenderObject::Persist(Writer); Writer.Write(m_FlipH); Writer.Write(m_FlipV); Writer.Write(m_ScaleFactorX); @@ -191,10 +191,10 @@ bool BS_Bitmap::Persist(BS_OutputPersistenceBlock &Writer) { // ----------------------------------------------------------------------------- -bool BS_Bitmap::Unpersist(BS_InputPersistenceBlock &Reader) { +bool Bitmap::Unpersist(BS_InputPersistenceBlock &Reader) { bool Result = true; - Result &= BS_RenderObject::Unpersist(Reader); + Result &= RenderObject::Unpersist(Reader); Reader.Read(m_FlipH); Reader.Read(m_FlipV); Reader.Read(m_ScaleFactorX); diff --git a/engines/sword25/gfx/bitmap.h b/engines/sword25/gfx/bitmap.h index a6c451d674..01d1b288da 100644 --- a/engines/sword25/gfx/bitmap.h +++ b/engines/sword25/gfx/bitmap.h @@ -48,13 +48,13 @@ namespace Sword25 { // Klassendeklaration // ----------------------------------------------------------------------------- -class BS_Bitmap : public BS_RenderObject { +class Bitmap : public RenderObject { protected: - BS_Bitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, TYPES Type, unsigned int Handle = 0); + Bitmap(RenderObjectPtr<RenderObject> ParentPtr, TYPES Type, unsigned int Handle = 0); public: - virtual ~BS_Bitmap(); + virtual ~Bitmap(); /** @brief Setzt den Alphawert des Bitmaps. diff --git a/engines/sword25/gfx/bitmapresource.cpp b/engines/sword25/gfx/bitmapresource.cpp index 4a8c96880d..4470cccb9f 100644 --- a/engines/sword25/gfx/bitmapresource.cpp +++ b/engines/sword25/gfx/bitmapresource.cpp @@ -47,20 +47,20 @@ namespace Sword25 { // Konstruktion / Destruktion // -------------------------- -BS_BitmapResource::BS_BitmapResource(const Common::String &Filename, BS_Image *pImage) : +BitmapResource::BitmapResource(const Common::String &Filename, Image *pImage) : m_Valid(false), m_pImage(pImage), BS_Resource(Filename, BS_Resource::TYPE_BITMAP) { m_Valid = m_pImage != 0; } -BS_BitmapResource::~BS_BitmapResource() { +BitmapResource::~BitmapResource() { delete m_pImage; } // ----------------------------------------------------------------------------- -unsigned int BS_BitmapResource::GetPixel(int X, int Y) const { +unsigned int BitmapResource::GetPixel(int X, int Y) const { BS_ASSERT(X >= 0 && X < m_pImage->GetWidth()); BS_ASSERT(Y >= 0 && Y < m_pImage->GetHeight()); diff --git a/engines/sword25/gfx/bitmapresource.h b/engines/sword25/gfx/bitmapresource.h index 112ee379cd..75bdf161f5 100644 --- a/engines/sword25/gfx/bitmapresource.h +++ b/engines/sword25/gfx/bitmapresource.h @@ -48,7 +48,7 @@ namespace Sword25 { class BS_Rect; -class BS_BitmapResource : public BS_Resource { +class BitmapResource : public BS_Resource { public: /** @brief Die möglichen Flippingparameter für die Blit-Methode. @@ -66,8 +66,8 @@ public: FLIP_VH = FLIP_H | FLIP_V }; - BS_BitmapResource(const Common::String &Filename, BS_Image *pImage); - virtual ~BS_BitmapResource(); + BitmapResource(const Common::String &Filename, Image *pImage); + virtual ~BitmapResource(); /** @brief Gibt zurück, ob das Objekt einen gültigen Zustand hat. @@ -210,7 +210,7 @@ public: } private: - BS_Image *m_pImage; + Image *m_pImage; bool m_Valid; }; diff --git a/engines/sword25/gfx/dynamicbitmap.cpp b/engines/sword25/gfx/dynamicbitmap.cpp index c042f5b88d..c0d307bca4 100644 --- a/engines/sword25/gfx/dynamicbitmap.cpp +++ b/engines/sword25/gfx/dynamicbitmap.cpp @@ -55,8 +55,8 @@ namespace Sword25 { // Konstruktion / Destruktion // ----------------------------------------------------------------------------- -BS_DynamicBitmap::BS_DynamicBitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Width, unsigned int Height) : - BS_Bitmap(ParentPtr, TYPE_DYNAMICBITMAP) { +DynamicBitmap::DynamicBitmap(RenderObjectPtr<RenderObject> ParentPtr, unsigned int Width, unsigned int Height) : + Bitmap(ParentPtr, TYPE_DYNAMICBITMAP) { // Das BS_Bitmap konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden. if (!m_InitSuccess) return; @@ -65,17 +65,17 @@ BS_DynamicBitmap::BS_DynamicBitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr // ----------------------------------------------------------------------------- -BS_DynamicBitmap::BS_DynamicBitmap(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) : - BS_Bitmap(ParentPtr, TYPE_DYNAMICBITMAP, Handle) { +DynamicBitmap::DynamicBitmap(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) : + Bitmap(ParentPtr, TYPE_DYNAMICBITMAP, Handle) { m_InitSuccess = Unpersist(Reader); } // ----------------------------------------------------------------------------- -bool BS_DynamicBitmap::CreateGLImage(unsigned int Width, unsigned int Height) { +bool DynamicBitmap::CreateGLImage(unsigned int Width, unsigned int Height) { // GLImage mit den gewünschten Maßen erstellen bool Result; - m_Image.reset(new BS_GLImage(Width, Height, Result)); + m_Image.reset(new GLImage(Width, Height, Result)); m_OriginalWidth = m_Width = Width; m_OriginalHeight = m_Height = Height; @@ -85,12 +85,12 @@ bool BS_DynamicBitmap::CreateGLImage(unsigned int Width, unsigned int Height) { // ----------------------------------------------------------------------------- -BS_DynamicBitmap::~BS_DynamicBitmap() { +DynamicBitmap::~DynamicBitmap() { } // ----------------------------------------------------------------------------- -unsigned int BS_DynamicBitmap::GetPixel(int X, int Y) const { +unsigned int DynamicBitmap::GetPixel(int X, int Y) const { BS_ASSERT(X >= 0 && X < m_Width); BS_ASSERT(Y >= 0 && Y < m_Height); @@ -99,22 +99,22 @@ unsigned int BS_DynamicBitmap::GetPixel(int X, int Y) const { // ----------------------------------------------------------------------------- -bool BS_DynamicBitmap::DoRender() { +bool DynamicBitmap::DoRender() { // Framebufferobjekt holen - BS_GraphicEngine *pGfx = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); + GraphicEngine *pGfx = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); BS_ASSERT(pGfx); // Bitmap zeichnen bool Result; if (m_ScaleFactorX == 1.0f && m_ScaleFactorY == 1.0f) { Result = m_Image->Blit(m_AbsoluteX, m_AbsoluteY, - (m_FlipV ? BS_BitmapResource::FLIP_V : 0) | - (m_FlipH ? BS_BitmapResource::FLIP_H : 0), + (m_FlipV ? BitmapResource::FLIP_V : 0) | + (m_FlipH ? BitmapResource::FLIP_H : 0), 0, m_ModulationColor, -1, -1); } else { Result = m_Image->Blit(m_AbsoluteX, m_AbsoluteY, - (m_FlipV ? BS_BitmapResource::FLIP_V : 0) | - (m_FlipH ? BS_BitmapResource::FLIP_H : 0), + (m_FlipV ? BitmapResource::FLIP_V : 0) | + (m_FlipH ? BitmapResource::FLIP_H : 0), 0, m_ModulationColor, m_Width, m_Height); } @@ -123,7 +123,7 @@ bool BS_DynamicBitmap::DoRender() { // ----------------------------------------------------------------------------- -bool BS_DynamicBitmap::SetContent(const byte *Pixeldata, uint size, unsigned int Offset, unsigned int Stride) { +bool DynamicBitmap::SetContent(const byte *Pixeldata, uint size, unsigned int Offset, unsigned int Stride) { return m_Image->SetContent(Pixeldata, size, Offset, Stride); } @@ -131,25 +131,25 @@ bool BS_DynamicBitmap::SetContent(const byte *Pixeldata, uint size, unsigned int // Auskunftsmethoden // ----------------------------------------------------------------------------- -bool BS_DynamicBitmap::IsScalingAllowed() const { +bool DynamicBitmap::IsScalingAllowed() const { return m_Image->IsScalingAllowed(); } // ----------------------------------------------------------------------------- -bool BS_DynamicBitmap::IsAlphaAllowed() const { +bool DynamicBitmap::IsAlphaAllowed() const { return m_Image->IsAlphaAllowed(); } // ----------------------------------------------------------------------------- -bool BS_DynamicBitmap::IsColorModulationAllowed() const { +bool DynamicBitmap::IsColorModulationAllowed() const { return m_Image->IsColorModulationAllowed(); } // ----------------------------------------------------------------------------- -bool BS_DynamicBitmap::IsSetContentAllowed() const { +bool DynamicBitmap::IsSetContentAllowed() const { return true; } @@ -157,24 +157,24 @@ bool BS_DynamicBitmap::IsSetContentAllowed() const { // Persistenz // ----------------------------------------------------------------------------- -bool BS_DynamicBitmap::Persist(BS_OutputPersistenceBlock &Writer) { +bool DynamicBitmap::Persist(BS_OutputPersistenceBlock &Writer) { bool Result = true; - Result &= BS_Bitmap::Persist(Writer); + Result &= Bitmap::Persist(Writer); // Bilddaten werden nicht gespeichert. Dies ist auch nicht weiter von bedeutung, da BS_DynamicBitmap nur vom Videoplayer benutzt wird. // Während ein Video abläuft kann niemals gespeichert werden. BS_DynamicBitmap kann nur der Vollständigkeit halber persistiert werden. BS_LOG_WARNINGLN("Persisting a BS_DynamicBitmap. Bitmap content is not persisted."); - Result &= BS_RenderObject::PersistChildren(Writer); + Result &= RenderObject::PersistChildren(Writer); return Result; } -bool BS_DynamicBitmap::Unpersist(BS_InputPersistenceBlock &Reader) { +bool DynamicBitmap::Unpersist(BS_InputPersistenceBlock &Reader) { bool Result = true; - Result &= BS_Bitmap::Unpersist(Reader); + Result &= Bitmap::Unpersist(Reader); // Ein BS_GLImage mit den gespeicherten Maßen erstellen. Result &= CreateGLImage(m_Width, m_Height); @@ -187,7 +187,7 @@ bool BS_DynamicBitmap::Unpersist(BS_InputPersistenceBlock &Reader) { m_Image->SetContent(TransparentImageData, m_Width * m_Height); free(TransparentImageData); - Result &= BS_RenderObject::UnpersistChildren(Reader); + Result &= RenderObject::UnpersistChildren(Reader); return Reader.IsGood() && Result; } diff --git a/engines/sword25/gfx/dynamicbitmap.h b/engines/sword25/gfx/dynamicbitmap.h index 4209c6e1a6..4cc47b14a5 100644 --- a/engines/sword25/gfx/dynamicbitmap.h +++ b/engines/sword25/gfx/dynamicbitmap.h @@ -54,11 +54,11 @@ namespace Sword25 { // Klassendeklaration // ----------------------------------------------------------------------------- -class BS_DynamicBitmap : public BS_Bitmap { - friend class BS_RenderObject; +class DynamicBitmap : public Bitmap { + friend class RenderObject; public: - virtual ~BS_DynamicBitmap(); + virtual ~DynamicBitmap(); virtual unsigned int GetPixel(int X, int Y) const; @@ -76,12 +76,12 @@ protected: virtual bool DoRender(); private: - BS_DynamicBitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Width, unsigned int Height); - BS_DynamicBitmap(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle); + DynamicBitmap(RenderObjectPtr<RenderObject> ParentPtr, unsigned int Width, unsigned int Height); + DynamicBitmap(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle); bool CreateGLImage(unsigned int Width, unsigned int Height); - std::auto_ptr<BS_GLImage> m_Image; + std::auto_ptr<GLImage> m_Image; }; } // End of namespace Sword25 diff --git a/engines/sword25/gfx/fontresource.cpp b/engines/sword25/gfx/fontresource.cpp index ca3232fc98..000b1619dc 100644 --- a/engines/sword25/gfx/fontresource.cpp +++ b/engines/sword25/gfx/fontresource.cpp @@ -60,7 +60,7 @@ static const unsigned int DEFAULT_GAPWIDTH = 1; // Konstruktion / Destruktion // ----------------------------------------------------------------------------- -BS_FontResource::BS_FontResource(BS_Kernel *pKernel, const Common::String &FileName) : +FontResource::FontResource(BS_Kernel *pKernel, const Common::String &FileName) : _pKernel(pKernel), _Valid(false), BS_Resource(FileName, BS_Resource::TYPE_FONT) { @@ -139,7 +139,7 @@ BS_FontResource::BS_FontResource(BS_Kernel *pKernel, const Common::String &FileN // ----------------------------------------------------------------------------- -bool BS_FontResource::_ParseXMLDocument(const Common::String &FileName, TiXmlDocument &Doc) const { +bool FontResource::_ParseXMLDocument(const Common::String &FileName, TiXmlDocument &Doc) const { // Pointer auf den Package-Manager bekommen BS_ASSERT(_pKernel); BS_PackageManager *pPackage = static_cast<BS_PackageManager *>(_pKernel->GetService("package")); @@ -171,7 +171,7 @@ bool BS_FontResource::_ParseXMLDocument(const Common::String &FileName, TiXmlDoc // ----------------------------------------------------------------------------- -bool BS_FontResource::_ParseFontTag(TiXmlElement &Tag, Common::String &BitmapFileName, int &Lineheight, int &GapWidth) const { +bool FontResource::_ParseFontTag(TiXmlElement &Tag, Common::String &BitmapFileName, int &Lineheight, int &GapWidth) const { // Bitmap Attribut auslesen const char *BitmapString = Tag.Attribute("bitmap"); if (!BitmapString) { @@ -202,7 +202,7 @@ bool BS_FontResource::_ParseFontTag(TiXmlElement &Tag, Common::String &BitmapFil // ----------------------------------------------------------------------------- -bool BS_FontResource::_ParseCharacterTag(TiXmlElement &Tag, int &Code, BS_Rect &Rect) const { +bool FontResource::_ParseCharacterTag(TiXmlElement &Tag, int &Code, BS_Rect &Rect) const { // Code Attribut auslesen const char *CodeString = Tag.Attribute("code"); if (!CodeString || !BS_String::ToInt(Common::String(CodeString), Code) || Code < 0 || Code >= 256) { diff --git a/engines/sword25/gfx/fontresource.h b/engines/sword25/gfx/fontresource.h index d26c79c575..8c45219b37 100644 --- a/engines/sword25/gfx/fontresource.h +++ b/engines/sword25/gfx/fontresource.h @@ -58,7 +58,7 @@ class BS_Kernel; // Klassendefinition // ----------------------------------------------------------------------------- -class BS_FontResource : public BS_Resource { +class FontResource : public BS_Resource { public: /** @brief Erzeugt eine neues Exemplar von BS_FontResource @@ -66,7 +66,7 @@ public: @param FileName der Dateiname der zu ladenen Resource @remark Wenn der Konstruktor erfolgreich ausgeführt werden konnte gibt die Methode IsValid true zurück. */ - BS_FontResource(BS_Kernel *pKernel, const Common::String &FileName); + FontResource(BS_Kernel *pKernel, const Common::String &FileName); /** @brief Gibt true zurück, wenn das Objekt korrekt initialisiert wurde. diff --git a/engines/sword25/gfx/framecounter.cpp b/engines/sword25/gfx/framecounter.cpp index 82d4d313a6..15bc7d00ea 100644 --- a/engines/sword25/gfx/framecounter.cpp +++ b/engines/sword25/gfx/framecounter.cpp @@ -37,14 +37,14 @@ namespace Sword25 { -BS_Framecounter::BS_Framecounter(int UpdateFrequency) : +Framecounter::Framecounter(int UpdateFrequency) : m_FPS(0), m_FPSCount(0), m_LastUpdateTime(-1) { SetUpdateFrequency(UpdateFrequency); } -void BS_Framecounter::Update() { +void Framecounter::Update() { // Aktuellen Systemtimerstand auslesen uint64_t Timer = g_system->getMillis() * 1000; diff --git a/engines/sword25/gfx/framecounter.h b/engines/sword25/gfx/framecounter.h index f4381eb1f2..8a8402a3bb 100644 --- a/engines/sword25/gfx/framecounter.h +++ b/engines/sword25/gfx/framecounter.h @@ -44,7 +44,7 @@ namespace Sword25 { /** * A simple class that implements a frame counter */ -class BS_Framecounter { +class Framecounter { private: enum { DEFAULT_UPDATE_FREQUENCY = 10 @@ -56,7 +56,7 @@ public: * @param UpdateFrequency Specifies how often the frame counter should be updated in a sceond. * The default value is 10. */ - BS_Framecounter(int UpdateFrequency = DEFAULT_UPDATE_FREQUENCY); + Framecounter(int UpdateFrequency = DEFAULT_UPDATE_FREQUENCY); /** * Determines how often the frame counter should be updated in a second. @@ -84,7 +84,7 @@ private: }; // Inlines -void BS_Framecounter::SetUpdateFrequency(int UpdateFrequency) { +void Framecounter::SetUpdateFrequency(int UpdateFrequency) { // Frequency in time (converted to microseconds) m_UpdateDelay = 1000000 / UpdateFrequency; } diff --git a/engines/sword25/gfx/graphicengine.cpp b/engines/sword25/gfx/graphicengine.cpp index 150c87366e..1f7f253a53 100644 --- a/engines/sword25/gfx/graphicengine.cpp +++ b/engines/sword25/gfx/graphicengine.cpp @@ -60,7 +60,7 @@ using namespace Lua; static const unsigned int FRAMETIME_SAMPLE_COUNT = 5; // Anzahl der Framezeiten über die, die Framezeit gemittelt wird -BS_GraphicEngine::BS_GraphicEngine(BS_Kernel *pKernel) : +GraphicEngine::GraphicEngine(BS_Kernel *pKernel) : m_Width(0), m_Height(0), m_BitDepth(0), @@ -81,7 +81,7 @@ BS_GraphicEngine::BS_GraphicEngine(BS_Kernel *pKernel) : // ----------------------------------------------------------------------------- -void BS_GraphicEngine::UpdateLastFrameDuration() { +void GraphicEngine::UpdateLastFrameDuration() { // Aktuelle Zeit holen uint64_t CurrentTime = BS_Kernel::GetInstance()->GetMicroTicks(); @@ -104,7 +104,7 @@ void BS_GraphicEngine::UpdateLastFrameDuration() { // ----------------------------------------------------------------------------- namespace { -bool DoSaveScreenshot(BS_GraphicEngine &GraphicEngine, const Common::String &Filename, bool Thumbnail) { +bool DoSaveScreenshot(GraphicEngine &GraphicEngine, const Common::String &Filename, bool Thumbnail) { unsigned int Width; unsigned int Height; byte *Data; @@ -114,27 +114,27 @@ bool DoSaveScreenshot(BS_GraphicEngine &GraphicEngine, const Common::String &Fil } if (Thumbnail) - return BS_Screenshot::SaveThumbnailToFile(Width, Height, Data, Filename); + return Screenshot::SaveThumbnailToFile(Width, Height, Data, Filename); else - return BS_Screenshot::SaveToFile(Width, Height, Data, Filename); + return Screenshot::SaveToFile(Width, Height, Data, Filename); } } // ----------------------------------------------------------------------------- -bool BS_GraphicEngine::SaveScreenshot(const Common::String &Filename) { +bool GraphicEngine::SaveScreenshot(const Common::String &Filename) { return DoSaveScreenshot(*this, Filename, false); } // ----------------------------------------------------------------------------- -bool BS_GraphicEngine::SaveThumbnailScreenshot(const Common::String &Filename) { +bool GraphicEngine::SaveThumbnailScreenshot(const Common::String &Filename) { return DoSaveScreenshot(*this, Filename, true); } // ----------------------------------------------------------------------------- -void BS_GraphicEngine::ARGBColorToLuaColor(lua_State *L, unsigned int Color) { +void GraphicEngine::ARGBColorToLuaColor(lua_State *L, unsigned int Color) { lua_Number Components[4] = { (Color >> 16) & 0xff, // Rot (Color >> 8) & 0xff, // Grün @@ -153,7 +153,7 @@ void BS_GraphicEngine::ARGBColorToLuaColor(lua_State *L, unsigned int Color) { // ----------------------------------------------------------------------------- -unsigned int BS_GraphicEngine::LuaColorToARGBColor(lua_State *L, int StackIndex) { +unsigned int GraphicEngine::LuaColorToARGBColor(lua_State *L, int StackIndex) { #ifdef DEBUG int __startStackDepth = lua_gettop(L); #endif @@ -201,14 +201,14 @@ unsigned int BS_GraphicEngine::LuaColorToARGBColor(lua_State *L, int StackIndex) // ----------------------------------------------------------------------------- -bool BS_GraphicEngine::Persist(BS_OutputPersistenceBlock &Writer) { +bool GraphicEngine::Persist(BS_OutputPersistenceBlock &Writer) { Writer.Write(m_TimerActive); return true; } // ----------------------------------------------------------------------------- -bool BS_GraphicEngine::Unpersist(BS_InputPersistenceBlock &Reader) { +bool GraphicEngine::Unpersist(BS_InputPersistenceBlock &Reader) { Reader.Read(m_TimerActive); return Reader.IsGood(); } diff --git a/engines/sword25/gfx/graphicengine.h b/engines/sword25/gfx/graphicengine.h index aaa3db64b4..3b00db115b 100644 --- a/engines/sword25/gfx/graphicengine.h +++ b/engines/sword25/gfx/graphicengine.h @@ -58,9 +58,9 @@ namespace Sword25 { class BS_Kernel; -class BS_Image; -class BS_Panel; -class BS_Screenshot; +class Image; +class Panel; +class Screenshot; // Typen typedef unsigned int BS_COLOR; @@ -77,7 +77,7 @@ typedef unsigned int BS_COLOR; Die bisher einzige Implementation ist BS_DDrawGfx. */ -class BS_GraphicEngine : public BS_ResourceService, public BS_Persistable { +class GraphicEngine : public BS_ResourceService, public BS_Persistable { public: // Enums // ----- @@ -203,7 +203,7 @@ public: virtual bool GetScreenshot(unsigned int &Width, unsigned int &Height, byte **Data) = 0; - virtual BS_RenderObjectPtr<BS_Panel> GetMainPanel() = 0; + virtual RenderObjectPtr<Panel> GetMainPanel() = 0; /** * Specifies the time (in microseconds) since the last frame has passed @@ -311,17 +311,17 @@ public: * @param ColorFormat The desired colour format. The parameter must be of type COLOR_FORMATS * @return Returns the size of a pixel in bytes. If the colour format is unknown, -1 is returned. */ - static int GetPixelSize(BS_GraphicEngine::COLOR_FORMATS ColorFormat) { + static int GetPixelSize(GraphicEngine::COLOR_FORMATS ColorFormat) { switch (ColorFormat) { - case BS_GraphicEngine::CF_RGB16: - case BS_GraphicEngine::CF_RGB15: + case GraphicEngine::CF_RGB16: + case GraphicEngine::CF_RGB15: return 2; - case BS_GraphicEngine::CF_RGB16_INTERLEAVED: - case BS_GraphicEngine::CF_RGB15_INTERLEAVED: + case GraphicEngine::CF_RGB16_INTERLEAVED: + case GraphicEngine::CF_RGB15_INTERLEAVED: return 3; - case BS_GraphicEngine::CF_ARGB32: + case GraphicEngine::CF_ARGB32: return 4; default: return -1; @@ -335,18 +335,18 @@ public: * @return Reflects the length of the line in bytes. If the colour format is * unknown, -1 is returned */ - static int CalcPitch(BS_GraphicEngine::COLOR_FORMATS ColorFormat, int Width) { + static int CalcPitch(GraphicEngine::COLOR_FORMATS ColorFormat, int Width) { switch (ColorFormat) { - case BS_GraphicEngine::CF_RGB16: - case BS_GraphicEngine::CF_RGB15: + case GraphicEngine::CF_RGB16: + case GraphicEngine::CF_RGB15: return Width * 2; - case BS_GraphicEngine::CF_RGB16_INTERLEAVED: - case BS_GraphicEngine::CF_RGB15_INTERLEAVED: + case GraphicEngine::CF_RGB16_INTERLEAVED: + case GraphicEngine::CF_RGB15_INTERLEAVED: return (Width + 3) / 4 * 12; - case BS_GraphicEngine::CF_ARGB32: - case BS_GraphicEngine::CF_ABGR32: + case GraphicEngine::CF_ARGB32: + case GraphicEngine::CF_ABGR32: return Width * 4; default: @@ -367,7 +367,7 @@ public: protected: // Constructor // ----------- - BS_GraphicEngine(BS_Kernel *pKernel); + GraphicEngine(BS_Kernel *pKernel); // Display Variables // ----------------- @@ -379,7 +379,7 @@ protected: // Debugging Variables // ------------------- - BS_Framecounter m_FPSCounter; + Framecounter m_FPSCounter; unsigned int m_RepaintedPixels; diff --git a/engines/sword25/gfx/graphicengine_script.cpp b/engines/sword25/gfx/graphicengine_script.cpp index 07a867bf6c..7447e0237b 100644 --- a/engines/sword25/gfx/graphicengine_script.cpp +++ b/engines/sword25/gfx/graphicengine_script.cpp @@ -143,11 +143,11 @@ static void NewUintUserData(lua_State *L, unsigned int Value) { // ----------------------------------------------------------------------------- -static BS_AnimationTemplate *CheckAnimationTemplate(lua_State *L, int idx = 1) { +static AnimationTemplate *CheckAnimationTemplate(lua_State *L, int idx = 1) { // Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.AnimationTemplate unsigned int AnimationTemplateHandle; if ((AnimationTemplateHandle = *reinterpret_cast<unsigned int *>(my_checkudata(L, idx, ANIMATION_TEMPLATE_CLASS_NAME))) != 0) { - BS_AnimationTemplate *AnimationTemplatePtr = BS_AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle); + AnimationTemplate *AnimationTemplatePtr = AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle); if (!AnimationTemplatePtr) luaL_error(L, "The animation template with the handle %d does no longer exist.", AnimationTemplateHandle); return AnimationTemplatePtr; @@ -161,8 +161,8 @@ static BS_AnimationTemplate *CheckAnimationTemplate(lua_State *L, int idx = 1) { // ----------------------------------------------------------------------------- static int NewAnimationTemplate(lua_State *L) { - unsigned int AnimationTemplateHandle = BS_AnimationTemplate::Create(luaL_checkstring(L, 1)); - BS_AnimationTemplate *AnimationTemplatePtr = BS_AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle); + unsigned int AnimationTemplateHandle = AnimationTemplate::Create(luaL_checkstring(L, 1)); + AnimationTemplate *AnimationTemplatePtr = AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle); if (AnimationTemplatePtr && AnimationTemplatePtr->IsValid()) { NewUintUserData(L, AnimationTemplateHandle); //luaL_getmetatable(L, ANIMATION_TEMPLATE_CLASS_NAME); @@ -179,7 +179,7 @@ static int NewAnimationTemplate(lua_State *L) { // ----------------------------------------------------------------------------- static int AT_AddFrame(lua_State *L) { - BS_AnimationTemplate *pAT = CheckAnimationTemplate(L); + AnimationTemplate *pAT = CheckAnimationTemplate(L); pAT->AddFrame(static_cast<int>(luaL_checknumber(L, 2))); return 0; } @@ -187,22 +187,22 @@ static int AT_AddFrame(lua_State *L) { // ----------------------------------------------------------------------------- static int AT_SetFrame(lua_State *L) { - BS_AnimationTemplate *pAT = CheckAnimationTemplate(L); + AnimationTemplate *pAT = CheckAnimationTemplate(L); pAT->SetFrame(static_cast<int>(luaL_checknumber(L, 2)), static_cast<int>(luaL_checknumber(L, 3))); return 0; } // ----------------------------------------------------------------------------- -static bool AnimationTypeStringToNumber(const char *TypeString, BS_Animation::ANIMATION_TYPES &Result) { +static bool AnimationTypeStringToNumber(const char *TypeString, Animation::ANIMATION_TYPES &Result) { if (strcmp(TypeString, "jojo") == 0) { - Result = BS_Animation::AT_JOJO; + Result = Animation::AT_JOJO; return true; } else if (strcmp(TypeString, "loop") == 0) { - Result = BS_Animation::AT_LOOP; + Result = Animation::AT_LOOP; return true; } else if (strcmp(TypeString, "oneshot") == 0) { - Result = BS_Animation::AT_ONESHOT; + Result = Animation::AT_ONESHOT; return true; } else return false; @@ -211,8 +211,8 @@ static bool AnimationTypeStringToNumber(const char *TypeString, BS_Animation::AN // ----------------------------------------------------------------------------- static int AT_SetAnimationType(lua_State *L) { - BS_AnimationTemplate *pAT = CheckAnimationTemplate(L); - BS_Animation::ANIMATION_TYPES AnimationType; + AnimationTemplate *pAT = CheckAnimationTemplate(L); + Animation::ANIMATION_TYPES AnimationType; if (AnimationTypeStringToNumber(luaL_checkstring(L, 2), AnimationType)) { pAT->SetAnimationType(AnimationType); } else { @@ -225,7 +225,7 @@ static int AT_SetAnimationType(lua_State *L) { // ----------------------------------------------------------------------------- static int AT_SetFPS(lua_State *L) { - BS_AnimationTemplate *pAT = CheckAnimationTemplate(L); + AnimationTemplate *pAT = CheckAnimationTemplate(L); pAT->SetFPS(static_cast<int>(luaL_checknumber(L, 2))); return 0; } @@ -233,7 +233,7 @@ static int AT_SetFPS(lua_State *L) { // ----------------------------------------------------------------------------- static int AT_Finalize(lua_State *L) { - BS_AnimationTemplate *pAT = CheckAnimationTemplate(L); + AnimationTemplate *pAT = CheckAnimationTemplate(L); delete pAT; return 0; } @@ -251,10 +251,10 @@ static const luaL_reg ANIMATION_TEMPLATE_METHODS[] = { // ----------------------------------------------------------------------------- -static BS_GraphicEngine *GetGE() { +static GraphicEngine *GetGE() { BS_Kernel *pKernel = BS_Kernel::GetInstance(); BS_ASSERT(pKernel); - BS_GraphicEngine *pGE = static_cast<BS_GraphicEngine *>(pKernel->GetService("gfx")); + GraphicEngine *pGE = static_cast<GraphicEngine *>(pKernel->GetService("gfx")); BS_ASSERT(pGE); return pGE; } @@ -262,7 +262,7 @@ static BS_GraphicEngine *GetGE() { // ----------------------------------------------------------------------------- static int Init(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); switch (lua_gettop(L)) { case 0: @@ -294,7 +294,7 @@ static int Init(lua_State *L) { #endif // Main-Panel zum Gfx-Modul hinzufügen - BS_RenderObjectPtr<BS_Panel> MainPanelPtr(GetGE()->GetMainPanel()); + RenderObjectPtr<Panel> MainPanelPtr(GetGE()->GetMainPanel()); BS_ASSERT(MainPanelPtr.IsValid()); lua_pushstring(L, GFX_LIBRARY_NAME); @@ -324,7 +324,7 @@ static int Init(lua_State *L) { // ----------------------------------------------------------------------------- static int StartFrame(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); if (lua_gettop(L) == 0) lua_pushbooleancpp(L, pGE->StartFrame()); @@ -337,7 +337,7 @@ static int StartFrame(lua_State *L) { // ----------------------------------------------------------------------------- static int EndFrame(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushbooleancpp(L, pGE->EndFrame()); @@ -347,13 +347,13 @@ static int EndFrame(lua_State *L) { // ----------------------------------------------------------------------------- static int DrawDebugLine(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); BS_Vertex Start; BS_Vertex End; BS_Vertex::LuaVertexToVertex(L, 1, Start); BS_Vertex::LuaVertexToVertex(L, 2, End); - pGE->DrawDebugLine(Start, End, BS_GraphicEngine::LuaColorToARGBColor(L, 3)); + pGE->DrawDebugLine(Start, End, GraphicEngine::LuaColorToARGBColor(L, 3)); return 0; } @@ -361,7 +361,7 @@ static int DrawDebugLine(lua_State *L) { // ----------------------------------------------------------------------------- static int GetDisplayWidth(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushnumber(L, pGE->GetDisplayWidth()); @@ -371,7 +371,7 @@ static int GetDisplayWidth(lua_State *L) { // ----------------------------------------------------------------------------- static int GetDisplayHeight(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushnumber(L, pGE->GetDisplayHeight()); @@ -381,7 +381,7 @@ static int GetDisplayHeight(lua_State *L) { // ----------------------------------------------------------------------------- static int GetBitDepth(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushnumber(L, pGE->GetBitDepth()); @@ -391,7 +391,7 @@ static int GetBitDepth(lua_State *L) { // ----------------------------------------------------------------------------- static int SetVsync(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); pGE->SetVsync(lua_tobooleancpp(L, 1)); @@ -401,7 +401,7 @@ static int SetVsync(lua_State *L) { // ----------------------------------------------------------------------------- static int IsVsync(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushbooleancpp(L, pGE->GetVsync()); @@ -411,7 +411,7 @@ static int IsVsync(lua_State *L) { // ----------------------------------------------------------------------------- static int IsWindowed(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushbooleancpp(L, pGE->IsWindowed()); @@ -421,7 +421,7 @@ static int IsWindowed(lua_State *L) { // ----------------------------------------------------------------------------- static int GetFPSCount(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushnumber(L, pGE->GetFPSCount()); @@ -431,7 +431,7 @@ static int GetFPSCount(lua_State *L) { // ----------------------------------------------------------------------------- static int GetLastFrameDuration(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushnumber(L, pGE->GetLastFrameDuration()); @@ -441,7 +441,7 @@ static int GetLastFrameDuration(lua_State *L) { // ----------------------------------------------------------------------------- static int StopMainTimer(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); pGE->StopMainTimer(); return 0; } @@ -449,7 +449,7 @@ static int StopMainTimer(lua_State *L) { // ----------------------------------------------------------------------------- static int ResumeMainTimer(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); pGE->ResumeMainTimer(); return 0; } @@ -457,7 +457,7 @@ static int ResumeMainTimer(lua_State *L) { // ----------------------------------------------------------------------------- static int GetSecondaryFrameDuration(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushnumber(L, pGE->GetSecondaryFrameDuration()); @@ -467,7 +467,7 @@ static int GetSecondaryFrameDuration(lua_State *L) { // ----------------------------------------------------------------------------- static int SaveScreenshot(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushbooleancpp(L, pGE->SaveScreenshot(luaL_checkstring(L, 1))); return 1; } @@ -475,7 +475,7 @@ static int SaveScreenshot(lua_State *L) { // ----------------------------------------------------------------------------- static int SaveThumbnailScreenshot(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushbooleancpp(L, pGE->SaveThumbnailScreenshot(luaL_checkstring(L, 1))); return 1; } @@ -483,7 +483,7 @@ static int SaveThumbnailScreenshot(lua_State *L) { // ----------------------------------------------------------------------------- static int GetRepaintedPixels(lua_State *L) { - BS_GraphicEngine *pGE = GetGE(); + GraphicEngine *pGE = GetGE(); lua_pushnumber(L, static_cast<lua_Number>(pGE->GetRepaintedPixels())); return 1; } @@ -515,14 +515,14 @@ static const luaL_reg GFX_FUNCTIONS[] = { // ----------------------------------------------------------------------------- -static BS_RenderObjectPtr<BS_RenderObject> CheckRenderObject(lua_State *L, bool ErrorIfRemoved = true) { +static RenderObjectPtr<RenderObject> CheckRenderObject(lua_State *L, bool ErrorIfRemoved = true) { // Der erste Parameter muss vom Typ userdata sein und die Metatable einer Klasse haben, die von Gfx.RenderObject "erbt". unsigned int *UserDataPtr; if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, BITMAP_CLASS_NAME)) != 0 || (UserDataPtr = (unsigned int *) my_checkudata(L, 1, ANIMATION_CLASS_NAME)) != 0 || (UserDataPtr = (unsigned int *) my_checkudata(L, 1, PANEL_CLASS_NAME)) != 0 || (UserDataPtr = (unsigned int *) my_checkudata(L, 1, TEXT_CLASS_NAME)) != 0) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr(* UserDataPtr); + RenderObjectPtr<RenderObject> ROPtr(* UserDataPtr); if (ROPtr.IsValid()) return ROPtr; else { @@ -533,13 +533,13 @@ static BS_RenderObjectPtr<BS_RenderObject> CheckRenderObject(lua_State *L, bool luaL_argcheck(L, 0, 1, "'" RENDEROBJECT_CLASS_NAME "' expected"); } - return BS_RenderObjectPtr<BS_RenderObject>(); + return RenderObjectPtr<RenderObject>(); } // ----------------------------------------------------------------------------- static int RO_SetPos(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); BS_Vertex Pos; BS_Vertex::LuaVertexToVertex(L, 2, Pos); @@ -550,7 +550,7 @@ static int RO_SetPos(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_SetX(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); ROPtr->SetX(static_cast<int>(luaL_checknumber(L, 2))); return 0; @@ -559,7 +559,7 @@ static int RO_SetX(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_SetY(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); ROPtr->SetY(static_cast<int>(luaL_checknumber(L, 2))); return 0; @@ -568,7 +568,7 @@ static int RO_SetY(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_SetZ(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); ROPtr->SetZ(static_cast<int>(luaL_checknumber(L, 2))); return 0; @@ -577,7 +577,7 @@ static int RO_SetZ(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_SetVisible(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); ROPtr->SetVisible(lua_tobooleancpp(L, 2)); return 0; @@ -586,7 +586,7 @@ static int RO_SetVisible(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_GetX(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); lua_pushnumber(L, ROPtr->GetX()); @@ -596,7 +596,7 @@ static int RO_GetX(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_GetY(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); lua_pushnumber(L, ROPtr->GetY()); @@ -606,7 +606,7 @@ static int RO_GetY(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_GetZ(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); lua_pushnumber(L, ROPtr->GetZ()); @@ -616,7 +616,7 @@ static int RO_GetZ(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_GetAbsoluteX(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); lua_pushnumber(L, ROPtr->GetAbsoluteX()); @@ -626,7 +626,7 @@ static int RO_GetAbsoluteX(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_GetAbsoluteY(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); lua_pushnumber(L, ROPtr->GetAbsoluteY()); @@ -636,7 +636,7 @@ static int RO_GetAbsoluteY(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_GetWidth(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); lua_pushnumber(L, ROPtr->GetWidth()); @@ -646,7 +646,7 @@ static int RO_GetWidth(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_GetHeight(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); lua_pushnumber(L, ROPtr->GetHeight()); @@ -656,7 +656,7 @@ static int RO_GetHeight(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_IsVisible(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); lua_pushbooleancpp(L, ROPtr->IsVisible()); @@ -666,11 +666,11 @@ static int RO_IsVisible(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_AddPanel(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); - BS_RenderObjectPtr<BS_Panel> PanelPtr = ROPtr->AddPanel(static_cast<int>(luaL_checknumber(L, 2)), + RenderObjectPtr<Panel> PanelPtr = ROPtr->AddPanel(static_cast<int>(luaL_checknumber(L, 2)), static_cast<int>(luaL_checknumber(L, 3)), - BS_GraphicEngine::LuaColorToARGBColor(L, 4)); + GraphicEngine::LuaColorToARGBColor(L, 4)); if (PanelPtr.IsValid()) { NewUintUserData(L, PanelPtr->GetHandle()); // luaL_getmetatable(L, PANEL_CLASS_NAME); @@ -686,9 +686,9 @@ static int RO_AddPanel(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_AddBitmap(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); - BS_RenderObjectPtr<BS_Bitmap> BitmaPtr = ROPtr->AddBitmap(luaL_checkstring(L, 2)); + RenderObjectPtr<Bitmap> BitmaPtr = ROPtr->AddBitmap(luaL_checkstring(L, 2)); if (BitmaPtr.IsValid()) { NewUintUserData(L, BitmaPtr->GetHandle()); // luaL_getmetatable(L, BITMAP_CLASS_NAME); @@ -704,10 +704,10 @@ static int RO_AddBitmap(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_AddText(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); - BS_RenderObjectPtr<BS_Text> TextPtr; + RenderObjectPtr<Text> TextPtr; if (lua_gettop(L) >= 3) TextPtr = ROPtr->AddText(luaL_checkstring(L, 2), luaL_checkstring(L, 3)); else TextPtr = ROPtr->AddText(luaL_checkstring(L, 2)); @@ -726,10 +726,10 @@ static int RO_AddText(lua_State *L) { // ----------------------------------------------------------------------------- static int RO_AddAnimation(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); - BS_RenderObjectPtr<BS_Animation> AnimationPtr; + RenderObjectPtr<Animation> AnimationPtr; if (lua_type(L, 2) == LUA_TUSERDATA) AnimationPtr = ROPtr->AddAnimation(*CheckAnimationTemplate(L, 2)); else @@ -777,11 +777,11 @@ static const luaL_reg RENDEROBJECT_METHODS[] = { // ----------------------------------------------------------------------------- -static BS_RenderObjectPtr<BS_Panel> CheckPanel(lua_State *L) { +static RenderObjectPtr<Panel> CheckPanel(lua_State *L) { // Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Panel unsigned int *UserDataPtr; if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, PANEL_CLASS_NAME)) != 0) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr); + RenderObjectPtr<RenderObject> ROPtr(*UserDataPtr); if (ROPtr.IsValid()) { return ROPtr->ToPanel(); } else @@ -790,15 +790,15 @@ static BS_RenderObjectPtr<BS_Panel> CheckPanel(lua_State *L) { luaL_argcheck(L, 0, 1, "'" PANEL_CLASS_NAME "' expected"); } - return BS_RenderObjectPtr<BS_Panel>(); + return RenderObjectPtr<Panel>(); } // ----------------------------------------------------------------------------- static int P_GetColor(lua_State *L) { - BS_RenderObjectPtr<BS_Panel> PanelPtr = CheckPanel(L); + RenderObjectPtr<Panel> PanelPtr = CheckPanel(L); BS_ASSERT(PanelPtr.IsValid()); - BS_GraphicEngine::ARGBColorToLuaColor(L, PanelPtr->GetColor()); + GraphicEngine::ARGBColorToLuaColor(L, PanelPtr->GetColor()); return 1; } @@ -806,16 +806,16 @@ static int P_GetColor(lua_State *L) { // ----------------------------------------------------------------------------- static int P_SetColor(lua_State *L) { - BS_RenderObjectPtr<BS_Panel> PanelPtr = CheckPanel(L); + RenderObjectPtr<Panel> PanelPtr = CheckPanel(L); BS_ASSERT(PanelPtr.IsValid()); - PanelPtr->SetColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2)); + PanelPtr->SetColor(GraphicEngine::LuaColorToARGBColor(L, 2)); return 0; } // ----------------------------------------------------------------------------- static int P_Remove(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); ROPtr.Erase(); return 0; @@ -832,11 +832,11 @@ static const luaL_reg PANEL_METHODS[] = { // ----------------------------------------------------------------------------- -static BS_RenderObjectPtr<BS_Bitmap> CheckBitmap(lua_State *L) { +static RenderObjectPtr<Bitmap> CheckBitmap(lua_State *L) { // Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Bitmap unsigned int *UserDataPtr; if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, BITMAP_CLASS_NAME)) != 0) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr); + RenderObjectPtr<RenderObject> ROPtr(*UserDataPtr); if (ROPtr.IsValid()) { return ROPtr->ToBitmap(); } else @@ -845,13 +845,13 @@ static BS_RenderObjectPtr<BS_Bitmap> CheckBitmap(lua_State *L) { luaL_argcheck(L, 0, 1, "'" BITMAP_CLASS_NAME "' expected"); } - return BS_RenderObjectPtr<BS_Bitmap>(); + return RenderObjectPtr<Bitmap>(); } // ----------------------------------------------------------------------------- static int B_SetAlpha(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); BitmapPtr->SetAlpha(static_cast<unsigned int>(luaL_checknumber(L, 2))); return 0; @@ -860,16 +860,16 @@ static int B_SetAlpha(lua_State *L) { // ----------------------------------------------------------------------------- static int B_SetTintColor(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); - BitmapPtr->SetModulationColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2)); + BitmapPtr->SetModulationColor(GraphicEngine::LuaColorToARGBColor(L, 2)); return 0; } // ----------------------------------------------------------------------------- static int B_SetScaleFactor(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); BitmapPtr->SetScaleFactor(static_cast<float>(luaL_checknumber(L, 2))); return 0; @@ -878,7 +878,7 @@ static int B_SetScaleFactor(lua_State *L) { // ----------------------------------------------------------------------------- static int B_SetScaleFactorX(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); BitmapPtr->SetScaleFactorX(static_cast<float>(luaL_checknumber(L, 2))); return 0; @@ -887,7 +887,7 @@ static int B_SetScaleFactorX(lua_State *L) { // ----------------------------------------------------------------------------- static int B_SetScaleFactorY(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); BitmapPtr->SetScaleFactorY(static_cast<float>(luaL_checknumber(L, 2))); return 0; @@ -896,7 +896,7 @@ static int B_SetScaleFactorY(lua_State *L) { // ----------------------------------------------------------------------------- static int B_SetFlipH(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); BitmapPtr->SetFlipH(lua_tobooleancpp(L, 2)); return 0; @@ -905,7 +905,7 @@ static int B_SetFlipH(lua_State *L) { // ----------------------------------------------------------------------------- static int B_SetFlipV(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); BitmapPtr->SetFlipV(lua_tobooleancpp(L, 2)); return 0; @@ -914,7 +914,7 @@ static int B_SetFlipV(lua_State *L) { // ----------------------------------------------------------------------------- static int B_GetAlpha(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); lua_pushnumber(L, BitmapPtr->GetAlpha()); return 1; @@ -923,16 +923,16 @@ static int B_GetAlpha(lua_State *L) { // ----------------------------------------------------------------------------- static int B_GetTintColor(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); - BS_GraphicEngine::ARGBColorToLuaColor(L, BitmapPtr->GetModulationColor()); + GraphicEngine::ARGBColorToLuaColor(L, BitmapPtr->GetModulationColor()); return 1; } // ----------------------------------------------------------------------------- static int B_GetScaleFactorX(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); lua_pushnumber(L, BitmapPtr->GetScaleFactorX()); return 1; @@ -941,7 +941,7 @@ static int B_GetScaleFactorX(lua_State *L) { // ----------------------------------------------------------------------------- static int B_GetScaleFactorY(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); lua_pushnumber(L, BitmapPtr->GetScaleFactorY()); return 1; @@ -950,7 +950,7 @@ static int B_GetScaleFactorY(lua_State *L) { // ----------------------------------------------------------------------------- static int B_IsFlipH(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); lua_pushbooleancpp(L, BitmapPtr->IsFlipH()); return 1; @@ -959,7 +959,7 @@ static int B_IsFlipH(lua_State *L) { // ----------------------------------------------------------------------------- static int B_IsFlipV(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); lua_pushbooleancpp(L, BitmapPtr->IsFlipV()); return 1; @@ -968,18 +968,18 @@ static int B_IsFlipV(lua_State *L) { // ----------------------------------------------------------------------------- static int B_GetPixel(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); BS_Vertex Pos; BS_Vertex::LuaVertexToVertex(L, 2, Pos); - BS_GraphicEngine::ARGBColorToLuaColor(L, BitmapPtr->GetPixel(Pos.X, Pos.Y)); + GraphicEngine::ARGBColorToLuaColor(L, BitmapPtr->GetPixel(Pos.X, Pos.Y)); return 1; } // ----------------------------------------------------------------------------- static int B_IsScalingAllowed(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); lua_pushbooleancpp(L, BitmapPtr->IsScalingAllowed()); return 1; @@ -988,7 +988,7 @@ static int B_IsScalingAllowed(lua_State *L) { // ----------------------------------------------------------------------------- static int B_IsAlphaAllowed(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); lua_pushbooleancpp(L, BitmapPtr->IsAlphaAllowed()); return 1; @@ -997,7 +997,7 @@ static int B_IsAlphaAllowed(lua_State *L) { // ----------------------------------------------------------------------------- static int B_IsTintingAllowed(lua_State *L) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L); + RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L); BS_ASSERT(BitmapPtr.IsValid()); lua_pushbooleancpp(L, BitmapPtr->IsColorModulationAllowed()); return 1; @@ -1005,7 +1005,7 @@ static int B_IsTintingAllowed(lua_State *L) { // ----------------------------------------------------------------------------- static int B_Remove(lua_State *L) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L); + RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L); BS_ASSERT(ROPtr.IsValid()); ROPtr.Erase(); return 0; @@ -1037,11 +1037,11 @@ static const luaL_reg BITMAP_METHODS[] = { // ----------------------------------------------------------------------------- -static BS_RenderObjectPtr<BS_Animation> CheckAnimation(lua_State *L) { +static RenderObjectPtr<Animation> CheckAnimation(lua_State *L) { // Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Animation unsigned int *UserDataPtr; if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, ANIMATION_CLASS_NAME)) != 0) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr); + RenderObjectPtr<RenderObject> ROPtr(*UserDataPtr); if (ROPtr.IsValid()) return ROPtr->ToAnimation(); else { @@ -1051,13 +1051,13 @@ static BS_RenderObjectPtr<BS_Animation> CheckAnimation(lua_State *L) { luaL_argcheck(L, 0, 1, "'" ANIMATION_CLASS_NAME "' expected"); } - return BS_RenderObjectPtr<BS_Animation>(); + return RenderObjectPtr<Animation>(); } // ----------------------------------------------------------------------------- static int A_Play(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); AnimationPtr->Play(); return 0; @@ -1066,7 +1066,7 @@ static int A_Play(lua_State *L) { // ----------------------------------------------------------------------------- static int A_Pause(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); AnimationPtr->Pause(); return 0; @@ -1075,7 +1075,7 @@ static int A_Pause(lua_State *L) { // ----------------------------------------------------------------------------- static int A_Stop(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); AnimationPtr->Stop(); return 0; @@ -1084,7 +1084,7 @@ static int A_Stop(lua_State *L) { // ----------------------------------------------------------------------------- static int A_SetFrame(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); AnimationPtr->SetFrame(static_cast<unsigned int>(luaL_checknumber(L, 2))); return 0; @@ -1093,7 +1093,7 @@ static int A_SetFrame(lua_State *L) { // ----------------------------------------------------------------------------- static int A_SetAlpha(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); AnimationPtr->SetAlpha(static_cast<int>(luaL_checknumber(L, 2))); return 0; @@ -1101,16 +1101,16 @@ static int A_SetAlpha(lua_State *L) { // ----------------------------------------------------------------------------- static int A_SetTintColor(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); - AnimationPtr->SetModulationColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2)); + AnimationPtr->SetModulationColor(GraphicEngine::LuaColorToARGBColor(L, 2)); return 0; } // ----------------------------------------------------------------------------- static int A_SetScaleFactor(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); AnimationPtr->SetScaleFactor(static_cast<float>(luaL_checknumber(L, 2))); return 0; @@ -1119,7 +1119,7 @@ static int A_SetScaleFactor(lua_State *L) { // ----------------------------------------------------------------------------- static int A_SetScaleFactorX(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); AnimationPtr->SetScaleFactorX(static_cast<float>(luaL_checknumber(L, 2))); return 0; @@ -1128,7 +1128,7 @@ static int A_SetScaleFactorX(lua_State *L) { // ----------------------------------------------------------------------------- static int A_SetScaleFactorY(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); AnimationPtr->SetScaleFactorY(static_cast<float>(luaL_checknumber(L, 2))); return 0; @@ -1137,7 +1137,7 @@ static int A_SetScaleFactorY(lua_State *L) { // ----------------------------------------------------------------------------- static int A_GetScaleFactorX(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); lua_pushnumber(L, AnimationPtr->GetScaleFactorX()); return 1; @@ -1146,7 +1146,7 @@ static int A_GetScaleFactorX(lua_State *L) { // ----------------------------------------------------------------------------- static int A_GetScaleFactorY(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); lua_pushnumber(L, AnimationPtr->GetScaleFactorY()); return 1; @@ -1155,16 +1155,16 @@ static int A_GetScaleFactorY(lua_State *L) { // ----------------------------------------------------------------------------- static int A_GetAnimationType(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); switch (AnimationPtr->GetAnimationType()) { - case BS_Animation::AT_JOJO: + case Animation::AT_JOJO: lua_pushstring(L, "jojo"); break; - case BS_Animation::AT_LOOP: + case Animation::AT_LOOP: lua_pushstring(L, "loop"); break; - case BS_Animation::AT_ONESHOT: + case Animation::AT_ONESHOT: lua_pushstring(L, "oneshot"); break; default: @@ -1176,7 +1176,7 @@ static int A_GetAnimationType(lua_State *L) { // ----------------------------------------------------------------------------- static int A_GetFPS(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); lua_pushnumber(L, AnimationPtr->GetFPS()); return 1; @@ -1186,7 +1186,7 @@ static int A_GetFPS(lua_State *L) { // ----------------------------------------------------------------------------- static int A_GetFrameCount(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); lua_pushnumber(L, AnimationPtr->GetFrameCount()); return 1; @@ -1195,7 +1195,7 @@ static int A_GetFrameCount(lua_State *L) { // ----------------------------------------------------------------------------- static int A_IsScalingAllowed(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); lua_pushbooleancpp(L, AnimationPtr->IsScalingAllowed()); return 1; @@ -1204,7 +1204,7 @@ static int A_IsScalingAllowed(lua_State *L) { // ----------------------------------------------------------------------------- static int A_IsAlphaAllowed(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); lua_pushbooleancpp(L, AnimationPtr->IsAlphaAllowed()); return 1; @@ -1213,7 +1213,7 @@ static int A_IsAlphaAllowed(lua_State *L) { // ----------------------------------------------------------------------------- static int A_IsTintingAllowed(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); lua_pushbooleancpp(L, AnimationPtr->IsColorModulationAllowed()); return 1; @@ -1222,7 +1222,7 @@ static int A_IsTintingAllowed(lua_State *L) { // ----------------------------------------------------------------------------- static int A_GetCurrentFrame(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); lua_pushnumber(L, AnimationPtr->GetCurrentFrame()); return 1; @@ -1231,7 +1231,7 @@ static int A_GetCurrentFrame(lua_State *L) { // ----------------------------------------------------------------------------- static int A_GetCurrentAction(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); lua_pushstring(L, AnimationPtr->GetCurrentAction().c_str()); return 1; @@ -1240,7 +1240,7 @@ static int A_GetCurrentAction(lua_State *L) { // ----------------------------------------------------------------------------- static int A_IsPlaying(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); lua_pushbooleancpp(L, AnimationPtr->IsRunning()); return 1; @@ -1258,7 +1258,7 @@ static bool AnimationLoopPointCallback(unsigned int Handle) { // ----------------------------------------------------------------------------- static int A_RegisterLoopPointCallback(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); luaL_checktype(L, 2, LUA_TFUNCTION); @@ -1271,7 +1271,7 @@ static int A_RegisterLoopPointCallback(lua_State *L) { // ----------------------------------------------------------------------------- static int A_UnregisterLoopPointCallback(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); luaL_checktype(L, 2, LUA_TFUNCTION); @@ -1284,7 +1284,7 @@ static int A_UnregisterLoopPointCallback(lua_State *L) { // ----------------------------------------------------------------------------- static bool AnimationActionCallback(unsigned int Handle) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr(Handle); + RenderObjectPtr<Animation> AnimationPtr(Handle); if (AnimationPtr.IsValid()) { ActionCallbackPtr->Action = AnimationPtr->GetCurrentAction(); lua_State *L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject()); @@ -1297,7 +1297,7 @@ static bool AnimationActionCallback(unsigned int Handle) { // ----------------------------------------------------------------------------- static int A_RegisterActionCallback(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); luaL_checktype(L, 2, LUA_TFUNCTION); @@ -1310,7 +1310,7 @@ static int A_RegisterActionCallback(lua_State *L) { // ----------------------------------------------------------------------------- static int A_UnregisterActionCallback(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); luaL_checktype(L, 2, LUA_TFUNCTION); @@ -1332,7 +1332,7 @@ static bool AnimationDeleteCallback(unsigned int Handle) { // ----------------------------------------------------------------------------- static int A_Remove(lua_State *L) { - BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L); + RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L); BS_ASSERT(AnimationPtr.IsValid()); AnimationPtr.Erase(); return 0; @@ -1371,11 +1371,11 @@ static const luaL_reg ANIMATION_METHODS[] = { // ----------------------------------------------------------------------------- -static BS_RenderObjectPtr<BS_Text> CheckText(lua_State *L) { +static RenderObjectPtr<Text> CheckText(lua_State *L) { // Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Text unsigned int *UserDataPtr; if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, TEXT_CLASS_NAME)) != 0) { - BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr); + RenderObjectPtr<RenderObject> ROPtr(*UserDataPtr); if (ROPtr.IsValid()) return ROPtr->ToText(); else @@ -1384,13 +1384,13 @@ static BS_RenderObjectPtr<BS_Text> CheckText(lua_State *L) { luaL_argcheck(L, 0, 1, "'" TEXT_CLASS_NAME "' expected"); } - return BS_RenderObjectPtr<BS_Text>(); + return RenderObjectPtr<Text>(); } // ----------------------------------------------------------------------------- static int T_SetFont(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); TextPtr->SetFont(luaL_checkstring(L, 2)); return 0; @@ -1399,7 +1399,7 @@ static int T_SetFont(lua_State *L) { // ----------------------------------------------------------------------------- static int T_SetText(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); TextPtr->SetText(luaL_checkstring(L, 2)); return 0; @@ -1408,7 +1408,7 @@ static int T_SetText(lua_State *L) { // ----------------------------------------------------------------------------- static int T_SetAlpha(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); TextPtr->SetAlpha(static_cast<int>(luaL_checknumber(L, 2))); return 0; @@ -1417,16 +1417,16 @@ static int T_SetAlpha(lua_State *L) { // ----------------------------------------------------------------------------- static int T_SetColor(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); - TextPtr->SetColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2)); + TextPtr->SetColor(GraphicEngine::LuaColorToARGBColor(L, 2)); return 0; } // ----------------------------------------------------------------------------- static int T_SetAutoWrap(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); TextPtr->SetAutoWrap(lua_tobooleancpp(L, 2)); return 0; @@ -1435,7 +1435,7 @@ static int T_SetAutoWrap(lua_State *L) { // ----------------------------------------------------------------------------- static int T_SetAutoWrapThreshold(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); TextPtr->SetAutoWrapThreshold(static_cast<unsigned int>(luaL_checknumber(L, 2))); return 0; @@ -1444,7 +1444,7 @@ static int T_SetAutoWrapThreshold(lua_State *L) { // ----------------------------------------------------------------------------- static int T_GetText(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); lua_pushstring(L, TextPtr->GetText().c_str()); return 1; @@ -1453,7 +1453,7 @@ static int T_GetText(lua_State *L) { // ----------------------------------------------------------------------------- static int T_GetFont(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); lua_pushstring(L, TextPtr->GetFont().c_str()); return 1; @@ -1462,7 +1462,7 @@ static int T_GetFont(lua_State *L) { // ----------------------------------------------------------------------------- static int T_GetAlpha(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); lua_pushnumber(L, TextPtr->GetAlpha()); return 1; @@ -1471,7 +1471,7 @@ static int T_GetAlpha(lua_State *L) { // ----------------------------------------------------------------------------- static int T_GetColor(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); lua_pushnumber(L, TextPtr->GetColor()); return 1; @@ -1480,7 +1480,7 @@ static int T_GetColor(lua_State *L) { // ----------------------------------------------------------------------------- static int T_IsAutoWrap(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); lua_pushbooleancpp(L, TextPtr->IsAutoWrapActive()); return 1; @@ -1489,7 +1489,7 @@ static int T_IsAutoWrap(lua_State *L) { // ----------------------------------------------------------------------------- static int T_GetAutoWrapThreshold(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); lua_pushnumber(L, TextPtr->GetAutoWrapThreshold()); return 1; @@ -1498,7 +1498,7 @@ static int T_GetAutoWrapThreshold(lua_State *L) { // ----------------------------------------------------------------------------- static int T_Remove(lua_State *L) { - BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L); + RenderObjectPtr<Text> TextPtr = CheckText(L); BS_ASSERT(TextPtr.IsValid()); TextPtr.Erase(); return 0; @@ -1525,7 +1525,7 @@ static const luaL_reg TEXT_METHODS[] = { // ----------------------------------------------------------------------------- -bool BS_GraphicEngine::RegisterScriptBindings() { +bool GraphicEngine::RegisterScriptBindings() { BS_Kernel *pKernel = BS_Kernel::GetInstance(); BS_ASSERT(pKernel); BS_ScriptEngine *pScript = static_cast<BS_ScriptEngine *>(pKernel->GetService("script")); diff --git a/engines/sword25/gfx/image/b25sloader.cpp b/engines/sword25/gfx/image/b25sloader.cpp index 9288e2c461..ea3266969c 100644 --- a/engines/sword25/gfx/image/b25sloader.cpp +++ b/engines/sword25/gfx/image/b25sloader.cpp @@ -73,11 +73,11 @@ unsigned int FindEmbeddedPNG(const char *FileDataPtr, unsigned int FileSize) { // ----------------------------------------------------------------------------- -bool BS_B25SLoader::IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) { +bool B25SLoader::IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) { // PNG innerhalb des Spielstandes finden und den Methodenaufruf zu BS_PNGLoader weiterreichen. unsigned int PNGOffset = FindEmbeddedPNG(FileDataPtr, FileSize); if (PNGOffset > 0) { - return BS_PNGLoader::DoIsCorrectImageFormat(FileDataPtr + PNGOffset, FileSize - PNGOffset); + return PNGLoader::DoIsCorrectImageFormat(FileDataPtr + PNGOffset, FileSize - PNGOffset); } return false; @@ -85,12 +85,12 @@ bool BS_B25SLoader::IsCorrectImageFormat(const char *FileDataPtr, unsigned int F // ----------------------------------------------------------------------------- -bool BS_B25SLoader::DecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr, +bool B25SLoader::DecodeImage(const char *FileDataPtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr, int &Width, int &Height, int &Pitch) { // PNG innerhalb des Spielstandes finden und den Methodenaufruf zu BS_PNGLoader weiterreichen. unsigned int PNGOffset = FindEmbeddedPNG(FileDataPtr, FileSize); if (PNGOffset > 0) { - return BS_PNGLoader::DoDecodeImage(FileDataPtr + PNGOffset, FileSize - PNGOffset, ColorFormat, UncompressedDataPtr, Width, Height, Pitch); + return PNGLoader::DoDecodeImage(FileDataPtr + PNGOffset, FileSize - PNGOffset, ColorFormat, UncompressedDataPtr, Width, Height, Pitch); } return false; @@ -98,11 +98,11 @@ bool BS_B25SLoader::DecodeImage(const char *FileDataPtr, unsigned int FileSize, // ----------------------------------------------------------------------------- -bool BS_B25SLoader::ImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) { +bool B25SLoader::ImageProperties(const char *FileDataPtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) { // PNG innerhalb des Spielstandes finden und den Methodenaufruf zu BS_PNGLoader weiterreichen. unsigned int PNGOffset = FindEmbeddedPNG(FileDataPtr, FileSize); if (PNGOffset > 0) { - return BS_PNGLoader::DoImageProperties(FileDataPtr + PNGOffset, FileSize - PNGOffset, ColorFormat, Width, Height); + return PNGLoader::DoImageProperties(FileDataPtr + PNGOffset, FileSize - PNGOffset, ColorFormat, Width, Height); } return false; diff --git a/engines/sword25/gfx/image/b25sloader.h b/engines/sword25/gfx/image/b25sloader.h index 8d8a68e6e8..aacac55ddd 100644 --- a/engines/sword25/gfx/image/b25sloader.h +++ b/engines/sword25/gfx/image/b25sloader.h @@ -48,19 +48,19 @@ namespace Sword25 { // Klassendeklaration // ----------------------------------------------------------------------------- -class BS_B25SLoader : public BS_ImageLoader { +class B25SLoader : public ImageLoader { public: - static BS_ImageLoader *CreateInstance() { + static ImageLoader *CreateInstance() { #include "sword25/kernel/memlog_off.h" - return static_cast<BS_ImageLoader *>(new BS_B25SLoader()); + return static_cast<ImageLoader *>(new B25SLoader()); #include "sword25/kernel/memlog_on.h" } protected: virtual bool IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize); - virtual bool DecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr, + virtual bool DecodeImage(const char *FileDataPtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr, int &Width, int &Height, int &Pitch); - virtual bool ImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height); + virtual bool ImageProperties(const char *FileDataPtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height); }; diff --git a/engines/sword25/gfx/image/image.h b/engines/sword25/gfx/image/image.h index 805a4b80a5..1b7b2f2694 100644 --- a/engines/sword25/gfx/image/image.h +++ b/engines/sword25/gfx/image/image.h @@ -52,9 +52,9 @@ namespace Sword25 { -class BS_Image { +class Image { public: - virtual ~BS_Image() {}; + virtual ~Image() {}; // Enums /** @@ -89,7 +89,7 @@ public: /** @brief Gibt das Farbformat des Bildes zurück */ - virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const = 0; + virtual GraphicEngine::COLOR_FORMATS GetColorFormat() const = 0; //@} diff --git a/engines/sword25/gfx/image/imageloader.cpp b/engines/sword25/gfx/image/imageloader.cpp index f350dba3f8..450bd1b8fb 100644 --- a/engines/sword25/gfx/image/imageloader.cpp +++ b/engines/sword25/gfx/image/imageloader.cpp @@ -40,14 +40,14 @@ namespace Sword25 { #define BS_LOG_PREFIX "IMAGELOADER" // Statische Elemente der Klasse BS_ImageLoader intialisieren. -std::list<BS_ImageLoader *> BS_ImageLoader::_ImageLoaderList; -bool BS_ImageLoader::_ImageLoaderListInitialized = false; +std::list<ImageLoader *> ImageLoader::_ImageLoaderList; +bool ImageLoader::_ImageLoaderListInitialized = false; // Lade Methode // ------------ -bool BS_ImageLoader::LoadImage(const char *pFileData, unsigned int FileSize, - BS_GraphicEngine::COLOR_FORMATS ColorFormat, +bool ImageLoader::LoadImage(const char *pFileData, unsigned int FileSize, + GraphicEngine::COLOR_FORMATS ColorFormat, byte *&pUncompressedData, int &Width, int &Height, int &Pitch) { @@ -56,7 +56,7 @@ bool BS_ImageLoader::LoadImage(const char *pFileData, unsigned int FileSize, _InitializeLoaderList(); // Passenden BS_ImageLoader finden und Bild dekodieren - BS_ImageLoader *pLoader = _FindSuitableImageLoader(pFileData, FileSize); + ImageLoader *pLoader = _FindSuitableImageLoader(pFileData, FileSize); if (pLoader) { return pLoader->DecodeImage(pFileData, FileSize, ColorFormat, @@ -71,15 +71,15 @@ bool BS_ImageLoader::LoadImage(const char *pFileData, unsigned int FileSize, // Info Methode // ------------ -bool BS_ImageLoader::ExtractImageProperties(const char *pFileData, unsigned int FileSize, - BS_GraphicEngine::COLOR_FORMATS &ColorFormat, +bool ImageLoader::ExtractImageProperties(const char *pFileData, unsigned int FileSize, + GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) { // Falls die Liste der BS_ImageLoader noch nicht initialisiert wurde, wird dies getan. if (!_ImageLoaderListInitialized) _InitializeLoaderList(); // Passenden BS_ImageLoader finden und Bildeigenschaften auslesen. - BS_ImageLoader *pLoader = _FindSuitableImageLoader(pFileData, FileSize); + ImageLoader *pLoader = _FindSuitableImageLoader(pFileData, FileSize); if (pLoader) { return pLoader->ImageProperties(pFileData, FileSize, ColorFormat, @@ -92,7 +92,7 @@ bool BS_ImageLoader::ExtractImageProperties(const char *pFileData, unsigned int // Verwaltungs Methoden // -------------------- -void BS_ImageLoader::_InitializeLoaderList() { +void ImageLoader::_InitializeLoaderList() { // Von jedem BS_ImageLoader wird eine Instanz erzeugt, diese fügen sich selbständig in die BS_ImageLoader-Liste ein. for (int i = 0; i < BS_IMAGELOADER_COUNT; i++) BS_IMAGELOADER_IDS[i](); @@ -101,19 +101,19 @@ void BS_ImageLoader::_InitializeLoaderList() { _ImageLoaderListInitialized = true; // Sicherstellen, dass beim Beenden alle BS_ImageLoader Instanzen zerstört werden. - atexit(BS_ImageLoader::_DeinitializeLoaderList); + atexit(ImageLoader::_DeinitializeLoaderList); } -void BS_ImageLoader::_DeinitializeLoaderList() { +void ImageLoader::_DeinitializeLoaderList() { while (!_ImageLoaderList.empty()) { delete _ImageLoaderList.back(); _ImageLoaderList.pop_back(); } } -BS_ImageLoader *BS_ImageLoader::_FindSuitableImageLoader(const char *pFileData, unsigned int FileSize) { +ImageLoader *ImageLoader::_FindSuitableImageLoader(const char *pFileData, unsigned int FileSize) { // Alle BS_ImageLoader-Objekte durchgehen, bis eins gefunden wurde, dass das Bild laden kann - std::list<BS_ImageLoader *>::iterator Iter = _ImageLoaderList.begin(); + std::list<ImageLoader *>::iterator Iter = _ImageLoaderList.begin(); for (; Iter != _ImageLoaderList.end(); ++Iter) { // Falls ein geeigneter BS-ImageLoader gefunden wurde, wird er zurückgegeben. if ((*Iter)->IsCorrectImageFormat(pFileData, FileSize)) { diff --git a/engines/sword25/gfx/image/imageloader.h b/engines/sword25/gfx/image/imageloader.h index 3d8e5cd05d..c626fc20a7 100644 --- a/engines/sword25/gfx/image/imageloader.h +++ b/engines/sword25/gfx/image/imageloader.h @@ -74,7 +74,7 @@ namespace Sword25 { - Zum Konvertieren der Bilddaten können die Hilfsmethoden dieser Klasse benutzt werden, die ARGB Bilddaten in alle benötigten Farbformate konvertieren. */ -class BS_ImageLoader { +class ImageLoader { public: //@{ @@ -105,7 +105,7 @@ public: @remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben. */ static bool LoadImage(const char *pFileData, unsigned int FileSize, - BS_GraphicEngine::COLOR_FORMATS ColorFormat, + GraphicEngine::COLOR_FORMATS ColorFormat, byte *&pUncompressedData, int &Width, int &Height, int &Pitch); @@ -122,7 +122,7 @@ public: @remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben. */ static bool ExtractImageProperties(const char *pFileData, unsigned int FileSize, - BS_GraphicEngine::COLOR_FORMATS &ColorFormat, + GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height); //@} @@ -136,12 +136,12 @@ protected: Diese Liste enthält jeweils eine Instanz jedes #BS_ImageLoader und wird benutzt um beliebige Bilddateien einem Loader zuzuordnen. @remark Dieser Konstruktor ist protected damit nur #BS_ImageLoader-Objekte diese Klasse instanziieren können. */ - BS_ImageLoader() { + ImageLoader() { // Klasse registrieren _ImageLoaderList.push_front(this); } - virtual ~BS_ImageLoader() {} + virtual ~ImageLoader() {} //@{ /** @name Abstrakte Methoden */ @@ -176,7 +176,7 @@ protected: @remark Diese Methode muss von allen BS_ImageLoader Klassen implementiert werden. */ virtual bool DecodeImage(const char *pFileData, unsigned int FileSize, - BS_GraphicEngine::COLOR_FORMATS ColorFormat, + GraphicEngine::COLOR_FORMATS ColorFormat, byte *&pUncompressedData, int &Width, int &Height, int &Pitch) = 0; @@ -193,7 +193,7 @@ protected: @remark Diese Methode muss von allen BS_ImageLoader Klassen implementiert werden. */ virtual bool ImageProperties(const char *pFileData, unsigned int FileSize, - BS_GraphicEngine::COLOR_FORMATS &ColorFormat, + GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) = 0; //@} @@ -354,9 +354,9 @@ private: @brief Sucht zu Bilddaten ein BS_ImageLoader Objekt, dass die Bilddaten dekodieren kann. @return Gibt einen Pointer auf ein passendes BS_ImageLoader Objekt zurück, oder NULL, wenn kein passendes Objekt gefunden wurde. */ - static BS_ImageLoader *_FindSuitableImageLoader(const char *pFileData, unsigned int FileSize); + static ImageLoader *_FindSuitableImageLoader(const char *pFileData, unsigned int FileSize); - static std::list<BS_ImageLoader *> _ImageLoaderList; // Die Liste aller BS_ImageLoader-Objekte + static std::list<ImageLoader *> _ImageLoaderList; // Die Liste aller BS_ImageLoader-Objekte static bool _ImageLoaderListInitialized; // Gibt an, ob die Liste schon intialisiert wurde }; diff --git a/engines/sword25/gfx/image/imageloader_ids.h b/engines/sword25/gfx/image/imageloader_ids.h index bde6293f50..8fb6872ad7 100644 --- a/engines/sword25/gfx/image/imageloader_ids.h +++ b/engines/sword25/gfx/image/imageloader_ids.h @@ -51,10 +51,10 @@ namespace Sword25 { // Die Tabelle enthält Pointer auf statische Member-Funktionen innerhalb der Klassen, die eine Instanz der Klasse // erzeugen -typedef BS_ImageLoader*(*BS_IMAGELOADER_NEW)(); +typedef ImageLoader*(*BS_IMAGELOADER_NEW)(); const BS_IMAGELOADER_NEW BS_IMAGELOADER_IDS[] = { - BS_PNGLoader::CreateInstance, - BS_B25SLoader::CreateInstance, + PNGLoader::CreateInstance, + B25SLoader::CreateInstance, }; const int BS_IMAGELOADER_COUNT = sizeof(BS_IMAGELOADER_IDS) / sizeof(BS_IMAGELOADER_NEW); diff --git a/engines/sword25/gfx/image/pngloader.cpp b/engines/sword25/gfx/image/pngloader.cpp index 8c323f9453..32a7769313 100644 --- a/engines/sword25/gfx/image/pngloader.cpp +++ b/engines/sword25/gfx/image/pngloader.cpp @@ -48,7 +48,7 @@ namespace Sword25 { // Konstruktor / Destruktor // ----------------------------------------------------------------------------- -BS_PNGLoader::BS_PNGLoader() { +PNGLoader::PNGLoader() { } // ----------------------------------------------------------------------------- @@ -62,7 +62,7 @@ static void png_user_read_data(png_structp png_ptr, png_bytep data, png_size_t l // ----------------------------------------------------------------------------- -bool BS_PNGLoader::DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr, +bool PNGLoader::DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr, int &Width, int &Height, int &Pitch) { png_structp png_ptr = NULL; png_infop info_ptr = NULL; @@ -75,12 +75,12 @@ bool BS_PNGLoader::DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, int i; // Zielfarbformat überprüfen - if (ColorFormat != BS_GraphicEngine::CF_RGB16 && - ColorFormat != BS_GraphicEngine::CF_RGB15 && - ColorFormat != BS_GraphicEngine::CF_RGB16_INTERLEAVED && - ColorFormat != BS_GraphicEngine::CF_RGB15_INTERLEAVED && - ColorFormat != BS_GraphicEngine::CF_ARGB32 && - ColorFormat != BS_GraphicEngine::CF_ABGR32) { + if (ColorFormat != GraphicEngine::CF_RGB16 && + ColorFormat != GraphicEngine::CF_RGB15 && + ColorFormat != GraphicEngine::CF_RGB16_INTERLEAVED && + ColorFormat != GraphicEngine::CF_RGB15_INTERLEAVED && + ColorFormat != GraphicEngine::CF_ARGB32 && + ColorFormat != GraphicEngine::CF_ABGR32) { BS_LOG_ERRORLN("Illegal or unsupported color format."); return false; } @@ -111,7 +111,7 @@ bool BS_PNGLoader::DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, png_get_IHDR(png_ptr, info_ptr, (png_uint_32 *)&Width, (png_uint_32 *)&Height, &BitDepth, &ColorType, &InterlaceType, NULL, NULL); // Pitch des Ausgabebildes berechnen - Pitch = BS_GraphicEngine::CalcPitch(ColorFormat, Width); + Pitch = GraphicEngine::CalcPitch(ColorFormat, Width); // Speicher für die endgültigen Bilddaten reservieren // Dieses geschieht vor dem reservieren von Speicher für temporäre Bilddaten um die Fragmentierung des Speichers gering zu halten @@ -157,28 +157,28 @@ bool BS_PNGLoader::DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, // Zeile konvertieren switch (ColorFormat) { - case BS_GraphicEngine::CF_RGB16: + case GraphicEngine::CF_RGB16: RowARGB32ToRGB16((byte *)RawDataBuffer, (byte *)&UncompressedDataPtr[i * Pitch], Width); break; - case BS_GraphicEngine::CF_RGB15: + case GraphicEngine::CF_RGB15: RowARGB32ToRGB15((byte *)RawDataBuffer, (byte *)&UncompressedDataPtr[i * Pitch], Width); break; - case BS_GraphicEngine::CF_RGB16_INTERLEAVED: + case GraphicEngine::CF_RGB16_INTERLEAVED: RowARGB32ToRGB16_INTERLEAVED((byte *)RawDataBuffer, (byte *)&UncompressedDataPtr[i * Pitch], Width); break; - case BS_GraphicEngine::CF_RGB15_INTERLEAVED: + case GraphicEngine::CF_RGB15_INTERLEAVED: RowARGB32ToRGB15_INTERLEAVED((byte *)RawDataBuffer, (byte *)&UncompressedDataPtr[i * Pitch], Width); break; - case BS_GraphicEngine::CF_ARGB32: + case GraphicEngine::CF_ARGB32: memcpy(&UncompressedDataPtr[i * Pitch], RawDataBuffer, Pitch); break; - case BS_GraphicEngine::CF_ABGR32: + case GraphicEngine::CF_ABGR32: RowARGB32ToABGR32((byte *)RawDataBuffer, (byte *)&UncompressedDataPtr[i * Pitch], Width); break; @@ -209,31 +209,31 @@ bool BS_PNGLoader::DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, // Bilddaten zeilenweise in das gewünschte Ausgabeformat konvertieren switch (ColorFormat) { - case BS_GraphicEngine::CF_RGB16: + case GraphicEngine::CF_RGB16: for (i = 0; i < Height; i++) RowARGB32ToRGB16((byte *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]), (byte *)&UncompressedDataPtr[i * Pitch], Width); break; - case BS_GraphicEngine::CF_RGB15: + case GraphicEngine::CF_RGB15: for (i = 0; i < Height; i++) RowARGB32ToRGB15((byte *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]), (byte *)&UncompressedDataPtr[i * Pitch], Width); break; - case BS_GraphicEngine::CF_RGB16_INTERLEAVED: + case GraphicEngine::CF_RGB16_INTERLEAVED: for (i = 0; i < Height; i++) RowARGB32ToRGB16_INTERLEAVED((byte *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]), (byte *)&UncompressedDataPtr[i * Pitch], Width); break; - case BS_GraphicEngine::CF_RGB15_INTERLEAVED: + case GraphicEngine::CF_RGB15_INTERLEAVED: for (i = 0; i < Height; i++) RowARGB32ToRGB15_INTERLEAVED((byte *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]), (byte *)&UncompressedDataPtr[i * Pitch], Width); break; - case BS_GraphicEngine::CF_ARGB32: + case GraphicEngine::CF_ARGB32: for (i = 0; i < Height; i++) memcpy(&UncompressedDataPtr[i * Pitch], &RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)], Pitch); break; @@ -259,14 +259,14 @@ bool BS_PNGLoader::DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, // ----------------------------------------------------------------------------- -bool BS_PNGLoader::DecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr, +bool PNGLoader::DecodeImage(const char *FileDataPtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr, int &Width, int &Height, int &Pitch) { return DoDecodeImage(FileDataPtr, FileSize, ColorFormat, UncompressedDataPtr, Width, Height, Pitch); } // ----------------------------------------------------------------------------- -bool BS_PNGLoader::DoImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) { +bool PNGLoader::DoImageProperties(const char *FileDataPtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) { // PNG Signatur überprüfen if (!DoIsCorrectImageFormat(FileDataPtr, FileSize)) return false; @@ -297,9 +297,9 @@ bool BS_PNGLoader::DoImageProperties(const char *FileDataPtr, unsigned int FileS // PNG-ColorType in BS ColorFormat konvertieren. if (ColorType & PNG_COLOR_MASK_ALPHA || png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) - ColorFormat = BS_GraphicEngine::CF_ARGB32; + ColorFormat = GraphicEngine::CF_ARGB32; else - ColorFormat = BS_GraphicEngine::CF_RGB24; + ColorFormat = GraphicEngine::CF_RGB24; // Die Strukturen freigeben png_destroy_read_struct(&png_ptr, &info_ptr, NULL); @@ -310,7 +310,7 @@ bool BS_PNGLoader::DoImageProperties(const char *FileDataPtr, unsigned int FileS // ----------------------------------------------------------------------------- -bool BS_PNGLoader::ImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) { +bool PNGLoader::ImageProperties(const char *FileDataPtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) { return DoImageProperties(FileDataPtr, FileSize, ColorFormat, Width, Height); } @@ -318,7 +318,7 @@ bool BS_PNGLoader::ImageProperties(const char *FileDataPtr, unsigned int FileSiz // Header überprüfen // ----------------------------------------------------------------------------- -bool BS_PNGLoader::DoIsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) { +bool PNGLoader::DoIsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) { if (FileSize > 8) return png_check_sig((byte *)FileDataPtr, 8) ? true : false; else @@ -327,7 +327,7 @@ bool BS_PNGLoader::DoIsCorrectImageFormat(const char *FileDataPtr, unsigned int // ----------------------------------------------------------------------------- -bool BS_PNGLoader::IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) { +bool PNGLoader::IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) { return DoIsCorrectImageFormat(FileDataPtr, FileSize); } diff --git a/engines/sword25/gfx/image/pngloader.h b/engines/sword25/gfx/image/pngloader.h index 17655c6fdc..68b7224868 100644 --- a/engines/sword25/gfx/image/pngloader.h +++ b/engines/sword25/gfx/image/pngloader.h @@ -50,30 +50,30 @@ namespace Sword25 { // Klassendefinition -class BS_PNGLoader : public BS_ImageLoader { +class PNGLoader : public ImageLoader { public: - static BS_ImageLoader *CreateInstance() { + static ImageLoader *CreateInstance() { #include "sword25/kernel/memlog_off.h" - return (BS_ImageLoader *) new BS_PNGLoader(); + return (ImageLoader *) new PNGLoader(); #include "sword25/kernel/memlog_on.h" } // Alle virtuellen Methoden von BS_ImageLoader sind hier als static-Methode implementiert, damit sie von BS_B25SLoader aufgerufen werden können. // Die virtuellen Methoden rufen diese Methoden auf. static bool DoIsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize); - static bool DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr, + static bool DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr, int &Width, int &Height, int &Pitch); - static bool DoImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height); + static bool DoImageProperties(const char *FileDataPtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height); protected: - BS_PNGLoader(); + PNGLoader(); bool DecodeImage(const char *pFileData, unsigned int FileSize, - BS_GraphicEngine::COLOR_FORMATS ColorFormat, + GraphicEngine::COLOR_FORMATS ColorFormat, byte *&pUncompressedData, int &Width, int &Height, int &Pitch); bool IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize); - bool ImageProperties(const char *FileDatePtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height); + bool ImageProperties(const char *FileDatePtr, unsigned int FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height); }; } // End of namespace Sword25 diff --git a/engines/sword25/gfx/image/vectorimage.cpp b/engines/sword25/gfx/image/vectorimage.cpp index f55833eccb..4d01e825ea 100644 --- a/engines/sword25/gfx/image/vectorimage.cpp +++ b/engines/sword25/gfx/image/vectorimage.cpp @@ -64,7 +64,7 @@ typedef int16_t s32; // Diese Klasse ist speziell dafür ausgestattet. // ----------------------------------------------------------------------------- -class BS_VectorImage::SWFBitStream { +class VectorImage::SWFBitStream { public: SWFBitStream(const unsigned char *pData, unsigned int DataSize) : m_Pos(pData), m_End(pData + DataSize), m_WordMask(0) @@ -171,7 +171,7 @@ const u32 MAX_ACCEPTED_FLASH_VERSION = 3; // Die höchste Flash-Dateiversion, d // Konvertiert SWF-Rechteckdaten in einem Bitstrom in BS_Rect-Objekte // ----------------------------------------------------------------------------- -BS_Rect FlashRectToBSRect(BS_VectorImage::SWFBitStream &bs) { +BS_Rect FlashRectToBSRect(VectorImage::SWFBitStream &bs) { bs.FlushByte(); // Feststellen mit wie vielen Bits die einzelnen Komponenten kodiert sind @@ -203,20 +203,20 @@ uint32 FlashColorToAGGRGBA8(unsigned int FlashColor) { // ----------------------------------------------------------------------------- struct CBBGetId { - CBBGetId(const BS_VectorImageElement &VectorImageElement_) : VectorImageElement(VectorImageElement_) {} + CBBGetId(const VectorImageElement &vectorImageElement_) : vectorImageElement(vectorImageElement_) {} unsigned operator [](unsigned i) const { - return VectorImageElement.GetPathInfo(i).GetID(); + return vectorImageElement.GetPathInfo(i).GetID(); } - const BS_VectorImageElement &VectorImageElement; + const VectorImageElement &vectorImageElement; }; -BS_Rect CalculateBoundingBox(const BS_VectorImageElement &VectorImageElement) { +BS_Rect CalculateBoundingBox(const VectorImageElement &vectorImageElement) { #if 0 // TODO - agg::path_storage Path = VectorImageElement.GetPaths(); - CBBGetId IdSource(VectorImageElement); + agg::path_storage Path = vectorImageElement.GetPaths(); + CBBGetId IdSource(vectorImageElement); double x1, x2, y1, y2; - agg::bounding_rect(Path, IdSource, 0, VectorImageElement.GetPathCount(), &x1, &y1, &x2, &y2); + agg::bounding_rect(Path, IdSource, 0, vectorImageElement.GetPathCount(), &x1, &y1, &x2, &y2); #else double x1, x2, y1, y2; x1 = x2 = y1 = y2 = 0; @@ -230,7 +230,7 @@ BS_Rect CalculateBoundingBox(const BS_VectorImageElement &VectorImageElement) { // Konstruktion // ----------------------------------------------------------------------------- -BS_VectorImage::BS_VectorImage(const unsigned char *pFileData, unsigned int FileSize, bool &Success) { +VectorImage::VectorImage(const unsigned char *pFileData, unsigned int FileSize, bool &Success) { Success = false; // Bitstream-Objekt erzeugen @@ -309,7 +309,7 @@ BS_VectorImage::BS_VectorImage(const unsigned char *pFileData, unsigned int File // ----------------------------------------------------------------------------- -bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream &bs) { +bool VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream &bs) { /*u32 ShapeID = */bs.GetU16(); // Bounding Box auslesen @@ -448,7 +448,7 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream &bs) } // Bounding-Boxes der einzelnen Elemente berechnen - Common::Array<BS_VectorImageElement>::iterator it = m_Elements.begin(); + Common::Array<VectorImageElement>::iterator it = m_Elements.begin(); for (; it != m_Elements.end(); ++it) it->m_BoundingBox = CalculateBoundingBox(*it); return true; @@ -457,7 +457,7 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream &bs) // ----------------------------------------------------------------------------- -bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream &bs, unsigned int &NumFillBits, unsigned int &NumLineBits) { +bool VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream &bs, unsigned int &NumFillBits, unsigned int &NumLineBits) { bs.FlushByte(); // Fillstyles parsen @@ -500,7 +500,7 @@ bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream &bs, unsig else Color = bs.GetBits(24) | (0xff << 24); - m_Elements.back().m_LineStyles.push_back(BS_VectorImageElement::LineStyleType(Width, FlashColorToAGGRGBA8(Color))); + m_Elements.back().m_LineStyles.push_back(VectorImageElement::LineStyleType(Width, FlashColorToAGGRGBA8(Color))); } // Bitbreite für die folgenden Styleindizes auslesen @@ -513,7 +513,7 @@ bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream &bs, unsig // ----------------------------------------------------------------------------- -bool BS_VectorImage::Fill(const BS_Rect *pFillRect, unsigned int Color) { +bool VectorImage::Fill(const BS_Rect *pFillRect, unsigned int Color) { BS_LOG_ERRORLN("Fill() is not supported."); return false; } @@ -521,14 +521,14 @@ bool BS_VectorImage::Fill(const BS_Rect *pFillRect, unsigned int Color) { // ----------------------------------------------------------------------------- -unsigned int BS_VectorImage::GetPixel(int X, int Y) { +unsigned int VectorImage::GetPixel(int X, int Y) { BS_LOG_ERRORLN("GetPixel() is not supported. Returning black."); return 0; } // ----------------------------------------------------------------------------- -bool BS_VectorImage::SetContent(const byte *Pixeldata, uint size, unsigned int Offset, unsigned int Stride) { +bool VectorImage::SetContent(const byte *Pixeldata, uint size, unsigned int Offset, unsigned int Stride) { BS_LOG_ERRORLN("SetContent() is not supported."); return 0; } diff --git a/engines/sword25/gfx/image/vectorimage.h b/engines/sword25/gfx/image/vectorimage.h index b17951bbdf..6fa98e57d1 100644 --- a/engines/sword25/gfx/image/vectorimage.h +++ b/engines/sword25/gfx/image/vectorimage.h @@ -50,7 +50,7 @@ namespace Sword25 { -class BS_VectorImage; +class VectorImage; /** @brief Pfadinformationen zu BS_VectorImageElement Objekten @@ -59,12 +59,12 @@ class BS_VectorImage; gespeichert werden. */ -class BS_VectorPathInfo { +class VectorPathInfo { public: - BS_VectorPathInfo(unsigned int ID, unsigned int LineStyle, unsigned int FillStyle0, unsigned int FillStyle1) : + VectorPathInfo(unsigned int ID, unsigned int LineStyle, unsigned int FillStyle0, unsigned int FillStyle1) : m_ID(ID), m_LineStyle(LineStyle), m_FillStyle0(FillStyle0), m_FillStyle1(FillStyle1) {} - BS_VectorPathInfo() { + VectorPathInfo() { m_ID = m_LineStyle = m_FillStyle0 = m_FillStyle1 = 0; } @@ -93,8 +93,8 @@ private: @brief Ein Element eines Vektorbild. Ein BS_VectorImage besteht aus diesen Elementen, die jeweils einen Teil der Graphik definieren. Werden alle Elemente eines Vektorbildes übereinandergelegt, ergibt sich das komplette Bild. */ -class BS_VectorImageElement { - friend class BS_VectorImage; +class VectorImageElement { + friend class VectorImage; public: #if 0 // TODO const agg::path_storage &GetPaths() const { @@ -105,7 +105,7 @@ public: unsigned int GetPathCount() const { return m_PathInfos.size(); } - const BS_VectorPathInfo &GetPathInfo(unsigned int PathNr) const { + const VectorPathInfo &GetPathInfo(unsigned int PathNr) const { BS_ASSERT(PathNr < GetPathCount()); return m_PathInfos[PathNr]; } @@ -148,7 +148,7 @@ private: #if 0 // TODO agg::path_storage m_Paths; #endif - Common::Array<BS_VectorPathInfo> m_PathInfos; + Common::Array<VectorPathInfo> m_PathInfos; Common::Array<LineStyleType> m_LineStyles; Common::Array<uint32> m_FillStyles; BS_Rect m_BoundingBox; @@ -161,14 +161,14 @@ private: Objekte dieser Klasse enthalten die Informationen eines SWF-Shapes. */ -class BS_VectorImage : public BS_Image { +class VectorImage : public Image { public: - BS_VectorImage(const unsigned char *pFileData, unsigned int FileSize, bool &Success); + VectorImage(const unsigned char *pFileData, unsigned int FileSize, bool &Success); unsigned int GetElementCount() const { return m_Elements.size(); } - const BS_VectorImageElement &GetElement(unsigned int ElementNr) const { + const VectorImageElement &GetElement(unsigned int ElementNr) const { BS_ASSERT(ElementNr < m_Elements.size()); return m_Elements[ElementNr]; } @@ -185,8 +185,8 @@ public: virtual int GetHeight() const { return m_BoundingBox.GetHeight(); } - virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const { - return BS_GraphicEngine::CF_ARGB32; + virtual GraphicEngine::COLOR_FORMATS GetColorFormat() const { + return GraphicEngine::CF_ARGB32; } virtual bool Fill(const BS_Rect *pFillRect = 0, unsigned int Color = BS_RGB(0, 0, 0)); virtual unsigned int GetPixel(int X, int Y); @@ -224,7 +224,7 @@ private: bool ParseDefineShape(unsigned int ShapeType, SWFBitStream &bs); bool ParseStyles(unsigned int ShapeType, SWFBitStream &bs, unsigned int &NumFillBits, unsigned int &NumLineBits); - Common::Array<BS_VectorImageElement> m_Elements; + Common::Array<VectorImageElement> m_Elements; BS_Rect m_BoundingBox; }; diff --git a/engines/sword25/gfx/image/vectorimagerenderer.cpp b/engines/sword25/gfx/image/vectorimagerenderer.cpp index 1b7fe29cdf..552b2cf58b 100644 --- a/engines/sword25/gfx/image/vectorimagerenderer.cpp +++ b/engines/sword25/gfx/image/vectorimagerenderer.cpp @@ -198,9 +198,9 @@ bool BS_VectorImageRenderer::Render(const BS_VectorImage &VectorImage, #else -BS_VectorImageRenderer::BS_VectorImageRenderer() {} +VectorImageRenderer::VectorImageRenderer() {} -bool BS_VectorImageRenderer::Render(const BS_VectorImage &VectorImage, +bool VectorImageRenderer::Render(const VectorImage &VectorImage, float ScaleFactorX, float ScaleFactorY, unsigned int &Width, unsigned int &Height, byte *ImageData, diff --git a/engines/sword25/gfx/image/vectorimagerenderer.h b/engines/sword25/gfx/image/vectorimagerenderer.h index 41e633ba76..e1cd25bb6a 100644 --- a/engines/sword25/gfx/image/vectorimagerenderer.h +++ b/engines/sword25/gfx/image/vectorimagerenderer.h @@ -55,18 +55,18 @@ namespace Sword25 { -class BS_VectorImage; +class VectorImage; /** @brief Rendert BS_VectorImage Objekte */ -class BS_VectorImageRenderer { +class VectorImageRenderer { public: - BS_VectorImageRenderer(); + VectorImageRenderer(); - bool Render(const BS_VectorImage &VectorImage, + bool Render(const VectorImage &VectorImage, float ScaleFactorX, float ScaleFactorY, unsigned int &Width, unsigned int &Height, byte *ImageData, diff --git a/engines/sword25/gfx/opengl/glimage.cpp b/engines/sword25/gfx/opengl/glimage.cpp index a7065cc03d..cc8f813fe6 100644 --- a/engines/sword25/gfx/opengl/glimage.cpp +++ b/engines/sword25/gfx/opengl/glimage.cpp @@ -51,7 +51,7 @@ namespace Sword25 { // CONSTRUCTION / DESTRUCTION // ----------------------------------------------------------------------------- -BS_GLImage::BS_GLImage(const Common::String &Filename, bool &Result) : +GLImage::GLImage(const Common::String &Filename, bool &Result) : _data(0), m_Width(0), m_Height(0) { @@ -60,7 +60,7 @@ BS_GLImage::BS_GLImage(const Common::String &Filename, bool &Result) : BS_PackageManager *pPackage = static_cast<BS_PackageManager *>(BS_Kernel::GetInstance()->GetService("package")); BS_ASSERT(pPackage); - _backSurface = (static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")))->getSurface(); + _backSurface = (static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")))->getSurface(); // Datei laden char *pFileData; @@ -71,15 +71,15 @@ BS_GLImage::BS_GLImage(const Common::String &Filename, bool &Result) : } // Bildeigenschaften bestimmen - BS_GraphicEngine::COLOR_FORMATS ColorFormat; + GraphicEngine::COLOR_FORMATS ColorFormat; int Pitch; - if (!BS_ImageLoader::ExtractImageProperties(pFileData, FileSize, ColorFormat, m_Width, m_Height)) { + if (!ImageLoader::ExtractImageProperties(pFileData, FileSize, ColorFormat, m_Width, m_Height)) { BS_LOG_ERRORLN("Could not read image properties."); return; } // Das Bild dekomprimieren - if (!BS_ImageLoader::LoadImage(pFileData, FileSize, BS_GraphicEngine::CF_ABGR32, _data, m_Width, m_Height, Pitch)) { + if (!ImageLoader::LoadImage(pFileData, FileSize, GraphicEngine::CF_ABGR32, _data, m_Width, m_Height, Pitch)) { BS_LOG_ERRORLN("Could not decode image."); return; } @@ -93,7 +93,7 @@ BS_GLImage::BS_GLImage(const Common::String &Filename, bool &Result) : // ----------------------------------------------------------------------------- -BS_GLImage::BS_GLImage(unsigned int Width, unsigned int Height, bool &Result) : +GLImage::GLImage(unsigned int Width, unsigned int Height, bool &Result) : m_Width(Width), m_Height(Height) { Result = false; @@ -106,20 +106,20 @@ BS_GLImage::BS_GLImage(unsigned int Width, unsigned int Height, bool &Result) : // ----------------------------------------------------------------------------- -BS_GLImage::~BS_GLImage() { +GLImage::~GLImage() { delete[] _data; } // ----------------------------------------------------------------------------- -bool BS_GLImage::Fill(const BS_Rect *pFillRect, unsigned int Color) { +bool GLImage::Fill(const BS_Rect *pFillRect, unsigned int Color) { BS_LOG_ERRORLN("Fill() is not supported."); return false; } // ----------------------------------------------------------------------------- -bool BS_GLImage::SetContent(const byte *Pixeldata, uint size, unsigned int Offset, unsigned int Stride) { +bool GLImage::SetContent(const byte *Pixeldata, uint size, unsigned int Offset, unsigned int Stride) { // Überprüfen, ob PixelData ausreichend viele Pixel enthält um ein Bild der Größe Width * Height zu erzeugen if (size < static_cast<unsigned int>(m_Width * m_Height * 4)) { BS_LOG_ERRORLN("PixelData vector is too small to define a 32 bit %dx%d image.", m_Width, m_Height); @@ -140,14 +140,14 @@ bool BS_GLImage::SetContent(const byte *Pixeldata, uint size, unsigned int Offse // ----------------------------------------------------------------------------- -unsigned int BS_GLImage::GetPixel(int X, int Y) { +unsigned int GLImage::GetPixel(int X, int Y) { BS_LOG_ERRORLN("GetPixel() is not supported. Returning black."); return 0; } // ----------------------------------------------------------------------------- -bool BS_GLImage::Blit(int PosX, int PosY, int Flipping, BS_Rect *pPartRect, unsigned int Color, int Width, int Height) { +bool GLImage::Blit(int PosX, int PosY, int Flipping, BS_Rect *pPartRect, unsigned int Color, int Width, int Height) { int x1 = 0, y1 = 0; int w = m_Width, h = m_Height; if (pPartRect) { @@ -177,7 +177,7 @@ bool BS_GLImage::Blit(int PosX, int PosY, int Flipping, BS_Rect *pPartRect, unsi warning("STUB: Sprite scaling (%f x %f)", ScaleX, ScaleY); } - if (Flipping & (BS_Image::FLIP_V | BS_Image::FLIP_H)) { + if (Flipping & (Image::FLIP_V | Image::FLIP_H)) { warning("STUB: Sprite flipping"); } diff --git a/engines/sword25/gfx/opengl/glimage.h b/engines/sword25/gfx/opengl/glimage.h index 678a40aff4..13276798e0 100644 --- a/engines/sword25/gfx/opengl/glimage.h +++ b/engines/sword25/gfx/opengl/glimage.h @@ -55,9 +55,9 @@ typedef void *GLS_Sprite; // CLASS DEFINITION // ----------------------------------------------------------------------------- -class BS_GLImage : public BS_Image { +class GLImage : public Image { public: - BS_GLImage(const Common::String &Filename, bool &Result); + GLImage(const Common::String &Filename, bool &Result); /** @brief Erzeugt ein leeres BS_GLImage @@ -67,8 +67,8 @@ public: @param Result gibt dem Aufrufer bekannt, ob der Konstruktor erfolgreich ausgeführt wurde. Wenn es nach dem Aufruf false enthalten sollte, dürfen keine Methoden am Objekt aufgerufen werden und das Objekt ist sofort zu zerstören. */ - BS_GLImage(unsigned int Width, unsigned int Height, bool &Result); - virtual ~BS_GLImage(); + GLImage(unsigned int Width, unsigned int Height, bool &Result); + virtual ~GLImage(); virtual int GetWidth() const { return m_Width; @@ -76,12 +76,12 @@ public: virtual int GetHeight() const { return m_Height; } - virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const { - return BS_GraphicEngine::CF_ARGB32; + virtual GraphicEngine::COLOR_FORMATS GetColorFormat() const { + return GraphicEngine::CF_ARGB32; } virtual bool Blit(int PosX = 0, int PosY = 0, - int Flipping = BS_Image::FLIP_NONE, + int Flipping = Image::FLIP_NONE, BS_Rect *pPartRect = NULL, unsigned int Color = BS_ARGB(255, 255, 255, 255), int Width = -1, int Height = -1); diff --git a/engines/sword25/gfx/opengl/glvectorimageblit.cpp b/engines/sword25/gfx/opengl/glvectorimageblit.cpp index a0945ba569..7dc6dd661d 100644 --- a/engines/sword25/gfx/opengl/glvectorimageblit.cpp +++ b/engines/sword25/gfx/opengl/glvectorimageblit.cpp @@ -51,7 +51,7 @@ const float LINE_SCALE_FACTOR = 1.0f; // ----------------------------------------------------------------------------- -bool BS_VectorImage::Blit(int PosX, int PosY, +bool VectorImage::Blit(int PosX, int PosY, int Flipping, BS_Rect *pPartRect, unsigned int Color, diff --git a/engines/sword25/gfx/opengl/openglgfx.cpp b/engines/sword25/gfx/opengl/openglgfx.cpp index 30263d7b1d..f9dda32b40 100644 --- a/engines/sword25/gfx/opengl/openglgfx.cpp +++ b/engines/sword25/gfx/opengl/openglgfx.cpp @@ -73,21 +73,21 @@ const Common::String B25S_EXTENSION(".b25s"); // CONSTRUCTION / DESTRUCTION // ----------------------------------------------------------------------------- -BS_OpenGLGfx::BS_OpenGLGfx(BS_Kernel *pKernel) : - BS_GraphicEngine(pKernel), +OpenGLGfx::OpenGLGfx(BS_Kernel *pKernel) : + GraphicEngine(pKernel), m_GLspritesInitialized(false) { } // ----------------------------------------------------------------------------- -BS_OpenGLGfx::~BS_OpenGLGfx() { +OpenGLGfx::~OpenGLGfx() { _backSurface.free(); } // ----------------------------------------------------------------------------- BS_Service *BS_OpenGLGfx_CreateObject(BS_Kernel *pKernel) { - return new BS_OpenGLGfx(pKernel); + return new OpenGLGfx(pKernel); } @@ -95,7 +95,7 @@ BS_Service *BS_OpenGLGfx_CreateObject(BS_Kernel *pKernel) { // INTERFACE // ----------------------------------------------------------------------------- -bool BS_OpenGLGfx::Init(int Width, int Height, int BitDepth, int BackbufferCount, bool Windowed) { +bool OpenGLGfx::Init(int Width, int Height, int BitDepth, int BackbufferCount, bool Windowed) { // Warnung ausgeben, wenn eine nicht unterstützte Bittiefe gewählt wurde. if (BitDepth != BIT_DEPTH) { BS_LOG_WARNINGLN("Can't use a bit depth of %d (not supported). Falling back to %d.", BitDepth, BIT_DEPTH); @@ -127,7 +127,7 @@ bool BS_OpenGLGfx::Init(int Width, int Height, int BitDepth, int BackbufferCount SetVsync(true); // Layer-Manager initialisieren. - m_RenderObjectManagerPtr.reset(new BS_RenderObjectManager(Width, Height, BackbufferCount + 1)); + m_RenderObjectManagerPtr.reset(new RenderObjectManager(Width, Height, BackbufferCount + 1)); // Hauptpanel erstellen m_MainPanelPtr = m_RenderObjectManagerPtr->GetTreeRoot()->AddPanel(Width, Height, BS_ARGB(0, 0, 0, 0)); @@ -139,7 +139,7 @@ bool BS_OpenGLGfx::Init(int Width, int Height, int BitDepth, int BackbufferCount // ----------------------------------------------------------------------------- -bool BS_OpenGLGfx::StartFrame(bool UpdateAll) { +bool OpenGLGfx::StartFrame(bool UpdateAll) { // Berechnen, wie viel Zeit seit dem letzten Frame vergangen ist. // Dieser Wert kann über GetLastFrameDuration() von Modulen abgefragt werden, die zeitabhängig arbeiten. UpdateLastFrameDuration(); @@ -152,7 +152,7 @@ bool BS_OpenGLGfx::StartFrame(bool UpdateAll) { // ----------------------------------------------------------------------------- -bool BS_OpenGLGfx::EndFrame() { +bool OpenGLGfx::EndFrame() { // Scene zeichnen m_RenderObjectManagerPtr->Render(); @@ -192,19 +192,19 @@ bool BS_OpenGLGfx::EndFrame() { // ----------------------------------------------------------------------------- -BS_RenderObjectPtr<BS_Panel> BS_OpenGLGfx::GetMainPanel() { +RenderObjectPtr<Panel> OpenGLGfx::GetMainPanel() { return m_MainPanelPtr; } // ----------------------------------------------------------------------------- -void BS_OpenGLGfx::SetVsync(bool Vsync) { +void OpenGLGfx::SetVsync(bool Vsync) { warning("STUB: SetVsync(%d)", Vsync); } // ----------------------------------------------------------------------------- -bool BS_OpenGLGfx::GetVsync() const { +bool OpenGLGfx::GetVsync() const { warning("STUB: GetVsync()"); return true; @@ -212,7 +212,7 @@ bool BS_OpenGLGfx::GetVsync() const { // ----------------------------------------------------------------------------- -bool BS_OpenGLGfx::Fill(const BS_Rect *FillRectPtr, unsigned int Color) { +bool OpenGLGfx::Fill(const BS_Rect *FillRectPtr, unsigned int Color) { BS_Rect Rect; if (!FillRectPtr) { @@ -230,7 +230,7 @@ bool BS_OpenGLGfx::Fill(const BS_Rect *FillRectPtr, unsigned int Color) { // ----------------------------------------------------------------------------- -bool BS_OpenGLGfx::GetScreenshot(unsigned int &Width, unsigned int &Height, byte **Data) { +bool OpenGLGfx::GetScreenshot(unsigned int &Width, unsigned int &Height, byte **Data) { if (!ReadFramebufferContents(m_Width, m_Height, Data)) return false; @@ -247,7 +247,7 @@ bool BS_OpenGLGfx::GetScreenshot(unsigned int &Width, unsigned int &Height, byte // ----------------------------------------------------------------------------- -bool BS_OpenGLGfx::ReadFramebufferContents(unsigned int Width, unsigned int Height, byte **Data) { +bool OpenGLGfx::ReadFramebufferContents(unsigned int Width, unsigned int Height, byte **Data) { *Data = (byte *)malloc(Width * Height * 4); return true; @@ -255,7 +255,7 @@ bool BS_OpenGLGfx::ReadFramebufferContents(unsigned int Width, unsigned int Heig // ----------------------------------------------------------------------------- -void BS_OpenGLGfx::ReverseRGBAComponentOrder(byte *Data, uint size) { +void OpenGLGfx::ReverseRGBAComponentOrder(byte *Data, uint size) { uint32 *ptr = (uint32 *)Data; for (uint i = 0; i < size; i++) { @@ -267,7 +267,7 @@ void BS_OpenGLGfx::ReverseRGBAComponentOrder(byte *Data, uint size) { // ----------------------------------------------------------------------------- -void BS_OpenGLGfx::FlipImagedataVertical(unsigned int Width, unsigned int Height, byte *Data) { +void OpenGLGfx::FlipImagedataVertical(unsigned int Width, unsigned int Height, byte *Data) { #if 0 // TODO vector<unsigned int> LineBuffer(Width); @@ -285,19 +285,19 @@ void BS_OpenGLGfx::FlipImagedataVertical(unsigned int Width, unsigned int Height // RESOURCE MANAGING // ----------------------------------------------------------------------------- -BS_Resource *BS_OpenGLGfx::LoadResource(const Common::String &FileName) { +BS_Resource *OpenGLGfx::LoadResource(const Common::String &FileName) { BS_ASSERT(CanLoadResource(FileName)); // Bild für den Softwarebuffer laden if (FileName.hasSuffix(PNG_S_EXTENSION)) { bool Result; - BS_SWImage *pImage = new BS_SWImage(FileName, Result); + SWImage *pImage = new SWImage(FileName, Result); if (!Result) { delete pImage; return 0; } - BS_BitmapResource *pResource = new BS_BitmapResource(FileName, pImage); + BitmapResource *pResource = new BitmapResource(FileName, pImage); if (!pResource->IsValid()) { delete pResource; return 0; @@ -309,13 +309,13 @@ BS_Resource *BS_OpenGLGfx::LoadResource(const Common::String &FileName) { // Sprite-Bild laden if (FileName.hasSuffix(PNG_EXTENSION) || FileName.hasSuffix(B25S_EXTENSION)) { bool Result; - BS_GLImage *pImage = new BS_GLImage(FileName, Result); + GLImage *pImage = new GLImage(FileName, Result); if (!Result) { delete pImage; return 0; } - BS_BitmapResource *pResource = new BS_BitmapResource(FileName, pImage); + BitmapResource *pResource = new BitmapResource(FileName, pImage); if (!pResource->IsValid()) { delete pResource; return 0; @@ -340,14 +340,14 @@ BS_Resource *BS_OpenGLGfx::LoadResource(const Common::String &FileName) { } bool Result; - BS_VectorImage *pImage = new BS_VectorImage(pFileData, FileSize, Result); + VectorImage *pImage = new VectorImage(pFileData, FileSize, Result); if (!Result) { delete pImage; delete [] pFileData; return 0; } - BS_BitmapResource *pResource = new BS_BitmapResource(FileName, pImage); + BitmapResource *pResource = new BitmapResource(FileName, pImage); if (!pResource->IsValid()) { delete pResource; delete [] pFileData; @@ -360,7 +360,7 @@ BS_Resource *BS_OpenGLGfx::LoadResource(const Common::String &FileName) { // Animation laden if (FileName.hasSuffix(ANI_EXTENSION)) { - BS_AnimationResource *pResource = new BS_AnimationResource(FileName); + AnimationResource *pResource = new AnimationResource(FileName); if (pResource->IsValid()) return pResource; else { @@ -371,7 +371,7 @@ BS_Resource *BS_OpenGLGfx::LoadResource(const Common::String &FileName) { // Font laden if (FileName.hasSuffix(FNT_EXTENSION)) { - BS_FontResource *pResource = new BS_FontResource(BS_Kernel::GetInstance(), FileName); + FontResource *pResource = new FontResource(BS_Kernel::GetInstance(), FileName); if (pResource->IsValid()) return pResource; else { @@ -386,7 +386,7 @@ BS_Resource *BS_OpenGLGfx::LoadResource(const Common::String &FileName) { // ----------------------------------------------------------------------------- -bool BS_OpenGLGfx::CanLoadResource(const Common::String &FileName) { +bool OpenGLGfx::CanLoadResource(const Common::String &FileName) { return FileName.hasSuffix(PNG_EXTENSION) || FileName.hasSuffix(ANI_EXTENSION) || FileName.hasSuffix(FNT_EXTENSION) || @@ -399,7 +399,7 @@ bool BS_OpenGLGfx::CanLoadResource(const Common::String &FileName) { // DEBUGGING // ----------------------------------------------------------------------------- -void BS_OpenGLGfx::DrawDebugLine(const BS_Vertex &Start, const BS_Vertex &End, unsigned int Color) { +void OpenGLGfx::DrawDebugLine(const BS_Vertex &Start, const BS_Vertex &End, unsigned int Color) { m_DebugLines.push_back(DebugLine(Start, End, Color)); } @@ -407,10 +407,10 @@ void BS_OpenGLGfx::DrawDebugLine(const BS_Vertex &Start, const BS_Vertex &End, u // PERSISTENZ // ----------------------------------------------------------------------------- -bool BS_OpenGLGfx::Persist(BS_OutputPersistenceBlock &Writer) { +bool OpenGLGfx::Persist(BS_OutputPersistenceBlock &Writer) { bool result = true; - result &= BS_GraphicEngine::Persist(Writer); + result &= GraphicEngine::Persist(Writer); result &= m_RenderObjectManagerPtr->Persist(Writer); return result; @@ -418,10 +418,10 @@ bool BS_OpenGLGfx::Persist(BS_OutputPersistenceBlock &Writer) { // ----------------------------------------------------------------------------- -bool BS_OpenGLGfx::Unpersist(BS_InputPersistenceBlock &Reader) { +bool OpenGLGfx::Unpersist(BS_InputPersistenceBlock &Reader) { bool result = true; - result &= BS_GraphicEngine::Unpersist(Reader); + result &= GraphicEngine::Unpersist(Reader); result &= m_RenderObjectManagerPtr->Unpersist(Reader); return result && Reader.IsGood(); diff --git a/engines/sword25/gfx/opengl/openglgfx.h b/engines/sword25/gfx/opengl/openglgfx.h index b62ecf960d..4a7994a92c 100644 --- a/engines/sword25/gfx/opengl/openglgfx.h +++ b/engines/sword25/gfx/opengl/openglgfx.h @@ -52,19 +52,19 @@ namespace Sword25 { class BS_Kernel; class BS_Service; class BS_Resource; -class BS_Panel; +class Panel; class BS_Image; -class BS_RenderObjectManager; +class RenderObjectManager; // ----------------------------------------------------------------------------- // CLASS DECLARATION // ----------------------------------------------------------------------------- -class BS_OpenGLGfx : public BS_GraphicEngine { +class OpenGLGfx : public GraphicEngine { public: - BS_OpenGLGfx(BS_Kernel *pKernel); - virtual ~BS_OpenGLGfx(); + OpenGLGfx(BS_Kernel *pKernel); + virtual ~OpenGLGfx(); // Interface // --------- @@ -72,7 +72,7 @@ public: virtual bool StartFrame(bool UpdateAll); virtual bool EndFrame(); - virtual BS_RenderObjectPtr<BS_Panel> GetMainPanel(); + virtual RenderObjectPtr<Panel> GetMainPanel(); virtual void SetVsync(bool Vsync); virtual bool GetVsync() const; @@ -98,9 +98,9 @@ private: bool m_GLspritesInitialized; byte *_backBuffer; - BS_RenderObjectPtr<BS_Panel> m_MainPanelPtr; + RenderObjectPtr<Panel> m_MainPanelPtr; - std::auto_ptr<BS_RenderObjectManager> m_RenderObjectManagerPtr; + std::auto_ptr<RenderObjectManager> m_RenderObjectManagerPtr; struct DebugLine { DebugLine(const BS_Vertex &_Start, const BS_Vertex &_End, unsigned int _Color) : diff --git a/engines/sword25/gfx/opengl/swimage.cpp b/engines/sword25/gfx/opengl/swimage.cpp index 6fff44a75c..06308bff87 100644 --- a/engines/sword25/gfx/opengl/swimage.cpp +++ b/engines/sword25/gfx/opengl/swimage.cpp @@ -50,7 +50,7 @@ namespace Sword25 { // CONSTRUCTION / DESTRUCTION // ----------------------------------------------------------------------------- -BS_SWImage::BS_SWImage(const Common::String &Filename, bool &Result) : +SWImage::SWImage(const Common::String &Filename, bool &Result) : _ImageDataPtr(0), m_Width(0), m_Height(0) { @@ -68,16 +68,16 @@ BS_SWImage::BS_SWImage(const Common::String &Filename, bool &Result) : } // Bildeigenschaften bestimmen - BS_GraphicEngine::COLOR_FORMATS ColorFormat; + GraphicEngine::COLOR_FORMATS ColorFormat; int Pitch; - if (!BS_ImageLoader::ExtractImageProperties(pFileData, FileSize, ColorFormat, m_Width, m_Height)) { + if (!ImageLoader::ExtractImageProperties(pFileData, FileSize, ColorFormat, m_Width, m_Height)) { BS_LOG_ERRORLN("Could not read image properties."); return; } // Das Bild dekomprimieren byte *pUncompressedData; - if (!BS_ImageLoader::LoadImage(pFileData, FileSize, BS_GraphicEngine::CF_ABGR32, pUncompressedData, m_Width, m_Height, Pitch)) { + if (!ImageLoader::LoadImage(pFileData, FileSize, GraphicEngine::CF_ABGR32, pUncompressedData, m_Width, m_Height, Pitch)) { BS_LOG_ERRORLN("Could not decode image."); return; } @@ -93,14 +93,14 @@ BS_SWImage::BS_SWImage(const Common::String &Filename, bool &Result) : // ----------------------------------------------------------------------------- -BS_SWImage::~BS_SWImage() { +SWImage::~SWImage() { delete [] _ImageDataPtr; } // ----------------------------------------------------------------------------- -bool BS_SWImage::Blit(int PosX, int PosY, +bool SWImage::Blit(int PosX, int PosY, int Flipping, BS_Rect *pPartRect, unsigned int Color, @@ -111,21 +111,21 @@ bool BS_SWImage::Blit(int PosX, int PosY, // ----------------------------------------------------------------------------- -bool BS_SWImage::Fill(const BS_Rect *pFillRect, unsigned int Color) { +bool SWImage::Fill(const BS_Rect *pFillRect, unsigned int Color) { BS_LOG_ERRORLN("Fill() is not supported."); return false; } // ----------------------------------------------------------------------------- - bool BS_SWImage::SetContent(const byte *Pixeldata, uint size, unsigned int Offset, unsigned int Stride) { + bool SWImage::SetContent(const byte *Pixeldata, uint size, unsigned int Offset, unsigned int Stride) { BS_LOG_ERRORLN("SetContent() is not supported."); return false; } // ----------------------------------------------------------------------------- -unsigned int BS_SWImage::GetPixel(int X, int Y) { +unsigned int SWImage::GetPixel(int X, int Y) { BS_ASSERT(X >= 0 && X < m_Width); BS_ASSERT(Y >= 0 && Y < m_Height); diff --git a/engines/sword25/gfx/opengl/swimage.h b/engines/sword25/gfx/opengl/swimage.h index d6e066661c..d563125d26 100644 --- a/engines/sword25/gfx/opengl/swimage.h +++ b/engines/sword25/gfx/opengl/swimage.h @@ -50,10 +50,10 @@ namespace Sword25 { // CLASS DEFINITION // ----------------------------------------------------------------------------- -class BS_SWImage : public BS_Image { +class SWImage : public Image { public: - BS_SWImage(const Common::String &Filename, bool &Result); - virtual ~BS_SWImage(); + SWImage(const Common::String &Filename, bool &Result); + virtual ~SWImage(); virtual int GetWidth() const { return m_Width; @@ -61,12 +61,12 @@ public: virtual int GetHeight() const { return m_Height; } - virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const { - return BS_GraphicEngine::CF_ARGB32; + virtual GraphicEngine::COLOR_FORMATS GetColorFormat() const { + return GraphicEngine::CF_ARGB32; } virtual bool Blit(int PosX = 0, int PosY = 0, - int Flipping = BS_Image::FLIP_NONE, + int Flipping = Image::FLIP_NONE, BS_Rect *pPartRect = NULL, unsigned int Color = BS_ARGB(255, 255, 255, 255), int Width = -1, int Height = -1); diff --git a/engines/sword25/gfx/panel.cpp b/engines/sword25/gfx/panel.cpp index 54d0dbc372..c7c7f0b817 100644 --- a/engines/sword25/gfx/panel.cpp +++ b/engines/sword25/gfx/panel.cpp @@ -53,8 +53,8 @@ namespace Sword25 { // Construction/Destruction // ----------------------------------------------------------------------------- -BS_Panel::BS_Panel(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, int Width, int Height, unsigned int Color) : - BS_RenderObject(ParentPtr, BS_RenderObject::TYPE_PANEL), +Panel::Panel(RenderObjectPtr<RenderObject> ParentPtr, int Width, int Height, unsigned int Color) : + RenderObject(ParentPtr, RenderObject::TYPE_PANEL), m_Color(Color) { m_InitSuccess = false; @@ -76,25 +76,25 @@ BS_Panel::BS_Panel(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, int Width, int // ----------------------------------------------------------------------------- -BS_Panel::BS_Panel(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) : - BS_RenderObject(ParentPtr, BS_RenderObject::TYPE_PANEL, Handle) { +Panel::Panel(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) : + RenderObject(ParentPtr, RenderObject::TYPE_PANEL, Handle) { m_InitSuccess = Unpersist(Reader); } // ----------------------------------------------------------------------------- -BS_Panel::~BS_Panel() { +Panel::~Panel() { } // ----------------------------------------------------------------------------- // Rendern // ----------------------------------------------------------------------------- -bool BS_Panel::DoRender() { +bool Panel::DoRender() { // Falls der Alphawert 0 ist, ist das Panel komplett durchsichtig und es muss nichts gezeichnet werden. if (m_Color >> 24 == 0) return true; - BS_GraphicEngine *GfxPtr = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); + GraphicEngine *GfxPtr = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); BS_ASSERT(GfxPtr); return GfxPtr->Fill(&m_BBox, m_Color); @@ -104,29 +104,29 @@ bool BS_Panel::DoRender() { // Persistenz // ----------------------------------------------------------------------------- -bool BS_Panel::Persist(BS_OutputPersistenceBlock &Writer) { +bool Panel::Persist(BS_OutputPersistenceBlock &Writer) { bool Result = true; - Result &= BS_RenderObject::Persist(Writer); + Result &= RenderObject::Persist(Writer); Writer.Write(m_Color); - Result &= BS_RenderObject::PersistChildren(Writer); + Result &= RenderObject::PersistChildren(Writer); return Result; } // ----------------------------------------------------------------------------- -bool BS_Panel::Unpersist(BS_InputPersistenceBlock &Reader) { +bool Panel::Unpersist(BS_InputPersistenceBlock &Reader) { bool Result = true; - Result &= BS_RenderObject::Unpersist(Reader); + Result &= RenderObject::Unpersist(Reader); unsigned int Color; Reader.Read(Color); SetColor(Color); - Result &= BS_RenderObject::UnpersistChildren(Reader); + Result &= RenderObject::UnpersistChildren(Reader); return Reader.IsGood() && Result; } diff --git a/engines/sword25/gfx/panel.h b/engines/sword25/gfx/panel.h index ca37c2703c..4e318dd7b1 100644 --- a/engines/sword25/gfx/panel.h +++ b/engines/sword25/gfx/panel.h @@ -48,15 +48,15 @@ namespace Sword25 { // Class Definition // ----------------------------------------------------------------------------- -class BS_Panel : public BS_RenderObject { - friend class BS_RenderObject; +class Panel : public RenderObject { + friend class RenderObject; private: - BS_Panel(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, int Width, int Height, unsigned int Color); - BS_Panel(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle); + Panel(RenderObjectPtr<RenderObject> ParentPtr, int Width, int Height, unsigned int Color); + Panel(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle); public: - virtual ~BS_Panel(); + virtual ~Panel(); unsigned int GetColor() const { return m_Color; diff --git a/engines/sword25/gfx/renderobject.cpp b/engines/sword25/gfx/renderobject.cpp index 90c7daf7d2..af44117e70 100644 --- a/engines/sword25/gfx/renderobject.cpp +++ b/engines/sword25/gfx/renderobject.cpp @@ -57,7 +57,7 @@ namespace Sword25 { // Konstruktion / Destruktion // -------------------------- -BS_RenderObject::BS_RenderObject(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, TYPES Type, unsigned int Handle) : +RenderObject::RenderObject(RenderObjectPtr<RenderObject> ParentPtr, TYPES Type, unsigned int Handle) : m_ManagerPtr(0), m_ParentPtr(ParentPtr), m_X(0), @@ -78,9 +78,9 @@ BS_RenderObject::BS_RenderObject(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, // Renderobject registrieren, abhängig vom Handle-Parameter entweder mit beliebigem oder vorgegebenen Handle. if (Handle == 0) - m_Handle = BS_RenderObjectRegistry::GetInstance().RegisterObject(this); + m_Handle = RenderObjectRegistry::GetInstance().RegisterObject(this); else - m_Handle = BS_RenderObjectRegistry::GetInstance().RegisterObject(this, Handle); + m_Handle = RenderObjectRegistry::GetInstance().RegisterObject(this, Handle); if (m_Handle == 0) return; UpdateAbsolutePos(); @@ -102,19 +102,19 @@ BS_RenderObject::BS_RenderObject(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, m_InitSuccess = true; } -BS_RenderObject::~BS_RenderObject() { +RenderObject::~RenderObject() { // Objekt aus dem Elternobjekt entfernen. if (m_ParentPtr.IsValid()) m_ParentPtr->DetatchChildren(this->GetHandle()); DeleteAllChildren(); // Objekt deregistrieren. - BS_RenderObjectRegistry::GetInstance().DeregisterObject(this); + RenderObjectRegistry::GetInstance().DeregisterObject(this); } // Rendern // ------- -bool BS_RenderObject::Render() { +bool RenderObject::Render() { // Objektänderungen validieren ValidateObject(); @@ -142,7 +142,7 @@ bool BS_RenderObject::Render() { // Objektverwaltung // ---------------- -void BS_RenderObject::ValidateObject() { +void RenderObject::ValidateObject() { // Die Veränderungen in den Objektvariablen aufheben m_OldBBox = m_BBox; m_OldVisible = m_Visible; @@ -152,7 +152,7 @@ void BS_RenderObject::ValidateObject() { m_RefreshForced = false; } -bool BS_RenderObject::UpdateObjectState() { +bool RenderObject::UpdateObjectState() { // Falls sich das Objekt verändert hat, muss der interne Zustand neu berechnet werden und evtl. Update-Regions für den nächsten Frame // registriert werden. if ((CalcBoundingBox() != m_OldBBox) || @@ -179,12 +179,12 @@ bool BS_RenderObject::UpdateObjectState() { return true; } -void BS_RenderObject::UpdateBoxes() { +void RenderObject::UpdateBoxes() { // Bounding-Box aktualisieren m_BBox = CalcBoundingBox(); } -BS_Rect BS_RenderObject::CalcBoundingBox() const { +BS_Rect RenderObject::CalcBoundingBox() const { // Die Bounding-Box mit der Objektgröße initialisieren. BS_Rect BBox(0, 0, m_Width, m_Height); @@ -197,19 +197,19 @@ BS_Rect BS_RenderObject::CalcBoundingBox() const { return BBox; } -void BS_RenderObject::CalcAbsolutePos(int &X, int &Y) const { +void RenderObject::CalcAbsolutePos(int &X, int &Y) const { X = CalcAbsoluteX(); Y = CalcAbsoluteY(); } -int BS_RenderObject::CalcAbsoluteX() const { +int RenderObject::CalcAbsoluteX() const { if (m_ParentPtr.IsValid()) return m_ParentPtr->GetAbsoluteX() + m_X; else return m_X; } -int BS_RenderObject::CalcAbsoluteY() const { +int RenderObject::CalcAbsoluteY() const { if (m_ParentPtr.IsValid()) return m_ParentPtr->GetAbsoluteY() + m_Y; else @@ -219,16 +219,16 @@ int BS_RenderObject::CalcAbsoluteY() const { // Baumverwaltung // -------------- -void BS_RenderObject::DeleteAllChildren() { +void RenderObject::DeleteAllChildren() { // Es ist nicht notwendig die Liste zu iterieren, da jedes Kind für sich DetatchChildren an diesem Objekt aufruft und sich somit // selber entfernt. Daher muss immer nur ein beliebiges Element (hier das letzte) gelöscht werden, bis die Liste leer ist. while (!m_Children.empty()) { - BS_RenderObjectPtr<BS_RenderObject> CurPtr = m_Children.back(); + RenderObjectPtr<RenderObject> CurPtr = m_Children.back(); CurPtr.Erase(); } } -bool BS_RenderObject::AddObject(BS_RenderObjectPtr<BS_RenderObject> pObject) { +bool RenderObject::AddObject(RenderObjectPtr<RenderObject> pObject) { if (!pObject.IsValid()) { BS_LOG_ERRORLN("Tried to add a null object to a renderobject."); return false; @@ -243,7 +243,7 @@ bool BS_RenderObject::AddObject(BS_RenderObjectPtr<BS_RenderObject> pObject) { return true; } -bool BS_RenderObject::DetatchChildren(BS_RenderObjectPtr<BS_RenderObject> pObject) { +bool RenderObject::DetatchChildren(RenderObjectPtr<RenderObject> pObject) { // Kinderliste durchgehen und Objekt entfernen falls vorhanden RENDEROBJECT_ITER it = m_Children.begin(); for (; it != m_Children.end(); ++it) @@ -256,11 +256,11 @@ bool BS_RenderObject::DetatchChildren(BS_RenderObjectPtr<BS_RenderObject> pObjec return false; } -void BS_RenderObject::SortRenderObjects() { +void RenderObject::SortRenderObjects() { Common::sort(m_Children.begin(), m_Children.end(), Greater); } -void BS_RenderObject::UpdateAbsolutePos() { +void RenderObject::UpdateAbsolutePos() { CalcAbsolutePos(m_AbsoluteX, m_AbsoluteY); RENDEROBJECT_ITER it = m_Children.begin(); @@ -271,36 +271,36 @@ void BS_RenderObject::UpdateAbsolutePos() { // Get-Methoden // ------------ -bool BS_RenderObject::GetObjectIntersection(BS_RenderObjectPtr<BS_RenderObject> pObject, BS_Rect &Result) { +bool RenderObject::GetObjectIntersection(RenderObjectPtr<RenderObject> pObject, BS_Rect &Result) { return m_BBox.Intersect(pObject->GetBBox(), Result); } // Set-Methoden // ------------ -void BS_RenderObject::SetPos(int X, int Y) { +void RenderObject::SetPos(int X, int Y) { m_X = X; m_Y = Y; UpdateAbsolutePos(); } -void BS_RenderObject::SetX(int X) { +void RenderObject::SetX(int X) { m_X = X; UpdateAbsolutePos(); } -void BS_RenderObject::SetY(int Y) { +void RenderObject::SetY(int Y) { m_Y = Y; UpdateAbsolutePos(); } -void BS_RenderObject::SetZ(int Z) { +void RenderObject::SetZ(int Z) { if (Z < 0) BS_LOG_ERRORLN("Tried to set a negative Z value (%d).", Z); else m_Z = Z; } -void BS_RenderObject::SetVisible(bool Visible) { +void RenderObject::SetVisible(bool Visible) { m_Visible = Visible; } @@ -308,82 +308,82 @@ void BS_RenderObject::SetVisible(bool Visible) { // Objekterzeuger // ----------------------------------------------------------------------------- -BS_RenderObjectPtr<BS_Animation> BS_RenderObject::AddAnimation(const Common::String &Filename) { - BS_RenderObjectPtr<BS_Animation> AniPtr((new BS_Animation(this->GetHandle(), Filename))->GetHandle()); +RenderObjectPtr<Animation> RenderObject::AddAnimation(const Common::String &Filename) { + RenderObjectPtr<Animation> AniPtr((new Animation(this->GetHandle(), Filename))->GetHandle()); if (AniPtr.IsValid() && AniPtr->GetInitSuccess()) return AniPtr; else { if (AniPtr.IsValid()) AniPtr.Erase(); - return BS_RenderObjectPtr<BS_Animation>(); + return RenderObjectPtr<Animation>(); } } // ----------------------------------------------------------------------------- -BS_RenderObjectPtr<BS_Animation> BS_RenderObject::AddAnimation(const BS_AnimationTemplate &AnimationTemplate) { - BS_Animation *AniPtr = new BS_Animation(this->GetHandle(), AnimationTemplate); +RenderObjectPtr<Animation> RenderObject::AddAnimation(const AnimationTemplate &AnimationTemplate) { + Animation *AniPtr = new Animation(this->GetHandle(), AnimationTemplate); if (AniPtr && AniPtr->GetInitSuccess()) return AniPtr->GetHandle(); else { delete AniPtr; - return BS_RenderObjectPtr<BS_Animation>(); + return RenderObjectPtr<Animation>(); } } // ----------------------------------------------------------------------------- -BS_RenderObjectPtr<BS_Bitmap> BS_RenderObject::AddBitmap(const Common::String &Filename) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr((new BS_StaticBitmap(this->GetHandle(), Filename))->GetHandle()); +RenderObjectPtr<Bitmap> RenderObject::AddBitmap(const Common::String &Filename) { + RenderObjectPtr<Bitmap> BitmapPtr((new StaticBitmap(this->GetHandle(), Filename))->GetHandle()); if (BitmapPtr.IsValid() && BitmapPtr->GetInitSuccess()) - return BS_RenderObjectPtr<BS_Bitmap>(BitmapPtr); + return RenderObjectPtr<Bitmap>(BitmapPtr); else { if (BitmapPtr.IsValid()) BitmapPtr.Erase(); - return BS_RenderObjectPtr<BS_Bitmap>(); + return RenderObjectPtr<Bitmap>(); } } // ----------------------------------------------------------------------------- -BS_RenderObjectPtr<BS_Bitmap> BS_RenderObject::AddDynamicBitmap(unsigned int Width, unsigned int Height) { - BS_RenderObjectPtr<BS_Bitmap> BitmapPtr((new BS_DynamicBitmap(this->GetHandle(), Width, Height))->GetHandle()); +RenderObjectPtr<Bitmap> RenderObject::AddDynamicBitmap(unsigned int Width, unsigned int Height) { + RenderObjectPtr<Bitmap> BitmapPtr((new DynamicBitmap(this->GetHandle(), Width, Height))->GetHandle()); if (BitmapPtr.IsValid() && BitmapPtr->GetInitSuccess()) return BitmapPtr; else { if (BitmapPtr.IsValid()) BitmapPtr.Erase(); - return BS_RenderObjectPtr<BS_Bitmap>(); + return RenderObjectPtr<Bitmap>(); } } // ----------------------------------------------------------------------------- -BS_RenderObjectPtr<BS_Panel> BS_RenderObject::AddPanel(int Width, int Height, unsigned int Color) { - BS_RenderObjectPtr<BS_Panel> PanelPtr((new BS_Panel(this->GetHandle(), Width, Height, Color))->GetHandle()); +RenderObjectPtr<Panel> RenderObject::AddPanel(int Width, int Height, unsigned int Color) { + RenderObjectPtr<Panel> PanelPtr((new Panel(this->GetHandle(), Width, Height, Color))->GetHandle()); if (PanelPtr.IsValid() && PanelPtr->GetInitSuccess()) return PanelPtr; else { if (PanelPtr.IsValid()) PanelPtr.Erase(); - return BS_RenderObjectPtr<BS_Panel>(); + return RenderObjectPtr<Panel>(); } } // ----------------------------------------------------------------------------- -BS_RenderObjectPtr<BS_Text> BS_RenderObject::AddText(const Common::String &Font, const Common::String &Text) { - BS_RenderObjectPtr<BS_Text> TextPtr((new BS_Text(this->GetHandle()))->GetHandle()); +RenderObjectPtr<Text> RenderObject::AddText(const Common::String &Font, const Common::String &text) { + RenderObjectPtr<Text> TextPtr((new Text(this->GetHandle()))->GetHandle()); if (TextPtr.IsValid() && TextPtr->GetInitSuccess() && TextPtr->SetFont(Font)) { - TextPtr->SetText(Text); + TextPtr->SetText(text); return TextPtr; } else { if (TextPtr.IsValid()) TextPtr.Erase(); - return BS_RenderObjectPtr<BS_Text>(); + return RenderObjectPtr<Text>(); } } // Persistenz-Methoden // ------------------- -bool BS_RenderObject::Persist(BS_OutputPersistenceBlock &Writer) { +bool RenderObject::Persist(BS_OutputPersistenceBlock &Writer) { // Typ und Handle werden als erstes gespeichert, damit beim Laden ein Objekt vom richtigen Typ mit dem richtigen Handle erzeugt werden kann. Writer.Write(static_cast<unsigned int>(m_Type)); Writer.Write(m_Handle); @@ -419,7 +419,7 @@ bool BS_RenderObject::Persist(BS_OutputPersistenceBlock &Writer) { // ----------------------------------------------------------------------------- -bool BS_RenderObject::Unpersist(BS_InputPersistenceBlock &Reader) { +bool RenderObject::Unpersist(BS_InputPersistenceBlock &Reader) { // Typ und Handle wurden schon von RecreatePersistedRenderObject() ausgelesen. Jetzt werden die restlichen Objekteigenschaften ausgelesen. Reader.Read(m_X); Reader.Read(m_Y); @@ -445,7 +445,7 @@ bool BS_RenderObject::Unpersist(BS_InputPersistenceBlock &Reader) { Reader.Read(m_OldVisible); unsigned int ParentHandle; Reader.Read(ParentHandle); - m_ParentPtr = BS_RenderObjectPtr<BS_RenderObject>(ParentHandle); + m_ParentPtr = RenderObjectPtr<RenderObject>(ParentHandle); Reader.Read(m_RefreshForced); UpdateAbsolutePos(); @@ -456,7 +456,7 @@ bool BS_RenderObject::Unpersist(BS_InputPersistenceBlock &Reader) { // ----------------------------------------------------------------------------- -bool BS_RenderObject::PersistChildren(BS_OutputPersistenceBlock &Writer) { +bool RenderObject::PersistChildren(BS_OutputPersistenceBlock &Writer) { bool Result = true; // Kinderanzahl speichern. @@ -474,7 +474,7 @@ bool BS_RenderObject::PersistChildren(BS_OutputPersistenceBlock &Writer) { // ----------------------------------------------------------------------------- -bool BS_RenderObject::UnpersistChildren(BS_InputPersistenceBlock &Reader) { +bool RenderObject::UnpersistChildren(BS_InputPersistenceBlock &Reader) { bool Result = true; // Kinderanzahl einlesen. @@ -492,8 +492,8 @@ bool BS_RenderObject::UnpersistChildren(BS_InputPersistenceBlock &Reader) { // ----------------------------------------------------------------------------- -BS_RenderObjectPtr<BS_RenderObject> BS_RenderObject::RecreatePersistedRenderObject(BS_InputPersistenceBlock &Reader) { - BS_RenderObjectPtr<BS_RenderObject> Result; +RenderObjectPtr<RenderObject> RenderObject::RecreatePersistedRenderObject(BS_InputPersistenceBlock &Reader) { + RenderObjectPtr<RenderObject> Result; // Typ und Handle auslesen. unsigned int Type; @@ -504,23 +504,23 @@ BS_RenderObjectPtr<BS_RenderObject> BS_RenderObject::RecreatePersistedRenderObje switch (Type) { case TYPE_PANEL: - Result = (new BS_Panel(Reader, this->GetHandle(), Handle))->GetHandle(); + Result = (new Panel(Reader, this->GetHandle(), Handle))->GetHandle(); break; case TYPE_STATICBITMAP: - Result = (new BS_StaticBitmap(Reader, this->GetHandle(), Handle))->GetHandle(); + Result = (new StaticBitmap(Reader, this->GetHandle(), Handle))->GetHandle(); break; case TYPE_DYNAMICBITMAP: - Result = (new BS_DynamicBitmap(Reader, this->GetHandle(), Handle))->GetHandle(); + Result = (new DynamicBitmap(Reader, this->GetHandle(), Handle))->GetHandle(); break; case TYPE_TEXT: - Result = (new BS_Text(Reader, this->GetHandle(), Handle))->GetHandle(); + Result = (new Text(Reader, this->GetHandle(), Handle))->GetHandle(); break; case TYPE_ANIMATION: - Result = (new BS_Animation(Reader, this->GetHandle(), Handle))->GetHandle(); + Result = (new Animation(Reader, this->GetHandle(), Handle))->GetHandle(); break; default: @@ -532,7 +532,7 @@ BS_RenderObjectPtr<BS_RenderObject> BS_RenderObject::RecreatePersistedRenderObje // Hilfs-Methoden // -------------- -bool BS_RenderObject::Greater(const BS_RenderObjectPtr<BS_RenderObject> lhs, const BS_RenderObjectPtr<BS_RenderObject> rhs) { +bool RenderObject::Greater(const RenderObjectPtr<RenderObject> lhs, const RenderObjectPtr<RenderObject> rhs) { // Das Objekt mit dem kleinem Z-Wert müssen zuerst gerendert werden. if (lhs->m_Z != rhs->m_Z) return lhs->m_Z < rhs->m_Z; diff --git a/engines/sword25/gfx/renderobject.h b/engines/sword25/gfx/renderobject.h index 98c1828822..0007e157a0 100644 --- a/engines/sword25/gfx/renderobject.h +++ b/engines/sword25/gfx/renderobject.h @@ -60,12 +60,12 @@ namespace Sword25 { // ----------------------------------------------------------------------------- class BS_Kernel; -class BS_RenderObjectManager; -class BS_Bitmap; -class BS_Animation; -class BS_AnimationTemplate; -class BS_Panel; -class BS_Text; +class RenderObjectManager; +class Bitmap; +class Animation; +class AnimationTemplate; +class Panel; +class Text; // Klassendefinition /** @@ -75,7 +75,7 @@ class BS_Text; Diese Klasse erledigt Aufgaben wie: minimales Neuzeichnen, Renderreihenfolge, Objekthierachie. Alle BS_RenderObject Instanzen werden von einem BS_RenderObjektManager in einem Baum verwaltet. */ -class BS_RenderObject { +class RenderObject { public: // Konstanten // ---------- @@ -104,7 +104,7 @@ public: @return Gibt einen BS_RenderObjectPtr auf das erzeugte Objekt zurück.<br> Falls ein Fehler aufgetreten ist wird ein ungültiger BS_RenderObjectPtr zurückgegeben. */ - BS_RenderObjectPtr<BS_Bitmap> AddBitmap(const Common::String &FileName); + RenderObjectPtr<Bitmap> AddBitmap(const Common::String &FileName); /** @brief Erzeugt ein veränderbares Bitmap als Kinderobjekt des Renderobjektes. @param Width die Breite des Bitmaps @@ -112,14 +112,14 @@ public: @return Gibt einen BS_RenderObjectPtr auf das erzeugte Objekt zurück.<br> Falls ein Fehler aufgetreten ist wird ein ungültiger BS_RenderObjectPtr zurückgegeben. */ - BS_RenderObjectPtr<BS_Bitmap> AddDynamicBitmap(unsigned int Width, unsigned int Height); + RenderObjectPtr<Bitmap> AddDynamicBitmap(unsigned int Width, unsigned int Height); /** @brief Erzeugt eine Animation auf Basis einer Animationsdatei als Kinderobjekt des Renderobjektes. @param FileName der Dateiname der Quelldatei @return Gibt einen BS_RenderObjectPtr auf das erzeugte Objekt zurück.<br> Falls ein Fehler aufgetreten ist wird ein ungültiger BS_RenderObjectPtr zurückgegeben. */ - BS_RenderObjectPtr<BS_Animation> AddAnimation(const Common::String &FileName); + RenderObjectPtr<Animation> AddAnimation(const Common::String &FileName); /** @brief Erzeugt eine Animation auf Basis eines Animationstemplate als Kinderobjekt des Renderobjektes. @param pAnimationTemplate ein Pointer auf das Animationstemplate @@ -127,7 +127,7 @@ public: Falls ein Fehler aufgetreten ist wird ein ungültiger BS_RenderObjectPtr zurückgegeben. @remark Das Renderobjekt übernimmt die Verwaltung des Animationstemplate. */ - BS_RenderObjectPtr<BS_Animation> AddAnimation(const BS_AnimationTemplate &AnimationTemplate); + RenderObjectPtr<Animation> AddAnimation(const AnimationTemplate &AnimationTemplate); /** @brief Erzeugt ein neues Farbpanel als Kinderobjekt des Renderobjektes. @param Width die Breite des Panels @@ -138,7 +138,7 @@ public: Falls ein Fehler aufgetreten ist wird ein ungültiger BS_RenderObjectPtr zurückgegeben. */ - BS_RenderObjectPtr<BS_Panel> AddPanel(int Width, int Height, unsigned int Color = 0xff000000); + RenderObjectPtr<Panel> AddPanel(int Width, int Height, unsigned int Color = 0xff000000); /** @brief Erzeugt ein Textobjekt als Kinderobjekt des Renderobjektes. @param Font der Dateiname des zu verwendenen Fonts @@ -147,7 +147,7 @@ public: @return Gibt einen BS_RenderObjectPtr auf das erzeugte Objekt zurück.<br> Falls ein Fehler aufgetreten ist wird ein ungültiger BS_RenderObjectPtr zurückgegeben. */ - BS_RenderObjectPtr<BS_Text> AddText(const Common::String &Font, const Common::String &Text = ""); + RenderObjectPtr<Text> AddText(const Common::String &Font, const Common::String &text = ""); // Cast-Methoden // ------------- @@ -156,36 +156,36 @@ public: @return Gibt einen BS_RenderObjectPtr auf das Objekt zurück.<br> Falls der Cast nicht zulässig ist, wird ein ungültiger BS_RenderObjectPtr zurückgegeben. */ - BS_RenderObjectPtr<BS_Bitmap> ToBitmap() { - if (m_Type == TYPE_STATICBITMAP || m_Type == TYPE_DYNAMICBITMAP) return BS_RenderObjectPtr<BS_Bitmap>(this->GetHandle()); - else return BS_RenderObjectPtr<BS_Bitmap>(); + RenderObjectPtr<Bitmap> ToBitmap() { + if (m_Type == TYPE_STATICBITMAP || m_Type == TYPE_DYNAMICBITMAP) return RenderObjectPtr<Bitmap>(this->GetHandle()); + else return RenderObjectPtr<Bitmap>(); } /** @brief Castet das Objekt zu einem BS_Animation-Objekt wenn zulässig. @return Gibt einen BS_RenderObjectPtr auf das Objekt zurück.<br> Falls der Cast nicht zulässig ist, wird ein ungültiger BS_RenderObjectPtr zurückgegeben. */ - BS_RenderObjectPtr<BS_Animation> ToAnimation() { - if (m_Type == TYPE_ANIMATION) return BS_RenderObjectPtr<BS_Animation>(this->GetHandle()); - else return BS_RenderObjectPtr<BS_Animation>(); + RenderObjectPtr<Animation> ToAnimation() { + if (m_Type == TYPE_ANIMATION) return RenderObjectPtr<Animation>(this->GetHandle()); + else return RenderObjectPtr<Animation>(); } /** @brief Castet das Objekt zu einem BS_Panel-Objekt wenn zulässig. @return Gibt einen BS_RenderObjectPtr auf das Objekt zurück.<br> Falls der Cast nicht zulässig ist, wird ein ungültiger BS_RenderObjectPtr zurückgegeben. */ - BS_RenderObjectPtr<BS_Panel> ToPanel() { - if (m_Type == TYPE_PANEL) return BS_RenderObjectPtr<BS_Panel>(this->GetHandle()); - else return BS_RenderObjectPtr<BS_Panel>(); + RenderObjectPtr<Panel> ToPanel() { + if (m_Type == TYPE_PANEL) return RenderObjectPtr<Panel>(this->GetHandle()); + else return RenderObjectPtr<Panel>(); } /** @brief Castet das Object zu einem BS_Text-Objekt wenn zulässig. @return Gibt einen BS_RenderObjectPtr auf das Objekt zurück.<br> Falls der Cast nicht zulässig ist, wird ein ungültiger BS_RenderObjectPtr zurückgegeben. */ - BS_RenderObjectPtr<BS_Text> ToText() { - if (m_Type == TYPE_TEXT) return BS_RenderObjectPtr<BS_Text>(this->GetHandle()); - else return BS_RenderObjectPtr<BS_Text>(); + RenderObjectPtr<Text> ToText() { + if (m_Type == TYPE_TEXT) return RenderObjectPtr<Text>(this->GetHandle()); + else return RenderObjectPtr<Text>(); } // Konstruktor / Desktruktor @@ -206,8 +206,8 @@ public: Es ist nicht notwendig alle BS_RenderObject Instanzen einzeln zu löschen. Dieses geschiet automatisch beim Löschen eines Vorfahren oder beim Löschen des zuständigen BS_RenderObjectManager. */ - BS_RenderObject(BS_RenderObjectPtr<BS_RenderObject> pParent, TYPES Type, unsigned int Handle = 0); - virtual ~BS_RenderObject(); + RenderObject(RenderObjectPtr<RenderObject> pParent, TYPES Type, unsigned int Handle = 0); + virtual ~RenderObject(); // Interface // --------- @@ -360,13 +360,13 @@ public: bool PersistChildren(BS_OutputPersistenceBlock &Writer); bool UnpersistChildren(BS_InputPersistenceBlock &Reader); // TODO: Evtl. private - BS_RenderObjectPtr<BS_RenderObject> RecreatePersistedRenderObject(BS_InputPersistenceBlock &Reader); + RenderObjectPtr<RenderObject> RecreatePersistedRenderObject(BS_InputPersistenceBlock &Reader); protected: // Typen // ----- - typedef Common::List<BS_RenderObjectPtr<BS_RenderObject> > RENDEROBJECT_LIST; - typedef Common::List<BS_RenderObjectPtr<BS_RenderObject> >::iterator RENDEROBJECT_ITER; + typedef Common::List<RenderObjectPtr<RenderObject> > RENDEROBJECT_LIST; + typedef Common::List<RenderObjectPtr<RenderObject> >::iterator RENDEROBJECT_ITER; int m_X; ///< Die X-Position des Objektes relativ zum Eltern-Objekt int m_Y; ///< Die Y-Position des Objektes relativ zum Eltern-Objekt @@ -389,7 +389,7 @@ protected: bool m_OldVisible; /// Ein Pointer auf den BS_RenderObjektManager, der das Objekt verwaltet. - BS_RenderObjectManager *m_ManagerPtr; + RenderObjectManager *m_ManagerPtr; // Render-Methode // -------------- @@ -426,14 +426,14 @@ protected: // Wenn der Hintergrund bewegt wird (Scrolling), bewegen sich auch die darauf befindlichen Gegenstände und Personen. /// Ein Pointer auf das Elternobjekt. - BS_RenderObjectPtr<BS_RenderObject> m_ParentPtr; + RenderObjectPtr<RenderObject> m_ParentPtr; /// Die Liste der Kinderobjekte nach der Renderreihenfolge geordnet RENDEROBJECT_LIST m_Children; /** @brief Gibt einen Pointer auf den BS_RenderObjektManager zurück, der das Objekt verwaltet. */ - BS_RenderObjectManager *GetManager() const { + RenderObjectManager *GetManager() const { return m_ManagerPtr; } /** @@ -441,7 +441,7 @@ protected: @param pObject ein Pointer auf das einzufügende Objekt @return Gibt false zurück, falls das Objekt nicht eingefügt werden konnte. */ - bool AddObject(BS_RenderObjectPtr<BS_RenderObject> pObject); + bool AddObject(RenderObjectPtr<RenderObject> pObject); private: /// Ist true, wenn das Objekt in nächsten Frame neu gezeichnet werden soll @@ -454,7 +454,7 @@ private: @param pObject ein Pointer auf das zu entfernende Objekt @return Gibt false zurück, falls das zu entfernende Objekt nicht in der Liste gefunden werden konnte. */ - bool DetatchChildren(BS_RenderObjectPtr<BS_RenderObject> pObject); + bool DetatchChildren(RenderObjectPtr<RenderObject> pObject); /** @brief Berechnet die Bounding-Box und registriert das Dirty-Rect beim BS_RenderObjectManager. */ @@ -509,12 +509,12 @@ private: @param Result das Ergebnisrechteck @return Gibt false zurück, falls sich die Objekte gar nicht schneiden. */ - bool GetObjectIntersection(BS_RenderObjectPtr<BS_RenderObject> pObject, BS_Rect &Result); + bool GetObjectIntersection(RenderObjectPtr<RenderObject> pObject, BS_Rect &Result); /** @brief Vergleichsoperator der auf Objektpointern basiert statt auf Objekten. @remark Diese Methode wird fürs Sortieren der Kinderliste nach der Rendereihenfolge benutzt. */ - static bool Greater(const BS_RenderObjectPtr<BS_RenderObject> lhs, const BS_RenderObjectPtr<BS_RenderObject> rhs); + static bool Greater(const RenderObjectPtr<RenderObject> lhs, const RenderObjectPtr<RenderObject> rhs); }; } // End of namespace Sword25 diff --git a/engines/sword25/gfx/renderobjectmanager.cpp b/engines/sword25/gfx/renderobjectmanager.cpp index 0198c7be2c..5d1147ea88 100644 --- a/engines/sword25/gfx/renderobjectmanager.cpp +++ b/engines/sword25/gfx/renderobjectmanager.cpp @@ -56,15 +56,15 @@ namespace Sword25 { // Konstruktion / Desktruktion // ----------------------------------------------------------------------------- -BS_RenderObjectManager::BS_RenderObjectManager(int Width, int Height, int FramebufferCount) : +RenderObjectManager::RenderObjectManager(int Width, int Height, int FramebufferCount) : m_FrameStarted(false) { // Wurzel des BS_RenderObject-Baumes erzeugen. - m_RootPtr = (new BS_RootRenderObject(this, Width, Height))->GetHandle(); + m_RootPtr = (new RootRenderObject(this, Width, Height))->GetHandle(); } // ----------------------------------------------------------------------------- -BS_RenderObjectManager::~BS_RenderObjectManager() { +RenderObjectManager::~RenderObjectManager() { // Die Wurzel des Baumes löschen, damit werden alle BS_RenderObjects mitgelöscht. m_RootPtr.Erase(); } @@ -73,7 +73,7 @@ BS_RenderObjectManager::~BS_RenderObjectManager() { // Interface // ----------------------------------------------------------------------------- -void BS_RenderObjectManager::StartFrame() { +void RenderObjectManager::StartFrame() { m_FrameStarted = true; // Verstrichene Zeit bestimmen @@ -87,7 +87,7 @@ void BS_RenderObjectManager::StartFrame() { // ----------------------------------------------------------------------------- -bool BS_RenderObjectManager::Render() { +bool RenderObjectManager::Render() { // Den Objekt-Status des Wurzelobjektes aktualisieren. Dadurch werden rekursiv alle Baumelemente aktualisiert. // Beim aktualisieren des Objekt-Status werden auch die Update-Rects gefunden, so dass feststeht, was neu gezeichnet // werden muss. @@ -101,13 +101,13 @@ bool BS_RenderObjectManager::Render() { // ----------------------------------------------------------------------------- -void BS_RenderObjectManager::AttatchTimedRenderObject(BS_RenderObjectPtr<BS_TimedRenderObject> RenderObjectPtr) { +void RenderObjectManager::AttatchTimedRenderObject(RenderObjectPtr<TimedRenderObject> RenderObjectPtr) { m_TimedRenderObjects.push_back(RenderObjectPtr); } // ----------------------------------------------------------------------------- -void BS_RenderObjectManager::DetatchTimedRenderObject(BS_RenderObjectPtr<BS_TimedRenderObject> RenderObjectPtr) { +void RenderObjectManager::DetatchTimedRenderObject(RenderObjectPtr<TimedRenderObject> RenderObjectPtr) { for (uint i = 0; i < m_TimedRenderObjects.size(); i++) if (m_TimedRenderObjects[i] == RenderObjectPtr) { m_TimedRenderObjects.remove_at(i); @@ -119,7 +119,7 @@ void BS_RenderObjectManager::DetatchTimedRenderObject(BS_RenderObjectPtr<BS_Time // Persistenz // ----------------------------------------------------------------------------- -bool BS_RenderObjectManager::Persist(BS_OutputPersistenceBlock &Writer) { +bool RenderObjectManager::Persist(BS_OutputPersistenceBlock &Writer) { bool Result = true; // Alle Kinder des Wurzelknotens speichern. Dadurch werden alle BS_RenderObjects gespeichert rekursiv gespeichert. @@ -136,14 +136,14 @@ bool BS_RenderObjectManager::Persist(BS_OutputPersistenceBlock &Writer) { } // Alle BS_AnimationTemplates persistieren. - Result &= BS_AnimationTemplateRegistry::GetInstance().Persist(Writer); + Result &= AnimationTemplateRegistry::GetInstance().Persist(Writer); return Result; } // ----------------------------------------------------------------------------- -bool BS_RenderObjectManager::Unpersist(BS_InputPersistenceBlock &Reader) { +bool RenderObjectManager::Unpersist(BS_InputPersistenceBlock &Reader) { bool Result = true; // Alle Kinder des Wurzelknotens löschen. Damit werden alle BS_RenderObjects gelöscht. @@ -167,7 +167,7 @@ bool BS_RenderObjectManager::Unpersist(BS_InputPersistenceBlock &Reader) { } // Alle BS_AnimationTemplates wieder herstellen. - Result &= BS_AnimationTemplateRegistry::GetInstance().Unpersist(Reader); + Result &= AnimationTemplateRegistry::GetInstance().Unpersist(Reader); return Result; } diff --git a/engines/sword25/gfx/renderobjectmanager.h b/engines/sword25/gfx/renderobjectmanager.h index 9cd857f8b4..71aa75a1a9 100644 --- a/engines/sword25/gfx/renderobjectmanager.h +++ b/engines/sword25/gfx/renderobjectmanager.h @@ -59,8 +59,8 @@ namespace Sword25 { // Klassendefinition class BS_Kernel; class BS_Rect; -class BS_RenderObject; -class BS_TimedRenderObject; +class RenderObject; +class TimedRenderObject; /** @brief Diese Klasse ist für die Verwaltung von BS_RenderObjects zuständig. @@ -68,7 +68,7 @@ class BS_TimedRenderObject; Sie sorgt dafür, dass die BS_RenderObjects in der richtigen Reihenfolge gerendert werden und ermöglicht den Zugriff auf die BS_RenderObjects über einen String. */ -class BS_RenderObjectManager : public BS_Persistable { +class RenderObjectManager : public BS_Persistable { public: /** @brief Erzeugt ein neues BS_RenderObjectManager-Objekt. @@ -76,8 +76,8 @@ public: @param Height die vertikale Bildschirmauflösung in Pixeln @param Die Anzahl an Framebuffern, die eingesetzt wird (Backbuffer + Primary). */ - BS_RenderObjectManager(int Width, int Height, int FramebufferCount); - virtual ~BS_RenderObjectManager(); + RenderObjectManager(int Width, int Height, int FramebufferCount); + virtual ~RenderObjectManager(); // Interface // --------- @@ -98,7 +98,7 @@ public: /** @brief Gibt einen Pointer auf die Wurzel des Objektbaumes zurück. */ - BS_RenderObjectPtr<BS_RenderObject> GetTreeRoot() { + RenderObjectPtr<RenderObject> GetTreeRoot() { return m_RootPtr; } /** @@ -109,25 +109,25 @@ public: @param RenderObject das einzufügende BS_TimedRenderObject */ - void AttatchTimedRenderObject(BS_RenderObjectPtr<BS_TimedRenderObject> pRenderObject); + void AttatchTimedRenderObject(RenderObjectPtr<TimedRenderObject> pRenderObject); /** @brief Entfernt ein BS_TimedRenderObject aus der Liste für zeitabhängige Render-Objekte. */ - void DetatchTimedRenderObject(BS_RenderObjectPtr<BS_TimedRenderObject> pRenderObject); + void DetatchTimedRenderObject(RenderObjectPtr<TimedRenderObject> pRenderObject); virtual bool Persist(BS_OutputPersistenceBlock &Writer); virtual bool Unpersist(BS_InputPersistenceBlock &Reader); private: bool m_FrameStarted; - typedef Common::Array<BS_RenderObjectPtr<BS_TimedRenderObject> > RenderObjectList; + typedef Common::Array<RenderObjectPtr<TimedRenderObject> > RenderObjectList; RenderObjectList m_TimedRenderObjects; // RenderObject-Tree Variablen // --------------------------- // Der Baum legt die hierachische Ordnung der BS_RenderObjects fest. // Zu weiteren Informationen siehe: "renderobject.h" - BS_RenderObjectPtr<BS_RenderObject> m_RootPtr; // Die Wurzel der Baumes + RenderObjectPtr<RenderObject> m_RootPtr; // Die Wurzel der Baumes }; } // End of namespace Sword25 diff --git a/engines/sword25/gfx/renderobjectptr.h b/engines/sword25/gfx/renderobjectptr.h index 33746f19d1..bcd426448d 100644 --- a/engines/sword25/gfx/renderobjectptr.h +++ b/engines/sword25/gfx/renderobjectptr.h @@ -48,33 +48,33 @@ namespace Sword25 { // Forward Declarations // ----------------------------------------------------------------------------- -class BS_RenderObject; +class RenderObject; // ----------------------------------------------------------------------------- // Klassendeklaration // ----------------------------------------------------------------------------- template<class T> -class BS_RenderObjectPtr { +class RenderObjectPtr { public: - BS_RenderObjectPtr() : m_Handle(0) {} + RenderObjectPtr() : m_Handle(0) {} - BS_RenderObjectPtr(unsigned int Handle) : m_Handle(Handle) {} + RenderObjectPtr(unsigned int Handle) : m_Handle(Handle) {} T *operator->() const { - return static_cast<T *>(BS_RenderObjectRegistry::GetInstance().ResolveHandle(m_Handle)); + return static_cast<T *>(RenderObjectRegistry::GetInstance().ResolveHandle(m_Handle)); } - bool operator==(const BS_RenderObjectPtr<T> & other) { + bool operator==(const RenderObjectPtr<T> & other) { return m_Handle == other.m_Handle; } bool IsValid() const { - return BS_RenderObjectRegistry::GetInstance().ResolveHandle(m_Handle) != 0; + return RenderObjectRegistry::GetInstance().ResolveHandle(m_Handle) != 0; } void Erase() { - delete static_cast<T *>(BS_RenderObjectRegistry::GetInstance().ResolveHandle(m_Handle)); + delete static_cast<T *>(RenderObjectRegistry::GetInstance().ResolveHandle(m_Handle)); m_Handle = 0; } diff --git a/engines/sword25/gfx/renderobjectregistry.cpp b/engines/sword25/gfx/renderobjectregistry.cpp index 4eecd54760..5082fe0e30 100644 --- a/engines/sword25/gfx/renderobjectregistry.cpp +++ b/engines/sword25/gfx/renderobjectregistry.cpp @@ -50,17 +50,17 @@ namespace Sword25 { // Implementation // ----------------------------------------------------------------------------- -std::auto_ptr<BS_RenderObjectRegistry> BS_RenderObjectRegistry::m_InstancePtr; +std::auto_ptr<RenderObjectRegistry> RenderObjectRegistry::m_InstancePtr; // ----------------------------------------------------------------------------- -void BS_RenderObjectRegistry::LogErrorLn(const char *Message) const { +void RenderObjectRegistry::LogErrorLn(const char *Message) const { BS_LOG_ERRORLN(Message); } // ----------------------------------------------------------------------------- -void BS_RenderObjectRegistry::LogWarningLn(const char *Message) const { +void RenderObjectRegistry::LogWarningLn(const char *Message) const { BS_LOG_WARNINGLN(Message); } diff --git a/engines/sword25/gfx/renderobjectregistry.h b/engines/sword25/gfx/renderobjectregistry.h index 6aea5afab2..c3a8ab3f29 100644 --- a/engines/sword25/gfx/renderobjectregistry.h +++ b/engines/sword25/gfx/renderobjectregistry.h @@ -52,26 +52,26 @@ namespace Sword25 { // Forward Deklarationen // ----------------------------------------------------------------------------- -class BS_RenderObject; +class RenderObject; // ----------------------------------------------------------------------------- // Klassendeklaration // ----------------------------------------------------------------------------- -class BS_RenderObjectRegistry : public BS_ObjectRegistry<BS_RenderObject> { +class RenderObjectRegistry : public BS_ObjectRegistry<RenderObject> { public: - static BS_RenderObjectRegistry &GetInstance() { - if (!m_InstancePtr.get()) m_InstancePtr.reset(new BS_RenderObjectRegistry); + static RenderObjectRegistry &GetInstance() { + if (!m_InstancePtr.get()) m_InstancePtr.reset(new RenderObjectRegistry); return *m_InstancePtr.get(); } - virtual ~BS_RenderObjectRegistry() {} + virtual ~RenderObjectRegistry() {} private: virtual void LogErrorLn(const char *Message) const; virtual void LogWarningLn(const char *Message) const; - static std::auto_ptr<BS_RenderObjectRegistry> m_InstancePtr; + static std::auto_ptr<RenderObjectRegistry> m_InstancePtr; }; } // End of namespace Sword25 diff --git a/engines/sword25/gfx/rootrenderobject.h b/engines/sword25/gfx/rootrenderobject.h index 5021f4f2d4..a4a78f24d9 100644 --- a/engines/sword25/gfx/rootrenderobject.h +++ b/engines/sword25/gfx/rootrenderobject.h @@ -48,14 +48,14 @@ namespace Sword25 { class BS_Kernel; // Klassendefinition -class BS_RenderObjectManager; +class RenderObjectManager; -class BS_RootRenderObject : public BS_RenderObject { - friend class BS_RenderObjectManager; +class RootRenderObject : public RenderObject { + friend class RenderObjectManager; private: - BS_RootRenderObject(BS_RenderObjectManager *ManagerPtr, int Width, int Height) : - BS_RenderObject(BS_RenderObjectPtr<BS_RenderObject>(), TYPE_ROOT) { + RootRenderObject(RenderObjectManager *ManagerPtr, int Width, int Height) : + RenderObject(RenderObjectPtr<RenderObject>(), TYPE_ROOT) { m_ManagerPtr = ManagerPtr; m_Width = Width; m_Height = Height; diff --git a/engines/sword25/gfx/screenshot.cpp b/engines/sword25/gfx/screenshot.cpp index 0c48966d0b..67273cc876 100644 --- a/engines/sword25/gfx/screenshot.cpp +++ b/engines/sword25/gfx/screenshot.cpp @@ -59,7 +59,7 @@ struct RGB_PIXEL { unsigned char Blue; }; -bool BS_Screenshot::SaveToFile(unsigned int Width, unsigned int Height, const byte *Data, const Common::String &Filename) { +bool Screenshot::SaveToFile(unsigned int Width, unsigned int Height, const byte *Data, const Common::String &Filename) { #if 0 BS_ASSERT(Data.size() == Width * Height); @@ -156,7 +156,7 @@ bool BS_Screenshot::SaveToFile(unsigned int Width, unsigned int Height, const by // ----------------------------------------------------------------------------- -bool BS_Screenshot::SaveThumbnailToFile(unsigned int Width, unsigned int Height, const byte *Data, const Common::String &Filename) { +bool Screenshot::SaveThumbnailToFile(unsigned int Width, unsigned int Height, const byte *Data, const Common::String &Filename) { #if 0 // // Diese Methode nimmt ein Screenshot mit den Maßen von 800x600 und erzeugt einen Screenshot mit den Maßen von 200x125. diff --git a/engines/sword25/gfx/screenshot.h b/engines/sword25/gfx/screenshot.h index a5b3f79e0f..11edc47962 100644 --- a/engines/sword25/gfx/screenshot.h +++ b/engines/sword25/gfx/screenshot.h @@ -51,7 +51,7 @@ namespace Sword25 { // Class declaration // ----------------------------------------------------------------------------- -class BS_Screenshot { +class Screenshot { public: static bool SaveToFile(unsigned int Width, unsigned int Height, const byte *Data, const Common::String &Filename); static bool SaveThumbnailToFile(unsigned int Width, unsigned int Height, const byte *Data, const Common::String &Filename); diff --git a/engines/sword25/gfx/staticbitmap.cpp b/engines/sword25/gfx/staticbitmap.cpp index 00df44c83a..575adcd03b 100644 --- a/engines/sword25/gfx/staticbitmap.cpp +++ b/engines/sword25/gfx/staticbitmap.cpp @@ -54,8 +54,8 @@ namespace Sword25 { // Konstruktion / Destruktion // ----------------------------------------------------------------------------- -BS_StaticBitmap::BS_StaticBitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const Common::String &Filename) : - BS_Bitmap(ParentPtr, TYPE_STATICBITMAP) { +StaticBitmap::StaticBitmap(RenderObjectPtr<RenderObject> ParentPtr, const Common::String &Filename) : + Bitmap(ParentPtr, TYPE_STATICBITMAP) { // Das BS_Bitmap konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden. if (!m_InitSuccess) return; @@ -64,14 +64,14 @@ BS_StaticBitmap::BS_StaticBitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, // ----------------------------------------------------------------------------- -BS_StaticBitmap::BS_StaticBitmap(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) : - BS_Bitmap(ParentPtr, TYPE_STATICBITMAP, Handle) { +StaticBitmap::StaticBitmap(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) : + Bitmap(ParentPtr, TYPE_STATICBITMAP, Handle) { m_InitSuccess = Unpersist(Reader); } // ----------------------------------------------------------------------------- -bool BS_StaticBitmap::InitBitmapResource(const Common::String &Filename) { +bool StaticBitmap::InitBitmapResource(const Common::String &Filename) { // Bild-Resource laden BS_Resource *ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(Filename); if (!ResourcePtr) { @@ -83,7 +83,7 @@ bool BS_StaticBitmap::InitBitmapResource(const Common::String &Filename) { return false; } - BS_BitmapResource *BitmapPtr = static_cast<BS_BitmapResource *>(ResourcePtr); + BitmapResource *BitmapPtr = static_cast<BitmapResource *>(ResourcePtr); // Den eindeutigen Dateinamen zum späteren Referenzieren speichern m_ResourceFilename = BitmapPtr->GetFileName(); @@ -100,33 +100,33 @@ bool BS_StaticBitmap::InitBitmapResource(const Common::String &Filename) { // ----------------------------------------------------------------------------- -BS_StaticBitmap::~BS_StaticBitmap() { +StaticBitmap::~StaticBitmap() { } // ----------------------------------------------------------------------------- -bool BS_StaticBitmap::DoRender() { +bool StaticBitmap::DoRender() { // Bitmap holen BS_Resource *ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename); BS_ASSERT(ResourcePtr); BS_ASSERT(ResourcePtr->GetType() == BS_Resource::TYPE_BITMAP); - BS_BitmapResource *BitmapResourcePtr = static_cast<BS_BitmapResource *>(ResourcePtr); + BitmapResource *BitmapResourcePtr = static_cast<BitmapResource *>(ResourcePtr); // Framebufferobjekt holen - BS_GraphicEngine *GfxPtr = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); + GraphicEngine *GfxPtr = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); BS_ASSERT(GfxPtr); // Bitmap zeichnen bool Result; if (m_ScaleFactorX == 1.0f && m_ScaleFactorY == 1.0f) { Result = BitmapResourcePtr->Blit(m_AbsoluteX, m_AbsoluteY, - (m_FlipV ? BS_BitmapResource::FLIP_V : 0) | - (m_FlipH ? BS_BitmapResource::FLIP_H : 0), + (m_FlipV ? BitmapResource::FLIP_V : 0) | + (m_FlipH ? BitmapResource::FLIP_H : 0), 0, m_ModulationColor, -1, -1); } else { Result = BitmapResourcePtr->Blit(m_AbsoluteX, m_AbsoluteY, - (m_FlipV ? BS_BitmapResource::FLIP_V : 0) | - (m_FlipH ? BS_BitmapResource::FLIP_H : 0), + (m_FlipV ? BitmapResource::FLIP_V : 0) | + (m_FlipH ? BitmapResource::FLIP_H : 0), 0, m_ModulationColor, m_Width, m_Height); } @@ -138,13 +138,13 @@ bool BS_StaticBitmap::DoRender() { // ----------------------------------------------------------------------------- -unsigned int BS_StaticBitmap::GetPixel(int X, int Y) const { +unsigned int StaticBitmap::GetPixel(int X, int Y) const { BS_ASSERT(X >= 0 && X < m_Width); BS_ASSERT(Y >= 0 && Y < m_Height); BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename); BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP); - BS_BitmapResource *pBitmapResource = static_cast<BS_BitmapResource *>(pResource); + BitmapResource *pBitmapResource = static_cast<BitmapResource *>(pResource); unsigned int Result = pBitmapResource->GetPixel(X, Y); pResource->Release(); return Result; @@ -152,7 +152,7 @@ unsigned int BS_StaticBitmap::GetPixel(int X, int Y) const { // ----------------------------------------------------------------------------- -bool BS_StaticBitmap::SetContent(const byte *Pixeldata, uint size, unsigned int Offset, unsigned int Stride) { +bool StaticBitmap::SetContent(const byte *Pixeldata, uint size, unsigned int Offset, unsigned int Stride) { BS_LOG_ERRORLN("SetContent() ist not supported with this object."); return false; } @@ -161,30 +161,30 @@ bool BS_StaticBitmap::SetContent(const byte *Pixeldata, uint size, unsigned int // Auskunftsmethoden // ----------------------------------------------------------------------------- -bool BS_StaticBitmap::IsAlphaAllowed() const { +bool StaticBitmap::IsAlphaAllowed() const { BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename); BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP); - bool Result = static_cast<BS_BitmapResource *>(pResource)->IsAlphaAllowed(); + bool Result = static_cast<BitmapResource *>(pResource)->IsAlphaAllowed(); pResource->Release(); return Result; } // ----------------------------------------------------------------------------- -bool BS_StaticBitmap::IsColorModulationAllowed() const { +bool StaticBitmap::IsColorModulationAllowed() const { BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename); BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP); - bool Result = static_cast<BS_BitmapResource *>(pResource)->IsColorModulationAllowed(); + bool Result = static_cast<BitmapResource *>(pResource)->IsColorModulationAllowed(); pResource->Release(); return Result; } // ----------------------------------------------------------------------------- -bool BS_StaticBitmap::IsScalingAllowed() const { +bool StaticBitmap::IsScalingAllowed() const { BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename); BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP); - bool Result = static_cast<BS_BitmapResource *>(pResource)->IsScalingAllowed(); + bool Result = static_cast<BitmapResource *>(pResource)->IsScalingAllowed(); pResource->Release(); return Result; } @@ -193,26 +193,26 @@ bool BS_StaticBitmap::IsScalingAllowed() const { // Persistenz // ----------------------------------------------------------------------------- -bool BS_StaticBitmap::Persist(BS_OutputPersistenceBlock &Writer) { +bool StaticBitmap::Persist(BS_OutputPersistenceBlock &Writer) { bool Result = true; - Result &= BS_Bitmap::Persist(Writer); + Result &= Bitmap::Persist(Writer); Writer.Write(m_ResourceFilename); - Result &= BS_RenderObject::PersistChildren(Writer); + Result &= RenderObject::PersistChildren(Writer); return Result; } -bool BS_StaticBitmap::Unpersist(BS_InputPersistenceBlock &Reader) { +bool StaticBitmap::Unpersist(BS_InputPersistenceBlock &Reader) { bool Result = true; - Result &= BS_Bitmap::Unpersist(Reader); + Result &= Bitmap::Unpersist(Reader); Common::String ResourceFilename; Reader.Read(ResourceFilename); Result &= InitBitmapResource(ResourceFilename); - Result &= BS_RenderObject::UnpersistChildren(Reader); + Result &= RenderObject::UnpersistChildren(Reader); return Reader.IsGood() && Result; } diff --git a/engines/sword25/gfx/staticbitmap.h b/engines/sword25/gfx/staticbitmap.h index b5b2aac64a..77b29be9bf 100644 --- a/engines/sword25/gfx/staticbitmap.h +++ b/engines/sword25/gfx/staticbitmap.h @@ -48,18 +48,18 @@ namespace Sword25 { // Klassendeklaration // ----------------------------------------------------------------------------- -class BS_StaticBitmap : public BS_Bitmap { - friend class BS_RenderObject; +class StaticBitmap : public Bitmap { + friend class RenderObject; private: /** @remark Filename muss absoluter Pfad sein */ - BS_StaticBitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const Common::String &Filename); - BS_StaticBitmap(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle); + StaticBitmap(RenderObjectPtr<RenderObject> ParentPtr, const Common::String &Filename); + StaticBitmap(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle); public: - virtual ~BS_StaticBitmap(); + virtual ~StaticBitmap(); virtual unsigned int GetPixel(int X, int Y) const; diff --git a/engines/sword25/gfx/text.cpp b/engines/sword25/gfx/text.cpp index 418c428258..d3e846abc5 100644 --- a/engines/sword25/gfx/text.cpp +++ b/engines/sword25/gfx/text.cpp @@ -64,8 +64,8 @@ const unsigned int AUTO_WRAP_THRESHOLD_DEFAULT = 300; // Konstruktion / Destruktion // ----------------------------------------------------------------------------- -BS_Text::BS_Text(BS_RenderObjectPtr<BS_RenderObject> ParentPtr) : - BS_RenderObject(ParentPtr, BS_RenderObject::TYPE_TEXT), +Text::Text(RenderObjectPtr<RenderObject> ParentPtr) : + RenderObject(ParentPtr, RenderObject::TYPE_TEXT), m_ModulationColor(0xffffffff), m_AutoWrap(false), m_AutoWrapThreshold(AUTO_WRAP_THRESHOLD_DEFAULT) { @@ -74,14 +74,14 @@ BS_Text::BS_Text(BS_RenderObjectPtr<BS_RenderObject> ParentPtr) : // ----------------------------------------------------------------------------- -BS_Text::BS_Text(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) : - BS_RenderObject(ParentPtr, TYPE_TEXT, Handle) { +Text::Text(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) : + RenderObject(ParentPtr, TYPE_TEXT, Handle) { m_InitSuccess = Unpersist(Reader); } // ----------------------------------------------------------------------------- -bool BS_Text::SetFont(const Common::String &Font) { +bool Text::SetFont(const Common::String &Font) { // Font precachen. if (GetResourceManager()->PrecacheResource(Font)) { m_Font = Font; @@ -97,15 +97,15 @@ bool BS_Text::SetFont(const Common::String &Font) { // ----------------------------------------------------------------------------- -void BS_Text::SetText(const Common::String &Text) { - m_Text = Text; +void Text::SetText(const Common::String &text) { + m_Text = text; UpdateFormat(); ForceRefresh(); } // ----------------------------------------------------------------------------- -void BS_Text::SetColor(unsigned int ModulationColor) { +void Text::SetColor(unsigned int ModulationColor) { unsigned int NewModulationColor = (ModulationColor & 0x00ffffff) | (m_ModulationColor & 0xff000000); if (NewModulationColor != m_ModulationColor) { m_ModulationColor = NewModulationColor; @@ -115,7 +115,7 @@ void BS_Text::SetColor(unsigned int ModulationColor) { // ----------------------------------------------------------------------------- -void BS_Text::SetAlpha(int Alpha) { +void Text::SetAlpha(int Alpha) { BS_ASSERT(Alpha >= 0 && Alpha < 256); unsigned int NewModulationColor = (m_ModulationColor & 0x00ffffff) | Alpha << 24; if (NewModulationColor != m_ModulationColor) { @@ -126,7 +126,7 @@ void BS_Text::SetAlpha(int Alpha) { // ----------------------------------------------------------------------------- -void BS_Text::SetAutoWrap(bool AutoWrap) { +void Text::SetAutoWrap(bool AutoWrap) { if (AutoWrap != m_AutoWrap) { m_AutoWrap = AutoWrap; UpdateFormat(); @@ -136,7 +136,7 @@ void BS_Text::SetAutoWrap(bool AutoWrap) { // ----------------------------------------------------------------------------- -void BS_Text::SetAutoWrapThreshold(unsigned int AutoWrapThreshold) { +void Text::SetAutoWrapThreshold(unsigned int AutoWrapThreshold) { if (AutoWrapThreshold != m_AutoWrapThreshold) { m_AutoWrapThreshold = AutoWrapThreshold; UpdateFormat(); @@ -146,14 +146,14 @@ void BS_Text::SetAutoWrapThreshold(unsigned int AutoWrapThreshold) { // ----------------------------------------------------------------------------- -bool BS_Text::DoRender() { +bool Text::DoRender() { // Font-Resource locken. - BS_FontResource *FontPtr = LockFontResource(); + FontResource *FontPtr = LockFontResource(); if (!FontPtr) return false; // Charactermap-Resource locken. BS_ResourceManager *RMPtr = GetResourceManager(); - BS_BitmapResource *CharMapPtr; + BitmapResource *CharMapPtr; { BS_Resource *pResource = RMPtr->RequestResource(FontPtr->GetCharactermapFileName()); if (!pResource) { @@ -165,11 +165,11 @@ bool BS_Text::DoRender() { return false; } - CharMapPtr = static_cast<BS_BitmapResource *>(pResource); + CharMapPtr = static_cast<BitmapResource *>(pResource); } // Framebufferobjekt holen. - BS_GraphicEngine *GfxPtr = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); + GraphicEngine *GfxPtr = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); BS_ASSERT(GfxPtr); bool Result = true; @@ -189,7 +189,7 @@ bool BS_Text::DoRender() { int RenderX = CurX + (RenderRect.left - RenderRect.left); int RenderY = CurY + (RenderRect.top - RenderRect.top); RenderRect.Move(CurRect.left - CurX, CurRect.top - CurY); - Result = CharMapPtr->Blit(RenderX, RenderY, BS_Image::FLIP_NONE, &RenderRect, m_ModulationColor); + Result = CharMapPtr->Blit(RenderX, RenderY, Image::FLIP_NONE, &RenderRect, m_ModulationColor); if (!Result) break; CurX += CurRect.GetWidth() + FontPtr->GetGapWidth(); @@ -207,18 +207,18 @@ bool BS_Text::DoRender() { // ----------------------------------------------------------------------------- -BS_ResourceManager *BS_Text::GetResourceManager() { +BS_ResourceManager *Text::GetResourceManager() { // Pointer auf den Resource-Manager holen. return BS_Kernel::GetInstance()->GetResourceManager(); } // ----------------------------------------------------------------------------- -BS_FontResource *BS_Text::LockFontResource() { +FontResource *Text::LockFontResource() { BS_ResourceManager *RMPtr = GetResourceManager(); // Font-Resource locken. - BS_FontResource *FontPtr; + FontResource *FontPtr; { BS_Resource *ResourcePtr = RMPtr->RequestResource(m_Font); if (!ResourcePtr) { @@ -230,7 +230,7 @@ BS_FontResource *BS_Text::LockFontResource() { return NULL; } - FontPtr = static_cast<BS_FontResource *>(ResourcePtr); + FontPtr = static_cast<FontResource *>(ResourcePtr); } return FontPtr; @@ -238,8 +238,8 @@ BS_FontResource *BS_Text::LockFontResource() { // ----------------------------------------------------------------------------- -void BS_Text::UpdateFormat() { - BS_FontResource *FontPtr = LockFontResource(); +void Text::UpdateFormat() { + FontResource *FontPtr = LockFontResource(); BS_ASSERT(FontPtr); UpdateMetrics(*FontPtr); @@ -317,7 +317,7 @@ void BS_Text::UpdateFormat() { // ----------------------------------------------------------------------------- -void BS_Text::UpdateMetrics(BS_FontResource &FontResource) { +void Text::UpdateMetrics(FontResource &FontResource) { m_Width = 0; m_Height = 0; @@ -333,10 +333,10 @@ void BS_Text::UpdateMetrics(BS_FontResource &FontResource) { // Persistenz // ----------------------------------------------------------------------------- -bool BS_Text::Persist(BS_OutputPersistenceBlock &Writer) { +bool Text::Persist(BS_OutputPersistenceBlock &Writer) { bool Result = true; - Result &= BS_RenderObject::Persist(Writer); + Result &= RenderObject::Persist(Writer); Writer.Write(m_ModulationColor); Writer.Write(m_Font); @@ -344,15 +344,15 @@ bool BS_Text::Persist(BS_OutputPersistenceBlock &Writer) { Writer.Write(m_AutoWrap); Writer.Write(m_AutoWrapThreshold); - Result &= BS_RenderObject::PersistChildren(Writer); + Result &= RenderObject::PersistChildren(Writer); return Result; } -bool BS_Text::Unpersist(BS_InputPersistenceBlock &Reader) { +bool Text::Unpersist(BS_InputPersistenceBlock &Reader) { bool Result = true; - Result &= BS_RenderObject::Unpersist(Reader); + Result &= RenderObject::Unpersist(Reader); // Farbe und Alpha einlesen. Reader.Read(m_ModulationColor); @@ -364,9 +364,9 @@ bool BS_Text::Unpersist(BS_InputPersistenceBlock &Reader) { Reader.Read(Font); SetFont(Font); - Common::String Text; - Reader.Read(Text); - SetText(Text); + Common::String text; + Reader.Read(text); + SetText(text); bool AutoWrap; Reader.Read(AutoWrap); @@ -376,7 +376,7 @@ bool BS_Text::Unpersist(BS_InputPersistenceBlock &Reader) { Reader.Read(AutoWrapThreshold); SetAutoWrapThreshold(AutoWrapThreshold); - Result &= BS_RenderObject::UnpersistChildren(Reader); + Result &= RenderObject::UnpersistChildren(Reader); return Reader.IsGood() && Result; } diff --git a/engines/sword25/gfx/text.h b/engines/sword25/gfx/text.h index 67295048d2..399472571d 100644 --- a/engines/sword25/gfx/text.h +++ b/engines/sword25/gfx/text.h @@ -54,15 +54,15 @@ namespace Sword25 { // ----------------------------------------------------------------------------- class BS_Kernel; -class BS_FontResource; +class FontResource; class BS_ResourceManager; // ----------------------------------------------------------------------------- // Klassendefinition // ----------------------------------------------------------------------------- -class BS_Text : public BS_RenderObject { - friend class BS_RenderObject; +class Text : public RenderObject { + friend class RenderObject; public: /** @@ -76,7 +76,7 @@ public: @brief Setzt den darzustellenden Text. @param Text der darzustellende Text */ - void SetText(const Common::String &Text); + void SetText(const Common::String &text); /** @brief Setzt den Alphawert des Textes. @@ -158,8 +158,8 @@ protected: virtual bool DoRender(); private: - BS_Text(BS_RenderObjectPtr<BS_RenderObject> ParentPtr); - BS_Text(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle); + Text(RenderObjectPtr<RenderObject> ParentPtr); + Text(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle); unsigned int m_ModulationColor; Common::String m_Font; @@ -175,9 +175,9 @@ private: Common::Array<LINE> m_Lines; void UpdateFormat(); - void UpdateMetrics(BS_FontResource &FontResource); + void UpdateMetrics(FontResource &FontResource); BS_ResourceManager *GetResourceManager(); - BS_FontResource *LockFontResource(); + FontResource *LockFontResource(); }; } // End of namespace Sword25 diff --git a/engines/sword25/gfx/timedrenderobject.cpp b/engines/sword25/gfx/timedrenderobject.cpp index 98510f056f..93217ab197 100644 --- a/engines/sword25/gfx/timedrenderobject.cpp +++ b/engines/sword25/gfx/timedrenderobject.cpp @@ -42,13 +42,13 @@ namespace Sword25 { // Konstruktion / Destruktion // ----------------------------------------------------------------------------- -BS_TimedRenderObject::BS_TimedRenderObject(BS_RenderObjectPtr<BS_RenderObject> pParent, TYPES Type, unsigned int Handle) : - BS_RenderObject(pParent, Type, Handle) { +TimedRenderObject::TimedRenderObject(RenderObjectPtr<RenderObject> pParent, TYPES Type, unsigned int Handle) : + RenderObject(pParent, Type, Handle) { BS_ASSERT(GetManager()); GetManager()->AttatchTimedRenderObject(this->GetHandle()); } -BS_TimedRenderObject::~BS_TimedRenderObject() { +TimedRenderObject::~TimedRenderObject() { BS_ASSERT(GetManager()); GetManager()->DetatchTimedRenderObject(this->GetHandle()); } diff --git a/engines/sword25/gfx/timedrenderobject.h b/engines/sword25/gfx/timedrenderobject.h index 576ab64383..ed617cb512 100644 --- a/engines/sword25/gfx/timedrenderobject.h +++ b/engines/sword25/gfx/timedrenderobject.h @@ -57,10 +57,10 @@ namespace Sword25 { @brief */ -class BS_TimedRenderObject : public BS_RenderObject { +class TimedRenderObject : public RenderObject { public: - BS_TimedRenderObject(BS_RenderObjectPtr<BS_RenderObject> pParent, TYPES Type, unsigned int Handle = 0); - ~BS_TimedRenderObject(); + TimedRenderObject(RenderObjectPtr<RenderObject> pParent, TYPES Type, unsigned int Handle = 0); + ~TimedRenderObject(); /** @brief Teilt dem Objekt mit, dass ein neuer Frame begonnen wird. diff --git a/engines/sword25/kernel/kernel.cpp b/engines/sword25/kernel/kernel.cpp index eb57a23232..4e61965c93 100644 --- a/engines/sword25/kernel/kernel.cpp +++ b/engines/sword25/kernel/kernel.cpp @@ -396,8 +396,8 @@ size_t BS_Kernel::GetUsedMemory() { /** * Returns a pointer to the active Gfx Service, or NULL if no Gfx service is active */ -BS_GraphicEngine *BS_Kernel::GetGfx() { - return static_cast<BS_GraphicEngine *>(GetService("gfx")); +GraphicEngine *BS_Kernel::GetGfx() { + return static_cast<GraphicEngine *>(GetService("gfx")); } // ----------------------------------------------------------------------------- @@ -441,8 +441,8 @@ BS_ScriptEngine *BS_Kernel::GetScript() { /** * Returns a pointer to the movie player, or NULL if it is not active */ -BS_MoviePlayer *BS_Kernel::GetFMV() { - return static_cast<BS_MoviePlayer *>(GetService("fmv")); +MoviePlayer *BS_Kernel::GetFMV() { + return static_cast<MoviePlayer *>(GetService("fmv")); } // ----------------------------------------------------------------------------- diff --git a/engines/sword25/kernel/kernel.h b/engines/sword25/kernel/kernel.h index b610c0caab..1ccf03b879 100644 --- a/engines/sword25/kernel/kernel.h +++ b/engines/sword25/kernel/kernel.h @@ -61,12 +61,12 @@ namespace Sword25 { // Class definitions class BS_Service; -class BS_GraphicEngine; +class GraphicEngine; class BS_ScriptEngine; class BS_SoundEngine; class BS_InputEngine; class BS_PackageManager; -class BS_MoviePlayer; +class MoviePlayer; /** * This is the main engine class @@ -190,7 +190,7 @@ public: /** * Returns a pointer to the active Gfx Service, or NULL if no Gfx service is active */ - BS_GraphicEngine *GetGfx(); + GraphicEngine *GetGfx(); /** * Returns a pointer to the active Sfx Service, or NULL if no Sfx service is active */ @@ -210,7 +210,7 @@ public: /** * Returns a pointer to the movie player, or NULL if it is not active */ - BS_MoviePlayer *GetFMV(); + MoviePlayer *GetFMV(); /** * Pauses for the specified amount of time diff --git a/engines/sword25/math/geometry_script.cpp b/engines/sword25/math/geometry_script.cpp index ccc73d290a..736e3f3d24 100644 --- a/engines/sword25/math/geometry_script.cpp +++ b/engines/sword25/math/geometry_script.cpp @@ -408,7 +408,7 @@ static int R_SetY(lua_State *L) { // ----------------------------------------------------------------------------- static void DrawPolygon(const BS_Polygon &Polygon, unsigned int Color, const BS_Vertex &Offset) { - BS_GraphicEngine *pGE = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); + GraphicEngine *pGE = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")); BS_ASSERT(pGE); for (int i = 0; i < Polygon.VertexCount - 1; i++) @@ -435,12 +435,12 @@ static int R_Draw(lua_State *L) { case 3: { BS_Vertex Offset; BS_Vertex::LuaVertexToVertex(L, 3, Offset); - DrawRegion(*pR, BS_GraphicEngine::LuaColorToARGBColor(L, 2), Offset); + DrawRegion(*pR, GraphicEngine::LuaColorToARGBColor(L, 2), Offset); } break; case 2: - DrawRegion(*pR, BS_GraphicEngine::LuaColorToARGBColor(L, 2), BS_Vertex(0, 0)); + DrawRegion(*pR, GraphicEngine::LuaColorToARGBColor(L, 2), BS_Vertex(0, 0)); break; default: |