thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

SWORD25: Mass-astyle.

Browse source 
svn-id: r53222
This commit is contained in:
Eugene Sandulenko 2010-08-06 13:13:25 +00:00
parent ca17def625
commit 47904bc7b2
146 changed files with 5057 additions and 5644 deletions
Download patch file Download diff file Expand all files Collapse all files

4
engines/sword25/fmv/movieplayer.cpp
View file

@ -38,7 +38,9 @@ namespace Sword25 {
#define BS_LOG_PREFIX "MOVIEPLAYER"
BS_Service *BS_OggTheora_CreateObject(BS_Kernel *pKernel) { return new BS_MoviePlayer(pKernel); }
BS_Service *BS_OggTheora_CreateObject(BS_Kernel *pKernel) {
return new BS_MoviePlayer(pKernel);
}
BS_MoviePlayer::BS_MoviePlayer(BS_Kernel *pKernel) : BS_Service(pKernel) {
if (!_RegisterScriptBindings())

26
engines/sword25/fmv/theora_decoder.h Executable file → Normal file
View file

@ -34,7 +34,7 @@
#include <vorbis/codec.h>
namespace Common {
class SeekableReadStream;
class SeekableReadStream;
}
namespace Sword25 {
@ -65,16 +65,28 @@ public:
*/
Graphics::Surface *decodeNextFrame();
bool isVideoLoaded() const { return _fileStream != 0; }
uint16 getWidth() const { return _surface->w; }
uint16 getHeight() const { return _surface->h; }
uint32 getFrameCount() const { return _frameCount; }
Graphics::PixelFormat getPixelFormat() const { return Graphics::PixelFormat(3, 8, 8, 8, 0, 0, 0, 0, 0); }
bool isVideoLoaded() const {
return _fileStream != 0;
}
uint16 getWidth() const {
return _surface->w;
}
uint16 getHeight() const {
return _surface->h;
}
uint32 getFrameCount() const {
return _frameCount;
}
Graphics::PixelFormat getPixelFormat() const {
return Graphics::PixelFormat(3, 8, 8, 8, 0, 0, 0, 0, 0);
}
uint32 getElapsedTime() const;
protected:
Common::Rational getFrameRate() const { return _frameRate; }
Common::Rational getFrameRate() const {
return _frameRate;
}
private:
void queuePage(ogg_page *page);

329
engines/sword25/gfx/animation.cpp
View file

@ -57,9 +57,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)
{
BS_Animation::BS_Animation(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const Common::String &FileName) :
BS_TimedRenderObject(ParentPtr, BS_RenderObject::TYPE_ANIMATION) {
// Das BS_RenderObject konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden.
if (!m_InitSuccess) return;
@ -76,9 +75,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)
{
BS_Animation::BS_Animation(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const BS_AnimationTemplate &Template) :
BS_TimedRenderObject(ParentPtr, BS_RenderObject::TYPE_ANIMATION) {
// Das BS_RenderObject konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden.
if (!m_InitSuccess) return;
@ -95,9 +93,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)
{
BS_Animation::BS_Animation(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) :
BS_TimedRenderObject(ParentPtr, BS_RenderObject::TYPE_ANIMATION, Handle) {
// Das BS_RenderObject konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden.
if (!m_InitSuccess) return;
@ -109,14 +106,12 @@ BS_Animation::BS_Animation(BS_InputPersistenceBlock & Reader, BS_RenderObjectPtr
// -----------------------------------------------------------------------------
void BS_Animation::InitializeAnimationResource(const Common::String &FileName)
{
void BS_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);
BS_Resource *ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(FileName);
if (ResourcePtr && ResourcePtr->GetType() == BS_Resource::TYPE_ANIMATION)
m_AnimationResourcePtr = static_cast<BS_AnimationResource *>(ResourcePtr);
else
{
else {
BS_LOG_ERRORLN("The resource \"%s\" could not be requested. The Animation can't be created.", FileName.c_str());
return;
}
@ -127,8 +122,7 @@ void BS_Animation::InitializeAnimationResource(const Common::String &FileName)
// -----------------------------------------------------------------------------
void BS_Animation::InitMembers()
{
void BS_Animation::InitMembers() {
m_CurrentFrame = 0;
m_CurrentFrameTime = 0;
m_Direction = FORWARD;
@ -146,17 +140,15 @@ void BS_Animation::InitMembers()
// -----------------------------------------------------------------------------
BS_Animation::~BS_Animation()
{
if (GetAnimationDescription())
{
BS_Animation::~BS_Animation() {
if (GetAnimationDescription()) {
Stop();
GetAnimationDescription()->Unlock();
}
// Delete Callbacks
Common::Array<ANIMATION_CALLBACK_DATA>::iterator it = m_DeleteCallbacks.begin();
for (; it != m_DeleteCallbacks.end(); it++) ((*it).Callback)((*it).Data);
for (; it != m_DeleteCallbacks.end(); it++)((*it).Callback)((*it).Data);
}
@ -164,8 +156,7 @@ BS_Animation::~BS_Animation()
// Steuermethoden
// -----------------------------------------------------------------------------
void BS_Animation::Play()
{
void BS_Animation::Play() {
// Wenn die Animation zuvor komplett durchgelaufen ist, wird sie wieder von Anfang abgespielt
if (m_Finished) Stop();
@ -175,16 +166,14 @@ void BS_Animation::Play()
// -----------------------------------------------------------------------------
void BS_Animation::Pause()
{
void BS_Animation::Pause() {
m_Running = false;
UnlockAllFrames();
}
// -----------------------------------------------------------------------------
void BS_Animation::Stop()
{
void BS_Animation::Stop() {
m_CurrentFrame = 0;
m_CurrentFrameTime = 0;
m_Direction = FORWARD;
@ -193,13 +182,11 @@ void BS_Animation::Stop()
// -----------------------------------------------------------------------------
void BS_Animation::SetFrame(unsigned int Nr)
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
void BS_Animation::SetFrame(unsigned int Nr) {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
if (Nr >= animationDescriptionPtr->GetFrameCount())
{
if (Nr >= animationDescriptionPtr->GetFrameCount()) {
BS_LOG_ERRORLN("Tried to set animation to illegal frame (%d). Value must be between 0 and %d.",
Nr, animationDescriptionPtr->GetFrameCount());
return;
@ -215,33 +202,29 @@ void BS_Animation::SetFrame(unsigned int Nr)
// Rendern
// -----------------------------------------------------------------------------
bool BS_Animation::DoRender()
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
bool BS_Animation::DoRender() {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
BS_ASSERT(m_CurrentFrame < animationDescriptionPtr->GetFrameCount());
// Bitmap des aktuellen Frames holen
BS_Resource* pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(m_CurrentFrame).FileName);
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);
BS_BitmapResource *pBitmapResource = static_cast<BS_BitmapResource *>(pResource);
// Framebufferobjekt holen
BS_GraphicEngine * pGfx = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
BS_GraphicEngine *pGfx = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
BS_ASSERT(pGfx);
// Bitmap zeichnen
bool Result;
if (IsScalingAllowed() && (m_Width != pBitmapResource->GetWidth() || m_Height != pBitmapResource->GetHeight()))
{
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),
0, m_ModulationColor, m_Width, m_Height);
}
else
{
} 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),
@ -258,15 +241,13 @@ bool BS_Animation::DoRender()
// Frame Notifikation
// -----------------------------------------------------------------------------
void BS_Animation::FrameNotification(int TimeElapsed)
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
void BS_Animation::FrameNotification(int TimeElapsed) {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
BS_ASSERT(TimeElapsed >= 0);
// Nur wenn die Animation läuft wird sie auch weiterbewegt
if (m_Running)
{
if (m_Running) {
int OldFrame = m_CurrentFrame;
// Gesamte vergangene Zeit bestimmen (inkl. Restzeit des aktuellen Frames)
@ -280,8 +261,7 @@ void BS_Animation::FrameNotification(int TimeElapsed)
// Neuen Frame bestimmen (je nach aktuellener Abspielrichtung wird addiert oder subtrahiert)
int TmpCurFrame = m_CurrentFrame;
switch (m_Direction)
{
switch (m_Direction) {
case FORWARD:
TmpCurFrame += SkipFrames;
break;
@ -295,17 +275,13 @@ void BS_Animation::FrameNotification(int TimeElapsed)
}
// Überläufe behandeln
if (TmpCurFrame < 0)
{
if (TmpCurFrame < 0) {
// Loop-Point Callbacks
Common::Array<ANIMATION_CALLBACK_DATA>::iterator it = m_LoopPointCallbacks.begin();
while (it != m_LoopPointCallbacks.end())
{
if (((*it).Callback)((*it).Data) == false)
{
while (it != m_LoopPointCallbacks.end()) {
if (((*it).Callback)((*it).Data) == false) {
it = m_LoopPointCallbacks.erase(it);
}
else
} else
it++;
}
@ -313,21 +289,17 @@ void BS_Animation::FrameNotification(int TimeElapsed)
BS_ASSERT(animationDescriptionPtr->GetAnimationType() == AT_JOJO);
TmpCurFrame = - TmpCurFrame;
m_Direction = FORWARD;
}
else if (static_cast<unsigned int>(TmpCurFrame) >= animationDescriptionPtr->GetFrameCount())
{
} else if (static_cast<unsigned int>(TmpCurFrame) >= animationDescriptionPtr->GetFrameCount()) {
// Loop-Point Callbacks
Common::Array<ANIMATION_CALLBACK_DATA>::iterator it = m_LoopPointCallbacks.begin();
while (it != m_LoopPointCallbacks.end())
{
while (it != m_LoopPointCallbacks.end()) {
if (((*it).Callback)((*it).Data) == false)
it = m_LoopPointCallbacks.erase(it);
else
it++;
}
switch (animationDescriptionPtr->GetAnimationType())
{
switch (animationDescriptionPtr->GetAnimationType()) {
case AT_ONESHOT:
TmpCurFrame = animationDescriptionPtr->GetFrameCount() - 1;
m_Finished = true;
@ -348,16 +320,13 @@ void BS_Animation::FrameNotification(int TimeElapsed)
}
}
if (m_CurrentFrame != TmpCurFrame)
{
if (m_CurrentFrame != TmpCurFrame) {
ForceRefresh();
if (animationDescriptionPtr->GetFrame(m_CurrentFrame).Action != "")
{
if (animationDescriptionPtr->GetFrame(m_CurrentFrame).Action != "") {
// Action Callbacks
Common::Array<ANIMATION_CALLBACK_DATA>::iterator it = m_ActionCallbacks.begin();
while (it != m_ActionCallbacks.end())
{
while (it != m_ActionCallbacks.end()) {
if (((*it).Callback)((*it).Data) == false)
it = m_ActionCallbacks.erase(it);
else
@ -378,16 +347,15 @@ void BS_Animation::FrameNotification(int TimeElapsed)
// -----------------------------------------------------------------------------
void BS_Animation::ComputeCurrentCharacteristics()
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
void BS_Animation::ComputeCurrentCharacteristics() {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
const BS_AnimationResource::Frame & CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame);
const BS_AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame);
BS_Resource* pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName);
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);
BS_BitmapResource *pBitmap = static_cast<BS_BitmapResource *>(pResource);
// Größe des Bitmaps auf die Animation übertragen
m_Width = static_cast<int>(pBitmap->GetWidth() * m_ScaleFactorX);
@ -404,16 +372,12 @@ void BS_Animation::ComputeCurrentCharacteristics()
// -----------------------------------------------------------------------------
bool BS_Animation::LockAllFrames()
{
if (!m_FramesLocked)
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
bool BS_Animation::LockAllFrames() {
if (!m_FramesLocked) {
BS_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))
{
for (unsigned int i = 0; i < animationDescriptionPtr->GetFrameCount(); ++i) {
if (!BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(i).FileName)) {
BS_LOG_ERRORLN("Could not lock all animation frames.");
return false;
}
@ -427,17 +391,13 @@ bool BS_Animation::LockAllFrames()
// -----------------------------------------------------------------------------
bool BS_Animation::UnlockAllFrames()
{
if (m_FramesLocked)
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
bool BS_Animation::UnlockAllFrames() {
if (m_FramesLocked) {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
for (unsigned int i = 0; i < animationDescriptionPtr->GetFrameCount(); ++i)
{
BS_Resource* pResource;
if (!(pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(i).FileName)))
{
for (unsigned int i = 0; i < animationDescriptionPtr->GetFrameCount(); ++i) {
BS_Resource *pResource;
if (!(pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(i).FileName))) {
BS_LOG_ERRORLN("Could not unlock all animation frames.");
return false;
}
@ -457,54 +417,48 @@ bool BS_Animation::UnlockAllFrames()
// Getter
// -----------------------------------------------------------------------------
BS_Animation::ANIMATION_TYPES BS_Animation::GetAnimationType() const
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
BS_Animation::ANIMATION_TYPES BS_Animation::GetAnimationType() const {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
return animationDescriptionPtr->GetAnimationType();
}
// -----------------------------------------------------------------------------
int BS_Animation::GetFPS() const
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
int BS_Animation::GetFPS() const {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
return animationDescriptionPtr->GetFPS();
}
// -----------------------------------------------------------------------------
int BS_Animation::GetFrameCount() const
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
int BS_Animation::GetFrameCount() const {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
return animationDescriptionPtr->GetFrameCount();
}
// -----------------------------------------------------------------------------
bool BS_Animation::IsScalingAllowed() const
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
bool BS_Animation::IsScalingAllowed() const {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
return animationDescriptionPtr->IsScalingAllowed();
}
// -----------------------------------------------------------------------------
bool BS_Animation::IsAlphaAllowed() const
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
bool BS_Animation::IsAlphaAllowed() const {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
return animationDescriptionPtr->IsAlphaAllowed();
}
// -----------------------------------------------------------------------------
bool BS_Animation::IsColorModulationAllowed() const
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
bool BS_Animation::IsColorModulationAllowed() const {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
return animationDescriptionPtr->IsColorModulationAllowed();
}
@ -513,8 +467,7 @@ bool BS_Animation::IsColorModulationAllowed() const
// Positionieren
// -----------------------------------------------------------------------------
void BS_Animation::SetPos(int RelX, int RelY)
{
void BS_Animation::SetPos(int RelX, int RelY) {
m_RelX = RelX;
m_RelY = RelY;
@ -523,8 +476,7 @@ void BS_Animation::SetPos(int RelX, int RelY)
// -----------------------------------------------------------------------------
void BS_Animation::SetX(int RelX)
{
void BS_Animation::SetX(int RelX) {
m_RelX = RelX;
ComputeCurrentCharacteristics();
@ -532,8 +484,7 @@ void BS_Animation::SetX(int RelX)
// -----------------------------------------------------------------------------
void BS_Animation::SetY(int RelY)
{
void BS_Animation::SetY(int RelY) {
m_RelY = RelY;
ComputeCurrentCharacteristics();
@ -543,19 +494,16 @@ void BS_Animation::SetY(int RelY)
// Darstellungsart festlegen
// -----------------------------------------------------------------------------
void BS_Animation::SetAlpha(int Alpha)
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
void BS_Animation::SetAlpha(int Alpha) {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
if (!animationDescriptionPtr->IsAlphaAllowed())
{
if (!animationDescriptionPtr->IsAlphaAllowed()) {
BS_LOG_WARNINGLN("Tried to set alpha value on an animation that does not support alpha. Call was ignored.");
return;
}
unsigned int NewModulationColor = (m_ModulationColor & 0x00ffffff) | Alpha << 24;
if (NewModulationColor != m_ModulationColor)
{
if (NewModulationColor != m_ModulationColor) {
m_ModulationColor = NewModulationColor;
ForceRefresh();
}
@ -563,19 +511,16 @@ void BS_Animation::SetAlpha(int Alpha)
// -----------------------------------------------------------------------------
void BS_Animation::SetModulationColor(unsigned int ModulationColor)
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
void BS_Animation::SetModulationColor(unsigned int ModulationColor) {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
if (!animationDescriptionPtr->IsColorModulationAllowed())
{
if (!animationDescriptionPtr->IsColorModulationAllowed()) {
BS_LOG_WARNINGLN("Tried to set modulation color on an animation that does not support color modulation. Call was ignored");
return;
}
unsigned int NewModulationColor = (ModulationColor & 0x00ffffff) | (m_ModulationColor & 0xff000000);
if (NewModulationColor != m_ModulationColor)
{
if (NewModulationColor != m_ModulationColor) {
m_ModulationColor = NewModulationColor;
ForceRefresh();
}
@ -583,26 +528,22 @@ void BS_Animation::SetModulationColor(unsigned int ModulationColor)
// -----------------------------------------------------------------------------
void BS_Animation::SetScaleFactor(float ScaleFactor)
{
void BS_Animation::SetScaleFactor(float ScaleFactor) {
SetScaleFactorX(ScaleFactor);
SetScaleFactorY(ScaleFactor);
}
// -----------------------------------------------------------------------------
void BS_Animation::SetScaleFactorX(float ScaleFactorX)
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
void BS_Animation::SetScaleFactorX(float ScaleFactorX) {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
if (!animationDescriptionPtr->IsScalingAllowed())
{
if (!animationDescriptionPtr->IsScalingAllowed()) {
BS_LOG_WARNINGLN("Tried to set x scale factor on an animation that does not support scaling. Call was ignored");
return;
}
if (ScaleFactorX != m_ScaleFactorX)
{
if (ScaleFactorX != m_ScaleFactorX) {
m_ScaleFactorX = ScaleFactorX;
if (m_ScaleFactorX <= 0.0f) m_ScaleFactorX = 0.001f;
ForceRefresh();
@ -612,18 +553,15 @@ void BS_Animation::SetScaleFactorX(float ScaleFactorX)
// -----------------------------------------------------------------------------
void BS_Animation::SetScaleFactorY(float ScaleFactorY)
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
void BS_Animation::SetScaleFactorY(float ScaleFactorY) {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
if (!animationDescriptionPtr->IsScalingAllowed())
{
if (!animationDescriptionPtr->IsScalingAllowed()) {
BS_LOG_WARNINGLN("Tried to set y scale factor on an animation that does not support scaling. Call was ignored");
return;
}
if (ScaleFactorY != m_ScaleFactorY)
{
if (ScaleFactorY != m_ScaleFactorY) {
m_ScaleFactorY = ScaleFactorY;
if (m_ScaleFactorY <= 0.0f) m_ScaleFactorY = 0.001f;
ForceRefresh();
@ -633,53 +571,47 @@ void BS_Animation::SetScaleFactorY(float ScaleFactorY)
// -----------------------------------------------------------------------------
const Common::String & BS_Animation::GetCurrentAction() const
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
const Common::String &BS_Animation::GetCurrentAction() const {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
return animationDescriptionPtr->GetFrame(m_CurrentFrame).Action;
}
// -----------------------------------------------------------------------------
int BS_Animation::GetX() const
{
int BS_Animation::GetX() const {
return m_RelX;
}
// -----------------------------------------------------------------------------
int BS_Animation::GetY() const
{
int BS_Animation::GetY() const {
return m_RelY;
}
// -----------------------------------------------------------------------------
int BS_Animation::GetAbsoluteX() const
{
int BS_Animation::GetAbsoluteX() const {
return m_AbsoluteX + (m_RelX - m_X);
}
// -----------------------------------------------------------------------------
int BS_Animation::GetAbsoluteY() const
{
int BS_Animation::GetAbsoluteY() const {
return m_AbsoluteY + (m_RelY - m_Y);
}
// -----------------------------------------------------------------------------
int BS_Animation::ComputeXModifier() const
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
int BS_Animation::ComputeXModifier() const {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
const BS_AnimationResource::Frame & CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame);
const BS_AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame);
BS_Resource* pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName);
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);
BS_BitmapResource *pBitmap = static_cast<BS_BitmapResource *>(pResource);
int Result = CurFrame.FlipV ? - static_cast<int>((pBitmap->GetWidth() - 1 - CurFrame.HotspotX) * m_ScaleFactorX) :
- static_cast<int>(CurFrame.HotspotX * m_ScaleFactorX);
@ -691,16 +623,15 @@ int BS_Animation::ComputeXModifier() const
// -----------------------------------------------------------------------------
int BS_Animation::ComputeYModifier() const
{
BS_AnimationDescription * animationDescriptionPtr = GetAnimationDescription();
int BS_Animation::ComputeYModifier() const {
BS_AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
const BS_AnimationResource::Frame & CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame);
const BS_AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame);
BS_Resource* pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName);
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);
BS_BitmapResource *pBitmap = static_cast<BS_BitmapResource *>(pResource);
int Result = CurFrame.FlipH ? - static_cast<int>((pBitmap->GetHeight() - 1 - CurFrame.HotspotY) * m_ScaleFactorY) :
- static_cast<int>(CurFrame.HotspotY * m_ScaleFactorY);
@ -712,8 +643,7 @@ int BS_Animation::ComputeYModifier() const
// -----------------------------------------------------------------------------
void BS_Animation::RegisterActionCallback(ANIMATION_CALLBACK Callback, unsigned int Data)
{
void BS_Animation::RegisterActionCallback(ANIMATION_CALLBACK Callback, unsigned int Data) {
ANIMATION_CALLBACK_DATA CD;
CD.Callback = Callback;
CD.Data = Data;
@ -722,8 +652,7 @@ void BS_Animation::RegisterActionCallback(ANIMATION_CALLBACK Callback, unsigned
// -----------------------------------------------------------------------------
void BS_Animation::RegisterLoopPointCallback(ANIMATION_CALLBACK Callback, unsigned int Data)
{
void BS_Animation::RegisterLoopPointCallback(ANIMATION_CALLBACK Callback, unsigned int Data) {
ANIMATION_CALLBACK_DATA CD;
CD.Callback = Callback;
CD.Data = Data;
@ -732,8 +661,7 @@ void BS_Animation::RegisterLoopPointCallback(ANIMATION_CALLBACK Callback, unsign
// -----------------------------------------------------------------------------
void BS_Animation::RegisterDeleteCallback(ANIMATION_CALLBACK Callback, unsigned int Data)
{
void BS_Animation::RegisterDeleteCallback(ANIMATION_CALLBACK Callback, unsigned int Data) {
ANIMATION_CALLBACK_DATA CD;
CD.Callback = Callback;
CD.Data = Data;
@ -744,15 +672,13 @@ void BS_Animation::RegisterDeleteCallback(ANIMATION_CALLBACK Callback, unsigned
// Persistenz
// -----------------------------------------------------------------------------
void BS_Animation::PersistCallbackVector(BS_OutputPersistenceBlock & Writer, const Common::Array<ANIMATION_CALLBACK_DATA> & Vector)
{
void BS_Animation::PersistCallbackVector(BS_OutputPersistenceBlock &Writer, const Common::Array<ANIMATION_CALLBACK_DATA> & Vector) {
// Anzahl an Callbacks persistieren.
Writer.Write(Vector.size());
// Alle Callbacks einzeln persistieren.
Common::Array<ANIMATION_CALLBACK_DATA>::const_iterator It = Vector.begin();
while (It != Vector.end())
{
while (It != Vector.end()) {
Writer.Write(BS_CallbackRegistry::GetInstance().ResolveCallbackPointer(It->Callback));
Writer.Write(It->Data);
@ -762,8 +688,7 @@ void BS_Animation::PersistCallbackVector(BS_OutputPersistenceBlock & Writer, con
// -----------------------------------------------------------------------------
void BS_Animation::UnpersistCallbackVector(BS_InputPersistenceBlock & Reader, Common::Array<ANIMATION_CALLBACK_DATA> & Vector)
{
void BS_Animation::UnpersistCallbackVector(BS_InputPersistenceBlock &Reader, Common::Array<ANIMATION_CALLBACK_DATA> & Vector) {
// Callbackvector leeren.
Vector.resize(0);
@ -772,8 +697,7 @@ void BS_Animation::UnpersistCallbackVector(BS_InputPersistenceBlock & Reader, Co
Reader.Read(CallbackCount);
// Alle Callbacks einzeln wieder herstellen.
for (unsigned int i = 0; i < CallbackCount; ++i)
{
for (unsigned int i = 0; i < CallbackCount; ++i) {
ANIMATION_CALLBACK_DATA CallbackData;
Common::String CallbackFunctionName;
@ -788,8 +712,7 @@ void BS_Animation::UnpersistCallbackVector(BS_InputPersistenceBlock & Reader, Co
// -----------------------------------------------------------------------------
bool BS_Animation::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_Animation::Persist(BS_OutputPersistenceBlock &Writer) {
bool Result = true;
Result &= BS_RenderObject::Persist(Writer);
@ -806,20 +729,15 @@ bool BS_Animation::Persist(BS_OutputPersistenceBlock & Writer)
Writer.Write(static_cast<unsigned int>(m_Direction));
// Je nach Animationstyp entweder das Template oder die Ressource speichern.
if (m_AnimationResourcePtr)
{
if (m_AnimationResourcePtr) {
unsigned int Marker = 0;
Writer.Write(Marker);
Writer.Write(m_AnimationResourcePtr->GetFileName());
}
else if (m_AnimationTemplateHandle)
{
} else if (m_AnimationTemplateHandle) {
unsigned int Marker = 1;
Writer.Write(Marker);
Writer.Write(m_AnimationTemplateHandle);
}
else
{
} else {
BS_ASSERT(false);
}
@ -837,8 +755,7 @@ bool BS_Animation::Persist(BS_OutputPersistenceBlock & Writer)
// -----------------------------------------------------------------------------
bool BS_Animation::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_Animation::Unpersist(BS_InputPersistenceBlock &Reader) {
bool Result = true;
Result &= BS_RenderObject::Unpersist(Reader);
@ -859,18 +776,13 @@ bool BS_Animation::Unpersist(BS_InputPersistenceBlock & Reader)
// Animationstyp einlesen.
unsigned int Marker;
Reader.Read(Marker);
if (Marker == 0)
{
if (Marker == 0) {
Common::String ResourceFilename;
Reader.Read(ResourceFilename);
InitializeAnimationResource(ResourceFilename);
}
else if (Marker == 1)
{
} else if (Marker == 1) {
Reader.Read(m_AnimationTemplateHandle);
}
else
{
} else {
BS_ASSERT(false);
}
@ -888,8 +800,7 @@ bool BS_Animation::Unpersist(BS_InputPersistenceBlock & Reader)
// -----------------------------------------------------------------------------
BS_AnimationDescription * BS_Animation::GetAnimationDescription() const
{
BS_AnimationDescription *BS_Animation::GetAnimationDescription() const {
if (m_AnimationResourcePtr) return m_AnimationResourcePtr;
else return BS_AnimationTemplateRegistry::GetInstance().ResolveHandle(m_AnimationTemplateHandle);
}

50
engines/sword25/gfx/animation.h
View file

@ -53,18 +53,16 @@ class BS_AnimationTemplate;
class BS_AnimationDescription;
class BS_InputPersistenceBlock;
class BS_Animation : public BS_TimedRenderObject
{
friend class BS_RenderObject;
class BS_Animation : public BS_TimedRenderObject {
friend class BS_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);
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);
public:
enum ANIMATION_TYPES
{
enum ANIMATION_TYPES {
AT_ONESHOT,
AT_LOOP,
AT_JOJO
@ -125,16 +123,20 @@ public:
@brief Gibt den Skalierungsfakter der Animation auf der X-Achse zurück.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsScalingAllowed() true zurückgibt.
*/
float GetScaleFactorX() const { return m_ScaleFactorX; }
float GetScaleFactorX() const {
return m_ScaleFactorX;
}
/**
@brief Gibt den Skalierungsfakter der Animation auf der Y-Achse zurück.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsScalingAllowed() true zurückgibt.
*/
float GetScaleFactorY() const { return m_ScaleFactorY; }
float GetScaleFactorY() const {
return m_ScaleFactorY;
}
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
virtual void FrameNotification(int TimeElapsed);
@ -144,9 +146,13 @@ public:
bool IsScalingAllowed() const;
bool IsAlphaAllowed() const;
bool IsColorModulationAllowed() const;
unsigned int GetCurrentFrame() const { return m_CurrentFrame; }
const Common::String & GetCurrentAction() const ;
bool IsRunning() const { return m_Running; }
unsigned int GetCurrentFrame() const {
return m_CurrentFrame;
}
const Common::String &GetCurrentAction() const ;
bool IsRunning() const {
return m_Running;
}
typedef bool (*ANIMATION_CALLBACK)(unsigned int);
@ -158,8 +164,7 @@ protected:
virtual bool DoRender();
private:
enum DIRECTION
{
enum DIRECTION {
FORWARD,
BACKWARD
};
@ -174,12 +179,11 @@ private:
bool m_Running;
bool m_Finished;
DIRECTION m_Direction;
BS_AnimationResource * m_AnimationResourcePtr;
BS_AnimationResource *m_AnimationResourcePtr;
unsigned int m_AnimationTemplateHandle;
bool m_FramesLocked;
struct ANIMATION_CALLBACK_DATA
{
struct ANIMATION_CALLBACK_DATA {
ANIMATION_CALLBACK Callback;
unsigned int Data;
};
@ -217,9 +221,9 @@ private:
int ComputeYModifier() const;
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;
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;
void InitializeAnimationResource(const Common::String &FileName);
};

6
engines/sword25/gfx/animationdescription.cpp
View file

@ -46,8 +46,7 @@ namespace Sword25 {
// Persistenz
// -----------------------------------------------------------------------------
bool BS_AnimationDescription::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_AnimationDescription::Persist(BS_OutputPersistenceBlock &Writer) {
Writer.Write(static_cast<unsigned int>(m_AnimationType));
Writer.Write(m_FPS);
Writer.Write(m_MillisPerFrame);
@ -60,8 +59,7 @@ bool BS_AnimationDescription::Persist(BS_OutputPersistenceBlock & Writer)
// -----------------------------------------------------------------------------
bool BS_AnimationDescription::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_AnimationDescription::Unpersist(BS_InputPersistenceBlock &Reader) {
unsigned int AnimationType;
Reader.Read(AnimationType);
m_AnimationType = static_cast<BS_Animation::ANIMATION_TYPES>(AnimationType);

36
engines/sword25/gfx/animationdescription.h
View file

@ -49,8 +49,7 @@ namespace Sword25 {
// Klassendefinition
// -----------------------------------------------------------------------------
class BS_AnimationDescription : public BS_Persistable
{
class BS_AnimationDescription : public BS_Persistable {
protected:
BS_AnimationDescription() :
m_AnimationType(BS_Animation::AT_LOOP),
@ -62,8 +61,7 @@ protected:
{};
public:
struct Frame
{
struct Frame {
// Die Hotspot-Angabe bezieht sich auf das ungeflippte Bild!!
int HotspotX;
int HotspotY;
@ -77,7 +75,7 @@ public:
// Abstrakte Methoden
// -----------------------------------------------------------------------------
virtual const Frame & GetFrame(unsigned int Index) const = 0;
virtual const Frame &GetFrame(unsigned int Index) const = 0;
virtual unsigned int GetFrameCount() const = 0;
virtual void Unlock() = 0;
@ -85,15 +83,27 @@ public:
// Getter Methoden
// -----------------------------------------------------------------------------
BS_Animation::ANIMATION_TYPES GetAnimationType() const { return m_AnimationType; }
int GetFPS() const { return m_FPS; }
int GetMillisPerFrame() const { return m_MillisPerFrame; }
bool IsScalingAllowed() const { return m_ScalingAllowed; }
bool IsAlphaAllowed() const { return m_AlphaAllowed; }
bool IsColorModulationAllowed() const { return m_ColorModulationAllowed; }
BS_Animation::ANIMATION_TYPES GetAnimationType() const {
return m_AnimationType;
}
int GetFPS() const {
return m_FPS;
}
int GetMillisPerFrame() const {
return m_MillisPerFrame;
}
bool IsScalingAllowed() const {
return m_ScalingAllowed;
}
bool IsAlphaAllowed() const {
return m_AlphaAllowed;
}
bool IsColorModulationAllowed() const {
return m_ColorModulationAllowed;
}
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
protected:
BS_Animation::ANIMATION_TYPES m_AnimationType;

134
engines/sword25/gfx/animationresource.cpp
View file

@ -54,23 +54,21 @@ namespace Sword25 {
// Constants
// -----------------------------------------------------------------------------
namespace
{
const int DEFAULT_FPS = 10;
const int MIN_FPS = 1;
const int MAX_FPS = 200;
namespace {
const int DEFAULT_FPS = 10;
const int MIN_FPS = 1;
const int MAX_FPS = 200;
}
// -----------------------------------------------------------------------------
// Construction / Destruction
// -----------------------------------------------------------------------------
BS_AnimationResource::BS_AnimationResource(const Common::String& FileName) :
BS_AnimationResource::BS_AnimationResource(const Common::String &FileName) :
BS_Resource(FileName, BS_Resource::TYPE_ANIMATION),
m_Valid(false)
{
m_Valid(false) {
// Pointer auf den Package-Manager bekommen
BS_PackageManager* PackagePtr = BS_Kernel::GetInstance()->GetPackage();
BS_PackageManager *PackagePtr = BS_Kernel::GetInstance()->GetPackage();
BS_ASSERT(PackagePtr);
// Animations-XML laden
@ -79,9 +77,8 @@ BS_AnimationResource::BS_AnimationResource(const Common::String& FileName) :
// Die Daten werden zunächst über den Package-Manager gelesen und dann in einen um ein Byte größeren Buffer kopiert und
// NULL-Terminiert, da TinyXML NULL-Terminierte Daten benötigt.
unsigned int FileSize;
char * LoadBuffer = (char *) PackagePtr->GetFile(GetFileName(), &FileSize);
if (!LoadBuffer)
{
char *LoadBuffer = (char *) PackagePtr->GetFile(GetFileName(), &FileSize);
if (!LoadBuffer) {
BS_LOG_ERRORLN("Could not read \"%s\".", GetFileName().c_str());
return;
}
@ -94,27 +91,24 @@ BS_AnimationResource::BS_AnimationResource(const Common::String& FileName) :
// Datei parsen
Doc.Parse(&WorkBuffer[0]);
free(WorkBuffer);
if (Doc.Error())
{
if (Doc.Error()) {
BS_LOG_ERRORLN("The following TinyXML-Error occured while parsing \"%s\": %s", GetFileName().c_str(), Doc.ErrorDesc());
return;
}
}
// Wurzelknoten des Animations-Tags finden, prüfen und Attribute auslesen.
TiXmlElement* pElement;
{
TiXmlNode* pNode = Doc.FirstChild("animation");
if (!pNode || pNode->Type() != TiXmlNode::ELEMENT)
TiXmlElement *pElement;
{
TiXmlNode *pNode = Doc.FirstChild("animation");
if (!pNode || pNode->Type() != TiXmlNode::ELEMENT) {
BS_LOG_ERRORLN("No <animation> tag found in \"%s\".", GetFileName().c_str());
return;
}
pElement = pNode->ToElement();
// Animation-Tag parsen
if (!ParseAnimationTag(*pElement, m_FPS, m_AnimationType))
{
if (!ParseAnimationTag(*pElement, m_FPS, m_AnimationType)) {
BS_LOG_ERRORLN("An error occurred while parsing <animation> tag in \"%s\".", GetFileName().c_str());
return;
}
@ -131,13 +125,11 @@ BS_AnimationResource::BS_AnimationResource(const Common::String& FileName) :
}
// Nacheinander alle Frames-Informationen erstellen.
TiXmlElement* pFrameElement = pElement->FirstChild("frame")->ToElement();
while (pFrameElement)
{
TiXmlElement *pFrameElement = pElement->FirstChild("frame")->ToElement();
while (pFrameElement) {
Frame CurFrame;
if (!ParseFrameTag(*pFrameElement, CurFrame, *PackagePtr))
{
if (!ParseFrameTag(*pFrameElement, CurFrame, *PackagePtr)) {
BS_LOG_ERRORLN("An error occurred in \"%s\" while parsing <frame> tag.", GetFileName().c_str());
return;
}
@ -150,22 +142,19 @@ BS_AnimationResource::BS_AnimationResource(const Common::String& FileName) :
PackagePtr->ChangeDirectory(OldDirectory);
// Sicherstellen, dass die Animation mindestens einen Frame besitzt
if (m_Frames.empty())
{
if (m_Frames.empty()) {
BS_LOG_ERRORLN("\"%s\" does not have any frames.", GetFileName().c_str());
return;
}
// Alle Frame-Dateien werden vorgecached
if (!PrecacheAllFrames())
{
if (!PrecacheAllFrames()) {
BS_LOG_ERRORLN("Could not precache all frames of \"%s\".", GetFileName().c_str());
return;
}
// Feststellen, ob die Animation skalierbar ist
if (!ComputeFeatures())
{
if (!ComputeFeatures()) {
BS_LOG_ERRORLN("Could not determine the features of \"%s\".", GetFileName().c_str());
return;
}
@ -177,27 +166,22 @@ BS_AnimationResource::BS_AnimationResource(const Common::String& FileName) :
// Dokument-Parsermethoden
// -----------------------------------------------------------------------------
bool BS_AnimationResource::ParseAnimationTag(TiXmlElement& AnimationTag, int& FPS, BS_Animation::ANIMATION_TYPES & AnimationType)
{
bool BS_AnimationResource::ParseAnimationTag(TiXmlElement &AnimationTag, int &FPS, BS_Animation::ANIMATION_TYPES &AnimationType) {
// FPS einlesen
const char* FPSString;
if (FPSString = AnimationTag.Attribute("fps"))
{
const char *FPSString;
if (FPSString = AnimationTag.Attribute("fps")) {
int TempFPS;
if (!BS_String::ToInt(Common::String(FPSString), TempFPS) || TempFPS < MIN_FPS || TempFPS > MAX_FPS)
{
if (!BS_String::ToInt(Common::String(FPSString), TempFPS) || TempFPS < MIN_FPS || TempFPS > MAX_FPS) {
BS_LOG_WARNINGLN("Illegal fps value (\"%s\") in <animation> tag in \"%s\". Assuming default (\"%d\"). "
"The fps value has to be between %d and %d.",
FPSString, GetFileName().c_str(), DEFAULT_FPS, MIN_FPS, MAX_FPS);
}
else
} else
FPS = TempFPS;
}
// Loop-Typ einlesen
const char* LoopTypeString;
if (LoopTypeString = AnimationTag.Attribute("type"))
{
const char *LoopTypeString;
if (LoopTypeString = AnimationTag.Attribute("type")) {
if (strcmp(LoopTypeString, "oneshot") == 0)
AnimationType = BS_Animation::AT_ONESHOT;
else if (strcmp(LoopTypeString, "loop") == 0)
@ -214,27 +198,24 @@ bool BS_AnimationResource::ParseAnimationTag(TiXmlElement& AnimationTag, int& FP
// -----------------------------------------------------------------------------
bool BS_AnimationResource::ParseFrameTag(TiXmlElement& FrameTag, Frame& Frame_, BS_PackageManager& PackageManager)
{
const char* FileString = FrameTag.Attribute("file");
if (!FileString)
{
bool BS_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());
return false;
}
Frame_.FileName = PackageManager.GetAbsolutePath(FileString);
if (Frame_.FileName == "")
{
if (Frame_.FileName == "") {
BS_LOG_ERRORLN("Could not create absolute path for file specified in <frame> tag in \"%s\": \"%s\".", GetFileName().c_str(), FileString);
return false;
}
const char* ActionString = FrameTag.Attribute("action");
const char *ActionString = FrameTag.Attribute("action");
if (ActionString)
Frame_.Action = ActionString;
const char* HotspotxString = FrameTag.Attribute("hotspotx");
const char* HotspotyString = FrameTag.Attribute("hotspoty");
const char *HotspotxString = FrameTag.Attribute("hotspotx");
const char *HotspotyString = FrameTag.Attribute("hotspoty");
if ((!HotspotxString && HotspotyString) ||
(HotspotxString && !HotspotyString))
BS_LOG_WARNINGLN("%s attribute occurred without %s attribute in <frame> tag in \"%s\". Assuming default (\"0\").",
@ -245,37 +226,31 @@ bool BS_AnimationResource::ParseFrameTag(TiXmlElement& FrameTag, Frame& Frame_,
Frame_.HotspotX = 0;
if (HotspotxString && !BS_String::ToInt(Common::String(HotspotxString), Frame_.HotspotX))
BS_LOG_WARNINGLN("Illegal hotspotx value (\"%s\") in frame tag in \"%s\". Assuming default (\"%s\").",
HotspotxString,GetFileName().c_str(), Frame_.HotspotX);
HotspotxString, GetFileName().c_str(), Frame_.HotspotX);
Frame_.HotspotY = 0;
if (HotspotyString && !BS_String::ToInt(Common::String(HotspotyString), Frame_.HotspotY))
BS_LOG_WARNINGLN("Illegal hotspoty value (\"%s\") in frame tag in \"%s\". Assuming default (\"%s\").",
HotspotyString, GetFileName().c_str(), Frame_.HotspotY);
const char* FlipVString = FrameTag.Attribute("flipv");
if (FlipVString)
{
if (!BS_String::ToBool(Common::String(FlipVString), Frame_.FlipV))
{
const char *FlipVString = FrameTag.Attribute("flipv");
if (FlipVString) {
if (!BS_String::ToBool(Common::String(FlipVString), Frame_.FlipV)) {
BS_LOG_WARNINGLN("Illegal flipv value (\"%s\") in <frame> tag in \"%s\". Assuming default (\"false\").",
FlipVString, GetFileName().c_str());
Frame_.FlipV = false;
}
}
else
} else
Frame_.FlipV = false;
const char* FlipHString = FrameTag.Attribute("fliph");
if (FlipHString)
{
if (!BS_String::ToBool(FlipHString, Frame_.FlipH))
{
const char *FlipHString = FrameTag.Attribute("fliph");
if (FlipHString) {
if (!BS_String::ToBool(FlipHString, Frame_.FlipH)) {
BS_LOG_WARNINGLN("Illegal fliph value (\"%s\") in <frame> tag in \"%s\". Assuming default (\"false\").",
FlipHString, GetFileName().c_str());
Frame_.FlipH = false;
}
}
else
} else
Frame_.FlipH = false;
return true;
@ -283,19 +258,15 @@ bool BS_AnimationResource::ParseFrameTag(TiXmlElement& FrameTag, Frame& Frame_,
// -----------------------------------------------------------------------------
BS_AnimationResource::~BS_AnimationResource()
{
BS_AnimationResource::~BS_AnimationResource() {
}
// -----------------------------------------------------------------------------
bool BS_AnimationResource::PrecacheAllFrames() const
{
bool BS_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))
{
for (; Iter != m_Frames.end(); ++Iter) {
if (!BS_Kernel::GetInstance()->GetResourceManager()->PrecacheResource((*Iter).FileName)) {
BS_LOG_ERRORLN("Could not precache \"%s\".", (*Iter).FileName.c_str());
return false;
}
@ -306,8 +277,7 @@ bool BS_AnimationResource::PrecacheAllFrames() const
// -----------------------------------------------------------------------------
bool BS_AnimationResource::ComputeFeatures()
{
bool BS_AnimationResource::ComputeFeatures() {
BS_ASSERT(m_Frames.size());
// Alle Features werden als vorhanden angenommen
@ -317,11 +287,9 @@ 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))))
{
for (; Iter != m_Frames.end(); ++Iter) {
BS_BitmapResource *pBitmap;
if (!(pBitmap = static_cast<BS_BitmapResource *>(BS_Kernel::GetInstance()->GetResourceManager()->RequestResource((*Iter).FileName)))) {
BS_LOG_ERRORLN("Could not request \"%s\".", (*Iter).FileName.c_str());
return false;
}

50
engines/sword25/gfx/animationresource.h
View file

@ -63,23 +63,43 @@ class BS_PackageManager;
// Class Definition
// -----------------------------------------------------------------------------
class BS_AnimationResource : public BS_Resource, public BS_AnimationDescription
{
class BS_AnimationResource : public BS_Resource, public BS_AnimationDescription {
public:
BS_AnimationResource(const Common::String & FileName);
BS_AnimationResource(const Common::String &FileName);
virtual ~BS_AnimationResource();
virtual const Frame & GetFrame(unsigned int Index) const { BS_ASSERT(Index < m_Frames.size()); return m_Frames[Index]; }
virtual unsigned int GetFrameCount() const { return m_Frames.size(); }
virtual void Unlock() { Release(); }
virtual const Frame &GetFrame(unsigned int Index) const {
BS_ASSERT(Index < m_Frames.size());
return m_Frames[Index];
}
virtual unsigned int GetFrameCount() const {
return m_Frames.size();
}
virtual void Unlock() {
Release();
}
BS_Animation::ANIMATION_TYPES GetAnimationType() const { return m_AnimationType; }
int GetFPS() const { return m_FPS; }
int GetMillisPerFrame() const { return m_MillisPerFrame; }
bool IsScalingAllowed() const { return m_ScalingAllowed; }
bool IsAlphaAllowed() const { return m_AlphaAllowed; }
bool IsColorModulationAllowed() const { return m_ColorModulationAllowed; }
bool IsValid() const { return m_Valid; }
BS_Animation::ANIMATION_TYPES GetAnimationType() const {
return m_AnimationType;
}
int GetFPS() const {
return m_FPS;
}
int GetMillisPerFrame() const {
return m_MillisPerFrame;
}
bool IsScalingAllowed() const {
return m_ScalingAllowed;
}
bool IsAlphaAllowed() const {
return m_AlphaAllowed;
}
bool IsColorModulationAllowed() const {
return m_ColorModulationAllowed;
}
bool IsValid() const {
return m_Valid;
}
private:
bool m_Valid;
@ -89,8 +109,8 @@ private:
//@{
/** @name Dokument-Parser Methoden */
bool ParseAnimationTag(TiXmlElement& AnimationTag, int& FPS, BS_Animation::ANIMATION_TYPES & AnimationType);
bool ParseFrameTag(TiXmlElement& FrameTag, Frame& Frame, BS_PackageManager& PackageManager);
bool ParseAnimationTag(TiXmlElement &AnimationTag, int &FPS, BS_Animation::ANIMATION_TYPES &AnimationType);
bool ParseFrameTag(TiXmlElement &FrameTag, Frame &Frame, BS_PackageManager &PackageManager);
//@}

106
engines/sword25/gfx/animationtemplate.cpp
View file

@ -53,16 +53,12 @@ namespace Sword25 {
// Konstruktion / Destruktion
// -----------------------------------------------------------------------------
unsigned int BS_AnimationTemplate::Create(const Common::String & SourceAnimation)
{
BS_AnimationTemplate * AnimationTemplatePtr = new BS_AnimationTemplate(SourceAnimation);
unsigned int BS_AnimationTemplate::Create(const Common::String &SourceAnimation) {
BS_AnimationTemplate *AnimationTemplatePtr = new BS_AnimationTemplate(SourceAnimation);
if (AnimationTemplatePtr->IsValid())
{
if (AnimationTemplatePtr->IsValid()) {
return BS_AnimationTemplateRegistry::GetInstance().ResolvePtr(AnimationTemplatePtr);
}
else
{
} else {
delete AnimationTemplatePtr;
return 0;
}
@ -70,16 +66,12 @@ 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 BS_AnimationTemplate::Create(const BS_AnimationTemplate &Other) {
BS_AnimationTemplate *AnimationTemplatePtr = new BS_AnimationTemplate(Other);
if (AnimationTemplatePtr->IsValid())
{
if (AnimationTemplatePtr->IsValid()) {
return BS_AnimationTemplateRegistry::GetInstance().ResolvePtr(AnimationTemplatePtr);
}
else
{
} else {
delete AnimationTemplatePtr;
return 0;
}
@ -87,16 +79,12 @@ 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 BS_AnimationTemplate::Create(BS_InputPersistenceBlock &Reader, unsigned int Handle) {
BS_AnimationTemplate *AnimationTemplatePtr = new BS_AnimationTemplate(Reader, Handle);
if (AnimationTemplatePtr->IsValid())
{
if (AnimationTemplatePtr->IsValid()) {
return BS_AnimationTemplateRegistry::GetInstance().ResolvePtr(AnimationTemplatePtr);
}
else
{
} else {
delete AnimationTemplatePtr;
return 0;
}
@ -104,8 +92,7 @@ unsigned int BS_AnimationTemplate::Create(BS_InputPersistenceBlock & Reader, uns
// -----------------------------------------------------------------------------
BS_AnimationTemplate::BS_AnimationTemplate(const Common::String & SourceAnimation)
{
BS_AnimationTemplate::BS_AnimationTemplate(const Common::String &SourceAnimation) {
// Objekt registrieren.
BS_AnimationTemplateRegistry::GetInstance().RegisterObject(this);
@ -120,8 +107,7 @@ BS_AnimationTemplate::BS_AnimationTemplate(const Common::String & SourceAnimatio
// -----------------------------------------------------------------------------
BS_AnimationTemplate::BS_AnimationTemplate(const BS_AnimationTemplate & Other)
{
BS_AnimationTemplate::BS_AnimationTemplate(const BS_AnimationTemplate &Other) {
// Objekt registrieren.
BS_AnimationTemplateRegistry::GetInstance().RegisterObject(this);
@ -147,8 +133,7 @@ BS_AnimationTemplate::BS_AnimationTemplate(const BS_AnimationTemplate & Other)
// -----------------------------------------------------------------------------
BS_AnimationTemplate::BS_AnimationTemplate(BS_InputPersistenceBlock & Reader, unsigned int Handle)
{
BS_AnimationTemplate::BS_AnimationTemplate(BS_InputPersistenceBlock &Reader, unsigned int Handle) {
// Objekt registrieren.
BS_AnimationTemplateRegistry::GetInstance().RegisterObject(this, Handle);
@ -158,12 +143,10 @@ BS_AnimationTemplate::BS_AnimationTemplate(BS_InputPersistenceBlock & Reader, un
// -----------------------------------------------------------------------------
BS_AnimationResource * BS_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_AnimationResource *BS_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;
}
@ -172,11 +155,9 @@ BS_AnimationResource * BS_AnimationTemplate::RequestSourceAnimation(const Common
// -----------------------------------------------------------------------------
BS_AnimationTemplate::~BS_AnimationTemplate()
{
BS_AnimationTemplate::~BS_AnimationTemplate() {
// Animations-Resource freigeben
if (m_SourceAnimationPtr)
{
if (m_SourceAnimationPtr) {
m_SourceAnimationPtr->Release();
}
@ -186,64 +167,52 @@ BS_AnimationTemplate::~BS_AnimationTemplate()
// -----------------------------------------------------------------------------
void BS_AnimationTemplate::AddFrame(int Index)
{
if (ValidateSourceIndex(Index))
{
void BS_AnimationTemplate::AddFrame(int Index) {
if (ValidateSourceIndex(Index)) {
m_Frames.push_back(m_SourceAnimationPtr->GetFrame(Index));
}
}
// -----------------------------------------------------------------------------
void BS_AnimationTemplate::SetFrame(int DestIndex, int SrcIndex)
{
if (ValidateDestIndex(DestIndex) && ValidateSourceIndex(SrcIndex))
{
void BS_AnimationTemplate::SetFrame(int DestIndex, int SrcIndex) {
if (ValidateDestIndex(DestIndex) && ValidateSourceIndex(SrcIndex)) {
m_Frames[DestIndex] = m_SourceAnimationPtr->GetFrame(SrcIndex);
}
}
// -----------------------------------------------------------------------------
bool BS_AnimationTemplate::ValidateSourceIndex(unsigned int Index) const
{
if (Index > m_SourceAnimationPtr->GetFrameCount())
{
bool BS_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());
return false;
}
else
} else
return true;
}
// -----------------------------------------------------------------------------
bool BS_AnimationTemplate::ValidateDestIndex(unsigned int Index) const
{
if (Index > m_Frames.size())
{
bool BS_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);
return false;
}
else
} else
return true;
}
// -----------------------------------------------------------------------------
void BS_AnimationTemplate::SetFPS(int FPS)
{
void BS_AnimationTemplate::SetFPS(int FPS) {
m_FPS = FPS;
m_MillisPerFrame = 1000000 / m_FPS;
}
// -----------------------------------------------------------------------------
bool BS_AnimationTemplate::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_AnimationTemplate::Persist(BS_OutputPersistenceBlock &Writer) {
bool Result = true;
// Parent persistieren.
@ -254,8 +223,7 @@ bool BS_AnimationTemplate::Persist(BS_OutputPersistenceBlock & Writer)
// Frames einzeln persistieren.
Common::Array<const Frame>::const_iterator Iter = m_Frames.begin();
while (Iter != m_Frames.end())
{
while (Iter != m_Frames.end()) {
Writer.Write(Iter->HotspotX);
Writer.Write(Iter->HotspotY);
Writer.Write(Iter->FlipV);
@ -274,8 +242,7 @@ bool BS_AnimationTemplate::Persist(BS_OutputPersistenceBlock & Writer)
// -----------------------------------------------------------------------------
bool BS_AnimationTemplate::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_AnimationTemplate::Unpersist(BS_InputPersistenceBlock &Reader) {
bool Result = true;
// Parent wieder herstellen.
@ -286,8 +253,7 @@ bool BS_AnimationTemplate::Unpersist(BS_InputPersistenceBlock & Reader)
Reader.Read(FrameCount);
// Frames einzeln wieder herstellen.
for (unsigned int i = 0; i < FrameCount; ++i)
{
for (unsigned int i = 0; i < FrameCount; ++i) {
Frame frame;
Reader.Read(frame.HotspotX);
Reader.Read(frame.HotspotY);

46
engines/sword25/gfx/animationtemplate.h
View file

@ -59,27 +59,35 @@ class BS_AnimationResource;
// Klassendefinition
// -----------------------------------------------------------------------------
class BS_AnimationTemplate : public BS_AnimationDescription
{
class BS_AnimationTemplate : public BS_AnimationDescription {
public:
static unsigned int Create(const Common::String & SourceAnimation);
static unsigned int Create(const BS_AnimationTemplate & Other);
static unsigned int Create(BS_InputPersistenceBlock & Reader, unsigned int Handle);
BS_AnimationTemplate * ResolveHandle(unsigned int Handle) const;
static unsigned int Create(const Common::String &SourceAnimation);
static unsigned int Create(const BS_AnimationTemplate &Other);
static unsigned int Create(BS_InputPersistenceBlock &Reader, unsigned int Handle);
BS_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);
BS_AnimationTemplate(const Common::String &SourceAnimation);
BS_AnimationTemplate(const BS_AnimationTemplate &Other);
BS_AnimationTemplate(BS_InputPersistenceBlock &Reader, unsigned int Handle);
public:
~BS_AnimationTemplate();
virtual const Frame & GetFrame(unsigned int Index) const { BS_ASSERT(Index < m_Frames.size()); return m_Frames[Index]; }
virtual unsigned int GetFrameCount() const { return m_Frames.size(); }
virtual void Unlock() { delete this; }
virtual const Frame &GetFrame(unsigned int Index) const {
BS_ASSERT(Index < m_Frames.size());
return m_Frames[Index];
}
virtual unsigned int GetFrameCount() const {
return m_Frames.size();
}
virtual void Unlock() {
delete this;
}
bool IsValid() const { return m_Valid; }
bool IsValid() const {
return m_Valid;
}
/**
@brief Fügt einen neuen Frame zur Animation hinzu.
@ -101,7 +109,9 @@ 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) { m_AnimationType = Type; }
void SetAnimationType(BS_Animation::ANIMATION_TYPES Type) {
m_AnimationType = Type;
}
/**
@brief Setzt die Abspielgeschwindigkeit.
@ -109,15 +119,15 @@ public:
*/
void SetFPS(int FPS);
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
private:
Common::Array<const Frame> m_Frames;
BS_AnimationResource * m_SourceAnimationPtr;
BS_AnimationResource *m_SourceAnimationPtr;
bool m_Valid;
BS_AnimationResource * RequestSourceAnimation(const Common::String & SourceAnimation) const;
BS_AnimationResource *RequestSourceAnimation(const Common::String &SourceAnimation) const;
bool ValidateSourceIndex(unsigned int Index) const;
bool ValidateDestIndex(unsigned int Index) const;
};

18
engines/sword25/gfx/animationtemplateregistry.cpp
View file

@ -57,22 +57,19 @@ std::auto_ptr<BS_AnimationTemplateRegistry> BS_AnimationTemplateRegistry::m_Inst
// -----------------------------------------------------------------------------
void BS_AnimationTemplateRegistry::LogErrorLn(const char * Message) const
{
void BS_AnimationTemplateRegistry::LogErrorLn(const char *Message) const {
BS_LOG_ERRORLN(Message);
}
// -----------------------------------------------------------------------------
void BS_AnimationTemplateRegistry::LogWarningLn(const char * Message) const
{
void BS_AnimationTemplateRegistry::LogWarningLn(const char *Message) const {
BS_LOG_WARNINGLN(Message);
}
// -----------------------------------------------------------------------------
bool BS_AnimationTemplateRegistry::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_AnimationTemplateRegistry::Persist(BS_OutputPersistenceBlock &Writer) {
bool Result = true;
// Das nächste zu vergebene Handle schreiben.
@ -83,8 +80,7 @@ bool BS_AnimationTemplateRegistry::Persist(BS_OutputPersistenceBlock & Writer)
// Alle BS_AnimationTemplates persistieren.
HANDLE2PTR_MAP::const_iterator Iter = m_Handle2PtrMap.begin();
while (Iter != m_Handle2PtrMap.end())
{
while (Iter != m_Handle2PtrMap.end()) {
// Handle persistieren.
Writer.Write(Iter->first);
@ -99,8 +95,7 @@ bool BS_AnimationTemplateRegistry::Persist(BS_OutputPersistenceBlock & Writer)
// -----------------------------------------------------------------------------
bool BS_AnimationTemplateRegistry::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_AnimationTemplateRegistry::Unpersist(BS_InputPersistenceBlock &Reader) {
bool Result = true;
// Das nächste zu vergebene Handle wieder herstellen.
@ -114,8 +109,7 @@ bool BS_AnimationTemplateRegistry::Unpersist(BS_InputPersistenceBlock & Reader)
Reader.Read(AnimationTemplateCount);
// Alle gespeicherten BS_AnimationTemplates wieder herstellen.
for (unsigned int i = 0; i < AnimationTemplateCount; ++i)
{
for (unsigned int i = 0; i < AnimationTemplateCount; ++i) {
// Handle lesen.
unsigned int Handle;
Reader.Read(Handle);

14
engines/sword25/gfx/animationtemplateregistry.h
View file

@ -59,21 +59,19 @@ class BS_AnimationTemplate;
// Klassendeklaration
// -----------------------------------------------------------------------------
class BS_AnimationTemplateRegistry : public BS_ObjectRegistry<BS_AnimationTemplate>, public BS_Persistable
{
class BS_AnimationTemplateRegistry : public BS_ObjectRegistry<BS_AnimationTemplate>, public BS_Persistable {
public:
static BS_AnimationTemplateRegistry & GetInstance()
{
static BS_AnimationTemplateRegistry &GetInstance() {
if (!m_InstancePtr.get()) m_InstancePtr.reset(new BS_AnimationTemplateRegistry);
return *m_InstancePtr.get();
}
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
private:
virtual void LogErrorLn(const char * Message) const;
virtual void LogWarningLn(const char * Message) const;
virtual void LogErrorLn(const char *Message) const;
virtual void LogWarningLn(const char *Message) const;
static std::auto_ptr<BS_AnimationTemplateRegistry> m_InstancePtr;
};

66
engines/sword25/gfx/bitmap.cpp
View file

@ -58,30 +58,25 @@ BS_Bitmap::BS_Bitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, TYPES Type,
m_ScaleFactorX(1.0f),
m_ScaleFactorY(1.0f),
m_FlipH(false),
m_FlipV(false)
{
m_FlipV(false) {
}
// -----------------------------------------------------------------------------
BS_Bitmap::~BS_Bitmap()
{
BS_Bitmap::~BS_Bitmap() {
}
// -----------------------------------------------------------------------------
// Darstellungsart festlegen
// -----------------------------------------------------------------------------
void BS_Bitmap::SetAlpha(int Alpha)
{
if (!IsAlphaAllowed())
{
void BS_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;
}
if (Alpha < 0 || Alpha > 255)
{
if (Alpha < 0 || Alpha > 255) {
int OldAlpha = Alpha;
if (Alpha < 0) Alpha = 0;
if (Alpha > 255) Alpha = 255;
@ -91,8 +86,7 @@ void BS_Bitmap::SetAlpha(int Alpha)
}
unsigned int NewModulationColor = (m_ModulationColor & 0x00ffffff) | Alpha << 24;
if (NewModulationColor != m_ModulationColor)
{
if (NewModulationColor != m_ModulationColor) {
m_ModulationColor = NewModulationColor;
ForceRefresh();
}
@ -100,17 +94,14 @@ void BS_Bitmap::SetAlpha(int Alpha)
// -----------------------------------------------------------------------------
void BS_Bitmap::SetModulationColor(unsigned int ModulationColor)
{
if (!IsColorModulationAllowed())
{
void BS_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;
}
unsigned int NewModulationColor = (ModulationColor & 0x00ffffff) | (m_ModulationColor & 0xff000000);
if (NewModulationColor != m_ModulationColor)
{
if (NewModulationColor != m_ModulationColor) {
m_ModulationColor = NewModulationColor;
ForceRefresh();
}
@ -118,30 +109,25 @@ void BS_Bitmap::SetModulationColor(unsigned int ModulationColor)
// -----------------------------------------------------------------------------
void BS_Bitmap::SetScaleFactor(float ScaleFactor)
{
void BS_Bitmap::SetScaleFactor(float ScaleFactor) {
SetScaleFactorX(ScaleFactor);
SetScaleFactorY(ScaleFactor);
}
// -----------------------------------------------------------------------------
void BS_Bitmap::SetScaleFactorX(float ScaleFactorX)
{
if (!IsScalingAllowed())
{
void BS_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;
}
if (ScaleFactorX < 0)
{
if (ScaleFactorX < 0) {
BS_LOG_WARNINGLN("Tried to set scale factor of a bitmap to a negative value. Call was ignored.");
return;
}
if (ScaleFactorX != m_ScaleFactorX)
{
if (ScaleFactorX != m_ScaleFactorX) {
m_ScaleFactorX = ScaleFactorX;
m_Width = static_cast<int>(m_OriginalWidth * m_ScaleFactorX);
if (m_ScaleFactorX <= 0.0f) m_ScaleFactorX = 0.001f;
@ -151,22 +137,18 @@ void BS_Bitmap::SetScaleFactorX(float ScaleFactorX)
// -----------------------------------------------------------------------------
void BS_Bitmap::SetScaleFactorY(float ScaleFactorY)
{
if (!IsScalingAllowed())
{
void BS_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;
}
if (ScaleFactorY < 0)
{
if (ScaleFactorY < 0) {
BS_LOG_WARNINGLN("Tried to set scale factor of a bitmap to a negative value. Call was ignored.");
return;
}
if (ScaleFactorY != m_ScaleFactorY)
{
if (ScaleFactorY != m_ScaleFactorY) {
m_ScaleFactorY = ScaleFactorY;
m_Height = static_cast<int>(m_OriginalHeight * ScaleFactorY);
if (m_ScaleFactorY <= 0.0f) m_ScaleFactorY = 0.001f;
@ -176,16 +158,14 @@ void BS_Bitmap::SetScaleFactorY(float ScaleFactorY)
// -----------------------------------------------------------------------------
void BS_Bitmap::SetFlipH(bool FlipH)
{
void BS_Bitmap::SetFlipH(bool FlipH) {
m_FlipH = FlipH;
ForceRefresh();
}
// -----------------------------------------------------------------------------
void BS_Bitmap::SetFlipV(bool FlipV)
{
void BS_Bitmap::SetFlipV(bool FlipV) {
m_FlipV = FlipV;
ForceRefresh();
}
@ -194,8 +174,7 @@ void BS_Bitmap::SetFlipV(bool FlipV)
// Persistenz
// -----------------------------------------------------------------------------
bool BS_Bitmap::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_Bitmap::Persist(BS_OutputPersistenceBlock &Writer) {
bool Result = true;
Result &= BS_RenderObject::Persist(Writer);
@ -212,8 +191,7 @@ bool BS_Bitmap::Persist(BS_OutputPersistenceBlock & Writer)
// -----------------------------------------------------------------------------
bool BS_Bitmap::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_Bitmap::Unpersist(BS_InputPersistenceBlock &Reader) {
bool Result = true;
Result &= BS_RenderObject::Unpersist(Reader);

31
engines/sword25/gfx/bitmap.h
View file

@ -48,8 +48,7 @@ namespace Sword25 {
// Klassendeklaration
// -----------------------------------------------------------------------------
class BS_Bitmap : public BS_RenderObject
{
class BS_Bitmap : public BS_RenderObject {
protected:
BS_Bitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, TYPES Type, unsigned int Handle = 0);
@ -106,35 +105,47 @@ public:
@brief Gibt den aktuellen Alphawert des Bildes zurück.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsAlphaAllowed() true zurückgibt.
*/
int GetAlpha() { return m_ModulationColor >> 24; }
int GetAlpha() {
return m_ModulationColor >> 24;
}
/**
@brief Gibt die aktuelle 24bit RGB Modulationsfarde des Bildes zurück.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsColorModulationAllowed() true zurückgibt.
*/
int GetModulationColor() { return m_ModulationColor & 0x00ffffff; }
int GetModulationColor() {
return m_ModulationColor & 0x00ffffff;
}
/**
@brief Gibt den Skalierungsfakter des Bitmaps auf der X-Achse zurück.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsScalingAllowed() true zurückgibt.
*/
float GetScaleFactorX() const { return m_ScaleFactorX; }
float GetScaleFactorX() const {
return m_ScaleFactorX;
}
/**
@brief Gibt den Skalierungsfakter des Bitmaps auf der Y-Achse zurück.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsScalingAllowed() true zurückgibt.
*/
float GetScaleFactorY() const { return m_ScaleFactorY; }
float GetScaleFactorY() const {
return m_ScaleFactorY;
}
/**
@brief Gibt zurück, ob das Bild an der X-Achse gespiegelt angezeigt wird.
*/
bool IsFlipH() { return m_FlipH; }
bool IsFlipH() {
return m_FlipH;
}
/**
@brief Gibt zurück, ob das Bild an der Y-Achse gespiegelt angezeigt wird.
*/
bool IsFlipV() { return m_FlipV; }
bool IsFlipV() {
return m_FlipV;
}
// -----------------------------------------------------------------------------
// Die folgenden Methoden müssen alle BS_Bitmap-Klassen implementieren
@ -168,8 +179,8 @@ public:
virtual bool IsColorModulationAllowed() const = 0;
virtual bool IsSetContentAllowed() const = 0;
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
protected:
bool m_FlipH;

11
engines/sword25/gfx/bitmapresource.cpp
View file

@ -47,23 +47,20 @@ namespace Sword25 {
// Konstruktion / Destruktion
// --------------------------
BS_BitmapResource::BS_BitmapResource(const Common::String & Filename, BS_Image * pImage) :
BS_BitmapResource::BS_BitmapResource(const Common::String &Filename, BS_Image *pImage) :
m_Valid(false),
m_pImage(pImage),
BS_Resource(Filename, BS_Resource::TYPE_BITMAP)
{
BS_Resource(Filename, BS_Resource::TYPE_BITMAP) {
m_Valid = m_pImage != 0;
}
BS_BitmapResource::~BS_BitmapResource()
{
BS_BitmapResource::~BS_BitmapResource() {
delete m_pImage;
}
// -----------------------------------------------------------------------------
unsigned int BS_BitmapResource::GetPixel(int X, int Y) const
{
unsigned int BS_BitmapResource::GetPixel(int X, int Y) const {
BS_ASSERT(X >= 0 && X < m_pImage->GetWidth());
BS_ASSERT(Y >= 0 && Y < m_pImage->GetHeight());

59
engines/sword25/gfx/bitmapresource.h
View file

@ -48,14 +48,12 @@ namespace Sword25 {
class BS_Rect;
class BS_BitmapResource : public BS_Resource
{
class BS_BitmapResource : public BS_Resource {
public:
/**
@brief Die möglichen Flippingparameter für die Blit-Methode.
*/
enum FLIP_FLAGS
{
enum FLIP_FLAGS {
/// Das Bild wird nicht gespiegelt.
FLIP_NONE = 0,
/// Das Bild wird an der horizontalen Achse gespiegelt.
@ -68,23 +66,31 @@ public:
FLIP_VH = FLIP_H | FLIP_V
};
BS_BitmapResource(const Common::String & Filename, BS_Image * pImage);
BS_BitmapResource(const Common::String &Filename, BS_Image *pImage);
virtual ~BS_BitmapResource();
/**
@brief Gibt zurück, ob das Objekt einen gültigen Zustand hat.
*/
bool IsValid() const { return m_Valid; }
bool IsValid() const {
return m_Valid;
}
/**
@brief Gibt die Breite des Bitmaps zurück.
*/
int GetWidth() const { BS_ASSERT(m_pImage); return m_pImage->GetWidth(); }
int GetWidth() const {
BS_ASSERT(m_pImage);
return m_pImage->GetWidth();
}
/**
@brief Gibt die Höhe des Bitmaps zurück.
*/
int GetHeight() const { BS_ASSERT(m_pImage); return m_pImage->GetHeight(); }
int GetHeight() const {
BS_ASSERT(m_pImage);
return m_pImage->GetHeight();
}
/**
@brief Rendert das Bild in den Framebuffer.
@ -124,10 +130,9 @@ public:
*/
bool Blit(int PosX = 0, int PosY = 0,
int Flipping = FLIP_NONE,
BS_Rect* pSrcPartRect = NULL,
BS_Rect *pSrcPartRect = NULL,
unsigned int Color = BS_ARGB(255, 255, 255, 255),
int Width = -1, int Height = -1)
{
int Width = -1, int Height = -1) {
BS_ASSERT(m_pImage);
return m_pImage->Blit(PosX, PosY, Flipping, pSrcPartRect, Color, Width, Height);
}
@ -145,7 +150,10 @@ public:
BS_RGB und BS_ARGB benutzt werden.
@remark Falls das Rechteck nicht völlig innerhalb des Bildschirms ist, wird es automatisch zurechtgestutzt.
*/
bool Fill(const BS_Rect* pFillRect = 0, unsigned int Color = BS_RGB(0, 0, 0)) { BS_ASSERT(m_pImage); return m_pImage->Fill(pFillRect, Color); }
bool Fill(const BS_Rect *pFillRect = 0, unsigned int Color = BS_RGB(0, 0, 0)) {
BS_ASSERT(m_pImage);
return m_pImage->Fill(pFillRect, Color);
}
/**
@brief Liest einen Pixel des Bildes.
@ -164,30 +172,45 @@ public:
@brief Überprüft, ob das BS_Image ein Zielbild für einen Blit-Aufruf sein kann.
@return Gibt false zurück, falls ein Blit-Aufruf mit diesem Objekt als Ziel nicht gestattet ist.
*/
bool IsBlitTarget() { BS_ASSERT(m_pImage); return m_pImage->IsBlitTarget(); }
bool IsBlitTarget() {
BS_ASSERT(m_pImage);
return m_pImage->IsBlitTarget();
}
/**
@brief Gibt true zurück, falls das BS_Image bei einem Aufruf von Blit() skaliert dargestellt werden kann.
*/
bool IsScalingAllowed() { BS_ASSERT(m_pImage); return m_pImage->IsScalingAllowed(); }
bool IsScalingAllowed() {
BS_ASSERT(m_pImage);
return m_pImage->IsScalingAllowed();
}
/**
@brief Gibt true zurück, wenn das BS_Image mit einem Aufruf von Fill() gefüllt werden kann.
*/
bool IsFillingAllowed() { BS_ASSERT(m_pImage); return m_pImage->IsFillingAllowed(); }
bool IsFillingAllowed() {
BS_ASSERT(m_pImage);
return m_pImage->IsFillingAllowed();
}
/**
@brief Gibt true zurück, wenn das BS_Image bei einem Aufruf von Blit() mit einem Alphawert dargestellt werden kann.
*/
bool IsAlphaAllowed() { BS_ASSERT(m_pImage); return m_pImage->IsAlphaAllowed(); }
bool IsAlphaAllowed() {
BS_ASSERT(m_pImage);
return m_pImage->IsAlphaAllowed();
}
/**
@brief Gibt true zurück, wenn das BS_Image bei einem Aufruf von Blit() mit Farbmodulation dargestellt werden kann.
*/
bool IsColorModulationAllowed() { BS_ASSERT(m_pImage); return m_pImage->IsColorModulationAllowed(); }
bool IsColorModulationAllowed() {
BS_ASSERT(m_pImage);
return m_pImage->IsColorModulationAllowed();
}
private:
BS_Image * m_pImage;
BS_Image *m_pImage;
bool m_Valid;
};

50
engines/sword25/gfx/dynamicbitmap.cpp
View file

@ -56,8 +56,7 @@ namespace Sword25 {
// -----------------------------------------------------------------------------
BS_DynamicBitmap::BS_DynamicBitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Width, unsigned int Height) :
BS_Bitmap(ParentPtr, TYPE_DYNAMICBITMAP)
{
BS_Bitmap(ParentPtr, TYPE_DYNAMICBITMAP) {
// Das BS_Bitmap konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden.
if (!m_InitSuccess) return;
@ -66,16 +65,14 @@ 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)
{
BS_DynamicBitmap::BS_DynamicBitmap(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) :
BS_Bitmap(ParentPtr, TYPE_DYNAMICBITMAP, Handle) {
m_InitSuccess = Unpersist(Reader);
}
// -----------------------------------------------------------------------------
bool BS_DynamicBitmap::CreateGLImage(unsigned int Width, unsigned int Height)
{
bool BS_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));
@ -88,14 +85,12 @@ bool BS_DynamicBitmap::CreateGLImage(unsigned int Width, unsigned int Height)
// -----------------------------------------------------------------------------
BS_DynamicBitmap::~BS_DynamicBitmap()
{
BS_DynamicBitmap::~BS_DynamicBitmap() {
}
// -----------------------------------------------------------------------------
unsigned int BS_DynamicBitmap::GetPixel(int X, int Y) const
{
unsigned int BS_DynamicBitmap::GetPixel(int X, int Y) const {
BS_ASSERT(X >= 0 && X < m_Width);
BS_ASSERT(Y >= 0 && Y < m_Height);
@ -104,23 +99,19 @@ unsigned int BS_DynamicBitmap::GetPixel(int X, int Y) const
// -----------------------------------------------------------------------------
bool BS_DynamicBitmap::DoRender()
{
bool BS_DynamicBitmap::DoRender() {
// Framebufferobjekt holen
BS_GraphicEngine * pGfx = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
BS_GraphicEngine *pGfx = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
BS_ASSERT(pGfx);
// Bitmap zeichnen
bool Result;
if (m_ScaleFactorX == 1.0f && m_ScaleFactorY == 1.0f)
{
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),
0, m_ModulationColor, -1, -1);
}
else
{
} else {
Result = m_Image->Blit(m_AbsoluteX, m_AbsoluteY,
(m_FlipV ? BS_BitmapResource::FLIP_V : 0) |
(m_FlipH ? BS_BitmapResource::FLIP_H : 0),
@ -132,8 +123,7 @@ bool BS_DynamicBitmap::DoRender()
// -----------------------------------------------------------------------------
bool BS_DynamicBitmap::SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride)
{
bool BS_DynamicBitmap::SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride) {
return m_Image->SetContent(Pixeldata, Offset, Stride);
}
@ -141,29 +131,25 @@ bool BS_DynamicBitmap::SetContent(const byte *Pixeldata, unsigned int Offset, un
// Auskunftsmethoden
// -----------------------------------------------------------------------------
bool BS_DynamicBitmap::IsScalingAllowed() const
{
bool BS_DynamicBitmap::IsScalingAllowed() const {
return m_Image->IsScalingAllowed();
}
// -----------------------------------------------------------------------------
bool BS_DynamicBitmap::IsAlphaAllowed() const
{
bool BS_DynamicBitmap::IsAlphaAllowed() const {
return m_Image->IsAlphaAllowed();
}
// -----------------------------------------------------------------------------
bool BS_DynamicBitmap::IsColorModulationAllowed() const
{
bool BS_DynamicBitmap::IsColorModulationAllowed() const {
return m_Image->IsColorModulationAllowed();
}
// -----------------------------------------------------------------------------
bool BS_DynamicBitmap::IsSetContentAllowed() const
{
bool BS_DynamicBitmap::IsSetContentAllowed() const {
return true;
}
@ -171,8 +157,7 @@ bool BS_DynamicBitmap::IsSetContentAllowed() const
// Persistenz
// -----------------------------------------------------------------------------
bool BS_DynamicBitmap::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_DynamicBitmap::Persist(BS_OutputPersistenceBlock &Writer) {
bool Result = true;
Result &= BS_Bitmap::Persist(Writer);
@ -186,8 +171,7 @@ bool BS_DynamicBitmap::Persist(BS_OutputPersistenceBlock & Writer)
return Result;
}
bool BS_DynamicBitmap::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_DynamicBitmap::Unpersist(BS_InputPersistenceBlock &Reader) {
bool Result = true;
Result &= BS_Bitmap::Unpersist(Reader);

11
engines/sword25/gfx/dynamicbitmap.h
View file

@ -54,9 +54,8 @@ namespace Sword25 {
// Klassendeklaration
// -----------------------------------------------------------------------------
class BS_DynamicBitmap : public BS_Bitmap
{
friend class BS_RenderObject;
class BS_DynamicBitmap : public BS_Bitmap {
friend class BS_RenderObject;
public:
virtual ~BS_DynamicBitmap();
@ -70,15 +69,15 @@ public:
virtual bool IsColorModulationAllowed() const;
virtual bool IsSetContentAllowed() const;
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
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);
BS_DynamicBitmap(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle);
bool CreateGLImage(unsigned int Width, unsigned int Height);

78
engines/sword25/gfx/fontresource.cpp
View file

@ -60,31 +60,27 @@ static const unsigned int DEFAULT_GAPWIDTH = 1;
// Konstruktion / Destruktion
// -----------------------------------------------------------------------------
BS_FontResource::BS_FontResource(BS_Kernel* pKernel, const Common::String& FileName) :
BS_FontResource::BS_FontResource(BS_Kernel *pKernel, const Common::String &FileName) :
_pKernel(pKernel),
_Valid(false),
BS_Resource(FileName, BS_Resource::TYPE_FONT)
{
BS_Resource(FileName, BS_Resource::TYPE_FONT) {
// XML Fontdatei parsen
TiXmlDocument Doc;
if (!_ParseXMLDocument(FileName, Doc))
{
if (!_ParseXMLDocument(FileName, Doc)) {
BS_LOG_ERRORLN("The following TinyXML-Error occured while parsing \"%s\": %s", GetFileName().c_str(), Doc.ErrorDesc());
return;
}
// Font-Tag finden
TiXmlElement* pElement = Doc.FirstChildElement("font");
if (!pElement)
{
TiXmlElement *pElement = Doc.FirstChildElement("font");
if (!pElement) {
BS_LOG_ERRORLN("No <font> tag found in \"%s\".", GetFileName().c_str());
return;
}
// Font-Tag parsen
Common::String BitmapFileName;
if (!_ParseFontTag(*pElement, BitmapFileName, _LineHeight, _GapWidth))
{
if (!_ParseFontTag(*pElement, BitmapFileName, _LineHeight, _GapWidth)) {
BS_LOG_ERRORLN("An error occurred while parsing <font> tag in \"%s\".", GetFileName().c_str());
return;
}
@ -93,21 +89,19 @@ BS_FontResource::BS_FontResource(BS_Kernel* pKernel, const Common::String& FileN
{
// Pointer auf den Package-Manager bekommen
BS_ASSERT(_pKernel);
BS_PackageManager* pPackage = static_cast<BS_PackageManager *>(_pKernel->GetService("package"));
BS_PackageManager *pPackage = static_cast<BS_PackageManager *>(_pKernel->GetService("package"));
BS_ASSERT(pPackage);
// Absoluten, eindeutigen Pfad bestimmen
_BitmapFileName = pPackage->GetAbsolutePath(BitmapFileName);
if (_BitmapFileName == "")
{
if (_BitmapFileName == "") {
BS_LOG_ERRORLN("Image file \"%s\" was specified in <font> tag of \"%s\" but could not be found.",
_BitmapFileName.c_str(), GetFileName().c_str());
return;
}
// Bitmapdatei cachen
if (!_pKernel->GetResourceManager()->PrecacheResource(_BitmapFileName))
{
if (!_pKernel->GetResourceManager()->PrecacheResource(_BitmapFileName)) {
BS_LOG_ERRORLN("Could not precache \"%s\".", _BitmapFileName.c_str());
return;
}
@ -115,21 +109,18 @@ BS_FontResource::BS_FontResource(BS_Kernel* pKernel, const Common::String& FileN
// Das Erste Character-Tag finden
pElement = pElement->FirstChildElement("character");
if (!pElement)
{
if (!pElement) {
BS_LOG_ERRORLN("No <character> tag found in \"%s\".", GetFileName().c_str());
return;
}
// Alle Character-Tags parsen
while (pElement)
{
while (pElement) {
int CharCode;
BS_Rect CharRect;
// Aktuelles Character-Tag parsen
if (!_ParseCharacterTag(*pElement, CharCode, CharRect))
{
if (!_ParseCharacterTag(*pElement, CharCode, CharRect)) {
BS_LOG_ERRORLN("An error occured while parsing a <character> tag in \"%s\".", GetFileName().c_str());
return;
}
@ -148,19 +139,17 @@ BS_FontResource::BS_FontResource(BS_Kernel* pKernel, const Common::String& FileN
// -----------------------------------------------------------------------------
bool BS_FontResource::_ParseXMLDocument(const Common::String & FileName, TiXmlDocument & Doc) const
{
bool BS_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"));
BS_PackageManager *pPackage = static_cast<BS_PackageManager *>(_pKernel->GetService("package"));
BS_ASSERT(pPackage);
// Die Daten werden zunächst über den Package-Manager gelesen und dann in einen um ein Byte größeren Buffer kopiert
// und NULL-Terminiert, da TinyXML NULL-Terminierte Daten benötigt.
unsigned int FileSize;
char * LoadBuffer = (char*) pPackage->GetFile(GetFileName(), &FileSize);
if (!LoadBuffer)
{
char *LoadBuffer = (char *) pPackage->GetFile(GetFileName(), &FileSize);
if (!LoadBuffer) {
BS_LOG_ERRORLN("Could not read \"%s\".", GetFileName().c_str());
return false;
}
@ -182,21 +171,18 @@ bool BS_FontResource::_ParseXMLDocument(const Common::String & FileName, TiXmlDo
// -----------------------------------------------------------------------------
bool BS_FontResource::_ParseFontTag(TiXmlElement & Tag, Common::String & BitmapFileName, int & Lineheight, int & GapWidth) const
{
bool BS_FontResource::_ParseFontTag(TiXmlElement &Tag, Common::String &BitmapFileName, int &Lineheight, int &GapWidth) const {
// Bitmap Attribut auslesen
const char * BitmapString = Tag.Attribute("bitmap");
if (!BitmapString)
{
const char *BitmapString = Tag.Attribute("bitmap");
if (!BitmapString) {
BS_LOG_ERRORLN("<font> tag without bitmap attribute occurred in \"%s\".", GetFileName().c_str());
return false;
}
BitmapFileName = BitmapString;
// Lineheight Attribut auslesen
const char * LineheightString = Tag.Attribute("lineheight");
if (!LineheightString || !BS_String::ToInt(Common::String(LineheightString), Lineheight) || Lineheight < 0)
{
const char *LineheightString = Tag.Attribute("lineheight");
if (!LineheightString || !BS_String::ToInt(Common::String(LineheightString), Lineheight) || Lineheight < 0) {
BS_LOG_WARNINGLN("Illegal or missing lineheight attribute in <font> tag in \"%s\". Assuming default (\"%d\").",
GetFileName().c_str(), DEFAULT_LINEHEIGHT);
Lineheight = DEFAULT_LINEHEIGHT;
@ -204,9 +190,8 @@ bool BS_FontResource::_ParseFontTag(TiXmlElement & Tag, Common::String & BitmapF
// Gap Attribut auslesen
const char * GapString = Tag.Attribute("gap");
if (!GapString || !BS_String::ToInt(Common::String(GapString), GapWidth) || GapWidth < 0)
{
const char *GapString = Tag.Attribute("gap");
if (!GapString || !BS_String::ToInt(Common::String(GapString), GapWidth) || GapWidth < 0) {
BS_LOG_WARNINGLN("Illegal or missing gap attribute in <font> tag in \"%s\". Assuming default (\"%d\").",
GetFileName().c_str(), DEFAULT_GAPWIDTH);
GapWidth = DEFAULT_GAPWIDTH;
@ -217,12 +202,10 @@ bool BS_FontResource::_ParseFontTag(TiXmlElement & Tag, Common::String & BitmapF
// -----------------------------------------------------------------------------
bool BS_FontResource::_ParseCharacterTag(TiXmlElement & Tag, int & Code, BS_Rect & Rect) const
{
bool BS_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)
{
const char *CodeString = Tag.Attribute("code");
if (!CodeString || !BS_String::ToInt(Common::String(CodeString), Code) || Code < 0 || Code >= 256) {
BS_LOG_ERRORLN("Illegal or missing code attribute in <character> tag in \"%s\".", GetFileName().c_str());
return false;
}
@ -238,7 +221,7 @@ bool BS_FontResource::_ParseCharacterTag(TiXmlElement & Tag, int & Code, BS_Rect
Rect.left = tmp;
// Right Attribut auslesen
const char * RightString = Tag.Attribute("right");
const char *RightString = Tag.Attribute("right");
if (!RightString || !BS_String::ToInt(RightString, tmp) || tmp < 0) {
BS_LOG_ERRORLN("Illegal or missing right attribute in <character> tag in \"%s\".", GetFileName().c_str());
return false;
@ -246,7 +229,7 @@ bool BS_FontResource::_ParseCharacterTag(TiXmlElement & Tag, int & Code, BS_Rect
Rect.right = tmp;
// Top Attribut auslesen
const char * TopString = Tag.Attribute("top");
const char *TopString = Tag.Attribute("top");
if (!TopString || !BS_String::ToInt(TopString, tmp) || tmp < 0) {
BS_LOG_ERRORLN("Illegal or missing top attribute in <character> tag in \"%s\".", GetFileName().c_str());
return false;
@ -254,9 +237,8 @@ bool BS_FontResource::_ParseCharacterTag(TiXmlElement & Tag, int & Code, BS_Rect
Rect.top = tmp;
// Bottom Attribut auslesen
const char * BottomString = Tag.Attribute("bottom");
if (!BottomString || !BS_String::ToInt(BottomString, tmp) || tmp < 0)
{
const char *BottomString = Tag.Attribute("bottom");
if (!BottomString || !BS_String::ToInt(BottomString, tmp) || tmp < 0) {
BS_LOG_ERRORLN("Illegal or missing bottom attribute in <character> tag in \"%s\".", GetFileName().c_str());
return false;
}

34
engines/sword25/gfx/fontresource.h
View file

@ -58,8 +58,7 @@ class BS_Kernel;
// Klassendefinition
// -----------------------------------------------------------------------------
class BS_FontResource : public BS_Resource
{
class BS_FontResource : public BS_Resource {
public:
/**
@brief Erzeugt eine neues Exemplar von BS_FontResource
@ -67,43 +66,54 @@ 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);
BS_FontResource(BS_Kernel *pKernel, const Common::String &FileName);
/**
@brief Gibt true zurück, wenn das Objekt korrekt initialisiert wurde.
Diese Methode kann dazu benutzt werden um festzustellen, ob der Konstruktor erfolgreich ausgeführt wurde.
*/
bool IsValid() const { return _Valid; }
bool IsValid() const {
return _Valid;
}
/**
@brief Gibt die Zeilenhöhe des Fonts in Pixeln zurück.
Die Zeilenhöhe ist der Wert, der zur Y-Koordinate addiert wird, wenn ein Zeilenumbruch auftritt.
*/
int GetLineHeight() const { return _LineHeight; }
int GetLineHeight() const {
return _LineHeight;
}
/**
@brief Gibt den Buchstabenabstand der Fonts in Pixeln zurück.
Der Buchstabenabstand ist der Wert, der zwischen zwei Buchstaben freigelassen wird.
*/
int GetGapWidth() const { return _GapWidth; }
int GetGapWidth() const {
return _GapWidth;
}
/**
@brief Gibt das Bounding-Rect eines Zeichens auf der Charactermap zurück.
@param Character der ASCII-Code des Zeichens
@return Das Bounding-Rect des übergebenen Zeichens auf der Charactermap.
*/
const BS_Rect & GetCharacterRect(int Character) const { BS_ASSERT(Character >= 0 && Character < 256); return _CharacterRects[Character]; }
const BS_Rect &GetCharacterRect(int Character) const {
BS_ASSERT(Character >= 0 && Character < 256);
return _CharacterRects[Character];
}
/**
@brief Gibt den Dateinamen der Charactermap zurück.
*/
const Common::String & GetCharactermapFileName() const { return _BitmapFileName; }
const Common::String &GetCharactermapFileName() const {
return _BitmapFileName;
}
private:
BS_Kernel * _pKernel;
BS_Kernel *_pKernel;
bool _Valid;
Common::String _BitmapFileName;
int _LineHeight;
@ -114,9 +124,9 @@ private:
// Hilfsmethoden
// -----------------------------------------------------------------------------
bool _ParseXMLDocument(const Common::String & FileName, TiXmlDocument & Doc) const;
bool _ParseFontTag(TiXmlElement & Tag, Common::String & BitmapFileName, int & LineHeight, int & GapWidth) const;
bool _ParseCharacterTag(TiXmlElement & Tag, int & Code, BS_Rect & Rect) const;
bool _ParseXMLDocument(const Common::String &FileName, TiXmlDocument &Doc) const;
bool _ParseFontTag(TiXmlElement &Tag, Common::String &BitmapFileName, int &LineHeight, int &GapWidth) const;
bool _ParseCharacterTag(TiXmlElement &Tag, int &Code, BS_Rect &Rect) const;
};
} // End of namespace Sword25

3
engines/sword25/gfx/framecounter.cpp
View file

@ -44,8 +44,7 @@ BS_Framecounter::BS_Framecounter(int UpdateFrequency) :
SetUpdateFrequency(UpdateFrequency);
}
void BS_Framecounter::Update()
{
void BS_Framecounter::Update() {
// Aktuellen Systemtimerstand auslesen
uint64_t Timer = g_system->getMillis() * 1000;

4
engines/sword25/gfx/framecounter.h
View file

@ -72,7 +72,9 @@ public:
/**
* Returns the current FPS value.
*/
int GetFPS() const { return m_FPS; }
int GetFPS() const {
return m_FPS;
}
private:
int m_FPS;

48
engines/sword25/gfx/graphicengine.cpp
View file

@ -60,18 +60,17 @@ 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) :
BS_GraphicEngine::BS_GraphicEngine(BS_Kernel *pKernel) :
m_Width(0),
m_Height(0),
m_BitDepth(0),
m_Windowed(0),
m_LastTimeStamp((uint64)-1), // max. BS_INT64 um beim ersten Aufruf von _UpdateLastFrameDuration() einen Reset zu erzwingen
m_LastTimeStamp((uint64) - 1), // max. BS_INT64 um beim ersten Aufruf von _UpdateLastFrameDuration() einen Reset zu erzwingen
m_LastFrameDuration(0),
m_TimerActive(true),
m_FrameTimeSampleSlot(0),
m_RepaintedPixels(0),
BS_ResourceService(pKernel)
{
BS_ResourceService(pKernel) {
for (int i = 0; i < FRAMETIME_SAMPLE_COUNT; i++)
m_FrameTimeSamples[i] = 0;
@ -83,8 +82,7 @@ BS_GraphicEngine::BS_GraphicEngine(BS_Kernel * pKernel) :
// -----------------------------------------------------------------------------
void BS_GraphicEngine::UpdateLastFrameDuration()
{
void BS_GraphicEngine::UpdateLastFrameDuration() {
// Aktuelle Zeit holen
uint64_t CurrentTime = BS_Kernel::GetInstance()->GetMicroTicks();
@ -106,15 +104,12 @@ void BS_GraphicEngine::UpdateLastFrameDuration()
// -----------------------------------------------------------------------------
namespace
{
bool DoSaveScreenshot(BS_GraphicEngine & GraphicEngine, const Common::String & Filename, bool Thumbnail)
{
namespace {
bool DoSaveScreenshot(BS_GraphicEngine &GraphicEngine, const Common::String &Filename, bool Thumbnail) {
unsigned int Width;
unsigned int Height;
Common::Array<unsigned int> Data;
if (!GraphicEngine.GetScreenshot(Width, Height, Data))
{
if (!GraphicEngine.GetScreenshot(Width, Height, Data)) {
BS_LOG_ERRORLN("Call to GetScreenshot() failed. Cannot save screenshot.");
return false;
}
@ -125,29 +120,25 @@ namespace
return BS_Screenshot::SaveThumbnailToFile(Width, Height, Data, Filename);
else
return BS_Screenshot::SaveToFile(Width, Height, Data, Filename);
}
}
}
// -----------------------------------------------------------------------------
bool BS_GraphicEngine::SaveScreenshot(const Common::String & Filename)
{
bool BS_GraphicEngine::SaveScreenshot(const Common::String &Filename) {
return DoSaveScreenshot(*this, Filename, false);
}
// -----------------------------------------------------------------------------
bool BS_GraphicEngine::SaveThumbnailScreenshot( const Common::String & Filename )
{
bool BS_GraphicEngine::SaveThumbnailScreenshot(const Common::String &Filename) {
return DoSaveScreenshot(*this, Filename, true);
}
// -----------------------------------------------------------------------------
void BS_GraphicEngine::ARGBColorToLuaColor(lua_State * L, unsigned int Color)
{
lua_Number Components[4] =
{
void BS_GraphicEngine::ARGBColorToLuaColor(lua_State *L, unsigned int Color) {
lua_Number Components[4] = {
(Color >> 16) & 0xff, // Rot
(Color >> 8) & 0xff, // Grün
Color & 0xff, // Blau
@ -156,8 +147,7 @@ void BS_GraphicEngine::ARGBColorToLuaColor(lua_State * L, unsigned int Color)
lua_newtable(L);
for (unsigned int i = 1; i <= 4; i++)
{
for (unsigned int i = 1; i <= 4; i++) {
lua_pushnumber(L, i);
lua_pushnumber(L, Components[i - 1]);
lua_settable(L, -3);
@ -166,8 +156,7 @@ void BS_GraphicEngine::ARGBColorToLuaColor(lua_State * L, unsigned int Color)
// -----------------------------------------------------------------------------
unsigned int BS_GraphicEngine::LuaColorToARGBColor(lua_State * L, int StackIndex)
{
unsigned int BS_GraphicEngine::LuaColorToARGBColor(lua_State *L, int StackIndex) {
#ifdef DEBUG
int __startStackDepth = lua_gettop(L);
#endif
@ -199,8 +188,7 @@ unsigned int BS_GraphicEngine::LuaColorToARGBColor(lua_State * L, int StackIndex
// Alpha Farbkomponente auslesen
unsigned int Alpha = 0xff;
if (n == 4)
{
if (n == 4) {
lua_rawgeti(L, StackIndex, 4);
Alpha = static_cast<unsigned int>(lua_tonumber(L, -1));
if (!lua_isnumber(L, -1) || Alpha >= 256) luaL_argcheck(L, 0, StackIndex, "alpha color component must be an integer between 0 and 255");
@ -216,16 +204,14 @@ unsigned int BS_GraphicEngine::LuaColorToARGBColor(lua_State * L, int StackIndex
// -----------------------------------------------------------------------------
bool BS_GraphicEngine::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_GraphicEngine::Persist(BS_OutputPersistenceBlock &Writer) {
Writer.Write(m_TimerActive);
return true;
}
// -----------------------------------------------------------------------------
bool BS_GraphicEngine::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_GraphicEngine::Unpersist(BS_InputPersistenceBlock &Reader) {
Reader.Read(m_TimerActive);
return Reader.IsGood();
}

56
engines/sword25/gfx/graphicengine.h
View file

@ -207,38 +207,58 @@ public:
/**
* Specifies the time (in microseconds) since the last frame has passed
*/
int GetLastFrameDurationMicro() { if (m_TimerActive) return m_LastFrameDuration; else return 0; }
int GetLastFrameDurationMicro() {
if (m_TimerActive) return m_LastFrameDuration;
else return 0;
}
/**
* Specifies the time (in microseconds) the previous frame took
*/
float GetLastFrameDuration() { if (m_TimerActive) return static_cast<float>(m_LastFrameDuration) / 1000000.0f; else return 0; }
float GetLastFrameDuration() {
if (m_TimerActive) return static_cast<float>(m_LastFrameDuration) / 1000000.0f;
else return 0;
}
void StopMainTimer() { m_TimerActive = false; }
void ResumeMainTimer() { m_TimerActive = true; }
float GetSecondaryFrameDuration() { return static_cast<float>(m_LastFrameDuration) / 1000000.0f; }
void StopMainTimer() {
m_TimerActive = false;
}
void ResumeMainTimer() {
m_TimerActive = true;
}
float GetSecondaryFrameDuration() {
return static_cast<float>(m_LastFrameDuration) / 1000000.0f;
}
// Accessor methods
/**
* Returns the width of the output buffer in pixels
*/
int GetDisplayWidth() { return m_Width; }
int GetDisplayWidth() {
return m_Width;
}
/**
* Returns the height of the output buffer in pixels
*/
int GetDisplayHeight() { return m_Height; }
int GetDisplayHeight() {
return m_Height;
}
/**
* Returns the bounding box of the output buffer: (0, 0, Width, Height)
*/
BS_Rect& GetDisplayRect() { return m_ScreenRect; }
BS_Rect &GetDisplayRect() {
return m_ScreenRect;
}
/**
* Returns the bit depth of the output buffer
*/
int GetBitDepth() { return m_BitDepth; }
int GetBitDepth() {
return m_BitDepth;
}
/**
* Determines whether the frame buffer change is to be synchronised with Vsync. This is turned on by default.
@ -256,7 +276,9 @@ public:
/**
* Returns true if the engine is running in Windowed mode.
*/
bool IsWindowed() { return m_Windowed; }
bool IsWindowed() {
return m_Windowed;
}
/**
* Fills a rectangular area of the frame buffer with a colour.
@ -267,12 +289,16 @@ public:
* @param Color The 32-bit colour with which the area is to be filled. The default is BS_RGB(0, 0, 0) (black)
@remark Falls das Rechteck nicht völlig innerhalb des Bildschirms ist, wird es automatisch zurechtgestutzt.
*/
virtual bool Fill(const BS_Rect * FillRectPtr = 0, unsigned int Color = BS_RGB(0, 0, 0)) = 0;
virtual bool Fill(const BS_Rect *FillRectPtr = 0, unsigned int Color = BS_RGB(0, 0, 0)) = 0;
// Debugging Methods
int GetFPSCount() const { return m_FPSCounter.GetFPS(); }
int GetRepaintedPixels() const { return m_RepaintedPixels; }
int GetFPSCount() const {
return m_FPSCounter.GetFPS();
}
int GetRepaintedPixels() const {
return m_RepaintedPixels;
}
// Access methods
@ -306,7 +332,7 @@ public:
* unknown, -1 is returned
*/
static int CalcPitch(BS_GraphicEngine::COLOR_FORMATS ColorFormat, int Width) {
switch (ColorFormat){
switch (ColorFormat) {
case BS_GraphicEngine::CF_RGB16:
case BS_GraphicEngine::CF_RGB15:
return Width * 2;
@ -337,7 +363,7 @@ public:
protected:
// Constructor
// -----------
BS_GraphicEngine(BS_Kernel* pKernel);
BS_GraphicEngine(BS_Kernel *pKernel);
// Display Variables
// -----------------

627
engines/sword25/gfx/graphicengine_script.cpp
View file

File diff suppressed because it is too large Load diff

31
engines/sword25/gfx/image/b25sloader.cpp
View file

@ -50,10 +50,8 @@ namespace Sword25 {
// -----------------------------------------------------------------------------
namespace
{
unsigned int FindEmbeddedPNG(const char * FileDataPtr, unsigned int FileSize)
{
namespace {
unsigned int FindEmbeddedPNG(const char *FileDataPtr, unsigned int FileSize) {
// Einen Stringstream mit dem Anfang der Datei intialisieren. 512 Byte sollten hierfür genügen.
istringstream StringStream(string(FileDataPtr, FileDataPtr + min(static_cast<unsigned int>(512), FileSize)));
@ -64,24 +62,21 @@ namespace
if (!StringStream.good()) return 0;
// Testen, ob wir tatsächlich einen Spielstand haben.
if (Marker == "BS25SAVEGAME")
{
if (Marker == "BS25SAVEGAME") {
// Offset zum PNG innerhalb des Spielstandes berechnen und zurückgeben.
return static_cast<unsigned int>(StringStream.tellg()) + CompressedGamedataSize + 1;
}
return 0;
}
}
}
// -----------------------------------------------------------------------------
bool BS_B25SLoader::IsCorrectImageFormat(const char * FileDataPtr, unsigned int FileSize)
{
bool BS_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)
{
if (PNGOffset > 0) {
return BS_PNGLoader::DoIsCorrectImageFormat(FileDataPtr + PNGOffset, FileSize - PNGOffset);
}
@ -90,13 +85,11 @@ bool BS_B25SLoader::IsCorrectImageFormat(const char * FileDataPtr, unsigned int
// -----------------------------------------------------------------------------
bool BS_B25SLoader::DecodeImage(const char * FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
int & Width, int & Height, int & Pitch)
{
bool BS_B25SLoader::DecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & 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)
{
if (PNGOffset > 0) {
return BS_PNGLoader::DoDecodeImage(FileDataPtr + PNGOffset, FileSize - PNGOffset, ColorFormat, UncompressedDataPtr, Width, Height, Pitch);
}
@ -105,12 +98,10 @@ 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 BS_B25SLoader::ImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_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)
{
if (PNGOffset > 0) {
return BS_PNGLoader::DoImageProperties(FileDataPtr + PNGOffset, FileSize - PNGOffset, ColorFormat, Width, Height);
}

18
engines/sword25/gfx/image/b25sloader.h
View file

@ -48,21 +48,19 @@ namespace Sword25 {
// Klassendeklaration
// -----------------------------------------------------------------------------
class BS_B25SLoader : public BS_ImageLoader
{
class BS_B25SLoader : public BS_ImageLoader {
public:
static BS_ImageLoader * CreateInstance()
{
#include "sword25/kernel/memlog_off.h"
static BS_ImageLoader *CreateInstance() {
#include "sword25/kernel/memlog_off.h"
return static_cast<BS_ImageLoader *>(new BS_B25SLoader());
#include "sword25/kernel/memlog_on.h"
#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, char * & 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 IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize);
virtual bool DecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & 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);
};

10
engines/sword25/gfx/image/image.h
View file

@ -52,8 +52,7 @@
namespace Sword25 {
class BS_Image
{
class BS_Image {
public:
virtual ~BS_Image() {};
@ -61,8 +60,7 @@ public:
/**
@brief Die möglichen Flippingparameter für die Blit-Methode.
*/
enum FLIP_FLAGS
{
enum FLIP_FLAGS {
/// Das Bild wird nicht gespiegelt.
FLIP_NONE = 0,
/// Das Bild wird an der horizontalen Achse gespiegelt.
@ -138,7 +136,7 @@ public:
*/
virtual bool Blit(int PosX = 0, int PosY = 0,
int Flipping = FLIP_NONE,
BS_Rect* pPartRect = NULL,
BS_Rect *pPartRect = NULL,
unsigned int Color = BS_ARGB(255, 255, 255, 255),
int Width = -1, int Height = -1) = 0;
@ -154,7 +152,7 @@ public:
BS_RGB und BS_ARGB benutzt werden.
@remark Falls das Rechteck nicht völlig innerhalb des Bildschirms ist, wird es automatisch zurechtgestutzt.
*/
virtual bool Fill(const BS_Rect* pFillRect = 0, unsigned int Color = BS_RGB(0, 0, 0)) = 0;
virtual bool Fill(const BS_Rect *pFillRect = 0, unsigned int Color = BS_RGB(0, 0, 0)) = 0;
/**
@brief Füllt den Inhalt des Bildes mit Pixeldaten.

46
engines/sword25/gfx/image/imageloader.cpp
View file

@ -40,26 +40,24 @@ namespace Sword25 {
#define BS_LOG_PREFIX "IMAGELOADER"
// Statische Elemente der Klasse BS_ImageLoader intialisieren.
std::list<BS_ImageLoader*> BS_ImageLoader::_ImageLoaderList;
std::list<BS_ImageLoader *> BS_ImageLoader::_ImageLoaderList;
bool BS_ImageLoader::_ImageLoaderListInitialized = false;
// Lade Methode
// ------------
bool BS_ImageLoader::LoadImage(const char* pFileData, unsigned int FileSize,
bool BS_ImageLoader::LoadImage(const char *pFileData, unsigned int FileSize,
BS_GraphicEngine::COLOR_FORMATS ColorFormat,
char*& pUncompressedData,
int& Width, int& Height,
int& Pitch)
{
int &Width, int &Height,
int &Pitch) {
// Falls die Liste der BS_ImageLoader noch nicht initialisiert wurde, wird dies getan.
if (!_ImageLoaderListInitialized)
_InitializeLoaderList();
// Passenden BS_ImageLoader finden und Bild dekodieren
BS_ImageLoader* pLoader = _FindSuitableImageLoader(pFileData, FileSize);
if (pLoader)
{
BS_ImageLoader *pLoader = _FindSuitableImageLoader(pFileData, FileSize);
if (pLoader) {
return pLoader->DecodeImage(pFileData, FileSize,
ColorFormat,
pUncompressedData,
@ -73,18 +71,16 @@ 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,
int& Width, int& Height)
{
bool BS_ImageLoader::ExtractImageProperties(const char *pFileData, unsigned int FileSize,
BS_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);
if (pLoader)
{
BS_ImageLoader *pLoader = _FindSuitableImageLoader(pFileData, FileSize);
if (pLoader) {
return pLoader->ImageProperties(pFileData, FileSize,
ColorFormat,
Width, Height);
@ -96,8 +92,7 @@ bool BS_ImageLoader::ExtractImageProperties(const char* pFileData, unsigned int
// Verwaltungs Methoden
// --------------------
void BS_ImageLoader::_InitializeLoaderList()
{
void BS_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]();
@ -109,24 +104,19 @@ void BS_ImageLoader::_InitializeLoaderList()
atexit(BS_ImageLoader::_DeinitializeLoaderList);
}
void BS_ImageLoader::_DeinitializeLoaderList()
{
while (!_ImageLoaderList.empty())
{
void BS_ImageLoader::_DeinitializeLoaderList() {
while (!_ImageLoaderList.empty()) {
delete _ImageLoaderList.back();
_ImageLoaderList.pop_back();
}
}
BS_ImageLoader* BS_ImageLoader::_FindSuitableImageLoader(const char* pFileData, unsigned int FileSize)
{
BS_ImageLoader *BS_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();
for (; Iter != _ImageLoaderList.end(); ++Iter)
{
std::list<BS_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))
{
if ((*Iter)->IsCorrectImageFormat(pFileData, FileSize)) {
return (*Iter);
}
}

80
engines/sword25/gfx/image/imageloader.h
View file

@ -74,8 +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 BS_ImageLoader {
public:
//@{
@ -105,11 +104,11 @@ public:
@remark Die Größe der Ausgabedaten in Bytes kann wie folgt berechnet werden: Pitch * Height.
@remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
*/
static bool LoadImage(const char* pFileData, unsigned int FileSize,
static bool LoadImage(const char *pFileData, unsigned int FileSize,
BS_GraphicEngine::COLOR_FORMATS ColorFormat,
char*& pUncompressedData,
int& Width, int& Height,
int& Pitch);
int &Width, int &Height,
int &Pitch);
/**
@brief Liest die Bildeigenschaften eines Bildes aus.
@ -122,9 +121,9 @@ public:
@return Gibt false zurück, wenn die Bildeigenschaften nicht ausgelesen werden konnten.
@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,
int& Width, int& Height);
static bool ExtractImageProperties(const char *pFileData, unsigned int FileSize,
BS_GraphicEngine::COLOR_FORMATS &ColorFormat,
int &Width, int &Height);
//@}
protected:
@ -137,8 +136,7 @@ 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()
{
BS_ImageLoader() {
// Klasse registrieren
_ImageLoaderList.push_front(this);
}
@ -153,7 +151,7 @@ protected:
@return Gibt true zurück, wenn der #BS_ImageLoader das Bild lesen kann, ansonsten false.
@remark Diese Methode muss von allen BS_ImageLoader Klassen implementiert werden.
*/
virtual bool IsCorrectImageFormat(const char* pFileData, unsigned int FileSize) = 0;
virtual bool IsCorrectImageFormat(const char *pFileData, unsigned int FileSize) = 0;
/**
@brief Lädt eine Bilddatei.
@ -175,11 +173,11 @@ protected:
@remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
@remark Diese Methode muss von allen BS_ImageLoader Klassen implementiert werden.
*/
virtual bool DecodeImage(const char* pFileData, unsigned int FileSize,
virtual bool DecodeImage(const char *pFileData, unsigned int FileSize,
BS_GraphicEngine::COLOR_FORMATS ColorFormat,
char*& pUncompressedData,
int& Width, int& Height,
int& Pitch) = 0;
int &Width, int &Height,
int &Pitch) = 0;
/**
@brief Liest die Bildeigenschaften aus.
@ -192,9 +190,9 @@ protected:
@remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
@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,
int& Width, int& Height) = 0;
virtual bool ImageProperties(const char *pFileData, unsigned int FileSize,
BS_GraphicEngine::COLOR_FORMATS &ColorFormat,
int &Width, int &Height) = 0;
//@}
@ -209,11 +207,9 @@ protected:
@remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß ist.<br>
Es sind mindestens Width * 2 Byte notwendig.
*/
static void RowARGB32ToRGB16(unsigned char* pSrcData, unsigned char* pDestData, unsigned int Width)
{
for (unsigned int i = 0; i < Width; i++)
{
((uint16_t*)pDestData)[i] = ((pSrcData[2] >> 3) << 11) | ((pSrcData[1] >> 2) << 5) | (pSrcData[0] >> 3);
static void RowARGB32ToRGB16(unsigned char *pSrcData, unsigned char *pDestData, unsigned int Width) {
for (unsigned int i = 0; i < Width; i++) {
((uint16_t *)pDestData)[i] = ((pSrcData[2] >> 3) << 11) | ((pSrcData[1] >> 2) << 5) | (pSrcData[0] >> 3);
pSrcData += 4;
}
}
@ -226,11 +222,9 @@ protected:
@remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß ist.<br>
Es sind mindestens Width * 2 Byte notwendig.
*/
static void RowARGB32ToRGB15(unsigned char* pSrcData, unsigned char* pDestData, unsigned int Width)
{
for (unsigned int i = 0; i < Width; i++)
{
((uint16_t*)pDestData)[i] = ((pSrcData[2] >> 3) << 10) | ((pSrcData[1] >> 3) << 5) | (pSrcData[0] >> 3);
static void RowARGB32ToRGB15(unsigned char *pSrcData, unsigned char *pDestData, unsigned int Width) {
for (unsigned int i = 0; i < Width; i++) {
((uint16_t *)pDestData)[i] = ((pSrcData[2] >> 3) << 10) | ((pSrcData[1] >> 3) << 5) | (pSrcData[0] >> 3);
pSrcData += 4;
}
}
@ -243,13 +237,11 @@ protected:
@remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß sein muss.<br>
Es sind mindestens ((Width + 3) / 4) * 12 Byte notwendig.
*/
static void RowARGB32ToRGB16_INTERLEAVED(unsigned char* pSrcData, unsigned char* pDestData, unsigned int Width)
{
static void RowARGB32ToRGB16_INTERLEAVED(unsigned char *pSrcData, unsigned char *pDestData, unsigned int Width) {
// Die Pixelblöcke erstellen, dabei werden immer jeweils 4 Pixel zu einem Block zusammengefasst
unsigned int BlockFillCount = 0;
unsigned int AlphaBlock = 0;
for (unsigned int i = 0; i < Width; i++)
{
for (unsigned int i = 0; i < Width; i++) {
// Alphawert in den Alphablock schreiben
AlphaBlock = (AlphaBlock >> 8) | (pSrcData[BlockFillCount * 4 + 3] << 24);
@ -257,14 +249,13 @@ protected:
BlockFillCount++;
// Sobald 4 Alphawerte gesammelt wurden, oder die Zeile zu Ende ist wird der Pixelblock in den Zielpuffer geschrieben
if (BlockFillCount == 4 || i == (Width - 1))
{
if (BlockFillCount == 4 || i == (Width - 1)) {
// Falls der AlphaBlock nicht ganz gefüllt ist muss geshiftet werden um sicherzustellen, dass die Alphawerte
// "left aligned" sind.
AlphaBlock >>= (4 - BlockFillCount) * 8;
// Alphablock schreiben
*((unsigned int*)pDestData) = AlphaBlock;
*((unsigned int *)pDestData) = AlphaBlock;
pDestData += 4;
// Pixel konvertieren und schreiben
@ -290,13 +281,11 @@ protected:
@remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß ist.<br>
Es sind mindestens (Width / 4 + Width % 4) * 3 Byte notwendig.
*/
static void RowARGB32ToRGB15_INTERLEAVED(unsigned char* pSrcData, unsigned char* pDestData, unsigned int Width)
{
static void RowARGB32ToRGB15_INTERLEAVED(unsigned char *pSrcData, unsigned char *pDestData, unsigned int Width) {
// Die Pixelblöcke erstellen, dabei werden immer jeweils 4 Pixel zu einem Block zusammengefasst
unsigned int BlockFillCount = 0;
unsigned int AlphaBlock = 0;
for (unsigned int i = 0; i < Width; i++)
{
for (unsigned int i = 0; i < Width; i++) {
// Alphawert in den Alphablock schreiben
AlphaBlock = (AlphaBlock >> 8) | (pSrcData[BlockFillCount * 4 + 3] << 24);
@ -304,14 +293,13 @@ protected:
BlockFillCount++;
// Sobald 4 Alphawerte gesammelt wurden, oder die Zeile zu Ende ist wird der Pixelblock in den Zielpuffer geschrieben
if (BlockFillCount == 4 || i == (Width - 1))
{
if (BlockFillCount == 4 || i == (Width - 1)) {
// Falls der AlphaBlock nicht ganz gefüllt ist muss geshiftet werden um sicherzustellen, dass die Alphawerte
// "left aligned" sind.
AlphaBlock >>= (4 - BlockFillCount) * 8;
// Alphablock schreiben
*((unsigned int*)pDestData) = AlphaBlock;
*((unsigned int *)pDestData) = AlphaBlock;
pDestData += 4;
// Pixel konvertieren und schreiben
@ -335,10 +323,8 @@ protected:
@param pDestData ein Pointer auf den Zielpuffern.
@param Width die Anzahl der Pixel in der Bildzeile.
*/
static void RowARGB32ToABGR32(unsigned char* pSrcData, unsigned char* pDestData, unsigned int Width)
{
for (unsigned int i = 0; i < Width; ++i)
{
static void RowARGB32ToABGR32(unsigned char *pSrcData, unsigned char *pDestData, unsigned int Width) {
for (unsigned int i = 0; i < Width; ++i) {
*pDestData++ = pSrcData[2];
*pDestData++ = pSrcData[1];
*pDestData++ = pSrcData[0];
@ -366,9 +352,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 BS_ImageLoader *_FindSuitableImageLoader(const char *pFileData, unsigned int FileSize);
static std::list<BS_ImageLoader*> _ImageLoaderList; // Die Liste aller BS_ImageLoader-Objekte
static std::list<BS_ImageLoader *> _ImageLoaderList; // Die Liste aller BS_ImageLoader-Objekte
static bool _ImageLoaderListInitialized; // Gibt an, ob die Liste schon intialisiert wurde
};

5
engines/sword25/gfx/image/imageloader_ids.h
View file

@ -51,9 +51,8 @@ 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)();
const BS_IMAGELOADER_NEW BS_IMAGELOADER_IDS[] =
{
typedef BS_ImageLoader*(*BS_IMAGELOADER_NEW)();
const BS_IMAGELOADER_NEW BS_IMAGELOADER_IDS[] = {
BS_PNGLoader::CreateInstance,
BS_B25SLoader::CreateInstance,
};

139
engines/sword25/gfx/image/pngloader.cpp
View file

@ -48,29 +48,26 @@ namespace Sword25 {
// Konstruktor / Destruktor
// -----------------------------------------------------------------------------
BS_PNGLoader::BS_PNGLoader()
{
BS_PNGLoader::BS_PNGLoader() {
}
// -----------------------------------------------------------------------------
// Laden
// -----------------------------------------------------------------------------
static void png_user_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
memcpy(data, (char*)png_ptr->io_ptr, length);
png_ptr->io_ptr = (void*)((png_size_t)png_ptr->io_ptr + length);
static void png_user_read_data(png_structp png_ptr, png_bytep data, png_size_t length) {
memcpy(data, (char *)png_ptr->io_ptr, length);
png_ptr->io_ptr = (void *)((png_size_t)png_ptr->io_ptr + length);
}
// -----------------------------------------------------------------------------
bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
int & Width, int & Height, int & Pitch)
{
bool BS_PNGLoader::DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
int &Width, int &Height, int &Pitch) {
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
png_bytep RawDataBuffer = NULL;
png_bytep* pRowPtr = NULL;
png_bytep *pRowPtr = NULL;
int BitDepth;
int ColorType;
@ -83,31 +80,26 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
ColorFormat != BS_GraphicEngine::CF_RGB16_INTERLEAVED &&
ColorFormat != BS_GraphicEngine::CF_RGB15_INTERLEAVED &&
ColorFormat != BS_GraphicEngine::CF_ARGB32 &&
ColorFormat != BS_GraphicEngine::CF_ABGR32)
{
ColorFormat != BS_GraphicEngine::CF_ABGR32) {
BS_LOG_ERRORLN("Illegal or unsupported color format.");
return false;
}
try
{
try {
// PNG Signatur überprüfen
if (!png_check_sig(reinterpret_cast<png_bytep>(const_cast<char *>(FileDataPtr)), 8))
{
if (!png_check_sig(reinterpret_cast<png_bytep>(const_cast<char *>(FileDataPtr)), 8)) {
throw(0);
}
// Die beiden PNG Strukturen erstellen
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr)
{
if (!png_ptr) {
BS_LOG_ERRORLN("Could not create libpng read struct.");
throw(0);
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{
if (!info_ptr) {
BS_LOG_ERRORLN("Could not create libpng info struct.");
throw(0);
}
@ -116,13 +108,13 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
if (setjmp(png_jmpbuf(png_ptr))) throw(0);
// Alternative Lesefunktion benutzen
png_set_read_fn(png_ptr, (void*)FileDataPtr, png_user_read_data);
png_set_read_fn(png_ptr, (void *)FileDataPtr, png_user_read_data);
// PNG Header einlesen
png_read_info(png_ptr, info_ptr);
// PNG Informationen auslesen
png_get_IHDR(png_ptr, info_ptr, (unsigned long*)&Width, (unsigned long*)&Height, &BitDepth, &ColorType, &InterlaceType, NULL, NULL);
png_get_IHDR(png_ptr, info_ptr, (unsigned long *)&Width, (unsigned long *)&Height, &BitDepth, &ColorType, &InterlaceType, NULL, NULL);
// Pitch des Ausgabebildes berechnen
Pitch = BS_GraphicEngine::CalcPitch(ColorFormat, Width);
@ -130,8 +122,7 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
// 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
UncompressedDataPtr = new char[Pitch * Height];
if (!UncompressedDataPtr)
{
if (!UncompressedDataPtr) {
BS_LOG_ERRORLN("Could not allocate memory for output image.");
throw(0);
}
@ -156,49 +147,45 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
// Nachdem die Transformationen registriert wurden, werden die Bilddaten erneut eingelesen
png_read_update_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, (unsigned long*)&Width, (unsigned long*)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);
png_get_IHDR(png_ptr, info_ptr, (unsigned long *)&Width, (unsigned long *)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);
// PNGs ohne Interlacing werden Zeilenweise eingelesen
if (InterlaceType == PNG_INTERLACE_NONE)
{
if (InterlaceType == PNG_INTERLACE_NONE) {
// Speicher für eine Bildzeile reservieren
RawDataBuffer = new png_byte[png_get_rowbytes(png_ptr, info_ptr)];
if (!RawDataBuffer)
{
if (!RawDataBuffer) {
BS_LOG_ERRORLN("Could not allocate memory for row buffer.");
throw(0);
}
// Bilddaten zeilenweise einlesen und in das gewünschte Zielformat konvertieren
for (i = 0; i < Height; i++)
{
for (i = 0; i < Height; i++) {
// Zeile einlesen
png_read_row(png_ptr, RawDataBuffer, NULL);
// Zeile konvertieren
switch (ColorFormat)
{
switch (ColorFormat) {
case BS_GraphicEngine::CF_RGB16:
RowARGB32ToRGB16((unsigned char*)RawDataBuffer,
(unsigned char*)&UncompressedDataPtr[i * Pitch],
RowARGB32ToRGB16((unsigned char *)RawDataBuffer,
(unsigned char *)&UncompressedDataPtr[i * Pitch],
Width);
break;
case BS_GraphicEngine::CF_RGB15:
RowARGB32ToRGB15((unsigned char*)RawDataBuffer,
(unsigned char*)&UncompressedDataPtr[i * Pitch],
RowARGB32ToRGB15((unsigned char *)RawDataBuffer,
(unsigned char *)&UncompressedDataPtr[i * Pitch],
Width);
break;
case BS_GraphicEngine::CF_RGB16_INTERLEAVED:
RowARGB32ToRGB16_INTERLEAVED((unsigned char*)RawDataBuffer,
(unsigned char*)&UncompressedDataPtr[i * Pitch],
RowARGB32ToRGB16_INTERLEAVED((unsigned char *)RawDataBuffer,
(unsigned char *)&UncompressedDataPtr[i * Pitch],
Width);
break;
case BS_GraphicEngine::CF_RGB15_INTERLEAVED:
RowARGB32ToRGB15_INTERLEAVED((unsigned char*)RawDataBuffer,
(unsigned char*)&UncompressedDataPtr[i * Pitch],
RowARGB32ToRGB15_INTERLEAVED((unsigned char *)RawDataBuffer,
(unsigned char *)&UncompressedDataPtr[i * Pitch],
Width);
break;
@ -209,8 +196,8 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
break;
case BS_GraphicEngine::CF_ABGR32:
RowARGB32ToABGR32((unsigned char*)RawDataBuffer,
(unsigned char*)&UncompressedDataPtr[i * Pitch],
RowARGB32ToABGR32((unsigned char *)RawDataBuffer,
(unsigned char *)&UncompressedDataPtr[i * Pitch],
Width);
break;
@ -220,20 +207,17 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
}
}
// PNGs mit Interlacing werden an einem Stück eingelesen
else
{
else {
// Speicher für das komplette Bild reservieren
RawDataBuffer = new png_byte[png_get_rowbytes(png_ptr, info_ptr) * Height];
if (!RawDataBuffer)
{
if (!RawDataBuffer) {
BS_LOG_ERRORLN("Could not allocate memory for raw image buffer.");
throw(0);
}
// Speicher für die Rowpointer reservieren
pRowPtr = new png_bytep[Height];
if (!pRowPtr)
{
if (!pRowPtr) {
BS_LOG_ERRORLN("Could not allocate memory for row pointers.");
throw(0);
}
@ -246,33 +230,32 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
png_read_image(png_ptr, pRowPtr);
// Bilddaten zeilenweise in das gewünschte Ausgabeformat konvertieren
switch (ColorFormat)
{
switch (ColorFormat) {
case BS_GraphicEngine::CF_RGB16:
for (i = 0; i < Height; i++)
RowARGB32ToRGB16((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
(unsigned char*)&UncompressedDataPtr[i * Pitch],
RowARGB32ToRGB16((unsigned char *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
(unsigned char *)&UncompressedDataPtr[i * Pitch],
Width);
break;
case BS_GraphicEngine::CF_RGB15:
for (i = 0; i < Height; i++)
RowARGB32ToRGB15((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
(unsigned char*)&UncompressedDataPtr[i * Pitch],
RowARGB32ToRGB15((unsigned char *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
(unsigned char *)&UncompressedDataPtr[i * Pitch],
Width);
break;
case BS_GraphicEngine::CF_RGB16_INTERLEAVED:
for (i = 0; i < Height; i++)
RowARGB32ToRGB16_INTERLEAVED((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
(unsigned char*)&UncompressedDataPtr[i * Pitch],
RowARGB32ToRGB16_INTERLEAVED((unsigned char *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
(unsigned char *)&UncompressedDataPtr[i * Pitch],
Width);
break;
case BS_GraphicEngine::CF_RGB15_INTERLEAVED:
for (i = 0; i < Height; i++)
RowARGB32ToRGB15_INTERLEAVED((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
(unsigned char*)&UncompressedDataPtr[i * Pitch],
RowARGB32ToRGB15_INTERLEAVED((unsigned char *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
(unsigned char *)&UncompressedDataPtr[i * Pitch],
Width);
break;
@ -296,8 +279,7 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
delete[] RawDataBuffer;
}
catch(int)
{
catch (int) {
delete[] pRowPtr;
delete[] RawDataBuffer;
if (png_ptr) png_destroy_read_struct(&png_ptr, NULL, NULL);
@ -313,40 +295,35 @@ 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, char * & UncompressedDataPtr,
int & Width, int & Height, int & Pitch)
{
bool BS_PNGLoader::DecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & 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 BS_PNGLoader::DoImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) {
// PNG Signatur überprüfen
if (!DoIsCorrectImageFormat(FileDataPtr, FileSize)) return false;
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
try
{
try {
// Die beiden PNG Strukturen erstellen
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr)
{
if (!png_ptr) {
BS_LOG_ERRORLN("Could not create libpng read struct.");
throw(0);
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{
if (!info_ptr) {
BS_LOG_ERRORLN("Could not create libpng info struct.");
throw(0);
}
// Alternative Lesefunktion benutzen
png_set_read_fn(png_ptr, (void*)FileDataPtr, png_user_read_data);
png_set_read_fn(png_ptr, (void *)FileDataPtr, png_user_read_data);
// PNG Header einlesen
png_read_info(png_ptr, info_ptr);
@ -354,7 +331,7 @@ bool BS_PNGLoader::DoImageProperties(const char * FileDataPtr, unsigned int File
// PNG Informationen auslesen
int BitDepth;
int ColorType;
png_get_IHDR(png_ptr, info_ptr, (unsigned long*)&Width, (unsigned long*)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);
png_get_IHDR(png_ptr, info_ptr, (unsigned long *)&Width, (unsigned long *)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);
// PNG-ColorType in BS ColorFormat konvertieren.
if (ColorType & PNG_COLOR_MASK_ALPHA || png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
@ -366,8 +343,7 @@ bool BS_PNGLoader::DoImageProperties(const char * FileDataPtr, unsigned int File
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
}
catch (int)
{
catch (int) {
if (png_ptr) png_destroy_read_struct(&png_ptr, NULL, NULL);
if (info_ptr) png_destroy_read_struct(NULL, &info_ptr, NULL);
@ -381,8 +357,7 @@ bool BS_PNGLoader::DoImageProperties(const char * FileDataPtr, unsigned int File
// -----------------------------------------------------------------------------
bool BS_PNGLoader::ImageProperties(const char* FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS & ColorFormat, int & Width, int & Height)
{
bool BS_PNGLoader::ImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) {
return DoImageProperties(FileDataPtr, FileSize, ColorFormat, Width, Height);
}
@ -390,18 +365,16 @@ bool BS_PNGLoader::ImageProperties(const char* FileDataPtr, unsigned int FileSiz
// Header überprüfen
// -----------------------------------------------------------------------------
bool BS_PNGLoader::DoIsCorrectImageFormat(const char * FileDataPtr, unsigned int FileSize)
{
bool BS_PNGLoader::DoIsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) {
if (FileSize > 8)
return png_check_sig((unsigned char*)FileDataPtr, 8) ? true : false;
return png_check_sig((unsigned char *)FileDataPtr, 8) ? true : false;
else
return false;
}
// -----------------------------------------------------------------------------
bool BS_PNGLoader::IsCorrectImageFormat(const char* FileDataPtr, unsigned int FileSize)
{
bool BS_PNGLoader::IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) {
return DoIsCorrectImageFormat(FileDataPtr, FileSize);
}

30
engines/sword25/gfx/image/pngloader.h
View file

@ -50,32 +50,30 @@
namespace Sword25 {
// Klassendefinition
class BS_PNGLoader : public BS_ImageLoader
{
class BS_PNGLoader : public BS_ImageLoader {
public:
static BS_ImageLoader* CreateInstance()
{
#include "sword25/kernel/memlog_off.h"
return (BS_ImageLoader*) new BS_PNGLoader();
#include "sword25/kernel/memlog_on.h"
static BS_ImageLoader *CreateInstance() {
#include "sword25/kernel/memlog_off.h"
return (BS_ImageLoader *) new BS_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, char * & 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 DoIsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize);
static bool DoDecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & 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);
protected:
BS_PNGLoader();
bool DecodeImage(const char * pFileData, unsigned int FileSize,
bool DecodeImage(const char *pFileData, unsigned int FileSize,
BS_GraphicEngine::COLOR_FORMATS ColorFormat,
char * & 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);
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);
};
} // End of namespace Sword25

208
engines/sword25/gfx/image/vectorimage.cpp
View file

@ -68,23 +68,19 @@ typedef int16_t s32;
// Diese Klasse ist speziell dafür ausgestattet.
// -----------------------------------------------------------------------------
class BS_VectorImage::SWFBitStream
{
class BS_VectorImage::SWFBitStream {
public:
SWFBitStream(const unsigned char * pData, unsigned int DataSize) :
SWFBitStream(const unsigned char *pData, unsigned int DataSize) :
m_Pos(pData), m_End(pData + DataSize), m_WordMask(0)
{}
inline u32 GetBits(unsigned int BitCount)
{
if (BitCount == 0 || BitCount > 32)
{
inline u32 GetBits(unsigned int BitCount) {
if (BitCount == 0 || BitCount > 32) {
throw(runtime_error("SWFBitStream::GetBits() must read at least 1 and at most 32 bits at a time"));
}
u32 value = 0;
while (BitCount)
{
while (BitCount) {
if (m_WordMask == 0) FlushByte();
value <<= 1;
@ -97,8 +93,7 @@ public:
return value;
}
inline s32 GetSignedBits(unsigned int BitCount)
{
inline s32 GetSignedBits(unsigned int BitCount) {
// Bits einlesen
u32 Temp = GetBits(BitCount);
@ -109,8 +104,7 @@ public:
return Temp;
}
inline u32 GetU32()
{
inline u32 GetU32() {
u32 Byte1 = GetU8();
u32 Byte2 = GetU8();
u32 Byte3 = GetU8();
@ -119,16 +113,14 @@ public:
return Byte1 | (Byte2 << 8) | (Byte3 << 16) | (Byte4 << 24);
}
inline u16 GetU16()
{
inline u16 GetU16() {
u32 Byte1 = GetU8();
u32 Byte2 = GetU8();
return Byte1 | (Byte2 << 8);
}
inline u8 GetU8()
{
inline u8 GetU8() {
FlushByte();
u8 Value = m_Word;
m_WordMask = 0;
@ -137,39 +129,30 @@ public:
return Value;
}
inline void FlushByte()
{
if (m_WordMask != 128)
{
if (m_Pos >= m_End)
{
inline void FlushByte() {
if (m_WordMask != 128) {
if (m_Pos >= m_End) {
throw(runtime_error("Attempted to read past end of file"));
}
else
{
} else {
m_Word = *m_Pos++;
m_WordMask = 128;
}
}
}
inline void SkipBytes(unsigned int SkipLength)
{
inline void SkipBytes(unsigned int SkipLength) {
FlushByte();
if (m_Pos + SkipLength >= m_End)
{
if (m_Pos + SkipLength >= m_End) {
throw(runtime_error("Attempted to read past end of file"));
}
else
{
} else {
m_Pos += SkipLength;
m_Word = *(m_Pos - 1);
}
}
private:
const unsigned char * m_Pos;
const unsigned char * m_End;
const unsigned char *m_Pos;
const unsigned char *m_End;
u8 m_Word;
unsigned int m_WordMask;
@ -180,21 +163,19 @@ private:
// Konstanten und Hilfsfunktionen
// -----------------------------------------------------------------------------
namespace
{
// -----------------------------------------------------------------------------
// Konstanten
// -----------------------------------------------------------------------------
namespace {
// -----------------------------------------------------------------------------
// Konstanten
// -----------------------------------------------------------------------------
const u32 MAX_ACCEPTED_FLASH_VERSION = 3; // Die höchste Flash-Dateiversion, die vom Lader akzeptiert wird
const u32 MAX_ACCEPTED_FLASH_VERSION = 3; // Die höchste Flash-Dateiversion, die vom Lader akzeptiert wird
// -----------------------------------------------------------------------------
// Konvertiert SWF-Rechteckdaten in einem Bitstrom in BS_Rect-Objekte
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Konvertiert SWF-Rechteckdaten in einem Bitstrom in BS_Rect-Objekte
// -----------------------------------------------------------------------------
BS_Rect FlashRectToBSRect(BS_VectorImage::SWFBitStream & bs)
{
BS_Rect FlashRectToBSRect(BS_VectorImage::SWFBitStream &bs) {
bs.FlushByte();
// Feststellen mit wie vielen Bits die einzelnen Komponenten kodiert sind
@ -207,34 +188,33 @@ namespace
s32 YMax = bs.GetSignedBits(BitsPerValue);
return BS_Rect(XMin, YMin, XMax + 1, YMax + 1);
}
}
// -----------------------------------------------------------------------------
// Konvertiert SWF-Farben in AntiGrain Farben
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Konvertiert SWF-Farben in AntiGrain Farben
// -----------------------------------------------------------------------------
agg::rgba8 FlashColorToAGGRGBA8(unsigned int FlashColor)
{
agg::rgba8 FlashColorToAGGRGBA8(unsigned int FlashColor) {
agg::rgba8 ResultColor((FlashColor >> 16) & 0xff, (FlashColor >> 8) & 0xff, FlashColor & 0xff, FlashColor >> 24);
ResultColor.premultiply();
return ResultColor;
}
// -----------------------------------------------------------------------------
// Berechnet die Bounding-Box eines BS_VectorImageElement
// -----------------------------------------------------------------------------
struct CBBGetId {
CBBGetId(const BS_VectorImageElement &VectorImageElement_) : VectorImageElement(VectorImageElement_) {}
unsigned operator [](unsigned i) const {
return VectorImageElement.GetPathInfo(i).GetID();
}
const BS_VectorImageElement &VectorImageElement;
};
// -----------------------------------------------------------------------------
// Berechnet die Bounding-Box eines BS_VectorImageElement
// -----------------------------------------------------------------------------
struct CBBGetId
{
CBBGetId(const BS_VectorImageElement & VectorImageElement_) : VectorImageElement(VectorImageElement_) {}
unsigned operator [] (unsigned i) const { return VectorImageElement.GetPathInfo(i).GetID(); }
const BS_VectorImageElement & VectorImageElement;
};
BS_Rect CalculateBoundingBox(const BS_VectorImageElement & VectorImageElement)
{
BS_Rect CalculateBoundingBox(const BS_VectorImageElement &VectorImageElement) {
agg::path_storage Path = VectorImageElement.GetPaths();
CBBGetId IdSource(VectorImageElement);
@ -242,7 +222,7 @@ namespace
agg::bounding_rect(Path, IdSource, 0, VectorImageElement.GetPathCount(), &x1, &y1, &x2, &y2);
return BS_Rect(static_cast<int>(x1), static_cast<int>(y1), static_cast<int>(x2) + 1, static_cast<int>(y2) + 1);
}
}
}
@ -250,16 +230,14 @@ namespace
// Konstruktion
// -----------------------------------------------------------------------------
BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int FileSize, bool & Success)
{
BS_VectorImage::BS_VectorImage(const unsigned char *pFileData, unsigned int FileSize, bool &Success) {
Success = false;
// Bitstream-Objekt erzeugen
// Im Folgenden werden die Dateidaten aus diesem ausgelesen.
SWFBitStream bs(pFileData, FileSize);
try
{
try {
// SWF-Signatur überprüfen
u32 Signature[3];
Signature[0] = bs.GetU8();
@ -267,24 +245,21 @@ BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int Fil
Signature[2] = bs.GetU8();
if (Signature[0] != 'F' ||
Signature[1] != 'W' ||
Signature[2] != 'S')
{
Signature[2] != 'S') {
BS_LOG_ERRORLN("File is not a valid SWF-file");
return;
}
// Versionsangabe überprüfen
u32 Version = bs.GetU8();
if (Version > MAX_ACCEPTED_FLASH_VERSION)
{
if (Version > MAX_ACCEPTED_FLASH_VERSION) {
BS_LOG_ERRORLN("File is of version %d. Highest accepted version is %d.", Version, MAX_ACCEPTED_FLASH_VERSION);
return;
}
// Dateigröße auslesen und mit der tatsächlichen Größe vergleichen
u32 StoredFileSize = bs.GetU32();
if (StoredFileSize != FileSize)
{
if (StoredFileSize != FileSize) {
BS_LOG_ERRORLN("File is not a valid SWF-file");
return;
}
@ -299,8 +274,7 @@ BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int Fil
// Tags parsen
// Da wir uns nur für das erste DefineShape-Tag interessieren
bool KeepParsing = true;
while (KeepParsing)
{
while (KeepParsing) {
// Tags beginnen immer an Bytegrenzen
bs.FlushByte();
@ -310,8 +284,7 @@ BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int Fil
u32 TagLength = TagTypeAndLength & 0x3f;
if (TagLength == 0x3f) TagLength = bs.GetU32();
switch (TagType)
{
switch (TagType) {
case 2:
// DefineShape
Success = ParseDefineShape(2, bs);
@ -330,8 +303,7 @@ BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int Fil
}
}
catch (runtime_error & e)
{
catch (runtime_error &e) {
// Fehler loggen und Funktion verlassen
// Success ist somit "false" und signalisiert dem Programmierer, dass die Konstruktion fehlgeschlagen ist.
BS_LOG_ERRORLN("The following exception occured while parsing a SWF-file: %s", e.what());
@ -345,8 +317,7 @@ BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int Fil
// -----------------------------------------------------------------------------
bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
{
bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream &bs) {
u32 ShapeID = bs.GetU16();
// Bounding Box auslesen
@ -368,13 +339,11 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
// ------------------
bool EndOfShapeDiscovered = false;
while (!EndOfShapeDiscovered)
{
while (!EndOfShapeDiscovered) {
u32 TypeFlag = bs.GetBits(1);
// Non-Edge Record
if (TypeFlag == 0)
{
if (TypeFlag == 0) {
// Feststellen welche Parameter gesetzt werden
u32 StateNewStyles = bs.GetBits(1);
u32 StateLineStyle = bs.GetBits(1);
@ -386,43 +355,37 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
if (!StateNewStyles && !StateLineStyle && !StateFillStyle0 && !StateFillStyle1 && !StateMoveTo)
EndOfShapeDiscovered = true;
// Parameter dekodieren
else
{
else {
s32 MoveDeltaX = 0;
s32 MoveDeltaY = 0;
if (StateMoveTo)
{
if (StateMoveTo) {
u32 MoveToBits = bs.GetBits(5);
MoveDeltaX = bs.GetSignedBits(MoveToBits);
MoveDeltaY = bs.GetSignedBits(MoveToBits);
}
if (StateFillStyle0)
{
if (StateFillStyle0) {
if (NumFillBits > 0)
FillStyle0 = bs.GetBits(NumFillBits);
else
FillStyle0 = 0;
}
if (StateFillStyle1)
{
if (StateFillStyle1) {
if (NumFillBits > 0)
FillStyle1 = bs.GetBits(NumFillBits);
else
FillStyle1 = 0;
}
if (StateLineStyle)
{
if (StateLineStyle) {
if (NumLineBits)
LineStyle = bs.GetBits(NumLineBits);
else
NumLineBits = 0;
}
if (StateNewStyles)
{
if (StateNewStyles) {
// An dieser Stelle werden in Flash die alten Style-Definitionen verworfen und mit den neuen überschrieben.
// Es wird ein neues Element begonnen.
m_Elements.resize(m_Elements.size() + 1);
@ -430,8 +393,7 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
}
// Ein neuen Pfad erzeugen, es sei denn, es wurden nur neue Styles definiert
if (StateLineStyle || StateFillStyle0 || StateFillStyle1 || StateMoveTo)
{
if (StateLineStyle || StateFillStyle0 || StateFillStyle1 || StateMoveTo) {
// Letzte Zeichenposition merken, beim Aufruf von start_new_path() wird die Zeichenpostionen auf 0, 0 zurückgesetzt
double LastX = m_Elements.back().m_Paths.last_x();
double LastY = m_Elements.back().m_Paths.last_y();
@ -449,14 +411,12 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
}
}
// Edge Record
else
{
else {
u32 EdgeFlag = bs.GetBits(1);
u32 NumBits = bs.GetBits(4) + 2;
// Curved edge
if (EdgeFlag == 0)
{
if (EdgeFlag == 0) {
s32 ControlDeltaX = bs.GetSignedBits(NumBits);
s32 ControlDeltaY = bs.GetSignedBits(NumBits);
s32 AnchorDeltaX = bs.GetSignedBits(NumBits);
@ -469,19 +429,15 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
m_Elements.back().m_Paths.curve3(ControlX, ControlY, AnchorX, AnchorY);
}
// Staight edge
else
{
else {
s32 DeltaX = 0;
s32 DeltaY = 0;
u32 GeneralLineFlag = bs.GetBits(1);
if (GeneralLineFlag)
{
if (GeneralLineFlag) {
DeltaX = bs.GetSignedBits(NumBits);
DeltaY = bs.GetSignedBits(NumBits);
}
else
{
} else {
u32 VertLineFlag = bs.GetBits(1);
if (VertLineFlag)
DeltaY = bs.GetSignedBits(NumBits);
@ -504,8 +460,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 BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream &bs, unsigned int &NumFillBits, unsigned int &NumLineBits) {
bs.FlushByte();
// Fillstyles parsen
@ -518,15 +473,12 @@ bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream & bs, unsi
// Alle Fillstyles einlesen, falls ein Fillstyle mit Typ != 0 gefunden wird, wird das Parsen abgebrochen.
// Es wird nur "solid fill" (Typ 0) unterstützt.
m_Elements.back().m_FillStyles.reserve(FillStyleCount);
for (unsigned int i = 0; i < FillStyleCount; ++i)
{
for (unsigned int i = 0; i < FillStyleCount; ++i) {
u8 Type = bs.GetU8();
u32 Color;
if (ShapeType == 3)
{
if (ShapeType == 3) {
Color = (bs.GetU8() << 16) | (bs.GetU8() << 8) | bs.GetU8() | (bs.GetU8() << 24);
}
else
} else
Color = bs.GetBits(24) | (0xff << 24);
if (Type != 0) return false;
@ -542,8 +494,7 @@ bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream & bs, unsi
// Alle Linestyles einlesen
m_Elements.back().m_LineStyles.reserve(LineStyleCount);
for (unsigned int i = 0; i < LineStyleCount; ++i)
{
for (unsigned int i = 0; i < LineStyleCount; ++i) {
double Width = bs.GetU16();
u32 Color;
if (ShapeType == 3)
@ -564,8 +515,7 @@ bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream & bs, unsi
// -----------------------------------------------------------------------------
bool BS_VectorImage::Fill(const BS_Rect* pFillRect, unsigned int Color)
{
bool BS_VectorImage::Fill(const BS_Rect *pFillRect, unsigned int Color) {
BS_LOG_ERRORLN("Fill() is not supported.");
return false;
}
@ -573,16 +523,14 @@ bool BS_VectorImage::Fill(const BS_Rect* pFillRect, unsigned int Color)
// -----------------------------------------------------------------------------
unsigned int BS_VectorImage::GetPixel(int X, int Y)
{
unsigned int BS_VectorImage::GetPixel(int X, int Y) {
BS_LOG_ERRORLN("GetPixel() is not supported. Returning black.");
return 0;
}
// -----------------------------------------------------------------------------
bool BS_VectorImage::SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride)
{
bool BS_VectorImage::SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride) {
BS_LOG_ERRORLN("SetContent() is not supported.");
return 0;
}

127
engines/sword25/gfx/image/vectorimage.h
View file

@ -59,16 +59,23 @@ class BS_VectorImage;
gespeichert werden.
*/
class BS_VectorPathInfo
{
class BS_VectorPathInfo {
public:
BS_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) {};
unsigned int GetID() const { return m_ID; }
unsigned int GetLineStyle() const { return m_LineStyle; }
unsigned int GetFillStyle0() const { return m_FillStyle0; }
unsigned int GetFillStyle1() const { return m_FillStyle1; }
unsigned int GetID() const {
return m_ID;
}
unsigned int GetLineStyle() const {
return m_LineStyle;
}
unsigned int GetFillStyle0() const {
return m_FillStyle0;
}
unsigned int GetFillStyle1() const {
return m_FillStyle1;
}
private:
unsigned int m_ID;
@ -82,42 +89,50 @@ 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 BS_VectorImage;
class BS_VectorImageElement {
friend BS_VectorImage;
public:
const agg::path_storage & GetPaths() const { return m_Paths; }
unsigned int GetPathCount() const { return m_PathInfos.size(); }
const BS_VectorPathInfo & GetPathInfo(unsigned int PathNr) const { BS_ASSERT(PathNr < GetPathCount()); return m_PathInfos[PathNr]; }
const agg::path_storage &GetPaths() const {
return m_Paths;
}
unsigned int GetPathCount() const {
return m_PathInfos.size();
}
const BS_VectorPathInfo &GetPathInfo(unsigned int PathNr) const {
BS_ASSERT(PathNr < GetPathCount());
return m_PathInfos[PathNr];
}
double GetLineStyleWidth(unsigned int LineStyle) const
{
double GetLineStyleWidth(unsigned int LineStyle) const {
BS_ASSERT(LineStyle < m_LineStyles.size());
return m_LineStyles[LineStyle].Width;
}
unsigned int GetLineStyleCount() const { return m_LineStyles.size(); }
unsigned int GetLineStyleCount() const {
return m_LineStyles.size();
}
const agg::rgba8 & GetLineStyleColor(unsigned int LineStyle) const
{
const agg::rgba8 &GetLineStyleColor(unsigned int LineStyle) const {
BS_ASSERT(LineStyle < m_LineStyles.size());
return m_LineStyles[LineStyle].Color;
}
unsigned int GetFillStyleCount() const { return m_FillStyles.size(); }
unsigned int GetFillStyleCount() const {
return m_FillStyles.size();
}
const agg::rgba8 & GetFillStyleColor(unsigned int FillStyle) const
{
const agg::rgba8 &GetFillStyleColor(unsigned int FillStyle) const {
BS_ASSERT(FillStyle < m_FillStyles.size());
return m_FillStyles[FillStyle];
}
const BS_Rect & GetBoundingBox() const { return m_BoundingBox; }
const BS_Rect &GetBoundingBox() const {
return m_BoundingBox;
}
private:
struct LineStyleType
{
LineStyleType(double Width_, const agg::rgba8 & Color_) : Width(Width_), Color(Color_) {};
struct LineStyleType {
LineStyleType(double Width_, const agg::rgba8 &Color_) : Width(Width_), Color(Color_) {};
double Width;
agg::rgba8 Color;
};
@ -136,46 +151,68 @@ private:
Objekte dieser Klasse enthalten die Informationen eines SWF-Shapes.
*/
class BS_VectorImage : public BS_Image
{
class BS_VectorImage : public BS_Image {
public:
BS_VectorImage(const unsigned char * pFileData, unsigned int FileSize, bool & Success);
BS_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
{
unsigned int GetElementCount() const {
return m_Elements.size();
}
const BS_VectorImageElement &GetElement(unsigned int ElementNr) const {
BS_ASSERT(ElementNr < m_Elements.size());
return m_Elements[ElementNr];
}
const BS_Rect & GetBoundingBox() const { return m_BoundingBox; }
const BS_Rect &GetBoundingBox() const {
return m_BoundingBox;
}
//
// Die abstrakten Methoden von BS_Image
//
virtual int GetWidth() const { return m_BoundingBox.GetWidth(); }
virtual int GetHeight() const { return m_BoundingBox.GetHeight(); }
virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const { return BS_GraphicEngine::CF_ARGB32; }
virtual bool Fill(const BS_Rect* pFillRect = 0, unsigned int Color = BS_RGB(0, 0, 0));
virtual int GetWidth() const {
return m_BoundingBox.GetWidth();
}
virtual int GetHeight() const {
return m_BoundingBox.GetHeight();
}
virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const {
return BS_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);
virtual bool IsBlitSource() const { return true; }
virtual bool IsBlitTarget() const { return false; }
virtual bool IsScalingAllowed() const { return true; }
virtual bool IsFillingAllowed() const { return false; }
virtual bool IsAlphaAllowed() const { return true; }
virtual bool IsColorModulationAllowed() const { return true; }
virtual bool IsSetContentAllowed() const { return false; }
virtual bool IsBlitSource() const {
return true;
}
virtual bool IsBlitTarget() const {
return false;
}
virtual bool IsScalingAllowed() const {
return true;
}
virtual bool IsFillingAllowed() const {
return false;
}
virtual bool IsAlphaAllowed() const {
return true;
}
virtual bool IsColorModulationAllowed() const {
return true;
}
virtual bool IsSetContentAllowed() const {
return false;
}
virtual bool SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride);
virtual bool Blit(int PosX = 0, int PosY = 0,
int Flipping = FLIP_NONE,
BS_Rect* pPartRect = NULL,
BS_Rect *pPartRect = NULL,
unsigned int Color = BS_ARGB(255, 255, 255, 255),
int Width = -1, int Height = -1);
class SWFBitStream;
private:
bool ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs);
bool ParseStyles(unsigned int ShapeType, SWFBitStream & bs, unsigned int & NumFillBits, unsigned int & NumLineBits);
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;
BS_Rect m_BoundingBox;

66
engines/sword25/gfx/image/vectorimagerenderer.cpp
View file

@ -49,10 +49,9 @@ namespace Sword25 {
// CompoundShape
// -----------------------------------------------------------------------------
class CompoundShape
{
class CompoundShape {
public:
CompoundShape(const BS_VectorImageElement & VectorImageElement) :
CompoundShape(const BS_VectorImageElement &VectorImageElement) :
m_ImageElement(VectorImageElement),
m_Path(VectorImageElement.GetPaths()),
m_Affine(),
@ -60,25 +59,24 @@ public:
m_Trans(m_Curve, m_Affine)
{}
unsigned operator [] (unsigned i) const
{
unsigned operator [](unsigned i) const {
return m_ImageElement.GetPathInfo(i).GetID();
}
unsigned paths() const { return m_ImageElement.GetPathCount(); }
unsigned paths() const {
return m_ImageElement.GetPathCount();
}
void rewind(unsigned path_id)
{
void rewind(unsigned path_id) {
m_Trans.rewind(path_id);
}
unsigned vertex(double* x, double* y)
{
unsigned vertex(double *x, double *y) {
return m_Trans.vertex(x, y);
}
private:
const BS_VectorImageElement & m_ImageElement;
const BS_VectorImageElement &m_ImageElement;
agg::path_storage m_Path;
agg::trans_affine m_Affine;
agg::conv_curve<agg::path_storage> m_Curve;
@ -90,29 +88,25 @@ private:
// StyleHandler
// -----------------------------------------------------------------------------
class StyleHandler
{
class StyleHandler {
public:
StyleHandler(const BS_VectorImageElement & VectorImageElement) : m_ImageElement(VectorImageElement) {}
StyleHandler(const BS_VectorImageElement &VectorImageElement) : m_ImageElement(VectorImageElement) {}
bool is_solid(unsigned int style) const
{
bool is_solid(unsigned int style) const {
return true;
}
const agg::rgba8 & color(unsigned style) const
{
const agg::rgba8 &color(unsigned style) const {
return m_ImageElement.GetFillStyleColor(style);
}
void generate_span(agg::rgba8 * span, int x, int y, unsigned len, unsigned style)
{
void generate_span(agg::rgba8 *span, int x, int y, unsigned len, unsigned style) {
// Wird nicht benutzt
return;
}
private:
const BS_VectorImageElement & m_ImageElement;
const BS_VectorImageElement &m_ImageElement;
};
@ -121,21 +115,19 @@ private:
// -----------------------------------------------------------------------------
BS_VectorImageRenderer::BS_VectorImageRenderer() :
PixelFormat(rbuf)
{
PixelFormat(rbuf) {
}
// -----------------------------------------------------------------------------
bool BS_VectorImageRenderer::Render(const BS_VectorImage & VectorImage,
bool BS_VectorImageRenderer::Render(const BS_VectorImage &VectorImage,
float ScaleFactorX, float ScaleFactorY,
unsigned int & Width, unsigned int & Height,
unsigned int &Width, unsigned int &Height,
Common::Array<char> & ImageData,
float LineScaleFactor,
bool NoAlphaShapes)
{
bool NoAlphaShapes) {
Width = static_cast<unsigned int>(VectorImage.GetWidth() * ScaleFactorX);
Height = static_cast<unsigned int>(VectorImage.GetHeight() * ScaleFactorY);
@ -151,9 +143,8 @@ bool BS_VectorImageRenderer::Render(const BS_VectorImage & VectorImage,
Scale = agg::trans_affine_translation(- VectorImage.GetBoundingBox().left, - VectorImage.GetBoundingBox().top);
Scale *= agg::trans_affine_scaling(ScaleFactorX, ScaleFactorY);
for (unsigned int element = 0; element < VectorImage.GetElementCount(); ++element)
{
const BS_VectorImageElement & CurImageElement = VectorImage.GetElement(element);
for (unsigned int element = 0; element < VectorImage.GetElementCount(); ++element) {
const BS_VectorImageElement &CurImageElement = VectorImage.GetElement(element);
CompoundShape ImageCompoundShape(CurImageElement);
StyleHandler ImageStyleHandler(CurImageElement);
@ -164,19 +155,16 @@ bool BS_VectorImageRenderer::Render(const BS_VectorImage & VectorImage,
//----------------------
CompoundRasterizer.clip_box(0, 0, Width, Height);
CompoundRasterizer.reset();
for(unsigned int i = 0; i < CurImageElement.GetPathCount(); ++i)
{
for (unsigned int i = 0; i < CurImageElement.GetPathCount(); ++i) {
unsigned int FillStyle0 = CurImageElement.GetPathInfo(i).GetFillStyle0();
unsigned int FillStyle1 = CurImageElement.GetPathInfo(i).GetFillStyle1();
if (NoAlphaShapes)
{
if (NoAlphaShapes) {
if (FillStyle0 != 0 && CurImageElement.GetFillStyleColor(FillStyle0 - 1).a != 255) FillStyle0 = 0;
if (FillStyle1 != 0 && CurImageElement.GetFillStyleColor(FillStyle1 - 1).a != 255) FillStyle1 = 0;
}
if(FillStyle0 != 0 || FillStyle1 != 0)
{
if (FillStyle0 != 0 || FillStyle1 != 0) {
CompoundRasterizer.styles(FillStyle0 - 1, FillStyle1 - 1);
CompoundRasterizer.add_path(Shape, CurImageElement.GetPathInfo(i).GetID());
}
@ -189,13 +177,11 @@ bool BS_VectorImageRenderer::Render(const BS_VectorImage & VectorImage,
Rasterizer.clip_box(0, 0, Width, Height);
Stroke.line_join(agg::round_join);
Stroke.line_cap(agg::round_cap);
for(unsigned int i = 0; i < CurImageElement.GetPathCount(); ++i)
{
for (unsigned int i = 0; i < CurImageElement.GetPathCount(); ++i) {
Rasterizer.reset();
unsigned int CurrentLineStyle = CurImageElement.GetPathInfo(i).GetLineStyle();
if (CurrentLineStyle != 0)
{
if (CurrentLineStyle != 0) {
Stroke.width(ScaleFactorX * CurImageElement.GetLineStyleWidth(CurrentLineStyle - 1) * LineScaleFactor);
Rasterizer.add_path(Stroke, CurImageElement.GetPathInfo(i).GetID());
ScanlineRenderer.color(CurImageElement.GetLineStyleColor(CurrentLineStyle - 1));

7
engines/sword25/gfx/image/vectorimagerenderer.h
View file

@ -61,14 +61,13 @@ class BS_VectorImage;
@brief Rendert BS_VectorImage Objekte
*/
class BS_VectorImageRenderer
{
class BS_VectorImageRenderer {
public:
BS_VectorImageRenderer();
bool Render(const BS_VectorImage & VectorImage,
bool Render(const BS_VectorImage &VectorImage,
float ScaleFactorX, float ScaleFactorY,
unsigned int & Width, unsigned int & Height,
unsigned int &Width, unsigned int &Height,
Common::Array<char> & ImageData,
float LineScaleFactor = 1.0f,
bool NoAlphaShapes = false);

57
engines/sword25/gfx/opengl/glimage.cpp
View file

@ -50,21 +50,19 @@ namespace Sword25 {
// CONSTRUCTION / DESTRUCTION
// -----------------------------------------------------------------------------
BS_GLImage::BS_GLImage(const Common::String & Filename, bool & Result) :
BS_GLImage::BS_GLImage(const Common::String &Filename, bool &Result) :
m_Sprite(0),
m_Width(0),
m_Height(0)
{
m_Height(0) {
Result = false;
BS_PackageManager * pPackage = static_cast<BS_PackageManager*>(BS_Kernel::GetInstance()->GetService("package"));
BS_PackageManager *pPackage = static_cast<BS_PackageManager *>(BS_Kernel::GetInstance()->GetService("package"));
BS_ASSERT(pPackage);
// Datei laden
char* pFileData;
char *pFileData;
unsigned int FileSize;
if (!(pFileData = (char*) pPackage->GetFile(Filename, &FileSize)))
{
if (!(pFileData = (char *) pPackage->GetFile(Filename, &FileSize))) {
BS_LOG_ERRORLN("File \"%s\" could not be loaded.", Filename.c_str());
return;
}
@ -72,16 +70,14 @@ BS_GLImage::BS_GLImage(const Common::String & Filename, bool & Result) :
// Bildeigenschaften bestimmen
BS_GraphicEngine::COLOR_FORMATS ColorFormat;
int Pitch;
if (!BS_ImageLoader::ExtractImageProperties(pFileData, FileSize, ColorFormat, m_Width, m_Height))
{
if (!BS_ImageLoader::ExtractImageProperties(pFileData, FileSize, ColorFormat, m_Width, m_Height)) {
BS_LOG_ERRORLN("Could not read image properties.");
return;
}
// Das Bild dekomprimieren
char * pUncompressedData;
if (!BS_ImageLoader::LoadImage(pFileData, FileSize, BS_GraphicEngine::CF_ABGR32, pUncompressedData, m_Width, m_Height, Pitch))
{
char *pUncompressedData;
if (!BS_ImageLoader::LoadImage(pFileData, FileSize, BS_GraphicEngine::CF_ABGR32, pUncompressedData, m_Width, m_Height, Pitch)) {
BS_LOG_ERRORLN("Could not decode image.");
return;
}
@ -94,8 +90,7 @@ BS_GLImage::BS_GLImage(const Common::String & Filename, bool & Result) :
(ColorFormat == BS_GraphicEngine::CF_ARGB32) ? GLS_True : GLS_False,
pUncompressedData,
&m_Sprite);
if (Result != GLS_OK)
{
if (Result != GLS_OK) {
BS_LOG_ERRORLN("Could not create GLS_Sprite. Reason: %s", GLS_ResultString(GLSResult));
return;
}
@ -109,11 +104,10 @@ BS_GLImage::BS_GLImage(const Common::String & Filename, bool & Result) :
// -----------------------------------------------------------------------------
BS_GLImage::BS_GLImage(unsigned int Width, unsigned int Height, bool & Result) :
BS_GLImage::BS_GLImage(unsigned int Width, unsigned int Height, bool &Result) :
m_Sprite(0),
m_Width(Width),
m_Height(Height)
{
m_Height(Height) {
Result = false;
// GLS-Sprite mit den Bilddaten erstellen
@ -121,8 +115,7 @@ BS_GLImage::BS_GLImage(unsigned int Width, unsigned int Height, bool & Result) :
GLS_True,
0,
&m_Sprite);
if (GLSResult != GLS_OK)
{
if (GLSResult != GLS_OK) {
BS_LOG_ERRORLN("Could not create GLS_Sprite. Reason: %s", GLS_ResultString(GLSResult));
return;
}
@ -133,34 +126,29 @@ BS_GLImage::BS_GLImage(unsigned int Width, unsigned int Height, bool & Result) :
// -----------------------------------------------------------------------------
BS_GLImage::~BS_GLImage()
{
BS_GLImage::~BS_GLImage() {
if (m_Sprite) GLS_DeleteSprite(m_Sprite);
}
// -----------------------------------------------------------------------------
bool BS_GLImage::Fill(const BS_Rect* pFillRect, unsigned int Color)
{
bool BS_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, unsigned int Offset, unsigned int Stride)
{
bool BS_GLImage::SetContent(const byte *Pixeldata, 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 (Pixeldata.size() < static_cast<unsigned int>(m_Width * m_Height * 4))
{
if (Pixeldata.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);
return false;
}
// GLS-Sprite mit den Bilddaten füllen
GLS_Result GLSResult = GLS_SetSpriteData(m_Sprite, m_Width, m_Height, &Pixeldata[Offset], Stride / 4);
if (GLSResult != GLS_OK)
{
if (GLSResult != GLS_OK) {
BS_LOG_ERRORLN("CGLS_SetSpriteData() failed. Reason: %s", GLS_ResultString(GLSResult));
return false;
}
@ -170,8 +158,7 @@ bool BS_GLImage::SetContent(const byte *Pixeldata, unsigned int Offset, unsigned
// -----------------------------------------------------------------------------
unsigned int BS_GLImage::GetPixel(int X, int Y)
{
unsigned int BS_GLImage::GetPixel(int X, int Y) {
BS_LOG_ERRORLN("GetPixel() is not supported. Returning black.");
return 0;
}
@ -180,14 +167,12 @@ unsigned int BS_GLImage::GetPixel(int X, int Y)
bool BS_GLImage::Blit(int PosX, int PosY,
int Flipping,
BS_Rect* pPartRect,
BS_Rect *pPartRect,
unsigned int Color,
int Width, int Height)
{
int Width, int Height) {
// BS_Rect nach GLS_Rect konvertieren
GLS_Rect SubImage;
if (pPartRect)
{
if (pPartRect) {
SubImage.x1 = pPartRect->left;
SubImage.y1 = pPartRect->top;
SubImage.x2 = pPartRect->right;

53
engines/sword25/gfx/opengl/glimage.h
View file

@ -51,16 +51,15 @@ namespace Sword25 {
// FORWARD DECLARATION
// -----------------------------------------------------------------------------
typedef void * GLS_Sprite;
typedef void *GLS_Sprite;
// -----------------------------------------------------------------------------
// CLASS DEFINITION
// -----------------------------------------------------------------------------
class BS_GLImage : public BS_Image
{
class BS_GLImage : public BS_Image {
public:
BS_GLImage(const Common::String & Filename, bool & Result);
BS_GLImage(const Common::String &Filename, bool &Result);
/**
@brief Erzeugt ein leeres BS_GLImage
@ -70,29 +69,49 @@ 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);
BS_GLImage(unsigned int Width, unsigned int Height, bool &Result);
virtual ~BS_GLImage();
virtual int GetWidth() const { return m_Width; }
virtual int GetHeight() const { return m_Height; }
virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const { return BS_GraphicEngine::CF_ARGB32; }
virtual int GetWidth() const {
return m_Width;
}
virtual int GetHeight() const {
return m_Height;
}
virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const {
return BS_GraphicEngine::CF_ARGB32;
}
virtual bool Blit(int PosX = 0, int PosY = 0,
int Flipping = BS_Image::FLIP_NONE,
BS_Rect* pPartRect = NULL,
BS_Rect *pPartRect = NULL,
unsigned int Color = BS_ARGB(255, 255, 255, 255),
int Width = -1, int Height = -1);
virtual bool Fill(const BS_Rect* pFillRect, unsigned int Color);
virtual bool Fill(const BS_Rect *pFillRect, unsigned int Color);
virtual bool SetContent(const byte *Pixeldata, unsigned int Offset = 0, unsigned int Stride = 0);
virtual unsigned int GetPixel(int X, int Y);
virtual bool IsBlitSource() const { return true; }
virtual bool IsBlitTarget() const { return false; }
virtual bool IsScalingAllowed() const { return true; }
virtual bool IsFillingAllowed() const { return false; }
virtual bool IsAlphaAllowed() const { return true; }
virtual bool IsColorModulationAllowed() const { return true; }
virtual bool IsSetContentAllowed() const { return true; }
virtual bool IsBlitSource() const {
return true;
}
virtual bool IsBlitTarget() const {
return false;
}
virtual bool IsScalingAllowed() const {
return true;
}
virtual bool IsFillingAllowed() const {
return false;
}
virtual bool IsAlphaAllowed() const {
return true;
}
virtual bool IsColorModulationAllowed() const {
return true;
}
virtual bool IsSetContentAllowed() const {
return true;
}
private:
GLS_Sprite m_Sprite;
int m_Width;

32
engines/sword25/gfx/opengl/glvectorimageblit.cpp
View file

@ -50,23 +50,21 @@ using namespace std;
// -----------------------------------------------------------------------------
namespace
{
const float LINE_SCALE_FACTOR = 1.0f;
namespace {
const float LINE_SCALE_FACTOR = 1.0f;
}
// -----------------------------------------------------------------------------
bool BS_VectorImage::Blit(int PosX, int PosY,
int Flipping,
BS_Rect* pPartRect,
BS_Rect *pPartRect,
unsigned int Color,
int Width, int Height)
{
int Width, int Height) {
static BS_VectorImageRenderer VectorImageRenderer;
static vector<char> PixelData;
static GLS_Sprite Sprite = 0;
static BS_VectorImage * OldThis = 0;
static BS_VectorImage *OldThis = 0;
static int OldWidth;
static int OldHeight;
static GLS_Rect OldSubImage;
@ -75,39 +73,33 @@ bool BS_VectorImage::Blit(int PosX, int PosY,
if (Width == 0 || Height == 0) return true;
// Sprite erstellen, falls es noch nicht erstellt wurde
if (Sprite == 0)
{
if (Sprite == 0) {
GLS_Result Result = GLS_NewSprite(512, 512, GLS_True, 0, &Sprite);
if (Result != GLS_OK)
{
if (Result != GLS_OK) {
BS_LOG_ERRORLN("Could not create GLS_Sprite. Reason: %s", GLS_ResultString(Result));
return false;
}
}
// Feststellen, ob das alte Bild im Cache nicht wiederbenutzt werden kann und neu Berechnet werden muss
if (!(OldThis == this && OldWidth == Width && OldHeight == Height && Sprite != 0))
{
if (!(OldThis == this && OldWidth == Width && OldHeight == Height && Sprite != 0)) {
float ScaleFactorX = (Width == - 1) ? 1 : static_cast<float>(Width) / static_cast<float>(GetWidth());
float ScaleFactorY = (Height == - 1) ? 1: static_cast<float>(Height) / static_cast<float>(GetHeight());
float ScaleFactorY = (Height == - 1) ? 1 : static_cast<float>(Height) / static_cast<float>(GetHeight());
unsigned int RenderedWidth;
unsigned int RenderedHeight;
if (!VectorImageRenderer.Render(*this, ScaleFactorX, ScaleFactorY, RenderedWidth, RenderedHeight, PixelData, LINE_SCALE_FACTOR))
{
if (!VectorImageRenderer.Render(*this, ScaleFactorX, ScaleFactorY, RenderedWidth, RenderedHeight, PixelData, LINE_SCALE_FACTOR)) {
BS_LOG_ERRORLN("Call to BS_VectorImageRenderer::Render() failed.");
return false;
}
if (RenderedWidth > 512 || RenderedHeight > 512)
{
if (RenderedWidth > 512 || RenderedHeight > 512) {
BS_LOG_WARNINGLN("Currently the maximum size for scaled vector images is 512x512.");
return true;
}
GLS_Result Result = GLS_SetSpriteData(Sprite, RenderedWidth, RenderedHeight, &PixelData[0], 0);
if (Result != GLS_OK)
{
if (Result != GLS_OK) {
BS_LOG_ERRORLN("Call to GLS_SetSpriteData() failed. Reason: %s", GLS_ResultString(Result));
return false;
}

187
engines/sword25/gfx/opengl/openglgfx.cpp
View file

@ -68,16 +68,15 @@ using namespace std;
// CONSTANTS
// -----------------------------------------------------------------------------
namespace
{
const unsigned int BIT_DEPTH = 32;
const unsigned int BACKBUFFER_COUNT = 1;
const Common::String PNG_EXTENSION(".png");
const Common::String PNG_S_EXTENSION("_s.png");
const Common::String ANI_EXTENSION("_ani.xml");
const Common::String FNT_EXTENSION("_fnt.xml");
const Common::String SWF_EXTENSION(".swf");
const Common::String B25S_EXTENSION(".b25s");
namespace {
const unsigned int BIT_DEPTH = 32;
const unsigned int BACKBUFFER_COUNT = 1;
const Common::String PNG_EXTENSION(".png");
const Common::String PNG_S_EXTENSION("_s.png");
const Common::String ANI_EXTENSION("_ani.xml");
const Common::String FNT_EXTENSION("_fnt.xml");
const Common::String SWF_EXTENSION(".swf");
const Common::String B25S_EXTENSION(".b25s");
}
@ -85,23 +84,20 @@ namespace
// CONSTRUCTION / DESTRUCTION
// -----------------------------------------------------------------------------
BS_OpenGLGfx::BS_OpenGLGfx(BS_Kernel * pKernel) :
BS_OpenGLGfx::BS_OpenGLGfx(BS_Kernel *pKernel) :
BS_GraphicEngine(pKernel),
m_GLspritesInitialized(false)
{
m_GLspritesInitialized(false) {
}
// -----------------------------------------------------------------------------
BS_OpenGLGfx::~BS_OpenGLGfx()
{
BS_OpenGLGfx::~BS_OpenGLGfx() {
if (m_GLspritesInitialized) GLS_Quit();
}
// -----------------------------------------------------------------------------
BS_Service * BS_OpenGLGfx_CreateObject(BS_Kernel* pKernel)
{
BS_Service *BS_OpenGLGfx_CreateObject(BS_Kernel *pKernel) {
return new BS_OpenGLGfx(pKernel);
}
@ -110,18 +106,15 @@ BS_Service * BS_OpenGLGfx_CreateObject(BS_Kernel* pKernel)
// INTERFACE
// -----------------------------------------------------------------------------
bool BS_OpenGLGfx::Init(int Width, int Height, int BitDepth, int BackbufferCount, bool Windowed)
{
bool BS_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)
{
if (BitDepth != BIT_DEPTH) {
BS_LOG_WARNINGLN("Can't use a bit depth of %d (not supported). Falling back to %d.", BitDepth, BIT_DEPTH);
m_BitDepth = BIT_DEPTH;
}
// Warnung ausgeben, wenn nicht genau ein Backbuffer gewählt wurde.
if (BackbufferCount != BACKBUFFER_COUNT)
{
if (BackbufferCount != BACKBUFFER_COUNT) {
BS_LOG_WARNINGLN("Can't use %d backbuffers (not supported). Falling back to %d.", BackbufferCount, BACKBUFFER_COUNT);
BackbufferCount = BACKBUFFER_COUNT;
}
@ -139,8 +132,7 @@ bool BS_OpenGLGfx::Init(int Width, int Height, int BitDepth, int BackbufferCount
// GLsprites initialisieren
HWND hwnd = reinterpret_cast<HWND>(BS_Kernel::GetInstance()->GetWindow()->GetWindowHandle());
GLS_Result Result = GLS_InitExternalWindow(Width, Height, Windowed ? GLS_False : GLS_True, hwnd);
if (Result != GLS_OK)
{
if (Result != GLS_OK) {
BS_LOG_ERRORLN("Could not initialize GLsprites. Reason: %s", GLS_ResultString(Result));
return false;
}
@ -153,7 +145,7 @@ bool BS_OpenGLGfx::Init(int Width, int Height, int BitDepth, int BackbufferCount
m_RenderObjectManagerPtr.reset(new BS_RenderObjectManager(Width, Height, BackbufferCount + 1));
// Hauptpanel erstellen
m_MainPanelPtr = m_RenderObjectManagerPtr->GetTreeRoot()->AddPanel(Width, Height, BS_ARGB(0,0,0,0));
m_MainPanelPtr = m_RenderObjectManagerPtr->GetTreeRoot()->AddPanel(Width, Height, BS_ARGB(0, 0, 0, 0));
if (!m_MainPanelPtr.IsValid()) return false;
m_MainPanelPtr->SetVisible(true);
@ -162,8 +154,7 @@ bool BS_OpenGLGfx::Init(int Width, int Height, int BitDepth, int BackbufferCount
// -----------------------------------------------------------------------------
bool BS_OpenGLGfx::StartFrame(bool UpdateAll)
{
bool BS_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();
@ -173,8 +164,7 @@ bool BS_OpenGLGfx::StartFrame(bool UpdateAll)
// GLsprites bescheidgeben
GLS_Result Result = GLS_StartFrame();
if (Result != GLS_OK)
{
if (Result != GLS_OK) {
BS_LOG_ERRORLN("Call to GLS_StartFrame() failed. Reason: %s", GLS_ResultString(Result));
return false;
}
@ -184,23 +174,20 @@ bool BS_OpenGLGfx::StartFrame(bool UpdateAll)
// -----------------------------------------------------------------------------
bool BS_OpenGLGfx::EndFrame()
{
bool BS_OpenGLGfx::EndFrame() {
// Scene zeichnen
m_RenderObjectManagerPtr->Render();
// Debug-Lines zeichnen
if (!m_DebugLines.empty())
{
if (!m_DebugLines.empty()) {
glEnable(GL_LINE_SMOOTH);
glBegin(GL_LINES);
Common::Array<DebugLine>::const_iterator iter = m_DebugLines.begin();
for (; iter != m_DebugLines.end(); ++iter)
{
const unsigned int & Color = (*iter).Color;
const BS_Vertex & Start = (*iter).Start;
const BS_Vertex & End = (*iter).End;
for (; iter != m_DebugLines.end(); ++iter) {
const unsigned int &Color = (*iter).Color;
const BS_Vertex &Start = (*iter).Start;
const BS_Vertex &End = (*iter).End;
glColor4ub((Color >> 16) & 0xff, (Color >> 8) & 0xff, Color & 0xff, Color >> 24);
glVertex2d(Start.X, Start.Y);
@ -215,8 +202,7 @@ bool BS_OpenGLGfx::EndFrame()
// Flippen
GLS_Result Result = GLS_EndFrame();
if (Result != GLS_OK)
{
if (Result != GLS_OK) {
BS_LOG_ERRORLN("Call to GLS_EndFrame() failed. Reason: %s", GLS_ResultString(Result));
return false;
}
@ -229,27 +215,23 @@ bool BS_OpenGLGfx::EndFrame()
// -----------------------------------------------------------------------------
BS_RenderObjectPtr<BS_Panel> BS_OpenGLGfx::GetMainPanel()
{
BS_RenderObjectPtr<BS_Panel> BS_OpenGLGfx::GetMainPanel() {
return m_MainPanelPtr;
}
// -----------------------------------------------------------------------------
void BS_OpenGLGfx::SetVsync(bool Vsync)
{
void BS_OpenGLGfx::SetVsync(bool Vsync) {
GLS_Result Result = GLS_SetVSync(Vsync ? GLS_True : GLS_False);
if (Result != GLS_OK) BS_LOG_WARNINGLN("Could not set vsync status. Reason: %s", GLS_ResultString(Result));
}
// -----------------------------------------------------------------------------
bool BS_OpenGLGfx::GetVsync() const
{
bool BS_OpenGLGfx::GetVsync() const {
GLS_Bool Status;
GLS_Result Result = GLS_IsVsync(&Status);
if (Result != GLS_OK)
{
if (Result != GLS_OK) {
BS_LOG_WARNINGLN("Could not get vsync status. Returning false. Reason: %s", GLS_ResultString(Result));
return false;
}
@ -259,12 +241,10 @@ bool BS_OpenGLGfx::GetVsync() const
// -----------------------------------------------------------------------------
bool BS_OpenGLGfx::Fill(const BS_Rect* FillRectPtr, unsigned int Color)
{
bool BS_OpenGLGfx::Fill(const BS_Rect *FillRectPtr, unsigned int Color) {
BS_Rect Rect;
if (!FillRectPtr)
{
if (!FillRectPtr) {
Rect.left = 0;
Rect.top = 0;
Rect.right = m_Width;
@ -286,8 +266,7 @@ bool BS_OpenGLGfx::Fill(const BS_Rect* FillRectPtr, unsigned int Color)
// -----------------------------------------------------------------------------
bool BS_OpenGLGfx::GetScreenshot(unsigned int & Width, unsigned int & Height, vector<unsigned int> & Data)
{
bool BS_OpenGLGfx::GetScreenshot(unsigned int &Width, unsigned int &Height, vector<unsigned int> & Data) {
if (!ReadFramebufferContents(m_Width, m_Height, Data)) return false;
// Die Größe des Framebuffers zurückgeben.
@ -303,15 +282,13 @@ bool BS_OpenGLGfx::GetScreenshot(unsigned int & Width, unsigned int & Height, ve
// -----------------------------------------------------------------------------
bool BS_OpenGLGfx::ReadFramebufferContents(unsigned int Width, unsigned int Height, Common::Array<unsigned int> & Data)
{
bool BS_OpenGLGfx::ReadFramebufferContents(unsigned int Width, unsigned int Height, Common::Array<unsigned int> & Data) {
Data.resize(Width * Height);
glReadPixels(0, 0, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, &Data[0]);
if (glGetError() == 0)
return true;
else
{
else {
Data.clear();
return false;
}
@ -319,11 +296,9 @@ bool BS_OpenGLGfx::ReadFramebufferContents(unsigned int Width, unsigned int Heig
// -----------------------------------------------------------------------------
void BS_OpenGLGfx::ReverseRGBAComponentOrder(vector<unsigned int> & Data)
{
void BS_OpenGLGfx::ReverseRGBAComponentOrder(vector<unsigned int> & Data) {
vector<unsigned int>::iterator It = Data.begin();
while (It != Data.end())
{
while (It != Data.end()) {
unsigned int Pixel = *It;
*It = (Pixel & 0xff00ff00) | ((Pixel >> 16) & 0xff) | ((Pixel & 0xff) << 16);
++It;
@ -332,12 +307,10 @@ void BS_OpenGLGfx::ReverseRGBAComponentOrder(vector<unsigned int> & Data)
// -----------------------------------------------------------------------------
void BS_OpenGLGfx::FlipImagedataVertical(unsigned int Width, unsigned int Height, vector<unsigned int> & Data)
{
void BS_OpenGLGfx::FlipImagedataVertical(unsigned int Width, unsigned int Height, vector<unsigned int> & Data) {
vector<unsigned int> LineBuffer(Width);
for (unsigned int Y = 0; Y < Height / 2; ++Y)
{
for (unsigned int Y = 0; Y < Height / 2; ++Y) {
vector<unsigned int>::iterator Line1It = Data.begin() + Y * Width;
vector<unsigned int>::iterator Line2It = Data.begin() + (Height - 1 - Y) * Width;
copy(Line1It, Line1It + Width, LineBuffer.begin());
@ -350,8 +323,7 @@ void BS_OpenGLGfx::FlipImagedataVertical(unsigned int Width, unsigned int Height
// RESOURCE MANAGING
// -----------------------------------------------------------------------------
static bool DoesStringEndWith(const Common::String & String, const std::string & OtherString)
{
static bool DoesStringEndWith(const Common::String &String, const std::string &OtherString) {
Common::String::size_type StringPos = String.rfind(OtherString);
if (StringPos == Common::String::npos) return false;
@ -360,24 +332,20 @@ static bool DoesStringEndWith(const Common::String & String, const std::string &
// -----------------------------------------------------------------------------
BS_Resource * BS_OpenGLGfx::LoadResource(const Common::String& FileName)
{
BS_Resource *BS_OpenGLGfx::LoadResource(const Common::String &FileName) {
BS_ASSERT(CanLoadResource(FileName));
// Bild für den Softwarebuffer laden
if (DoesStringEndWith(FileName, PNG_S_EXTENSION))
{
if (DoesStringEndWith(FileName, PNG_S_EXTENSION)) {
bool Result;
BS_SWImage * pImage = new BS_SWImage(FileName, Result);
if (!Result)
{
BS_SWImage *pImage = new BS_SWImage(FileName, Result);
if (!Result) {
delete pImage;
return 0;
}
BS_BitmapResource * pResource = new BS_BitmapResource(FileName, pImage);
if (!pResource->IsValid())
{
BS_BitmapResource *pResource = new BS_BitmapResource(FileName, pImage);
if (!pResource->IsValid()) {
delete pResource;
return 0;
}
@ -386,19 +354,16 @@ BS_Resource * BS_OpenGLGfx::LoadResource(const Common::String& FileName)
}
// Sprite-Bild laden
if (DoesStringEndWith(FileName, PNG_EXTENSION) || DoesStringEndWith(FileName, B25S_EXTENSION))
{
if (DoesStringEndWith(FileName, PNG_EXTENSION) || DoesStringEndWith(FileName, B25S_EXTENSION)) {
bool Result;
BS_GLImage * pImage = new BS_GLImage(FileName, Result);
if (!Result)
{
BS_GLImage *pImage = new BS_GLImage(FileName, Result);
if (!Result) {
delete pImage;
return 0;
}
BS_BitmapResource * pResource = new BS_BitmapResource(FileName, pImage);
if (!pResource->IsValid())
{
BS_BitmapResource *pResource = new BS_BitmapResource(FileName, pImage);
if (!pResource->IsValid()) {
delete pResource;
return 0;
}
@ -408,33 +373,29 @@ BS_Resource * BS_OpenGLGfx::LoadResource(const Common::String& FileName)
// Vectorgraphik laden
if (DoesStringEndWith(FileName, SWF_EXTENSION))
{
if (DoesStringEndWith(FileName, SWF_EXTENSION)) {
// Pointer auf Package-Manager holen
BS_PackageManager * pPackage = BS_Kernel::GetInstance()->GetPackage();
BS_PackageManager *pPackage = BS_Kernel::GetInstance()->GetPackage();
BS_ASSERT(pPackage);
// Datei laden
unsigned char* pFileData;
unsigned char *pFileData;
unsigned int FileSize;
if (!(pFileData = static_cast<unsigned char*>(pPackage->GetFile(FileName, &FileSize))))
{
if (!(pFileData = static_cast<unsigned char *>(pPackage->GetFile(FileName, &FileSize)))) {
BS_LOG_ERRORLN("File \"%s\" could not be loaded.", FileName.c_str());
return 0;
}
bool Result;
BS_VectorImage * pImage = new BS_VectorImage(pFileData, FileSize, Result);
if (!Result)
{
BS_VectorImage *pImage = new BS_VectorImage(pFileData, FileSize, Result);
if (!Result) {
delete pImage;
delete [] pFileData;
return 0;
}
BS_BitmapResource * pResource = new BS_BitmapResource(FileName, pImage);
if (!pResource->IsValid())
{
BS_BitmapResource *pResource = new BS_BitmapResource(FileName, pImage);
if (!pResource->IsValid()) {
delete pResource;
delete [] pFileData;
return 0;
@ -445,26 +406,22 @@ BS_Resource * BS_OpenGLGfx::LoadResource(const Common::String& FileName)
}
// Animation laden
if (DoesStringEndWith(FileName, ANI_EXTENSION))
{
BS_AnimationResource * pResource = new BS_AnimationResource(FileName);
if (DoesStringEndWith(FileName, ANI_EXTENSION)) {
BS_AnimationResource *pResource = new BS_AnimationResource(FileName);
if (pResource->IsValid())
return pResource;
else
{
else {
delete pResource;
return 0;
}
}
// Font laden
if (DoesStringEndWith(FileName, FNT_EXTENSION))
{
BS_FontResource * pResource = new BS_FontResource(BS_Kernel::GetInstance(), FileName);
if (DoesStringEndWith(FileName, FNT_EXTENSION)) {
BS_FontResource *pResource = new BS_FontResource(BS_Kernel::GetInstance(), FileName);
if (pResource->IsValid())
return pResource;
else
{
else {
delete pResource;
return 0;
}
@ -476,8 +433,7 @@ BS_Resource * BS_OpenGLGfx::LoadResource(const Common::String& FileName)
// -----------------------------------------------------------------------------
bool BS_OpenGLGfx::CanLoadResource(const Common::String& FileName)
{
bool BS_OpenGLGfx::CanLoadResource(const Common::String &FileName) {
return DoesStringEndWith(FileName, PNG_EXTENSION) ||
DoesStringEndWith(FileName, ANI_EXTENSION) ||
DoesStringEndWith(FileName, FNT_EXTENSION) ||
@ -490,8 +446,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 BS_OpenGLGfx::DrawDebugLine(const BS_Vertex &Start, const BS_Vertex &End, unsigned int Color) {
m_DebugLines.push_back(DebugLine(Start, End, Color));
}
@ -499,8 +454,7 @@ void BS_OpenGLGfx::DrawDebugLine(const BS_Vertex & Start, const BS_Vertex & End,
// PERSISTENZ
// -----------------------------------------------------------------------------
bool BS_OpenGLGfx::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_OpenGLGfx::Persist(BS_OutputPersistenceBlock &Writer) {
bool result = true;
result &= BS_GraphicEngine::Persist(Writer);
@ -511,8 +465,7 @@ bool BS_OpenGLGfx::Persist(BS_OutputPersistenceBlock & Writer)
// -----------------------------------------------------------------------------
bool BS_OpenGLGfx::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_OpenGLGfx::Unpersist(BS_InputPersistenceBlock &Reader) {
bool result = true;
result &= BS_GraphicEngine::Unpersist(Reader);

26
engines/sword25/gfx/opengl/openglgfx.h
View file

@ -67,10 +67,9 @@ class BS_RenderObjectManager;
// CLASS DECLARATION
// -----------------------------------------------------------------------------
class BS_OpenGLGfx : public BS_GraphicEngine
{
class BS_OpenGLGfx : public BS_GraphicEngine {
public:
BS_OpenGLGfx(BS_Kernel* pKernel);
BS_OpenGLGfx(BS_Kernel *pKernel);
virtual ~BS_OpenGLGfx();
// Interface
@ -84,23 +83,23 @@ public:
virtual void SetVsync(bool Vsync);
virtual bool GetVsync() const;
virtual bool Fill(const BS_Rect* FillRectPtr = 0, unsigned int Color = BS_RGB(0, 0, 0));
virtual bool GetScreenshot(unsigned int & Width, unsigned int & Height, Common::Array<unsigned int> & Data);
virtual bool Fill(const BS_Rect *FillRectPtr = 0, unsigned int Color = BS_RGB(0, 0, 0));
virtual bool GetScreenshot(unsigned int &Width, unsigned int &Height, Common::Array<unsigned int> & Data);
// Resource-Managing Methoden
// --------------------------
virtual BS_Resource* LoadResource(const Common::String& FileName);
virtual bool CanLoadResource(const Common::String& FileName);
virtual BS_Resource *LoadResource(const Common::String &FileName);
virtual bool CanLoadResource(const Common::String &FileName);
// Debugging Methoden
// ------------------
virtual void DrawDebugLine(const BS_Vertex & Start, const BS_Vertex & End, unsigned int Color);
static const char * GetGLSResultString(GLS_Result Result);
virtual void DrawDebugLine(const BS_Vertex &Start, const BS_Vertex &End, unsigned int Color);
static const char *GetGLSResultString(GLS_Result Result);
// Persistenz Methoden
// -------------------
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
private:
bool m_GLspritesInitialized;
@ -109,9 +108,8 @@ private:
std::auto_ptr<BS_RenderObjectManager> m_RenderObjectManagerPtr;
struct DebugLine
{
DebugLine(const BS_Vertex & _Start, const BS_Vertex & _End, unsigned int _Color) :
struct DebugLine {
DebugLine(const BS_Vertex &_Start, const BS_Vertex &_End, unsigned int _Color) :
Start(_Start),
End(_End),
Color(_Color) {};

37
engines/sword25/gfx/opengl/swimage.cpp
View file

@ -50,21 +50,19 @@ namespace Sword25 {
// CONSTRUCTION / DESTRUCTION
// -----------------------------------------------------------------------------
BS_SWImage::BS_SWImage(const Common::String & Filename, bool & Result) :
BS_SWImage::BS_SWImage(const Common::String &Filename, bool &Result) :
_ImageDataPtr(0),
m_Width(0),
m_Height(0)
{
m_Height(0) {
Result = false;
BS_PackageManager * pPackage = static_cast<BS_PackageManager*>(BS_Kernel::GetInstance()->GetService("package"));
BS_PackageManager *pPackage = static_cast<BS_PackageManager *>(BS_Kernel::GetInstance()->GetService("package"));
BS_ASSERT(pPackage);
// Datei laden
char* pFileData;
char *pFileData;
unsigned int FileSize;
if (!(pFileData = (char*) pPackage->GetFile(Filename, &FileSize)))
{
if (!(pFileData = (char *) pPackage->GetFile(Filename, &FileSize))) {
BS_LOG_ERRORLN("File \"%s\" could not be loaded.", Filename.c_str());
return;
}
@ -72,16 +70,14 @@ BS_SWImage::BS_SWImage(const Common::String & Filename, bool & Result) :
// Bildeigenschaften bestimmen
BS_GraphicEngine::COLOR_FORMATS ColorFormat;
int Pitch;
if (!BS_ImageLoader::ExtractImageProperties(pFileData, FileSize, ColorFormat, m_Width, m_Height))
{
if (!BS_ImageLoader::ExtractImageProperties(pFileData, FileSize, ColorFormat, m_Width, m_Height)) {
BS_LOG_ERRORLN("Could not read image properties.");
return;
}
// Das Bild dekomprimieren
char * pUncompressedData;
if (!BS_ImageLoader::LoadImage(pFileData, FileSize, BS_GraphicEngine::CF_ABGR32, pUncompressedData, m_Width, m_Height, Pitch))
{
char *pUncompressedData;
if (!BS_ImageLoader::LoadImage(pFileData, FileSize, BS_GraphicEngine::CF_ABGR32, pUncompressedData, m_Width, m_Height, Pitch)) {
BS_LOG_ERRORLN("Could not decode image.");
return;
}
@ -97,8 +93,7 @@ BS_SWImage::BS_SWImage(const Common::String & Filename, bool & Result) :
// -----------------------------------------------------------------------------
BS_SWImage::~BS_SWImage()
{
BS_SWImage::~BS_SWImage() {
delete [] _ImageDataPtr;
}
@ -107,34 +102,30 @@ BS_SWImage::~BS_SWImage()
bool BS_SWImage::Blit(int PosX, int PosY,
int Flipping,
BS_Rect* pPartRect,
BS_Rect *pPartRect,
unsigned int Color,
int Width, int Height)
{
int Width, int Height) {
BS_LOG_ERRORLN("Blit() is not supported.");
return false;
}
// -----------------------------------------------------------------------------
bool BS_SWImage::Fill(const BS_Rect* pFillRect, unsigned int Color)
{
bool BS_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, unsigned int Offset, unsigned int Stride)
{
bool BS_SWImage::SetContent(const byte *Pixeldata, 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 BS_SWImage::GetPixel(int X, int Y) {
BS_ASSERT(X >= 0 && X < m_Width);
BS_ASSERT(Y >= 0 && Y < m_Height);

51
engines/sword25/gfx/opengl/swimage.h
View file

@ -50,34 +50,53 @@ namespace Sword25 {
// CLASS DEFINITION
// -----------------------------------------------------------------------------
class BS_SWImage : public BS_Image
{
class BS_SWImage : public BS_Image {
public:
BS_SWImage(const Common::String & Filename, bool & Result);
BS_SWImage(const Common::String &Filename, bool &Result);
virtual ~BS_SWImage();
virtual int GetWidth() const { return m_Width; }
virtual int GetHeight() const { return m_Height; }
virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const { return BS_GraphicEngine::CF_ARGB32; }
virtual int GetWidth() const {
return m_Width;
}
virtual int GetHeight() const {
return m_Height;
}
virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const {
return BS_GraphicEngine::CF_ARGB32;
}
virtual bool Blit(int PosX = 0, int PosY = 0,
int Flipping = BS_Image::FLIP_NONE,
BS_Rect* pPartRect = NULL,
BS_Rect *pPartRect = NULL,
unsigned int Color = BS_ARGB(255, 255, 255, 255),
int Width = -1, int Height = -1);
virtual bool Fill(const BS_Rect* FillRectPtr, unsigned int Color);
virtual bool Fill(const BS_Rect *FillRectPtr, unsigned int Color);
virtual bool SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride);
virtual unsigned int GetPixel(int X, int Y);
virtual bool IsBlitSource() const { return false; }
virtual bool IsBlitTarget() const { return false; }
virtual bool IsScalingAllowed() const { return false; }
virtual bool IsFillingAllowed() const { return false; }
virtual bool IsAlphaAllowed() const { return false; }
virtual bool IsColorModulationAllowed() const { return false; }
virtual bool IsSetContentAllowed() const { return false; }
virtual bool IsBlitSource() const {
return false;
}
virtual bool IsBlitTarget() const {
return false;
}
virtual bool IsScalingAllowed() const {
return false;
}
virtual bool IsFillingAllowed() const {
return false;
}
virtual bool IsAlphaAllowed() const {
return false;
}
virtual bool IsColorModulationAllowed() const {
return false;
}
virtual bool IsSetContentAllowed() const {
return false;
}
private:
unsigned int * _ImageDataPtr;
unsigned int *_ImageDataPtr;
int m_Width;
int m_Height;

28
engines/sword25/gfx/panel.cpp
View file

@ -55,21 +55,18 @@ namespace Sword25 {
BS_Panel::BS_Panel(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, int Width, int Height, unsigned int Color) :
BS_RenderObject(ParentPtr, BS_RenderObject::TYPE_PANEL),
m_Color(Color)
{
m_Color(Color) {
m_InitSuccess = false;
m_Width = Width;
m_Height = Height;
if (m_Width < 0)
{
if (m_Width < 0) {
BS_LOG_ERRORLN("Tried to initialise a panel with an invalid width (%d).", m_Width);
return;
}
if (m_Height < 0)
{
if (m_Height < 0) {
BS_LOG_ERRORLN("Tried to initialise a panel with an invalid height (%d).", m_Height);
return;
}
@ -79,28 +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)
{
BS_Panel::BS_Panel(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) :
BS_RenderObject(ParentPtr, BS_RenderObject::TYPE_PANEL, Handle) {
m_InitSuccess = Unpersist(Reader);
}
// -----------------------------------------------------------------------------
BS_Panel::~BS_Panel()
{
BS_Panel::~BS_Panel() {
}
// -----------------------------------------------------------------------------
// Rendern
// -----------------------------------------------------------------------------
bool BS_Panel::DoRender()
{
bool BS_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"));
BS_GraphicEngine *GfxPtr = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
BS_ASSERT(GfxPtr);
return GfxPtr->Fill(&m_BBox, m_Color);
@ -110,8 +104,7 @@ bool BS_Panel::DoRender()
// Persistenz
// -----------------------------------------------------------------------------
bool BS_Panel::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_Panel::Persist(BS_OutputPersistenceBlock &Writer) {
bool Result = true;
Result &= BS_RenderObject::Persist(Writer);
@ -124,8 +117,7 @@ bool BS_Panel::Persist(BS_OutputPersistenceBlock & Writer)
// -----------------------------------------------------------------------------
bool BS_Panel::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_Panel::Unpersist(BS_InputPersistenceBlock &Reader) {
bool Result = true;
Result &= BS_RenderObject::Unpersist(Reader);

20
engines/sword25/gfx/panel.h
View file

@ -48,22 +48,26 @@ namespace Sword25 {
// Class Definition
// -----------------------------------------------------------------------------
class BS_Panel : public BS_RenderObject
{
friend class BS_RenderObject;
class BS_Panel : public BS_RenderObject {
friend class BS_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);
BS_Panel(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle);
public:
virtual ~BS_Panel();
unsigned int GetColor() const { return m_Color; }
void SetColor(unsigned int Color) { m_Color = Color; ForceRefresh(); }
unsigned int GetColor() const {
return m_Color;
}
void SetColor(unsigned int Color) {
m_Color = Color;
ForceRefresh();
}
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
protected:
virtual bool DoRender();

157
engines/sword25/gfx/renderobject.cpp
View file

@ -70,8 +70,7 @@ BS_RenderObject::BS_RenderObject(BS_RenderObjectPtr<BS_RenderObject> ParentPtr,
m_Type(Type),
m_InitSuccess(false),
m_RefreshForced(true),
m_Handle(0)
{
m_Handle(0) {
// Renderobject registrieren, abhängig vom Handle-Parameter entweder mit beliebigem oder vorgegebenen Handle.
if (Handle == 0)
m_Handle = BS_RenderObjectRegistry::GetInstance().RegisterObject(this);
@ -83,15 +82,11 @@ BS_RenderObject::BS_RenderObject(BS_RenderObjectPtr<BS_RenderObject> ParentPtr,
// Dieses Objekt zu den Kindern der Elternobjektes hinzufügen, falls nicht Wurzel (ParentPtr ungültig) und dem
// selben RenderObjektManager zuweisen.
if (m_ParentPtr.IsValid())
{
if (m_ParentPtr.IsValid()) {
m_ManagerPtr = m_ParentPtr->GetManager();
m_ParentPtr->AddObject(this);
}
else
{
if (GetType() != TYPE_ROOT)
{
} else {
if (GetType() != TYPE_ROOT) {
BS_LOG_ERRORLN("Tried to create a non-root render object and has no parent. All non-root render objects have to have a parent.");
return;
}
@ -102,8 +97,7 @@ BS_RenderObject::BS_RenderObject(BS_RenderObjectPtr<BS_RenderObject> ParentPtr,
m_InitSuccess = true;
}
BS_RenderObject::~BS_RenderObject()
{
BS_RenderObject::~BS_RenderObject() {
// Objekt aus dem Elternobjekt entfernen.
if (m_ParentPtr.IsValid()) m_ParentPtr->DetatchChildren(this);
@ -115,8 +109,7 @@ BS_RenderObject::~BS_RenderObject()
// Rendern
// -------
bool BS_RenderObject::Render()
{
bool BS_RenderObject::Render() {
// Objektänderungen validieren
ValidateObject();
@ -124,8 +117,7 @@ bool BS_RenderObject::Render()
if (!m_Visible) return true;
// Falls notwendig, wird die Renderreihenfolge der Kinderobjekte aktualisiert.
if (m_ChildChanged)
{
if (m_ChildChanged) {
SortRenderObjects();
m_ChildChanged = false;
}
@ -144,8 +136,7 @@ bool BS_RenderObject::Render()
// Objektverwaltung
// ----------------
void BS_RenderObject::ValidateObject()
{
void BS_RenderObject::ValidateObject() {
// Die Veränderungen in den Objektvariablen aufheben
m_OldBBox = m_BBox;
m_OldVisible = m_Visible;
@ -155,8 +146,7 @@ void BS_RenderObject::ValidateObject()
m_RefreshForced = false;
}
bool BS_RenderObject::UpdateObjectState()
{
bool BS_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) ||
@ -164,8 +154,7 @@ bool BS_RenderObject::UpdateObjectState()
(m_X != m_OldX) ||
(m_Y != m_OldY) ||
(m_Z != m_OldZ) ||
m_RefreshForced)
{
m_RefreshForced) {
// Renderrang des Objektes neu bestimmen, da sich dieser verändert haben könnte
if (m_ParentPtr.IsValid()) m_ParentPtr->SignalChildChange();
@ -184,14 +173,12 @@ bool BS_RenderObject::UpdateObjectState()
return true;
}
void BS_RenderObject::UpdateBoxes()
{
void BS_RenderObject::UpdateBoxes() {
// Bounding-Box aktualisieren
m_BBox = CalcBoundingBox();
}
BS_Rect BS_RenderObject::CalcBoundingBox() const
{
BS_Rect BS_RenderObject::CalcBoundingBox() const {
// Die Bounding-Box mit der Objektgröße initialisieren.
BS_Rect BBox(0, 0, m_Width, m_Height);
@ -204,22 +191,19 @@ BS_Rect BS_RenderObject::CalcBoundingBox() const
return BBox;
}
void BS_RenderObject::CalcAbsolutePos(int& X, int& Y) const
{
void BS_RenderObject::CalcAbsolutePos(int &X, int &Y) const {
X = CalcAbsoluteX();
Y = CalcAbsoluteY();
}
int BS_RenderObject::CalcAbsoluteX() const
{
int BS_RenderObject::CalcAbsoluteX() const {
if (m_ParentPtr.IsValid())
return m_ParentPtr->GetAbsoluteX() + m_X;
else
return m_X;
}
int BS_RenderObject::CalcAbsoluteY() const
{
int BS_RenderObject::CalcAbsoluteY() const {
if (m_ParentPtr.IsValid())
return m_ParentPtr->GetAbsoluteY() + m_Y;
else
@ -229,21 +213,17 @@ int BS_RenderObject::CalcAbsoluteY() const
// Baumverwaltung
// --------------
void BS_RenderObject::DeleteAllChildren()
{
void BS_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())
{
while (!m_Children.empty()) {
BS_RenderObjectPtr<BS_RenderObject> CurPtr = m_Children.back();
CurPtr.Erase();
}
}
bool BS_RenderObject::AddObject(BS_RenderObjectPtr<BS_RenderObject> pObject)
{
if (!pObject.IsValid())
{
bool BS_RenderObject::AddObject(BS_RenderObjectPtr<BS_RenderObject> pObject) {
if (!pObject.IsValid()) {
BS_LOG_ERRORLN("Tried to add a null object to a renderobject.");
return false;
}
@ -257,13 +237,11 @@ bool BS_RenderObject::AddObject(BS_RenderObjectPtr<BS_RenderObject> pObject)
return true;
}
bool BS_RenderObject::DetatchChildren(BS_RenderObjectPtr<BS_RenderObject> pObject)
{
bool BS_RenderObject::DetatchChildren(BS_RenderObjectPtr<BS_RenderObject> pObject) {
// Kinderliste durchgehen und Objekt entfernen falls vorhanden
RENDEROBJECT_ITER it = m_Children.begin();
for (; it != m_Children.end(); ++it)
if (*it == pObject)
{
if (*it == pObject) {
m_Children.erase(it);
return true;
}
@ -272,13 +250,11 @@ bool BS_RenderObject::DetatchChildren(BS_RenderObjectPtr<BS_RenderObject> pObjec
return false;
}
void BS_RenderObject::SortRenderObjects()
{
void BS_RenderObject::SortRenderObjects() {
std::sort(m_Children.begin(), m_Children.end(), Greater);
}
void BS_RenderObject::UpdateAbsolutePos()
{
void BS_RenderObject::UpdateAbsolutePos() {
CalcAbsolutePos(m_AbsoluteX, m_AbsoluteY);
RENDEROBJECT_ITER it = m_Children.begin();
@ -289,42 +265,36 @@ void BS_RenderObject::UpdateAbsolutePos()
// Get-Methoden
// ------------
bool BS_RenderObject::GetObjectIntersection(BS_RenderObjectPtr<BS_RenderObject> pObject, BS_Rect& Result)
{
bool BS_RenderObject::GetObjectIntersection(BS_RenderObjectPtr<BS_RenderObject> pObject, BS_Rect &Result) {
return m_BBox.Intersect(pObject->GetBBox(), Result);
}
// Set-Methoden
// ------------
void BS_RenderObject::SetPos(int X, int Y)
{
void BS_RenderObject::SetPos(int X, int Y) {
m_X = X;
m_Y = Y;
UpdateAbsolutePos();
}
void BS_RenderObject::SetX(int X)
{
void BS_RenderObject::SetX(int X) {
m_X = X;
UpdateAbsolutePos();
}
void BS_RenderObject::SetY(int Y)
{
void BS_RenderObject::SetY(int Y) {
m_Y = Y;
UpdateAbsolutePos();
}
void BS_RenderObject::SetZ(int Z)
{
void BS_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 BS_RenderObject::SetVisible(bool Visible) {
m_Visible = Visible;
}
@ -332,13 +302,11 @@ void BS_RenderObject::SetVisible(bool Visible)
// Objekterzeuger
// -----------------------------------------------------------------------------
BS_RenderObjectPtr<BS_Animation> BS_RenderObject::AddAnimation(const Common::String& Filename)
{
BS_RenderObjectPtr<BS_Animation> BS_RenderObject::AddAnimation(const Common::String &Filename) {
BS_RenderObjectPtr<BS_Animation> AniPtr(new BS_Animation(this, Filename));
if (AniPtr.IsValid() && AniPtr->GetInitSuccess())
return AniPtr;
else
{
else {
if (AniPtr.IsValid()) AniPtr.Erase();
return BS_RenderObjectPtr<BS_Animation>();
}
@ -347,13 +315,11 @@ BS_RenderObjectPtr<BS_Animation> BS_RenderObject::AddAnimation(const Common::Str
// -----------------------------------------------------------------------------
BS_RenderObjectPtr<BS_Animation> BS_RenderObject::AddAnimation(const BS_AnimationTemplate & AnimationTemplate)
{
BS_Animation * AniPtr = new BS_Animation(this, AnimationTemplate);
BS_RenderObjectPtr<BS_Animation> BS_RenderObject::AddAnimation(const BS_AnimationTemplate &AnimationTemplate) {
BS_Animation *AniPtr = new BS_Animation(this, AnimationTemplate);
if (AniPtr && AniPtr->GetInitSuccess())
return AniPtr;
else
{
else {
delete AniPtr;
return BS_RenderObjectPtr<BS_Animation>();
}
@ -361,13 +327,11 @@ BS_RenderObjectPtr<BS_Animation> BS_RenderObject::AddAnimation(const BS_Animatio
// -----------------------------------------------------------------------------
BS_RenderObjectPtr<BS_Bitmap> BS_RenderObject::AddBitmap(const Common::String& Filename)
{
BS_RenderObjectPtr<BS_Bitmap> BS_RenderObject::AddBitmap(const Common::String &Filename) {
BS_RenderObjectPtr<BS_Bitmap> BitmapPtr(new BS_StaticBitmap(this, Filename));
if (BitmapPtr.IsValid() && BitmapPtr->GetInitSuccess())
return BS_RenderObjectPtr<BS_Bitmap>(BitmapPtr);
else
{
else {
if (BitmapPtr.IsValid()) BitmapPtr.Erase();
return BS_RenderObjectPtr<BS_Bitmap>();
}
@ -375,13 +339,11 @@ BS_RenderObjectPtr<BS_Bitmap> BS_RenderObject::AddBitmap(const Common::String& F
// -----------------------------------------------------------------------------
BS_RenderObjectPtr<BS_Bitmap> BS_RenderObject::AddDynamicBitmap(unsigned int Width, unsigned int Height)
{
BS_RenderObjectPtr<BS_Bitmap> BS_RenderObject::AddDynamicBitmap(unsigned int Width, unsigned int Height) {
BS_RenderObjectPtr<BS_Bitmap> BitmapPtr(new BS_DynamicBitmap(this, Width, Height));
if (BitmapPtr.IsValid() && BitmapPtr->GetInitSuccess())
return BitmapPtr;
else
{
else {
if (BitmapPtr.IsValid()) BitmapPtr.Erase();
return BS_RenderObjectPtr<BS_Bitmap>();
}
@ -389,13 +351,11 @@ BS_RenderObjectPtr<BS_Bitmap> BS_RenderObject::AddDynamicBitmap(unsigned int Wid
// -----------------------------------------------------------------------------
BS_RenderObjectPtr<BS_Panel> BS_RenderObject::AddPanel(int Width, int Height, unsigned int Color)
{
BS_RenderObjectPtr<BS_Panel> BS_RenderObject::AddPanel(int Width, int Height, unsigned int Color) {
BS_RenderObjectPtr<BS_Panel> PanelPtr(new BS_Panel(this, Width, Height, Color));
if (PanelPtr.IsValid() && PanelPtr->GetInitSuccess())
return PanelPtr;
else
{
else {
if (PanelPtr.IsValid()) PanelPtr.Erase();
return BS_RenderObjectPtr<BS_Panel>();
}
@ -403,16 +363,12 @@ BS_RenderObjectPtr<BS_Panel> BS_RenderObject::AddPanel(int Width, int Height, un
// -----------------------------------------------------------------------------
BS_RenderObjectPtr<BS_Text> BS_RenderObject::AddText(const Common::String & Font, const std::string & Text)
{
BS_RenderObjectPtr<BS_Text> BS_RenderObject::AddText(const Common::String &Font, const std::string &Text) {
BS_RenderObjectPtr<BS_Text> TextPtr(new BS_Text(this));
if (TextPtr.IsValid() && TextPtr->GetInitSuccess() && TextPtr->SetFont(Font))
{
if (TextPtr.IsValid() && TextPtr->GetInitSuccess() && TextPtr->SetFont(Font)) {
TextPtr->SetText(Text);
return TextPtr;
}
else
{
} else {
if (TextPtr.IsValid()) TextPtr.Erase();
return BS_RenderObjectPtr<BS_Text>();
}
@ -421,8 +377,7 @@ BS_RenderObjectPtr<BS_Text> BS_RenderObject::AddText(const Common::String & Font
// Persistenz-Methoden
// -------------------
bool BS_RenderObject::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_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);
@ -458,8 +413,7 @@ bool BS_RenderObject::Persist(BS_OutputPersistenceBlock & Writer)
// -----------------------------------------------------------------------------
bool BS_RenderObject::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_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);
@ -496,8 +450,7 @@ bool BS_RenderObject::Unpersist(BS_InputPersistenceBlock & Reader)
// -----------------------------------------------------------------------------
bool BS_RenderObject::PersistChildren(BS_OutputPersistenceBlock & Writer)
{
bool BS_RenderObject::PersistChildren(BS_OutputPersistenceBlock &Writer) {
bool Result = true;
// Kinderanzahl speichern.
@ -505,8 +458,7 @@ bool BS_RenderObject::PersistChildren(BS_OutputPersistenceBlock & Writer)
// Rekursiv alle Kinder speichern.
RENDEROBJECT_LIST::iterator It = m_Children.begin();
while (It != m_Children.end())
{
while (It != m_Children.end()) {
Result &= (*It)->Persist(Writer);
++It;
}
@ -516,8 +468,7 @@ bool BS_RenderObject::PersistChildren(BS_OutputPersistenceBlock & Writer)
// -----------------------------------------------------------------------------
bool BS_RenderObject::UnpersistChildren(BS_InputPersistenceBlock & Reader)
{
bool BS_RenderObject::UnpersistChildren(BS_InputPersistenceBlock &Reader) {
bool Result = true;
// Kinderanzahl einlesen.
@ -526,8 +477,7 @@ bool BS_RenderObject::UnpersistChildren(BS_InputPersistenceBlock & Reader)
if (!Reader.IsGood()) return false;
// Alle Kinder rekursiv wieder herstellen.
for (unsigned int i = 0; i < ChildrenCount; ++i)
{
for (unsigned int i = 0; i < ChildrenCount; ++i) {
if (!RecreatePersistedRenderObject(Reader).IsValid()) return false;
}
@ -536,8 +486,7 @@ bool BS_RenderObject::UnpersistChildren(BS_InputPersistenceBlock & Reader)
// -----------------------------------------------------------------------------
BS_RenderObjectPtr<BS_RenderObject> BS_RenderObject::RecreatePersistedRenderObject(BS_InputPersistenceBlock & Reader)
{
BS_RenderObjectPtr<BS_RenderObject> BS_RenderObject::RecreatePersistedRenderObject(BS_InputPersistenceBlock &Reader) {
BS_RenderObjectPtr<BS_RenderObject> Result;
// Typ und Handle auslesen.
@ -547,8 +496,7 @@ BS_RenderObjectPtr<BS_RenderObject> BS_RenderObject::RecreatePersistedRenderObje
Reader.Read(Handle);
if (!Reader.IsGood()) return Result;
switch (Type)
{
switch (Type) {
case TYPE_PANEL:
Result = new BS_Panel(Reader, this, Handle);
break;
@ -578,8 +526,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 BS_RenderObject::Greater(const BS_RenderObjectPtr<BS_RenderObject> lhs, const BS_RenderObjectPtr<BS_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;

92
engines/sword25/gfx/renderobject.h
View file

@ -75,13 +75,11 @@ 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 BS_RenderObject {
public:
// Konstanten
// ----------
enum TYPES
{
enum TYPES {
/// Das Wurzelobjekt. Siehe BS_RenderObjectManager
TYPE_ROOT,
/// Ein Image. Siehe BS_Bitmap.
@ -158,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); else return BS_RenderObjectPtr<BS_Bitmap>();
BS_RenderObjectPtr<BS_Bitmap> ToBitmap() {
if (m_Type == TYPE_STATICBITMAP || m_Type == TYPE_DYNAMICBITMAP) return BS_RenderObjectPtr<BS_Bitmap>(this);
else return BS_RenderObjectPtr<BS_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); else return BS_RenderObjectPtr<BS_Animation>();
BS_RenderObjectPtr<BS_Animation> ToAnimation() {
if (m_Type == TYPE_ANIMATION) return BS_RenderObjectPtr<BS_Animation>(this);
else return BS_RenderObjectPtr<BS_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); else return BS_RenderObjectPtr<BS_Panel>();
BS_RenderObjectPtr<BS_Panel> ToPanel() {
if (m_Type == TYPE_PANEL) return BS_RenderObjectPtr<BS_Panel>(this);
else return BS_RenderObjectPtr<BS_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); else return BS_RenderObjectPtr<BS_Text>();
BS_RenderObjectPtr<BS_Text> ToText() {
if (m_Type == TYPE_TEXT) return BS_RenderObjectPtr<BS_Text>(this);
else return BS_RenderObjectPtr<BS_Text>();
}
// Konstruktor / Desktruktor
@ -270,19 +268,27 @@ public:
/**
@brief Gibt die Position des Objektes auf der X-Achse relativ zum Elternobjekt zurück.
*/
virtual int GetX() const { return m_X; }
virtual int GetX() const {
return m_X;
}
/**
@brief Gibt die Position des Objektes auf der Y-Achse relativ zum Elternobjekt zurück.
*/
virtual int GetY() const { return m_Y; }
virtual int GetY() const {
return m_Y;
}
/**
@brief Gibt die absolute Position des Objektes auf der X-Achse zurück.
*/
virtual int GetAbsoluteX() const { return m_AbsoluteX; }
virtual int GetAbsoluteX() const {
return m_AbsoluteX;
}
/**
@brief Gibt die absolute Position des Objektes auf der Y-Achse zurück.
*/
virtual int GetAbsoluteY() const { return m_AbsoluteY; }
virtual int GetAbsoluteY() const {
return m_AbsoluteY;
}
/**
@brief Gibt den Z-Wert des Objektes relativ zum Elternobjekt zurück.
@remark Der Z-Wert legt die Renderreihenfolge der Objekte fest. Objekte mit niedrigem Z-Wert werden vor Objekten mit höherem
@ -290,43 +296,61 @@ public:
Wie alle andere Attribute ist auch dieses relativ zum Elternobjekt, ein Kinderobjekt kann also nie unter seinem
Elternobjekt liegen, auch wenn es einen Z-Wert von 0 hat.
*/
int GetZ() const { return m_Z; }
int GetZ() const {
return m_Z;
}
/**
@brief Gibt die Breite des Objektes zurück.
*/
int GetWidth() const { return m_Width; }
int GetWidth() const {
return m_Width;
}
/**
@brief Gibt die Höhe des Objektes zurück.
*/
int GetHeight() const { return m_Height; }
int GetHeight() const {
return m_Height;
}
/**
@brief Gibt den Sichtbarkeitszustand des Objektes zurück.
@return Gibt den Sichtbarkeitszustand des Objektes zurück.<br>
true entspricht sichtbar, false entspricht unsichtbar.
*/
bool IsVisible() const { return m_Visible; }
bool IsVisible() const {
return m_Visible;
}
/**
@brief Gibt den Typ des Objektes zurück.
*/
TYPES GetType() const { return m_Type; }
TYPES GetType() const {
return m_Type;
}
/**
@brief Gibt zurück, ob das Objekt erfolgreich initialisiert wurde.
@remark Hässlicher Workaround um das Problem, dass Konstruktoren keine Rückgabewerte haben.
*/
bool GetInitSuccess() const { return m_InitSuccess; }
bool GetInitSuccess() const {
return m_InitSuccess;
}
/**
@brief Gibt die Bounding-Box des Objektes zurück.
@remark Diese Angabe erfolgt ausnahmsweise in Bildschirmkoordianten und nicht relativ zum Elternobjekt.
*/
const BS_Rect& GetBBox() const { return m_BBox; }
const BS_Rect &GetBBox() const {
return m_BBox;
}
/**
@brief Stellt sicher, dass das Objekt im nächsten Frame neu gezeichnet wird.
*/
void ForceRefresh() { m_RefreshForced = true; };
void ForceRefresh() {
m_RefreshForced = true;
};
/**
@brief Gibt das Handle des Objekte zurück.
*/
unsigned int GetHandle() const { return m_Handle; }
unsigned int GetHandle() const {
return m_Handle;
}
// Persistenz-Methoden
// -------------------
@ -409,7 +433,9 @@ protected:
/**
@brief Gibt einen Pointer auf den BS_RenderObjektManager zurück, der das Objekt verwaltet.
*/
BS_RenderObjectManager* GetManager() const { return m_ManagerPtr; }
BS_RenderObjectManager *GetManager() const {
return m_ManagerPtr;
}
/**
@brief Fügt dem Objekt ein neues Kinderobjekt hinzu.
@param pObject ein Pointer auf das einzufügende Objekt
@ -474,14 +500,16 @@ private:
@brief Teilt dem Objekt mit, dass sich eines seiner Kinderobjekte dahingehend verändert hat, die eine erneute Bestimmung der
Rendereihenfolge verlangt.
*/
void SignalChildChange() { m_ChildChanged = true; }
void SignalChildChange() {
m_ChildChanged = true;
}
/**
@brief Berechnet des Schnittrechteck der Bounding-Box des Objektes mit einem anderen Objekt.
@param pObjekt ein Pointer auf das Objekt mit dem geschnitten werden soll
@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(BS_RenderObjectPtr<BS_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.

30
engines/sword25/gfx/renderobjectmanager.cpp
View file

@ -57,16 +57,14 @@ namespace Sword25 {
// -----------------------------------------------------------------------------
BS_RenderObjectManager::BS_RenderObjectManager(int Width, int Height, int FramebufferCount) :
m_FrameStarted(false)
{
m_FrameStarted(false) {
// Wurzel des BS_RenderObject-Baumes erzeugen.
m_RootPtr = new BS_RootRenderObject(this, Width, Height);
}
// -----------------------------------------------------------------------------
BS_RenderObjectManager::~BS_RenderObjectManager()
{
BS_RenderObjectManager::~BS_RenderObjectManager() {
// Die Wurzel des Baumes löschen, damit werden alle BS_RenderObjects mitgelöscht.
m_RootPtr.Erase();
}
@ -75,8 +73,7 @@ BS_RenderObjectManager::~BS_RenderObjectManager()
// Interface
// -----------------------------------------------------------------------------
void BS_RenderObjectManager::StartFrame()
{
void BS_RenderObjectManager::StartFrame() {
m_FrameStarted = true;
// Verstrichene Zeit bestimmen
@ -90,8 +87,7 @@ void BS_RenderObjectManager::StartFrame()
// -----------------------------------------------------------------------------
bool BS_RenderObjectManager::Render()
{
bool BS_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.
@ -105,15 +101,13 @@ bool BS_RenderObjectManager::Render()
// -----------------------------------------------------------------------------
void BS_RenderObjectManager::AttatchTimedRenderObject(BS_RenderObjectPtr<BS_TimedRenderObject> RenderObjectPtr)
{
void BS_RenderObjectManager::AttatchTimedRenderObject(BS_RenderObjectPtr<BS_TimedRenderObject> RenderObjectPtr) {
m_TimedRenderObjects.push_back(RenderObjectPtr);
}
// -----------------------------------------------------------------------------
void BS_RenderObjectManager::DetatchTimedRenderObject(BS_RenderObjectPtr<BS_TimedRenderObject> RenderObjectPtr)
{
void BS_RenderObjectManager::DetatchTimedRenderObject(BS_RenderObjectPtr<BS_TimedRenderObject> RenderObjectPtr) {
RenderObjectList::iterator Iter = find(m_TimedRenderObjects.begin(), m_TimedRenderObjects.end(), RenderObjectPtr);
if (Iter != m_TimedRenderObjects.end()) m_TimedRenderObjects.erase(Iter);
}
@ -122,8 +116,7 @@ void BS_RenderObjectManager::DetatchTimedRenderObject(BS_RenderObjectPtr<BS_Time
// Persistenz
// -----------------------------------------------------------------------------
bool BS_RenderObjectManager::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_RenderObjectManager::Persist(BS_OutputPersistenceBlock &Writer) {
bool Result = true;
// Alle Kinder des Wurzelknotens speichern. Dadurch werden alle BS_RenderObjects gespeichert rekursiv gespeichert.
@ -134,8 +127,7 @@ bool BS_RenderObjectManager::Persist(BS_OutputPersistenceBlock & Writer)
// Referenzen auf die TimedRenderObjects persistieren.
Writer.Write(m_TimedRenderObjects.size());
RenderObjectList::const_iterator Iter = m_TimedRenderObjects.begin();
while (Iter != m_TimedRenderObjects.end())
{
while (Iter != m_TimedRenderObjects.end()) {
Writer.Write((*Iter)->GetHandle());
++Iter;
}
@ -148,8 +140,7 @@ bool BS_RenderObjectManager::Persist(BS_OutputPersistenceBlock & Writer)
// -----------------------------------------------------------------------------
bool BS_RenderObjectManager::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_RenderObjectManager::Unpersist(BS_InputPersistenceBlock &Reader) {
bool Result = true;
// Alle Kinder des Wurzelknotens löschen. Damit werden alle BS_RenderObjects gelöscht.
@ -166,8 +157,7 @@ bool BS_RenderObjectManager::Unpersist(BS_InputPersistenceBlock & Reader)
// Referenzen auf die TimedRenderObjects wieder herstellen.
unsigned int TimedObjectCount;
Reader.Read(TimedObjectCount);
for (unsigned int i = 0; i < TimedObjectCount; ++i)
{
for (unsigned int i = 0; i < TimedObjectCount; ++i) {
unsigned int Handle;
Reader.Read(Handle);
m_TimedRenderObjects.push_back(Handle);

11
engines/sword25/gfx/renderobjectmanager.h
View file

@ -68,8 +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 BS_RenderObjectManager : public BS_Persistable {
public:
/**
@brief Erzeugt ein neues BS_RenderObjectManager-Objekt.
@ -99,7 +98,9 @@ public:
/**
@brief Gibt einen Pointer auf die Wurzel des Objektbaumes zurück.
*/
BS_RenderObjectPtr<BS_RenderObject> GetTreeRoot() { return m_RootPtr; }
BS_RenderObjectPtr<BS_RenderObject> GetTreeRoot() {
return m_RootPtr;
}
/**
@brief Fügt ein BS_TimedRenderObject in die Liste der zeitabhängigen Render-Objekte.
@ -114,8 +115,8 @@ public:
*/
void DetatchTimedRenderObject(BS_RenderObjectPtr<BS_TimedRenderObject> pRenderObject);
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
private:
bool m_FrameStarted;

2
engines/sword25/gfx/renderobjectptr.cpp
View file

@ -35,7 +35,7 @@
namespace Sword25 {
BS_RenderObjectPtr::BS_RenderObjectPtr(BS_RenderObject * RenderObjectPtr) {
BS_RenderObjectPtr::BS_RenderObjectPtr(BS_RenderObject *RenderObjectPtr) {
m_Handle = RenderObjectPtr->GetHandle();
}

17
engines/sword25/gfx/renderobjectptr.h
View file

@ -55,8 +55,7 @@ class BS_RenderObject;
// -----------------------------------------------------------------------------
template<class T>
class BS_RenderObjectPtr
{
class BS_RenderObjectPtr {
public:
BS_RenderObjectPtr() : m_Handle(0)
{}
@ -64,25 +63,21 @@ public:
BS_RenderObjectPtr(unsigned int Handle) : m_Handle(Handle)
{}
BS_RenderObjectPtr(BS_RenderObject * RenderObjectPtr);
BS_RenderObjectPtr(BS_RenderObject *RenderObjectPtr);
T * operator->() const
{
T *operator->() const {
return static_cast<T *>(BS_RenderObjectRegistry::GetInstance().ResolveHandle(m_Handle));
}
bool operator==(const BS_RenderObjectPtr<T> & other)
{
bool operator==(const BS_RenderObjectPtr<T> & other) {
return m_Handle == other.m_Handle;
}
bool IsValid() const
{
bool IsValid() const {
return BS_RenderObjectRegistry::GetInstance().ResolveHandle(m_Handle) != 0;
}
void Erase()
{
void Erase() {
delete static_cast<T *>(BS_RenderObjectRegistry::GetInstance().ResolveHandle(m_Handle));
m_Handle = 0;
}

6
engines/sword25/gfx/renderobjectregistry.cpp
View file

@ -54,15 +54,13 @@ std::auto_ptr<BS_RenderObjectRegistry> BS_RenderObjectRegistry::m_InstancePtr;
// -----------------------------------------------------------------------------
void BS_RenderObjectRegistry::LogErrorLn(const char * Message) const
{
void BS_RenderObjectRegistry::LogErrorLn(const char *Message) const {
BS_LOG_ERRORLN(Message);
}
// -----------------------------------------------------------------------------
void BS_RenderObjectRegistry::LogWarningLn(const char * Message) const
{
void BS_RenderObjectRegistry::LogWarningLn(const char *Message) const {
BS_LOG_WARNINGLN(Message);
}

6
engines/sword25/gfx/renderobjectregistry.h
View file

@ -60,7 +60,7 @@ class BS_RenderObject;
class BS_RenderObjectRegistry : public BS_ObjectRegistry<BS_RenderObject> {
public:
static BS_RenderObjectRegistry & GetInstance() {
static BS_RenderObjectRegistry &GetInstance() {
if (!m_InstancePtr.get()) m_InstancePtr.reset(new BS_RenderObjectRegistry);
return *m_InstancePtr.get();
}
@ -68,8 +68,8 @@ public:
virtual ~BS_RenderObjectRegistry() {}
private:
virtual void LogErrorLn(const char * Message) const;
virtual void LogWarningLn(const char * Message) const;
virtual void LogErrorLn(const char *Message) const;
virtual void LogWarningLn(const char *Message) const;
static std::auto_ptr<BS_RenderObjectRegistry> m_InstancePtr;
};

14
engines/sword25/gfx/rootrenderobject.h
View file

@ -50,21 +50,21 @@ class BS_Kernel;
// Klassendefinition
class BS_RenderObjectManager;
class BS_RootRenderObject : public BS_RenderObject
{
friend BS_RenderObjectManager;
class BS_RootRenderObject : public BS_RenderObject {
friend BS_RenderObjectManager;
private:
BS_RootRenderObject(BS_RenderObjectManager * ManagerPtr, int Width, int Height) :
BS_RenderObject(BS_RenderObjectPtr<BS_RenderObject>(), TYPE_ROOT)
{
BS_RootRenderObject(BS_RenderObjectManager *ManagerPtr, int Width, int Height) :
BS_RenderObject(BS_RenderObjectPtr<BS_RenderObject>(), TYPE_ROOT) {
m_ManagerPtr = ManagerPtr;
m_Width = Width;
m_Height = Height;
}
protected:
virtual bool DoRender() { return true; }
virtual bool DoRender() {
return true;
}
};
} // End of namespace Sword25

53
engines/sword25/gfx/screenshot.cpp
View file

@ -47,8 +47,7 @@ using namespace std;
// -----------------------------------------------------------------------------
struct RGB_PIXEL
{
struct RGB_PIXEL {
RGB_PIXEL(unsigned char _Red, unsigned char _Green, unsigned char _Blue) :
Red(_Red),
Green(_Green),
@ -60,8 +59,7 @@ struct RGB_PIXEL
unsigned char Blue;
};
bool BS_Screenshot::SaveToFile(unsigned int Width, unsigned int Height, const vector<unsigned int> & Data, const string & Filename)
{
bool BS_Screenshot::SaveToFile(unsigned int Width, unsigned int Height, const vector<unsigned int> & Data, const string &Filename) {
BS_ASSERT(Data.size() == Width * Height);
// Buffer für Bildschirminhalt in RGB reservieren
@ -70,10 +68,8 @@ bool BS_Screenshot::SaveToFile(unsigned int Width, unsigned int Height, const ve
// Framebufferdaten pixelweise von RGBA nach RGB konvertieren
vector<unsigned int>::const_iterator it = Data.begin();
for (unsigned int y = 0; y < Height; y++)
{
for (unsigned int x = 0; x < Width; x++)
{
for (unsigned int y = 0; y < Height; y++) {
for (unsigned int x = 0; x < Width; x++) {
unsigned int SrcPixel = *it++;
PixelBuffer.push_back(RGB_PIXEL((SrcPixel >> 16) & 0xff, (SrcPixel >> 8) & 0xff, SrcPixel & 0xff));
}
@ -82,29 +78,25 @@ bool BS_Screenshot::SaveToFile(unsigned int Width, unsigned int Height, const ve
BS_ASSERT(Data.size() == PixelBuffer.size());
// Variablen für die PNG-Erstellung
FILE * OutFile = 0;
FILE *OutFile = 0;
png_structp png_ptr = 0;
png_infop info_ptr = 0;
try
{
try {
OutFile = fopen(Filename.c_str(), "wb");
if (!OutFile)
{
if (!OutFile) {
BS_LOG_ERRORLN("Could not create screenshot-file \"%s\".", Filename.c_str());
throw(0);
}
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr)
{
if (!png_ptr) {
BS_LOG_ERRORLN("Could not create PNG write-struct.");
throw(0);
}
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{
if (!info_ptr) {
BS_LOG_ERRORLN("Could not create PNG info-struct.");
throw(0);
}
@ -127,8 +119,7 @@ bool BS_Screenshot::SaveToFile(unsigned int Width, unsigned int Height, const ve
// Rowpointer erstellen
vector<png_bytep> RowPointers;
RowPointers.reserve(Height);
for (unsigned int i = 0; i < Height; i++)
{
for (unsigned int i = 0; i < Height; i++) {
RowPointers.push_back((png_bytep)(&PixelBuffer[Width * i]));
}
png_set_rows(png_ptr, info_ptr, &RowPointers[0]);
@ -142,11 +133,9 @@ bool BS_Screenshot::SaveToFile(unsigned int Width, unsigned int Height, const ve
fclose(OutFile);
}
catch (int)
{
catch (int) {
// Wenn die Datei bereits erstellt wurde, Datei schließen und löschen.
if (OutFile)
{
if (OutFile) {
fclose(OutFile);
remove(Filename.c_str());
}
@ -163,8 +152,7 @@ bool BS_Screenshot::SaveToFile(unsigned int Width, unsigned int Height, const ve
// -----------------------------------------------------------------------------
bool BS_Screenshot::SaveThumbnailToFile(unsigned int Width, unsigned int Height, const vector<unsigned int> & Data, const string & Filename)
{
bool BS_Screenshot::SaveThumbnailToFile(unsigned int Width, unsigned int Height, const vector<unsigned int> & Data, const string &Filename) {
//
// Diese Methode nimmt ein Screenshot mit den Maßen von 800x600 und erzeugt einen Screenshot mit den Maßen von 200x125.
// Dabei werden je 50 Pixel oben und unten abgeschnitten (die Interface-Leisten im Spiel). Das verbleibende Bild von 800x500 wird auf
@ -173,8 +161,7 @@ bool BS_Screenshot::SaveThumbnailToFile(unsigned int Width, unsigned int Height,
//
// Die Ausgangsgröße muss 800x600 sein.
if (Width != 800 || Height != 600)
{
if (Width != 800 || Height != 600) {
BS_LOG_ERRORLN("The sreenshot dimensions have to be 800x600 in order to be saved as a thumbnail.");
return false;
}
@ -185,15 +172,12 @@ bool BS_Screenshot::SaveThumbnailToFile(unsigned int Width, unsigned int Height,
// Über das Zielbild iterieren und einen Pixel zur Zeit berechnen.
unsigned int x, y;
x = y = 0;
for(vector<unsigned int>::iterator Iter = ThumbnailData.begin(); Iter != ThumbnailData.end(); ++Iter)
{
for (vector<unsigned int>::iterator Iter = ThumbnailData.begin(); Iter != ThumbnailData.end(); ++Iter) {
// Durchschnitt über 4x4 Pixelblock im Quellbild bilden.
unsigned int Alpha, Red, Green, Blue;
Alpha = Red = Green = Blue = 0;
for (unsigned int j = 0; j < 4; ++j)
{
for (unsigned int i = 0; i < 4; ++i)
{
for (unsigned int j = 0; j < 4; ++j) {
for (unsigned int i = 0; i < 4; ++i) {
unsigned int Pixel = Data[((y * 4) + j + 50) * 800 + ((x * 4) + i)];
Alpha += (Pixel >> 24);
Red += (Pixel >> 16) & 0xff;
@ -207,8 +191,7 @@ bool BS_Screenshot::SaveThumbnailToFile(unsigned int Width, unsigned int Height,
// Mitzählen an welcher Stelle im Zielbild wir uns befinden.
++x;
if (x == 200)
{
if (x == 200) {
x = 0;
++y;
}

7
engines/sword25/gfx/screenshot.h
View file

@ -51,11 +51,10 @@ namespace Sword25 {
// Class declaration
// -----------------------------------------------------------------------------
class BS_Screenshot
{
class BS_Screenshot {
public:
static bool SaveToFile(unsigned int Width, unsigned int Height, const Common::Array<unsigned int> & Data, const Common::String & Filename);
static bool SaveThumbnailToFile(unsigned int Width, unsigned int Height, const Common::Array<unsigned int> & Data, const Common::String & Filename);
static bool SaveToFile(unsigned int Width, unsigned int Height, const Common::Array<unsigned int> & Data, const Common::String &Filename);
static bool SaveThumbnailToFile(unsigned int Width, unsigned int Height, const Common::Array<unsigned int> & Data, const Common::String &Filename);
};
} // End of namespace Sword25

79
engines/sword25/gfx/staticbitmap.cpp
View file

@ -54,9 +54,8 @@ namespace Sword25 {
// Konstruktion / Destruktion
// -----------------------------------------------------------------------------
BS_StaticBitmap::BS_StaticBitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const Common::String& Filename) :
BS_Bitmap(ParentPtr, TYPE_STATICBITMAP)
{
BS_StaticBitmap::BS_StaticBitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const Common::String &Filename) :
BS_Bitmap(ParentPtr, TYPE_STATICBITMAP) {
// Das BS_Bitmap konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden.
if (!m_InitSuccess) return;
@ -65,30 +64,26 @@ 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)
{
BS_StaticBitmap::BS_StaticBitmap(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) :
BS_Bitmap(ParentPtr, TYPE_STATICBITMAP, Handle) {
m_InitSuccess = Unpersist(Reader);
}
// -----------------------------------------------------------------------------
bool BS_StaticBitmap::InitBitmapResource(const Common::String & Filename)
{
bool BS_StaticBitmap::InitBitmapResource(const Common::String &Filename) {
// Bild-Resource laden
BS_Resource* ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(Filename);
if (!ResourcePtr)
{
BS_Resource *ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(Filename);
if (!ResourcePtr) {
BS_LOG_ERRORLN("Could not request resource \"%s\".", Filename.c_str());
return false;
}
if (ResourcePtr->GetType() != BS_Resource::TYPE_BITMAP)
{
if (ResourcePtr->GetType() != BS_Resource::TYPE_BITMAP) {
BS_LOG_ERRORLN("Requested resource \"%s\" is not a bitmap.", Filename.c_str());
return false;
}
BS_BitmapResource * BitmapPtr = static_cast<BS_BitmapResource*>(ResourcePtr);
BS_BitmapResource *BitmapPtr = static_cast<BS_BitmapResource *>(ResourcePtr);
// Den eindeutigen Dateinamen zum späteren Referenzieren speichern
m_ResourceFilename = BitmapPtr->GetFileName();
@ -105,35 +100,30 @@ bool BS_StaticBitmap::InitBitmapResource(const Common::String & Filename)
// -----------------------------------------------------------------------------
BS_StaticBitmap::~BS_StaticBitmap()
{
BS_StaticBitmap::~BS_StaticBitmap() {
}
// -----------------------------------------------------------------------------
bool BS_StaticBitmap::DoRender()
{
bool BS_StaticBitmap::DoRender() {
// Bitmap holen
BS_Resource* ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
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);
BS_BitmapResource *BitmapResourcePtr = static_cast<BS_BitmapResource *>(ResourcePtr);
// Framebufferobjekt holen
BS_GraphicEngine * GfxPtr = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
BS_GraphicEngine *GfxPtr = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
BS_ASSERT(GfxPtr);
// Bitmap zeichnen
bool Result;
if (m_ScaleFactorX == 1.0f && m_ScaleFactorY == 1.0f)
{
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),
0, m_ModulationColor, -1, -1);
}
else
{
} else {
Result = BitmapResourcePtr->Blit(m_AbsoluteX, m_AbsoluteY,
(m_FlipV ? BS_BitmapResource::FLIP_V : 0) |
(m_FlipH ? BS_BitmapResource::FLIP_H : 0),
@ -148,14 +138,13 @@ bool BS_StaticBitmap::DoRender()
// -----------------------------------------------------------------------------
unsigned int BS_StaticBitmap::GetPixel(int X, int Y) const
{
unsigned int BS_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_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);
BS_BitmapResource *pBitmapResource = static_cast<BS_BitmapResource *>(pResource);
unsigned int Result = pBitmapResource->GetPixel(X, Y);
pResource->Release();
return Result;
@ -163,8 +152,7 @@ unsigned int BS_StaticBitmap::GetPixel(int X, int Y) const
// -----------------------------------------------------------------------------
bool BS_StaticBitmap::SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride)
{
bool BS_StaticBitmap::SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride) {
BS_LOG_ERRORLN("SetContent() ist not supported with this object.");
return false;
}
@ -173,33 +161,30 @@ bool BS_StaticBitmap::SetContent(const byte *Pixeldata, unsigned int Offset, uns
// Auskunftsmethoden
// -----------------------------------------------------------------------------
bool BS_StaticBitmap::IsAlphaAllowed() const
{
BS_Resource* pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
bool BS_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<BS_BitmapResource *>(pResource)->IsAlphaAllowed();
pResource->Release();
return Result;
}
// -----------------------------------------------------------------------------
bool BS_StaticBitmap::IsColorModulationAllowed() const
{
BS_Resource* pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
bool BS_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<BS_BitmapResource *>(pResource)->IsColorModulationAllowed();
pResource->Release();
return Result;
}
// -----------------------------------------------------------------------------
bool BS_StaticBitmap::IsScalingAllowed() const
{
BS_Resource* pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
bool BS_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<BS_BitmapResource *>(pResource)->IsScalingAllowed();
pResource->Release();
return Result;
}
@ -208,8 +193,7 @@ bool BS_StaticBitmap::IsScalingAllowed() const
// Persistenz
// -----------------------------------------------------------------------------
bool BS_StaticBitmap::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_StaticBitmap::Persist(BS_OutputPersistenceBlock &Writer) {
bool Result = true;
Result &= BS_Bitmap::Persist(Writer);
@ -220,8 +204,7 @@ bool BS_StaticBitmap::Persist(BS_OutputPersistenceBlock & Writer)
return Result;
}
bool BS_StaticBitmap::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_StaticBitmap::Unpersist(BS_InputPersistenceBlock &Reader) {
bool Result = true;
Result &= BS_Bitmap::Unpersist(Reader);

19
engines/sword25/gfx/staticbitmap.h
View file

@ -48,16 +48,15 @@ namespace Sword25 {
// Klassendeklaration
// -----------------------------------------------------------------------------
class BS_StaticBitmap : public BS_Bitmap
{
friend class BS_RenderObject;
class BS_StaticBitmap : public BS_Bitmap {
friend class BS_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);
BS_StaticBitmap(BS_RenderObjectPtr<BS_RenderObject> ParentPtr, const Common::String &Filename);
BS_StaticBitmap(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle);
public:
virtual ~BS_StaticBitmap();
@ -69,10 +68,12 @@ public:
virtual bool IsScalingAllowed() const;
virtual bool IsAlphaAllowed() const;
virtual bool IsColorModulationAllowed() const;
virtual bool IsSetContentAllowed() const { return false; }
virtual bool IsSetContentAllowed() const {
return false;
}
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
protected:
virtual bool DoRender();
@ -80,7 +81,7 @@ protected:
private:
Common::String m_ResourceFilename;
bool InitBitmapResource(const Common::String & Filename);
bool InitBitmapResource(const Common::String &Filename);
};
} // End of namespace Sword25

144
engines/sword25/gfx/text.cpp
View file

@ -56,9 +56,8 @@ namespace Sword25 {
// Konstanten
// -----------------------------------------------------------------------------
namespace
{
const unsigned int AUTO_WRAP_THRESHOLD_DEFAULT = 300;
namespace {
const unsigned int AUTO_WRAP_THRESHOLD_DEFAULT = 300;
}
// -----------------------------------------------------------------------------
@ -69,33 +68,27 @@ BS_Text::BS_Text(BS_RenderObjectPtr<BS_RenderObject> ParentPtr) :
BS_RenderObject(ParentPtr, BS_RenderObject::TYPE_TEXT),
m_ModulationColor(0xffffffff),
m_AutoWrap(false),
m_AutoWrapThreshold(AUTO_WRAP_THRESHOLD_DEFAULT)
{
m_AutoWrapThreshold(AUTO_WRAP_THRESHOLD_DEFAULT) {
}
// -----------------------------------------------------------------------------
BS_Text::BS_Text(BS_InputPersistenceBlock & Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) :
BS_RenderObject(ParentPtr, TYPE_TEXT, Handle)
{
BS_Text::BS_Text(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle) :
BS_RenderObject(ParentPtr, TYPE_TEXT, Handle) {
m_InitSuccess = Unpersist(Reader);
}
// -----------------------------------------------------------------------------
bool BS_Text::SetFont(const Common::String & Font)
{
bool BS_Text::SetFont(const Common::String &Font) {
// Font precachen.
if (GetResourceManager()->PrecacheResource(Font))
{
if (GetResourceManager()->PrecacheResource(Font)) {
m_Font = Font;
UpdateFormat();
ForceRefresh();
return true;
}
else
{
} else {
BS_LOG_ERRORLN("Could not precache font \"%s\". Font probably does not exist.", Font.c_str());
return false;
}
@ -104,8 +97,7 @@ bool BS_Text::SetFont(const Common::String & Font)
// -----------------------------------------------------------------------------
void BS_Text::SetText(const Common::String & Text)
{
void BS_Text::SetText(const Common::String &Text) {
m_Text = Text;
UpdateFormat();
ForceRefresh();
@ -113,11 +105,9 @@ void BS_Text::SetText(const Common::String & Text)
// -----------------------------------------------------------------------------
void BS_Text::SetColor(unsigned int ModulationColor)
{
void BS_Text::SetColor(unsigned int ModulationColor) {
unsigned int NewModulationColor = (ModulationColor & 0x00ffffff) | (m_ModulationColor & 0xff000000);
if (NewModulationColor != m_ModulationColor)
{
if (NewModulationColor != m_ModulationColor) {
m_ModulationColor = NewModulationColor;
ForceRefresh();
}
@ -125,12 +115,10 @@ void BS_Text::SetColor(unsigned int ModulationColor)
// -----------------------------------------------------------------------------
void BS_Text::SetAlpha(int Alpha)
{
void BS_Text::SetAlpha(int Alpha) {
BS_ASSERT(Alpha >= 0 && Alpha < 256);
unsigned int NewModulationColor = (m_ModulationColor & 0x00ffffff) | Alpha << 24;
if (NewModulationColor != m_ModulationColor)
{
if (NewModulationColor != m_ModulationColor) {
m_ModulationColor = NewModulationColor;
ForceRefresh();
}
@ -138,10 +126,8 @@ void BS_Text::SetAlpha(int Alpha)
// -----------------------------------------------------------------------------
void BS_Text::SetAutoWrap(bool AutoWrap)
{
if (AutoWrap != m_AutoWrap)
{
void BS_Text::SetAutoWrap(bool AutoWrap) {
if (AutoWrap != m_AutoWrap) {
m_AutoWrap = AutoWrap;
UpdateFormat();
ForceRefresh();
@ -150,10 +136,8 @@ void BS_Text::SetAutoWrap(bool AutoWrap)
// -----------------------------------------------------------------------------
void BS_Text::SetAutoWrapThreshold(unsigned int AutoWrapThreshold)
{
if (AutoWrapThreshold != m_AutoWrapThreshold)
{
void BS_Text::SetAutoWrapThreshold(unsigned int AutoWrapThreshold) {
if (AutoWrapThreshold != m_AutoWrapThreshold) {
m_AutoWrapThreshold = AutoWrapThreshold;
UpdateFormat();
ForceRefresh();
@ -162,39 +146,35 @@ void BS_Text::SetAutoWrapThreshold(unsigned int AutoWrapThreshold)
// -----------------------------------------------------------------------------
bool BS_Text::DoRender()
{
bool BS_Text::DoRender() {
// Font-Resource locken.
BS_FontResource * FontPtr = LockFontResource();
BS_FontResource *FontPtr = LockFontResource();
if (!FontPtr) return false;
// Charactermap-Resource locken.
BS_ResourceManager * RMPtr = GetResourceManager();
BS_BitmapResource * CharMapPtr;
{
BS_Resource * pResource = RMPtr->RequestResource(FontPtr->GetCharactermapFileName());
if (!pResource)
BS_ResourceManager *RMPtr = GetResourceManager();
BS_BitmapResource *CharMapPtr;
{
BS_Resource *pResource = RMPtr->RequestResource(FontPtr->GetCharactermapFileName());
if (!pResource) {
BS_LOG_ERRORLN("Could not request resource \"%s\".", FontPtr->GetCharactermapFileName().c_str());
return false;
}
if (pResource->GetType() != BS_Resource::TYPE_BITMAP)
{
if (pResource->GetType() != BS_Resource::TYPE_BITMAP) {
BS_LOG_ERRORLN("Requested resource \"%s\" is not a bitmap.", FontPtr->GetCharactermapFileName().c_str());
return false;
}
CharMapPtr = static_cast<BS_BitmapResource*>(pResource);
CharMapPtr = static_cast<BS_BitmapResource *>(pResource);
}
// Framebufferobjekt holen.
BS_GraphicEngine * GfxPtr = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
BS_GraphicEngine *GfxPtr = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
BS_ASSERT(GfxPtr);
bool Result = true;
Common::Array<LINE>::iterator Iter = m_Lines.begin();
for (; Iter != m_Lines.end(); ++Iter)
{
for (; Iter != m_Lines.end(); ++Iter) {
// Feststellen, ob überhaupt Buchstaben der aktuellen Zeile vom Update betroffen sind.
BS_Rect CheckRect = (*Iter).BBox;
CheckRect.Move(m_AbsoluteX, m_AbsoluteY);
@ -202,8 +182,7 @@ bool BS_Text::DoRender()
// Jeden Buchstaben einzeln Rendern.
int CurX = m_AbsoluteX + (*Iter).BBox.left;
int CurY = m_AbsoluteY + (*Iter).BBox.top;
for (unsigned int i = 0; i < (*Iter).Text.size(); ++i)
{
for (unsigned int i = 0; i < (*Iter).Text.size(); ++i) {
BS_Rect CurRect = FontPtr->GetCharacterRect((unsigned char)(*Iter).Text.at(i));
BS_Rect RenderRect(CurX, CurY, CurX + CurRect.GetWidth(), CurY + CurRect.GetHeight());
@ -228,34 +207,30 @@ bool BS_Text::DoRender()
// -----------------------------------------------------------------------------
BS_ResourceManager * BS_Text::GetResourceManager()
{
BS_ResourceManager *BS_Text::GetResourceManager() {
// Pointer auf den Resource-Manager holen.
return BS_Kernel::GetInstance()->GetResourceManager();
}
// -----------------------------------------------------------------------------
BS_FontResource * BS_Text::LockFontResource()
{
BS_ResourceManager * RMPtr = GetResourceManager();
BS_FontResource *BS_Text::LockFontResource() {
BS_ResourceManager *RMPtr = GetResourceManager();
// Font-Resource locken.
BS_FontResource * FontPtr;
{
BS_Resource * ResourcePtr = RMPtr->RequestResource(m_Font);
if (!ResourcePtr)
BS_FontResource *FontPtr;
{
BS_Resource *ResourcePtr = RMPtr->RequestResource(m_Font);
if (!ResourcePtr) {
BS_LOG_ERRORLN("Could not request resource \"%s\".", m_Font.c_str());
return NULL;
}
if (ResourcePtr->GetType() != BS_Resource::TYPE_FONT)
{
if (ResourcePtr->GetType() != BS_Resource::TYPE_FONT) {
BS_LOG_ERRORLN("Requested resource \"%s\" is not a font.", m_Font.c_str());
return NULL;
}
FontPtr = static_cast<BS_FontResource*>(ResourcePtr);
FontPtr = static_cast<BS_FontResource *>(ResourcePtr);
}
return FontPtr;
@ -263,16 +238,14 @@ BS_FontResource * BS_Text::LockFontResource()
// -----------------------------------------------------------------------------
void BS_Text::UpdateFormat()
{
BS_FontResource * FontPtr = LockFontResource();
void BS_Text::UpdateFormat() {
BS_FontResource *FontPtr = LockFontResource();
BS_ASSERT(FontPtr);
UpdateMetrics(*FontPtr);
m_Lines.resize(1);
if (m_AutoWrap && (unsigned int) m_Width >= m_AutoWrapThreshold && m_Text.size() >= 2)
{
if (m_AutoWrap && (unsigned int) m_Width >= m_AutoWrapThreshold && m_Text.size() >= 2) {
m_Width = 0;
unsigned int CurLineWidth = 0;
unsigned int CurLineHeight = 0;
@ -280,16 +253,14 @@ void BS_Text::UpdateFormat()
unsigned int TempLineWidth = 0;
unsigned int LastSpace = 0; // we need at least 1 space character to start a new line...
m_Lines[0].Text = "";
for (unsigned int i = 0; i < m_Text.size(); ++i)
{
for (unsigned int i = 0; i < m_Text.size(); ++i) {
unsigned int j;
TempLineWidth = 0;
LastSpace = 0;
for (j = i; j < m_Text.size(); ++j)
{
for (j = i; j < m_Text.size(); ++j) {
if ((unsigned char)m_Text[j] == ' ') LastSpace = j;
const BS_Rect & CurCharRect = FontPtr->GetCharacterRect((unsigned char)m_Text[j]);
const BS_Rect &CurCharRect = FontPtr->GetCharacterRect((unsigned char)m_Text[j]);
TempLineWidth += CurCharRect.GetWidth();
TempLineWidth += FontPtr->GetGapWidth();
@ -301,11 +272,10 @@ void BS_Text::UpdateFormat()
CurLineWidth = 0;
CurLineHeight = 0;
for (j = i; j < LastSpace; ++j)
{
for (j = i; j < LastSpace; ++j) {
m_Lines[CurLine].Text += m_Text[j];
const BS_Rect & CurCharRect = FontPtr->GetCharacterRect((unsigned char)m_Text[j]);
const BS_Rect &CurCharRect = FontPtr->GetCharacterRect((unsigned char)m_Text[j]);
CurLineWidth += CurCharRect.GetWidth();
CurLineWidth += FontPtr->GetGapWidth();
if ((unsigned int) CurCharRect.GetHeight() > CurLineHeight) CurLineHeight = CurCharRect.GetHeight();
@ -315,8 +285,7 @@ void BS_Text::UpdateFormat()
m_Lines[CurLine].BBox.bottom = CurLineHeight;
if ((unsigned int) m_Width < CurLineWidth) m_Width = CurLineWidth;
if(LastSpace < m_Text.size())
{
if (LastSpace < m_Text.size()) {
++CurLine;
BS_ASSERT(CurLine == m_Lines.size());
m_Lines.resize(CurLine + 1);
@ -329,18 +298,15 @@ void BS_Text::UpdateFormat()
// Bounding-Box der einzelnen Zeilen relativ zur ersten festlegen (vor allem zentrieren).
m_Height = 0;
Common::Array<LINE>::iterator Iter = m_Lines.begin();
for (; Iter != m_Lines.end(); ++Iter)
{
BS_Rect & BBox = (*Iter).BBox;
for (; Iter != m_Lines.end(); ++Iter) {
BS_Rect &BBox = (*Iter).BBox;
BBox.left = (m_Width - BBox.right) / 2;
BBox.right = BBox.left + BBox.right;
BBox.top = (Iter - m_Lines.begin()) * FontPtr->GetLineHeight();
BBox.bottom = BBox.top + BBox.bottom;
m_Height += BBox.GetHeight();
}
}
else
{
} else {
// Keine automatische Formatierung, also wird der gesamte Text in nur eine Zeile kopiert.
m_Lines[0].Text = m_Text;
m_Lines[0].BBox = BS_Rect(0, 0, m_Width, m_Height);
@ -351,14 +317,12 @@ void BS_Text::UpdateFormat()
// -----------------------------------------------------------------------------
void BS_Text::UpdateMetrics(BS_FontResource & FontResource)
{
void BS_Text::UpdateMetrics(BS_FontResource &FontResource) {
m_Width = 0;
m_Height = 0;
for (unsigned int i = 0; i < m_Text.size(); ++i)
{
const BS_Rect & CurRect = FontResource.GetCharacterRect((unsigned char)m_Text.at(i));
for (unsigned int i = 0; i < m_Text.size(); ++i) {
const BS_Rect &CurRect = FontResource.GetCharacterRect((unsigned char)m_Text.at(i));
m_Width += CurRect.GetWidth();
if (i != m_Text.size() - 1) m_Width += FontResource.GetGapWidth();
if (m_Height < CurRect.GetHeight()) m_Height = CurRect.GetHeight();
@ -369,8 +333,7 @@ void BS_Text::UpdateMetrics(BS_FontResource & FontResource)
// Persistenz
// -----------------------------------------------------------------------------
bool BS_Text::Persist(BS_OutputPersistenceBlock & Writer)
{
bool BS_Text::Persist(BS_OutputPersistenceBlock &Writer) {
bool Result = true;
Result &= BS_RenderObject::Persist(Writer);
@ -386,8 +349,7 @@ bool BS_Text::Persist(BS_OutputPersistenceBlock & Writer)
return Result;
}
bool BS_Text::Unpersist(BS_InputPersistenceBlock & Reader)
{
bool BS_Text::Unpersist(BS_InputPersistenceBlock &Reader) {
bool Result = true;
Result &= BS_RenderObject::Unpersist(Reader);

48
engines/sword25/gfx/text.h
View file

@ -61,9 +61,8 @@ class BS_ResourceManager;
// Klassendefinition
// -----------------------------------------------------------------------------
class BS_Text : public BS_RenderObject
{
friend class BS_RenderObject;
class BS_Text : public BS_RenderObject {
friend class BS_RenderObject;
public:
/**
@ -71,13 +70,13 @@ public:
@param Font der Dateiname der Fontdatei.
@return Gibt false zurück, wenn der Font nicht gefunden wurde.
*/
bool SetFont(const Common::String & Font);
bool SetFont(const Common::String &Font);
/**
@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.
@ -105,12 +104,16 @@ public:
/**
@brief Gibt den dargestellten Text zurück.
*/
const Common::String & GetText() { return m_Text; }
const Common::String &GetText() {
return m_Text;
}
/**
@brief Gibt den Namen das momentan benutzten Fonts zurück.
*/
const Common::String & GetFont() { return m_Font; }
const Common::String &GetFont() {
return m_Font;
}
/**
@brief Setzt die Farbe des Textes.
@ -122,33 +125,41 @@ public:
@brief Gibt den Alphawert des Textes zurück.
@return Der Alphawert des Textes (0 = keine Deckung, 255 = volle Deckung).
*/
int GetAlpha() const { return m_ModulationColor >> 24; }
int GetAlpha() const {
return m_ModulationColor >> 24;
}
/**
@brief Gibt die Farbe des Textes zurück.
@return Eine 24-Bit RGB Farbe, die die Farbe des Textes angibt.
*/
int GetColor() const { return m_ModulationColor & 0x00ffffff; }
int GetColor() const {
return m_ModulationColor & 0x00ffffff;
}
/**
@brief Gibt zurück, ob die automatische Formatierung aktiviert ist.
*/
bool IsAutoWrapActive() const { return m_AutoWrap; }
bool IsAutoWrapActive() const {
return m_AutoWrap;
}
/**
@brief Gibt die Längengrenze des Textes in Pixeln zurück, ab der eine automatische Formatierung vorgenommen wird.
*/
unsigned int GetAutoWrapThreshold() const { return m_AutoWrapThreshold; }
unsigned int GetAutoWrapThreshold() const {
return m_AutoWrapThreshold;
}
virtual bool Persist(BS_OutputPersistenceBlock & Writer);
virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
virtual bool Persist(BS_OutputPersistenceBlock &Writer);
virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
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);
BS_Text(BS_InputPersistenceBlock &Reader, BS_RenderObjectPtr<BS_RenderObject> ParentPtr, unsigned int Handle);
unsigned int m_ModulationColor;
Common::String m_Font;
@ -156,8 +167,7 @@ private:
bool m_AutoWrap;
unsigned int m_AutoWrapThreshold;
struct LINE
{
struct LINE {
BS_Rect BBox;
Common::String Text;
};
@ -165,9 +175,9 @@ private:
Common::Array<LINE> m_Lines;
void UpdateFormat();
void UpdateMetrics(BS_FontResource & FontResource);
BS_ResourceManager * GetResourceManager();
BS_FontResource * LockFontResource();
void UpdateMetrics(BS_FontResource &FontResource);
BS_ResourceManager *GetResourceManager();
BS_FontResource *LockFontResource();
};
} // End of namespace Sword25

6
engines/sword25/gfx/timedrenderobject.cpp
View file

@ -43,14 +43,12 @@ namespace Sword25 {
// -----------------------------------------------------------------------------
BS_TimedRenderObject::BS_TimedRenderObject(BS_RenderObjectPtr<BS_RenderObject> pParent, TYPES Type, unsigned int Handle) :
BS_RenderObject(pParent, Type, Handle)
{
BS_RenderObject(pParent, Type, Handle) {
BS_ASSERT(GetManager());
GetManager()->AttatchTimedRenderObject(this);
}
BS_TimedRenderObject::~BS_TimedRenderObject()
{
BS_TimedRenderObject::~BS_TimedRenderObject() {
BS_ASSERT(GetManager());
GetManager()->DetatchTimedRenderObject(this);
}

3
engines/sword25/gfx/timedrenderobject.h
View file

@ -57,8 +57,7 @@ namespace Sword25 {
@brief
*/
class BS_TimedRenderObject : public BS_RenderObject
{
class BS_TimedRenderObject : public BS_RenderObject {
public:
BS_TimedRenderObject(BS_RenderObjectPtr<BS_RenderObject> pParent, TYPES Type, unsigned int Handle = 0);
~BS_TimedRenderObject();

4
engines/sword25/input/inputengine.h
View file

@ -57,8 +57,8 @@ namespace Sword25 {
class BS_InputEngine : public BS_Service, public BS_Persistable {
public:
BS_InputEngine(BS_Kernel* pKernel);
virtual ~BS_InputEngine(){};
BS_InputEngine(BS_Kernel *pKernel);
virtual ~BS_InputEngine() {};
// NOTE: These codes are registered in inputengine_script.cpp
// Any changes to these enums must also adjust the above file.

34
engines/sword25/input/inputengine_script.cpp
View file

@ -61,45 +61,47 @@ static void TheCharacterCallback(int Character);
static void TheCommandCallback(int Command);
namespace {
class CharacterCallbackClass : public BS_LuaCallback {
public:
class CharacterCallbackClass : public BS_LuaCallback {
public:
CharacterCallbackClass(lua_State *L) : BS_LuaCallback(L) {};
Common::String Character;
protected:
protected:
int PreFunctionInvokation(lua_State *L) {
lua_pushstring(L, Character.c_str());
return 1;
}
};
Common::SharedPtr<CharacterCallbackClass> CharacterCallbackPtr;
};
Common::SharedPtr<CharacterCallbackClass> CharacterCallbackPtr;
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
class CommandCallbackClass : public BS_LuaCallback {
public:
CommandCallbackClass(lua_State *L) : BS_LuaCallback(L) { Command = BS_InputEngine::KEY_COMMAND_BACKSPACE; }
class CommandCallbackClass : public BS_LuaCallback {
public:
CommandCallbackClass(lua_State *L) : BS_LuaCallback(L) {
Command = BS_InputEngine::KEY_COMMAND_BACKSPACE;
}
BS_InputEngine::KEY_COMMANDS Command;
protected:
protected:
int PreFunctionInvokation(lua_State *L) {
lua_pushnumber(L, Command);
return 1;
}
};
Common::SharedPtr<CommandCallbackClass> CommandCallbackPtr;
};
Common::SharedPtr<CommandCallbackClass> CommandCallbackPtr;
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
struct CallbackfunctionRegisterer {
struct CallbackfunctionRegisterer {
CallbackfunctionRegisterer() {
BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaCommandCB", TheCommandCallback);
BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaCharacterCB", TheCharacterCallback);
}
};
static CallbackfunctionRegisterer Instance;
};
static CallbackfunctionRegisterer Instance;
}
// -----------------------------------------------------------------------------

13
engines/sword25/input/scummvminput.cpp
View file

@ -80,7 +80,9 @@ ScummVMInput::~ScummVMInput() {
// -----------------------------------------------------------------------------
BS_Service *ScummVMInput_CreateObject(BS_Kernel *pKernel) { return new ScummVMInput(pKernel); }
BS_Service *ScummVMInput_CreateObject(BS_Kernel *pKernel) {
return new ScummVMInput(pKernel);
}
// -----------------------------------------------------------------------------
@ -102,18 +104,21 @@ void ScummVMInput::Update() {
case Common::EVENT_LBUTTONDOWN:
case Common::EVENT_LBUTTONUP:
m_LeftMouseDown = event.type == Common::EVENT_LBUTTONDOWN;
m_MouseX = event.mouse.x; m_MouseY = event.mouse.y;
m_MouseX = event.mouse.x;
m_MouseY = event.mouse.y;
handleEvents = false;
break;
case Common::EVENT_RBUTTONDOWN:
case Common::EVENT_RBUTTONUP:
m_RightMouseDown = event.type == Common::EVENT_RBUTTONDOWN;
m_MouseX = event.mouse.x; m_MouseY = event.mouse.y;
m_MouseX = event.mouse.x;
m_MouseY = event.mouse.y;
handleEvents = false;
break;
case Common::EVENT_MOUSEMOVE:
m_MouseX = event.mouse.x; m_MouseY = event.mouse.y;
m_MouseX = event.mouse.x;
m_MouseY = event.mouse.y;
break;
case Common::EVENT_KEYDOWN:

6
engines/sword25/kernel/callbackregistry.h
View file

@ -56,7 +56,7 @@ typedef void (*CallbackPtr)(int Command);
class BS_CallbackRegistry {
public:
static BS_CallbackRegistry & GetInstance() {
static BS_CallbackRegistry &GetInstance() {
static BS_CallbackRegistry Instance;
return Instance;
}
@ -70,7 +70,9 @@ private:
NameToPtrMap m_NameToPtrMap;
struct CallbackPtr_EqualTo {
bool operator()(CallbackPtr x, CallbackPtr y) const { return x == y; }
bool operator()(CallbackPtr x, CallbackPtr y) const {
return x == y;
}
};
struct CallbackPtr_Hash {
uint operator()(CallbackPtr x) const {

2
engines/sword25/kernel/common.h
View file

@ -47,7 +47,7 @@
// Global constants
#if _DEBUG && !DEBUG
#define DEBUG
#define DEBUG
#endif
#define BS_ACTIVATE_LOGGING // When defined, logging is activated

4
engines/sword25/kernel/inputpersistenceblock.cpp
View file

@ -46,7 +46,7 @@ namespace Sword25 {
// Constructor / Destructor
// -----------------------------------------------------------------------------
BS_InputPersistenceBlock::BS_InputPersistenceBlock(const void * Data, unsigned int DataLength) :
BS_InputPersistenceBlock::BS_InputPersistenceBlock(const void *Data, unsigned int DataLength) :
m_Data(static_cast<const unsigned char *>(Data), DataLength),
m_ErrorState(NONE) {
m_Iter = m_Data.begin();
@ -146,7 +146,7 @@ void BS_InputPersistenceBlock::Read(Common::Array<unsigned char> &Value) {
// -----------------------------------------------------------------------------
void BS_InputPersistenceBlock::RawRead(void * DestPtr, size_t Size) {
void BS_InputPersistenceBlock::RawRead(void *DestPtr, size_t Size) {
if (CheckBlockSize(Size)) {
memcpy(DestPtr, &*m_Iter, Size);
m_Iter += Size;

8
engines/sword25/kernel/inputpersistenceblock.h
View file

@ -68,8 +68,12 @@ public:
void Read(Common::String &Value);
void Read(Common::Array<unsigned char> &Value);
bool IsGood() const { return m_ErrorState == NONE; }
ErrorState GetErrorState() const { return m_ErrorState; }
bool IsGood() const {
return m_ErrorState == NONE;
}
ErrorState GetErrorState() const {
return m_ErrorState;
}
private:
bool CheckMarker(unsigned char Marker);

56
engines/sword25/kernel/kernel.cpp
View file

@ -129,12 +129,11 @@ BS_Kernel::~BS_Kernel() {
// Service Methoden
// ----------------
BS_Kernel::Superclass::Superclass (BS_Kernel* pKernel, const Common::String& Identifier) :
BS_Kernel::Superclass::Superclass(BS_Kernel *pKernel, const Common::String &Identifier) :
_pKernel(pKernel),
_Identifier(Identifier),
_ServiceCount(0),
_ActiveService(NULL)
{
_ActiveService(NULL) {
for (unsigned int i = 0; i < BS_SERVICE_COUNT; i++)
if (BS_SERVICE_TABLE[i].SuperclassIdentifier == _Identifier)
_ServiceCount++;
@ -180,20 +179,16 @@ Common::String BS_Kernel::Superclass::GetServiceIdentifier(unsigned int Number)
BS_Service *BS_Kernel::Superclass::NewService(const Common::String &ServiceIdentifier) {
for (unsigned int i = 0; i < BS_SERVICE_COUNT; i++)
if (BS_SERVICE_TABLE[i].SuperclassIdentifier == _Identifier &&
BS_SERVICE_TABLE[i].ServiceIdentifier == ServiceIdentifier)
{
BS_Service* NewService = BS_SERVICE_TABLE[i].CreateMethod(_pKernel);
BS_SERVICE_TABLE[i].ServiceIdentifier == ServiceIdentifier) {
BS_Service *NewService = BS_SERVICE_TABLE[i].CreateMethod(_pKernel);
if (NewService)
{
if (NewService) {
DisconnectService();
BS_LOGLN("Service '%s' created from superclass '%s'.", ServiceIdentifier.c_str(), _Identifier.c_str());
_ActiveService = NewService;
_ActiveServiceName = BS_SERVICE_TABLE[i].ServiceIdentifier;
return _ActiveService;
}
else
{
} else {
BS_LOG_ERRORLN("Failed to create service '%s' from superclass '%s'.", ServiceIdentifier.c_str(), _Identifier.c_str());
return NULL;
}
@ -221,7 +216,7 @@ bool BS_Kernel::Superclass::DisconnectService() {
}
BS_Kernel::Superclass *BS_Kernel::GetSuperclassByIdentifier(const Common::String &Identifier) {
Common::Array<Superclass*>::iterator Iter;
Common::Array<Superclass *>::iterator Iter;
for (Iter = _SuperclassList.begin(); Iter != _SuperclassList.end(); ++Iter) {
if ((*Iter)->GetIdentifier() == Identifier)
return *Iter;
@ -248,7 +243,7 @@ Common::String BS_Kernel::GetSuperclassIdentifier(unsigned int Number) {
if (Number > _SuperclassList.size()) return NULL;
unsigned int CurSuperclassOrd = 0;
Common::Array<Superclass*>::iterator Iter;
Common::Array<Superclass *>::iterator Iter;
for (Iter = _SuperclassList.begin(); Iter != _SuperclassList.end(); ++Iter) {
if (CurSuperclassOrd == Number)
return ((*Iter)->GetIdentifier());
@ -264,7 +259,7 @@ Common::String BS_Kernel::GetSuperclassIdentifier(unsigned int Number) {
* @param SuperclassIdentifier The name of the superclass
* z.B: "sfx", "gfx", "package" ...
*/
unsigned int BS_Kernel::GetServiceCount(const Common::String & SuperclassIdentifier) {
unsigned int BS_Kernel::GetServiceCount(const Common::String &SuperclassIdentifier) {
Superclass *pSuperclass;
if (!(pSuperclass = GetSuperclassByIdentifier(SuperclassIdentifier)))
return 0;
@ -282,8 +277,8 @@ unsigned int BS_Kernel::GetServiceCount(const Common::String & SuperclassIdentif
* Hierbei ist zu beachten, dass der erste Service die Nummer 0 erhält. Number muss also eine Zahl zwischen
* 0 und GetServiceCount() - 1 sein.
*/
Common::String BS_Kernel::GetServiceIdentifier(const Common::String & SuperclassIdentifier, unsigned int Number) {
Superclass* pSuperclass;
Common::String BS_Kernel::GetServiceIdentifier(const Common::String &SuperclassIdentifier, unsigned int Number) {
Superclass *pSuperclass;
if (!(pSuperclass = GetSuperclassByIdentifier(SuperclassIdentifier))) return NULL;
return (pSuperclass->GetServiceIdentifier(Number));
@ -298,7 +293,7 @@ Common::String BS_Kernel::GetServiceIdentifier(const Common::String & Superclass
* @param ServiceIdentifier The name of the service
* For the superclass "sfx" an example could be "Fmod" or "directsound"
*/
BS_Service *BS_Kernel::NewService(const Common::String& SuperclassIdentifier, const Common::String& ServiceIdentifier) {
BS_Service *BS_Kernel::NewService(const Common::String &SuperclassIdentifier, const Common::String &ServiceIdentifier) {
Superclass *pSuperclass;
if (!(pSuperclass = GetSuperclassByIdentifier(SuperclassIdentifier))) return NULL;
@ -314,7 +309,7 @@ BS_Service *BS_Kernel::NewService(const Common::String& SuperclassIdentifier, co
* @param SuperclassIdentfier The name of the superclass which is to be disconnected
* z.B: "sfx", "gfx", "package" ...
*/
bool BS_Kernel::DisconnectService(const Common::String& SuperclassIdentifier) {
bool BS_Kernel::DisconnectService(const Common::String &SuperclassIdentifier) {
Superclass *pSuperclass;
if (!(pSuperclass = GetSuperclassByIdentifier(SuperclassIdentifier))) return false;
@ -326,7 +321,7 @@ bool BS_Kernel::DisconnectService(const Common::String& SuperclassIdentifier) {
* @param SuperclassIdentfier The name of the superclass
* z.B: "sfx", "gfx", "package" ...
*/
BS_Service *BS_Kernel::GetService(const Common::String& SuperclassIdentifier) {
BS_Service *BS_Kernel::GetService(const Common::String &SuperclassIdentifier) {
Superclass *pSuperclass;
if (!(pSuperclass = GetSuperclassByIdentifier(SuperclassIdentifier))) return NULL;
@ -339,8 +334,8 @@ BS_Service *BS_Kernel::GetService(const Common::String& SuperclassIdentifier) {
* @param SuperclassIdentfier The name of the superclass
* z.B: "sfx", "gfx", "package" ...
*/
Common::String BS_Kernel::GetActiveServiceIdentifier(const Common::String& SuperclassIdentifier) {
Superclass * pSuperclass = GetSuperclassByIdentifier(SuperclassIdentifier);
Common::String BS_Kernel::GetActiveServiceIdentifier(const Common::String &SuperclassIdentifier) {
Superclass *pSuperclass = GetSuperclassByIdentifier(SuperclassIdentifier);
if (!pSuperclass) return Common::String("");
return (pSuperclass->GetActiveServiceName());
@ -386,12 +381,9 @@ size_t BS_Kernel::GetUsedMemory() {
#ifdef SCUMMVM_DISABLED_CODE
PROCESS_MEMORY_COUNTERS pmc;
pmc.cb = sizeof(pmc);
if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc)))
{
if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) {
return pmc.WorkingSetSize;
}
else
{
} else {
BS_LOG_ERRORLN("Call to GetProcessMemoryInfo() failed. Error code: %d", GetLastError());
return 0;
}
@ -403,7 +395,7 @@ 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() {
BS_GraphicEngine *BS_Kernel::GetGfx() {
return static_cast<BS_GraphicEngine *>(GetService("gfx"));
}
@ -412,7 +404,7 @@ BS_GraphicEngine * BS_Kernel::GetGfx() {
/**
* Returns a pointer to the active Sfx Service, or NULL if no Sfx service is active
*/
BS_SoundEngine * BS_Kernel::GetSfx() {
BS_SoundEngine *BS_Kernel::GetSfx() {
return static_cast<BS_SoundEngine *>(GetService("sfx"));
}
@ -421,7 +413,7 @@ BS_SoundEngine * BS_Kernel::GetSfx() {
/**
* Returns a pointer to the active input service, or NULL if no input service is active
*/
BS_InputEngine * BS_Kernel::GetInput() {
BS_InputEngine *BS_Kernel::GetInput() {
return static_cast<BS_InputEngine *>(GetService("input"));
}
@ -430,7 +422,7 @@ BS_InputEngine * BS_Kernel::GetInput() {
/**
* Returns a pointer to the active package manager, or NULL if no manager is active
*/
BS_PackageManager * BS_Kernel::GetPackage() {
BS_PackageManager *BS_Kernel::GetPackage() {
return static_cast<BS_PackageManager *>(GetService("package"));
}
@ -439,7 +431,7 @@ BS_PackageManager * BS_Kernel::GetPackage() {
/**
* Returns a pointer to the script engine, or NULL if it is not active
*/
BS_ScriptEngine * BS_Kernel::GetScript() {
BS_ScriptEngine *BS_Kernel::GetScript() {
return static_cast<BS_ScriptEngine *>(GetService("script"));
}
@ -448,7 +440,7 @@ BS_ScriptEngine * BS_Kernel::GetScript() {
/**
* Returns a pointer to the movie player, or NULL if it is not active
*/
BS_MoviePlayer * BS_Kernel::GetFMV() {
BS_MoviePlayer *BS_Kernel::GetFMV() {
return static_cast<BS_MoviePlayer *>(GetService("fmv"));
}

40
engines/sword25/kernel/kernel.h
View file

@ -82,7 +82,9 @@ public:
/**
* Returns a pointer to the window object
*/
BS_Window *GetWindow() { return _pWindow; }
BS_Window *GetWindow() {
return _pWindow;
}
// Service Methods
// ---------------
@ -139,7 +141,7 @@ public:
* @param SuperclassIdentifier The name of the superclass
* z.B: "sfx", "gfx", "package" ...
*/
unsigned int GetServiceCount(const Common::String & SuperclassIdentifier);
unsigned int GetServiceCount(const Common::String &SuperclassIdentifier);
/**
* Gets the identifier of a service with a given superclass.
@ -166,11 +168,15 @@ public:
/**
* Specifies whether the kernel was successfully initialised
*/
bool GetInitSuccess() { return _InitSuccess; }
bool GetInitSuccess() {
return _InitSuccess;
}
/**
* Returns a pointer to the BS_ResourceManager
*/
BS_ResourceManager *GetResourceManager() { return _pResourceManager; }
BS_ResourceManager *GetResourceManager() {
return _pResourceManager;
}
/**
* Returns how much memory is being used
*/
@ -264,19 +270,27 @@ private:
Common::String _ActiveServiceName;
public:
Superclass (BS_Kernel *pKernel, const Common::String &Identifier);
Superclass(BS_Kernel *pKernel, const Common::String &Identifier);
~Superclass();
unsigned int GetServiceCount() const { return _ServiceCount; }
Common::String GetIdentifier() const { return _Identifier; }
BS_Service *GetActiveService() const { return _ActiveService; }
Common::String GetActiveServiceName() const { return _ActiveServiceName; }
unsigned int GetServiceCount() const {
return _ServiceCount;
}
Common::String GetIdentifier() const {
return _Identifier;
}
BS_Service *GetActiveService() const {
return _ActiveService;
}
Common::String GetActiveServiceName() const {
return _ActiveServiceName;
}
Common::String GetServiceIdentifier(unsigned int Number);
BS_Service *NewService(const Common::String &ServiceIdentifier);
bool DisconnectService();
};
Common::Array<Superclass*> _SuperclassList;
Common::Array<Superclass *> _SuperclassList;
Common::Stack<Common::String> _ServiceCreationOrder;
Superclass *GetSuperclassByIdentifier(const Common::String &Identifier);
@ -327,8 +341,8 @@ private:
*/
class BS_ServiceInfo {
public:
BS_ServiceInfo(const Common::String &SuperclassIdentifier_, const Common::String& ServiceIdentifier_,
BS_Service* (*CreateMethod_)(BS_Kernel*)) {
BS_ServiceInfo(const Common::String &SuperclassIdentifier_, const Common::String &ServiceIdentifier_,
BS_Service*(*CreateMethod_)(BS_Kernel *)) {
this->SuperclassIdentifier = SuperclassIdentifier_;
this->ServiceIdentifier = ServiceIdentifier_;
this->CreateMethod = CreateMethod_;
@ -336,7 +350,7 @@ public:
Common::String SuperclassIdentifier;
Common::String ServiceIdentifier;
BS_Service* (*CreateMethod)(BS_Kernel *);
BS_Service*(*CreateMethod)(BS_Kernel *);
};
template<class T>

16
engines/sword25/kernel/kernel_script.cpp
View file

@ -64,7 +64,7 @@ static int GetActiveServiceIdentifier(lua_State *L) {
BS_Kernel *pKernel = BS_Kernel::GetInstance();
BS_ASSERT(pKernel);
lua_pushstring(L, pKernel->GetActiveServiceIdentifier(luaL_checkstring(L,1)).c_str());
lua_pushstring(L, pKernel->GetActiveServiceIdentifier(luaL_checkstring(L, 1)).c_str());
return 1;
}
@ -87,7 +87,7 @@ static int GetSuperclassIdentifier(lua_State *L) {
BS_ASSERT(pKernel);
lua_pushstring(L, pKernel->GetSuperclassIdentifier(
static_cast<unsigned int>(luaL_checknumber(L,1))).c_str());
static_cast<unsigned int>(luaL_checknumber(L, 1))).c_str());
return 1;
}
@ -171,7 +171,7 @@ static int Crash(lua_State *L) {
static int ExecuteFile(lua_State *L) {
BS_Kernel *pKernel = BS_Kernel::GetInstance();
BS_ASSERT(pKernel);
BS_ScriptEngine * pSE = static_cast<BS_ScriptEngine *>(pKernel->GetService("script"));
BS_ScriptEngine *pSE = static_cast<BS_ScriptEngine *>(pKernel->GetService("script"));
BS_ASSERT(pSE);
lua_pushbooleancpp(L, pSE->ExecuteFile(luaL_checkstring(L, 1)));
@ -231,7 +231,7 @@ static int GetUsedMemory(lua_State *L) {
// -----------------------------------------------------------------------------
static const char * KERNEL_LIBRARY_NAME = "Kernel";
static const char *KERNEL_LIBRARY_NAME = "Kernel";
static const luaL_reg KERNEL_FUNCTIONS[] = {
"DisconnectService", DisconnectService,
@ -492,7 +492,7 @@ static int HasFocus(lua_State *L) {
// -----------------------------------------------------------------------------
static const char * WINDOW_LIBRARY_NAME = "Window";
static const char *WINDOW_LIBRARY_NAME = "Window";
static const luaL_reg WINDOW_FUNCTIONS[] = {
"IsVisible", IsVisible,
@ -622,7 +622,7 @@ static int DumpLockedResources(lua_State *L) {
// -----------------------------------------------------------------------------
static const char * RESOURCE_LIBRARY_NAME = "Resource";
static const char *RESOURCE_LIBRARY_NAME = "Resource";
static const luaL_reg RESOURCE_FUNCTIONS[] = {
"PrecacheResource", PrecacheResource,
@ -705,7 +705,7 @@ static int SaveGame(lua_State *L) {
// -----------------------------------------------------------------------------
static const char * PERSISTENCE_LIBRARY_NAME = "Persistence";
static const char *PERSISTENCE_LIBRARY_NAME = "Persistence";
static const luaL_reg PERSISTENCE_FUNCTIONS[] = {
"ReloadSlots", ReloadSlots,
@ -723,7 +723,7 @@ static const luaL_reg PERSISTENCE_FUNCTIONS[] = {
// -----------------------------------------------------------------------------
bool BS_Kernel::_RegisterScriptBindings() {
BS_ScriptEngine * pScript = static_cast<BS_ScriptEngine *>(GetService("script"));
BS_ScriptEngine *pScript = static_cast<BS_ScriptEngine *>(GetService("script"));
BS_ASSERT(pScript);
lua_State *L = static_cast<lua_State *>(pScript->GetScriptObject());
BS_ASSERT(L);

10
engines/sword25/kernel/log.cpp
View file

@ -46,10 +46,10 @@ static const size_t LOG_BUFFERSIZE = 1024 * 16;
// Logging will take place only when it's activated
#ifdef BS_ACTIVATE_LOGGING
Common::WriteStream* BS_Log::_LogFile = NULL;
Common::WriteStream *BS_Log::_LogFile = NULL;
bool BS_Log::_LineBegin = true;
const char * BS_Log::_Prefix = NULL;
const char * BS_Log::_File = NULL;
const char *BS_Log::_Prefix = NULL;
const char *BS_Log::_File = NULL;
int BS_Log::_Line = 0;
bool BS_Log::_AutoNewline = false;
Common::Array<BS_Log::LOG_LISTENER_CALLBACK> BS_Log::_LogListener;
@ -183,7 +183,7 @@ void BS_Log::LogDecorated(const char *Format, ...) {
_FlushLog();
}
int BS_Log::_WriteLog(const char * Message) {
int BS_Log::_WriteLog(const char *Message) {
if (!_LogFile) if (!_CreateLog()) return false;
Common::Array<LOG_LISTENER_CALLBACK>::iterator Iter = _LogListener.begin();
@ -207,7 +207,7 @@ void BS_Log_C(const char *Message) {
#else
void BS_Log_C(const char* Message) {};
void BS_Log_C(const char *Message) {};
#endif

47
engines/sword25/kernel/log.h
View file

@ -56,21 +56,30 @@ namespace Sword25 {
#define BS_LOG_EXTERRORLN BS_Log::SetPrefix(BS_LOG_PREFIX ": ERROR "), BS_Log::SetFile(__FILE__), BS_Log::SetLine(__LINE__), BS_Log::SetAutoNewline(true), BS_Log::LogDecorated
// Die Version der Logging-Klasse mit aktiviertem Logging
class BS_Log
{
class BS_Log {
public:
static void Clear();
static void Log(const char* Format, ...);
static void LogPrefix(const char* Prefix, const char* Format, ...);
static void LogDecorated(const char* Format, ...);
static void Log(const char *Format, ...);
static void LogPrefix(const char *Prefix, const char *Format, ...);
static void LogDecorated(const char *Format, ...);
static void SetPrefix(const char* Prefix) { _Prefix = Prefix; }
static void SetFile(const char* File) { _File = File; }
static void SetLine(int Line) { _Line = Line; }
static void SetAutoNewline(bool AutoNewline) { _AutoNewline = AutoNewline; }
static void SetPrefix(const char *Prefix) {
_Prefix = Prefix;
}
static void SetFile(const char *File) {
_File = File;
}
static void SetLine(int Line) {
_Line = Line;
}
static void SetAutoNewline(bool AutoNewline) {
_AutoNewline = AutoNewline;
}
typedef void (*LOG_LISTENER_CALLBACK)(const char *);
static void RegisterLogListener(LOG_LISTENER_CALLBACK Callback) { _LogListener.push_back(Callback); }
static void RegisterLogListener(LOG_LISTENER_CALLBACK Callback) {
_LogListener.push_back(Callback);
}
static bool IsListenerRegistered(LOG_LISTENER_CALLBACK Callback) {
Common::Array<LOG_LISTENER_CALLBACK>::iterator i;
for (i = _LogListener.begin(); i != _LogListener.end(); ++i) {
@ -82,17 +91,17 @@ public:
static void _CloseLog();
private:
static Common::WriteStream * _LogFile;
static Common::WriteStream *_LogFile;
static bool _LineBegin;
static const char * _Prefix;
static const char * _File;
static const char *_Prefix;
static const char *_File;
static int _Line;
static bool _AutoNewline;
static Common::Array<LOG_LISTENER_CALLBACK> _LogListener;
static bool _CreateLog();
static int _WriteLog(const char* Message);
static int _WriteLog(const char *Message);
static void _FlushLog();
};
@ -116,12 +125,12 @@ private:
class BS_Log {
public:
// This version implements all the various methods as empty stubs
static void Log(const char* Text, ...) {};
static void LogPrefix(const char* Prefix, const char* Format, ...) {};
static void LogDecorated(const char* Format, ...) {};
static void Log(const char *Text, ...) {};
static void LogPrefix(const char *Prefix, const char *Format, ...) {};
static void LogDecorated(const char *Format, ...) {};
static void SetPrefix(const char* Prefix) {};
static void SetFile(const char* File) {};
static void SetPrefix(const char *Prefix) {};
static void SetFile(const char *File) {};
static void SetLine(int Line) {};
static void SetAutoNewline(bool AutoNewline) {};

42
engines/sword25/kernel/memleaks.cpp
View file

@ -53,49 +53,42 @@
#include <stdio.h>
#include <string.h>
typedef struct
{
typedef struct {
unsigned int address;
unsigned int size;
std::string file;
unsigned int line;
} ALLOC_INFO;
static const char * MEMLEAK_LOG_FILE = "memory_leaks.txt";
static const char *MEMLEAK_LOG_FILE = "memory_leaks.txt";
static const unsigned int BUCKET_COUNT = 1021;
std::vector< std::vector<ALLOC_INFO> > TrackData(BUCKET_COUNT);
static unsigned int TotalSize = 0;
// Diese Klasse stellt sicher, dass beim Programmende, das Memory-Leak Log geschrieben wird.
static class LeakDumper
{
static class LeakDumper {
public:
LeakDumper() : OutputFilename(BS_FileSystemUtil::GetInstance().GetUserdataDirectory() + "\\" + MEMLEAK_LOG_FILE)
{
LeakDumper() : OutputFilename(BS_FileSystemUtil::GetInstance().GetUserdataDirectory() + "\\" + MEMLEAK_LOG_FILE) {
// Sicherstellen, dass das Ausgabeverzeichnis für die Datei existiert.
BS_FileSystemUtil::GetInstance().CreateDirectory(BS_FileSystemUtil::GetInstance().GetUserdataDirectory());
}
~LeakDumper()
{
~LeakDumper() {
DumpUnfreed(OutputFilename.c_str());
}
std::string OutputFilename;
} LeakDumperInstance;
void DumpUnfreed(const char * OutputFilename)
{
FILE * Log = fopen(OutputFilename, "w");
void DumpUnfreed(const char *OutputFilename) {
FILE *Log = fopen(OutputFilename, "w");
fputs("MEMORY LEAK REPORT:\n----------------------\n", Log);
std::vector< std::vector<ALLOC_INFO> >::iterator BucketIter = TrackData.begin();
for (; BucketIter != TrackData.end(); ++BucketIter)
{
for (; BucketIter != TrackData.end(); ++BucketIter) {
std::vector<ALLOC_INFO>::iterator Iter = (*BucketIter).begin();
for (; Iter != (*BucketIter).end(); ++Iter)
{
ALLOC_INFO & CurItem = (*Iter);
for (; Iter != (*BucketIter).end(); ++Iter) {
ALLOC_INFO &CurItem = (*Iter);
fprintf(Log, "%-50s LINE:%d ADDRESS:0x%x SIZE:%d\n",
CurItem.file.c_str(),
CurItem.line,
@ -109,8 +102,7 @@ void DumpUnfreed(const char * OutputFilename)
fclose(Log);
}
void AddTrack(unsigned int addr, unsigned int asize, const char *fname, unsigned int lnum)
{
void AddTrack(unsigned int addr, unsigned int asize, const char *fname, unsigned int lnum) {
std::vector<ALLOC_INFO> & CurBucket = TrackData[(addr >> 3) % BUCKET_COUNT];
ALLOC_INFO Info;
Info.address = addr;
@ -122,16 +114,12 @@ void AddTrack(unsigned int addr, unsigned int asize, const char *fname, unsign
TotalSize += asize;
}
void RemoveTrack(unsigned int addr)
{
if (addr != 0 && TrackData.size() == BUCKET_COUNT)
{
void RemoveTrack(unsigned int addr) {
if (addr != 0 && TrackData.size() == BUCKET_COUNT) {
std::vector<ALLOC_INFO> & CurBucket = TrackData[(addr >> 3) % BUCKET_COUNT];
std::vector<ALLOC_INFO>::iterator Iter = CurBucket.begin();
for (; Iter != CurBucket.end(); ++Iter)
{
if ((*Iter).address == addr)
{
for (; Iter != CurBucket.end(); ++Iter) {
if ((*Iter).address == addr) {
TotalSize -= (*Iter).size;
std::swap(*Iter, CurBucket.back());

11
engines/sword25/kernel/memleaks.h
View file

@ -43,25 +43,22 @@
#include <malloc.h>
void DumpUnfreed(const char * OutputFilename);
void DumpUnfreed(const char *OutputFilename);
void AddTrack(unsigned int addr, unsigned int asize, const char *fname, unsigned int lnum);
void RemoveTrack(unsigned int addr);
inline void * __cdecl operator new(unsigned int size, const char *file, int line)
{
inline void *__cdecl operator new(unsigned int size, const char *file, int line) {
void *ptr = malloc(size);
if (ptr) AddTrack((unsigned int)ptr, size, file, line);
return(ptr);
};
inline void __cdecl operator delete(void *p)
{
inline void __cdecl operator delete(void *p) {
RemoveTrack((unsigned int)p);
free(p);
};
inline void __cdecl operator delete[](void *p)
{
inline void __cdecl operator delete[](void *p) {
RemoveTrack((unsigned int)p);
free(p);
};

8
engines/sword25/kernel/memlog_off.h
View file

@ -35,8 +35,8 @@
// Deaktivieren der Memory-Leak Detektion
#ifdef BS_MEMLOG
#ifdef new
#undef new
#undef DEBUG_NEW
#endif
#ifdef new
#undef new
#undef DEBUG_NEW
#endif
#endif

8
engines/sword25/kernel/memlog_on.h
View file

@ -35,8 +35,8 @@
// Aktivieren der Memory-Leak Detektion
#ifdef BS_MEMLOG
#ifndef DEBUG_NEW
#define DEBUG_NEW new(__FILE__, __LINE__)
#endif
#define new DEBUG_NEW
#ifndef DEBUG_NEW
#define DEBUG_NEW new(__FILE__, __LINE__)
#endif
#define new DEBUG_NEW
#endif

4
engines/sword25/kernel/objectregistry.h
View file

@ -150,7 +150,9 @@ public:
protected:
// FIXME: I'm not entirely sure my current hash function is legitimate
struct ClassPointer_EqualTo {
bool operator()(const T *x, const T *y) const { return x == y; }
bool operator()(const T *x, const T *y) const {
return x == y;
}
};
struct ClassPointer_Hash {
uint operator()(const T *x) const {

2
engines/sword25/kernel/outputpersistenceblock.cpp
View file

@ -45,7 +45,7 @@
// -----------------------------------------------------------------------------
namespace {
const unsigned int INITIAL_BUFFER_SIZE = 1024 * 64;
const unsigned int INITIAL_BUFFER_SIZE = 1024 * 64;
}
namespace Sword25 {

8
engines/sword25/kernel/outputpersistenceblock.h
View file

@ -59,8 +59,12 @@ public:
void Write(const Common::String &String);
void Write(const void *BufferPtr, size_t Size);
const void *GetData() const { return &m_Data[0]; }
unsigned int GetDataSize() const { return m_Data.size(); }
const void *GetData() const {
return &m_Data[0];
}
unsigned int GetDataSize() const {
return m_Data.size();
}
private:
void WriteMarker(unsigned char Marker);

4
engines/sword25/kernel/persistable.h
View file

@ -44,8 +44,8 @@ class BS_Persistable {
public:
virtual ~BS_Persistable() {};
virtual bool Persist(BS_OutputPersistenceBlock & Writer) = 0;
virtual bool Unpersist(BS_InputPersistenceBlock & Reader) = 0;
virtual bool Persist(BS_OutputPersistenceBlock &Writer) = 0;
virtual bool Unpersist(BS_InputPersistenceBlock &Reader) = 0;
};
} // End of namespace Sword25

20
engines/sword25/kernel/persistenceblock.h
View file

@ -49,10 +49,18 @@ namespace Sword25 {
class BS_PersistenceBlock {
public:
static unsigned int GetSInt32Size() { return sizeof(signed int) + sizeof(unsigned char); }
static unsigned int GetUInt32Size() { return sizeof(unsigned int) + sizeof(unsigned char); }
static unsigned int GetFloat32Size() { return sizeof(float) + sizeof(unsigned char); }
static unsigned int GetBoolSize() { return sizeof(unsigned char) + sizeof(unsigned char); }
static unsigned int GetSInt32Size() {
return sizeof(signed int) + sizeof(unsigned char);
}
static unsigned int GetUInt32Size() {
return sizeof(unsigned int) + sizeof(unsigned char);
}
static unsigned int GetFloat32Size() {
return sizeof(float) + sizeof(unsigned char);
}
static unsigned int GetBoolSize() {
return sizeof(unsigned char) + sizeof(unsigned char);
}
static unsigned int GetStringSize(const Common::String &String) {
return static_cast<unsigned int>(sizeof(unsigned int) + String.size() + sizeof(unsigned char));
}
@ -90,7 +98,7 @@ protected:
private:
static bool IsBigEndian() {
unsigned int Dummy = 1;
unsigned char * DummyPtr = reinterpret_cast<unsigned char *>(&Dummy);
unsigned char *DummyPtr = reinterpret_cast<unsigned char *>(&Dummy);
return DummyPtr[0] == 0;
}
@ -103,7 +111,7 @@ private:
static void ReverseByteOrder(void *Ptr) {
// Reverses the byte order of the 32-bit word pointed to by Ptr
unsigned char * CharPtr = static_cast<unsigned char *>(Ptr);
unsigned char *CharPtr = static_cast<unsigned char *>(Ptr);
Swap(CharPtr[0], CharPtr[3]);
Swap(CharPtr[1], CharPtr[2]);
}

53
engines/sword25/kernel/persistenceservice.cpp
View file

@ -58,35 +58,35 @@ using namespace std;
// -----------------------------------------------------------------------------
namespace Sword25 {
const char * SAVEGAME_EXTENSION = ".b25s";
const char * SAVEGAME_DIRECTORY = "saves";
const char * FILE_MARKER = "BS25SAVEGAME";
const unsigned int SLOT_COUNT = 18;
const unsigned int FILE_COPY_BUFFER_SIZE = 1024 * 10;
const char *VERSIONID = "1";
const char *SAVEGAME_EXTENSION = ".b25s";
const char *SAVEGAME_DIRECTORY = "saves";
const char *FILE_MARKER = "BS25SAVEGAME";
const unsigned int SLOT_COUNT = 18;
const unsigned int FILE_COPY_BUFFER_SIZE = 1024 * 10;
const char *VERSIONID = "1";
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
Common::String GenerateSavegameFilename(unsigned int SlotID) {
Common::String GenerateSavegameFilename(unsigned int SlotID) {
Common::String oss;
oss += SlotID;
oss += SAVEGAME_EXTENSION;
return oss;
}
}
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
Common::String GenerateSavegamePath(unsigned int SlotID) {
Common::String GenerateSavegamePath(unsigned int SlotID) {
Common::String oss;
oss = BS_PersistenceService::GetSavegameDirectory();
oss += BS_FileSystemUtil::GetInstance().GetPathSeparator();
oss += GenerateSavegameFilename(SlotID);
return oss;
}
}
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
Common::String FormatTimestamp(TimeDate Time) {
Common::String FormatTimestamp(TimeDate Time) {
// In the original BS2.5 engine, this used a local object to show the date/time as as a string.
// For now in ScummVM it's being hardcoded to 'dd-MON-yyyy hh:mm:ss'
Common::String monthList[12] = {
@ -99,11 +99,11 @@ namespace Sword25 {
);
return Common::String(buffer);
}
}
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
Common::String LoadString(Common::InSaveFile *In, uint MaxSize = 999) {
Common::String LoadString(Common::InSaveFile *In, uint MaxSize = 999) {
Common::String Result;
char ch;
while ((ch = (char)In->readByte()) != '\0') {
@ -112,7 +112,7 @@ namespace Sword25 {
}
return Result;
}
}
}
namespace Sword25 {
@ -130,7 +130,9 @@ struct SavegameInformation {
unsigned int GamedataOffset;
unsigned int GamedataUncompressedLength;
SavegameInformation() { Clear(); }
SavegameInformation() {
Clear();
}
void Clear() {
IsOccupied = false;
@ -163,7 +165,7 @@ struct BS_PersistenceService::Impl {
void ReadSlotSavegameInformation(unsigned int SlotID) {
// Aktuelle Slotinformationen in den Ausgangszustand versetzen, er wird im Folgenden neu gefüllt.
SavegameInformation & CurSavegameInfo = m_SavegameInformations[SlotID];
SavegameInformation &CurSavegameInfo = m_SavegameInformations[SlotID];
CurSavegameInfo.Clear();
// Den Dateinamen für den Spielstand des Slots generieren.
@ -207,7 +209,7 @@ struct BS_PersistenceService::Impl {
// Construction / Destruction
// -----------------------------------------------------------------------------
BS_PersistenceService & BS_PersistenceService::GetInstance() {
BS_PersistenceService &BS_PersistenceService::GetInstance() {
static BS_PersistenceService Instance;
return Instance;
}
@ -246,7 +248,7 @@ Common::String BS_PersistenceService::GetSavegameDirectory() {
// -----------------------------------------------------------------------------
namespace {
bool CheckSlotID(unsigned int SlotID) {
bool CheckSlotID(unsigned int SlotID) {
// Überprüfen, ob die Slot-ID zulässig ist.
if (SlotID >= SLOT_COUNT) {
BS_LOG_ERRORLN("Tried to access an invalid slot (%d). Only slot ids from 0 to %d are allowed.", SlotID, SLOT_COUNT - 1);
@ -254,7 +256,7 @@ namespace {
} else {
return true;
}
}
}
}
// -----------------------------------------------------------------------------
@ -386,7 +388,7 @@ bool BS_PersistenceService::LoadGame(unsigned int SlotID) {
return false;
}
SavegameInformation & CurSavegameInfo = m_impl->m_SavegameInformations[SlotID];
SavegameInformation &CurSavegameInfo = m_impl->m_SavegameInformations[SlotID];
// Überprüfen, ob der Slot belegt ist.
if (!CurSavegameInfo.IsOccupied) {
@ -398,8 +400,7 @@ bool BS_PersistenceService::LoadGame(unsigned int SlotID) {
// Im Debug-Modus wird dieser Test übersprungen. Für das Testen ist es hinderlich auf die Einhaltung dieser strengen Bedingung zu bestehen,
// da sich die Versions-ID bei jeder Codeänderung mitändert.
#ifndef DEBUG
if (!CurSavegameInfo.IsCompatible)
{
if (!CurSavegameInfo.IsCompatible) {
BS_LOG_ERRORLN("Tried to load a savegame (%d) that is not compatible with this engine version.", SlotID);
return false;
}

4
engines/sword25/kernel/persistenceservice.h
View file

@ -71,12 +71,12 @@ public:
Common::String &GetSavegameDescription(unsigned int SlotID);
Common::String &GetSavegameFilename(unsigned int SlotID);
bool SaveGame(unsigned int SlotID, const Common::String & ScreenshotFilename);
bool SaveGame(unsigned int SlotID, const Common::String &ScreenshotFilename);
bool LoadGame(unsigned int SlotID);
private:
struct Impl;
Impl * m_impl;
Impl *m_impl;
};
} // End of namespace Sword25

19
engines/sword25/kernel/resmanager.cpp
View file

@ -53,7 +53,9 @@ BS_ResourceManager::~BS_ResourceManager() {
BS_LOG_WARNINGLN("Resource \"%s\" was not released.", (*Iter)->GetFileName().c_str());
// Set the lock count to zero
while ((*Iter)->GetLockCount() > 0) { (*Iter)->Release(); };
while ((*Iter)->GetLockCount() > 0) {
(*Iter)->Release();
};
// Delete the resource
delete(*Iter);
@ -74,7 +76,7 @@ BS_Resource *BS_ResourceManager::GetResourceByOrdinal(int Ord) const {
// Liste durchlaufen und die Resource mit dem gewünschten Index zurückgeben.
int CurOrd = 0;
Common::List<BS_Resource*>::const_iterator Iter = m_Resources.begin();
Common::List<BS_Resource *>::const_iterator Iter = m_Resources.begin();
for (; Iter != m_Resources.end(); ++Iter, ++CurOrd) {
if (CurOrd == Ord)
return (*Iter);
@ -174,7 +176,7 @@ BS_Resource *BS_ResourceManager::RequestResource(const Common::String &FileName)
* @param ForceReload Indicates whether the file should be reloaded if it's already in the cache.
* This is useful for files that may have changed in the interim
*/
bool BS_ResourceManager::PrecacheResource(const Common::String& FileName, bool ForceReload) {
bool BS_ResourceManager::PrecacheResource(const Common::String &FileName, bool ForceReload) {
// Get the absolute path to the file
Common::String UniqueFileName = GetUniqueFileName(FileName);
if (UniqueFileName == "")
@ -252,7 +254,7 @@ BS_Resource *BS_ResourceManager::LoadResource(const Common::String &FileName) {
* Returns the full path of a given resource filename.
* It will return an empty string if a path could not be created.
*/
Common::String BS_ResourceManager::GetUniqueFileName(const Common::String& FileName) const {
Common::String BS_ResourceManager::GetUniqueFileName(const Common::String &FileName) const {
// Get a pointer to the package manager
BS_PackageManager *pPackage = (BS_PackageManager *)m_KernelPtr->GetService("package");
if (!pPackage) {
@ -281,7 +283,7 @@ Common::List<BS_Resource *>::iterator BS_ResourceManager::DeleteResource(BS_Reso
Common::List<BS_Resource *>::iterator Result = m_Resources.erase(pResource->_Iterator);
// Delete the resource
delete (pDummy);
delete(pDummy);
// Return the iterator
return Result;
@ -292,14 +294,13 @@ Common::List<BS_Resource *>::iterator BS_ResourceManager::DeleteResource(BS_Reso
* @param UniqueFileName The absolute path and filename
* Gibt einen Pointer auf die angeforderte Resource zurück, oder NULL, wenn die Resourcen nicht geladen ist.
*/
BS_Resource * BS_ResourceManager::GetResource(const Common::String &UniqueFileName) const {
BS_Resource *BS_ResourceManager::GetResource(const Common::String &UniqueFileName) const {
// Determine whether the resource is already loaded
const Common::List<BS_Resource *>& HashBucket = m_ResourceHashTable[
BS_String::GetHash(UniqueFileName) % HASH_TABLE_BUCKETS];
{
Common::List<BS_Resource*>::const_iterator Iter = HashBucket.begin();
for (; Iter != HashBucket.end(); ++Iter)
{
Common::List<BS_Resource *>::const_iterator Iter = HashBucket.begin();
for (; Iter != HashBucket.end(); ++Iter) {
// Wenn die Resource gefunden wurde wird sie zurückgegeben.
if ((*Iter)->GetFileName() == UniqueFileName)
return *Iter;

31
engines/sword25/kernel/resmanager.h
View file

@ -48,7 +48,7 @@ class BS_Resource;
class BS_Kernel;
class BS_ResourceManager {
friend class BS_Kernel;
friend class BS_Kernel;
public:
/**
@ -63,12 +63,14 @@ public:
* @param ForceReload Indicates whether the file should be reloaded if it's already in the cache.
* This is useful for files that may have changed in the interim
*/
bool PrecacheResource(const Common::String& FileName, bool ForceReload = false);
bool PrecacheResource(const Common::String &FileName, bool ForceReload = false);
/**
* Returns the number of loaded resources
*/
int GetResourceCount() const { return static_cast<int>(m_Resources.size()); }
int GetResourceCount() const {
return static_cast<int>(m_Resources.size());
}
/**
* Returns a resource by it's ordinal index. Returns NULL if any error occurs
@ -82,7 +84,7 @@ public:
* BS_ResourceService, and thus helps all resource services in the ResourceManager list
* @param pService Which service
*/
bool RegisterResourceService(BS_ResourceService* pService);
bool RegisterResourceService(BS_ResourceService *pService);
/**
* Releases all resources that are not locked.
@ -92,7 +94,9 @@ public:
/**
* Returns the maximum memory the kernel has used
*/
int GetMaxMemoryUsage() const { return m_MaxMemoryUsage; }
int GetMaxMemoryUsage() const {
return m_MaxMemoryUsage;
}
/**
* Specifies the maximum amount of memory the engine is allowed to use.
@ -106,13 +110,17 @@ public:
* Specifies whether a warning is written to the log when a cache miss occurs.
* THe default value is "false".
*/
bool IsLogCacheMiss() const { return m_LogCacheMiss; }
bool IsLogCacheMiss() const {
return m_LogCacheMiss;
}
/**
* Sets whether warnings are written to the log if a cache miss occurs.
* @param Flag If "true", then future warnings will be logged
*/
void SetLogCacheMiss(bool Flag) { m_LogCacheMiss = Flag; }
void SetLogCacheMiss(bool Flag) {
m_LogCacheMiss = Flag;
}
/**
* Writes the names of all currently locked resources to the log file
@ -124,15 +132,14 @@ private:
* Creates a new resource manager
* Only the BS_Kernel class can generate copies this class. Thus, the constructor is private
*/
BS_ResourceManager(BS_Kernel* pKernel) :
BS_ResourceManager(BS_Kernel *pKernel) :
m_KernelPtr(pKernel),
m_MaxMemoryUsage(100000000),
m_LogCacheMiss(false)
{};
virtual ~BS_ResourceManager();
enum
{
enum {
HASH_TABLE_BUCKETS = 256
};
@ -159,7 +166,7 @@ private:
/**
* Deletes a resource, removes it from the lists, and updates m_UsedMemory
*/
Common::List<BS_Resource*>::iterator DeleteResource(BS_Resource *pResource);
Common::List<BS_Resource *>::iterator DeleteResource(BS_Resource *pResource);
/**
* Returns a pointer to a loaded resource. If any error occurs, NULL will be returned.
@ -173,7 +180,7 @@ private:
*/
void DeleteResourcesIfNecessary();
BS_Kernel * m_KernelPtr;
BS_Kernel *m_KernelPtr;
unsigned int m_MaxMemoryUsage;
Common::Array<BS_ResourceService *> m_ResourceServices;
Common::List<BS_Resource *> m_Resources;

22
engines/sword25/kernel/resource.h
View file

@ -45,7 +45,7 @@ class BS_Kernel;
class BS_ResourceManager;
class BS_Resource {
friend class BS_ResourceManager;
friend class BS_ResourceManager;
public:
enum RESOURCE_TYPES {
@ -62,7 +62,9 @@ public:
* Prevents the resource from being released.
* @remarks This method allows a resource to be locked multiple times.
**/
void AddReference() { ++_RefCount; }
void AddReference() {
++_RefCount;
}
/**
* Cancels a previous lock
@ -75,22 +77,30 @@ public:
* Returns the current lock count for the resource
* @return The current lock count
**/
int GetLockCount() const { return _RefCount; }
int GetLockCount() const {
return _RefCount;
}
/**
* Returns the absolute path of the given resource
*/
const Common::String &GetFileName() const { return _FileName; }
const Common::String &GetFileName() const {
return _FileName;
}
/**
* Returns the hash of the filename of a resource
*/
unsigned int GetFileNameHash() const { return _FileNameHash; }
unsigned int GetFileNameHash() const {
return _FileNameHash;
}
/**
* Returns a resource's type
*/
unsigned int GetType() const { return _Type; }
unsigned int GetType() const {
return _Type;
}
protected:
virtual ~BS_Resource() {};

11
engines/sword25/kernel/resservice.h
View file

@ -47,9 +47,8 @@ class BS_Resource;
class BS_ResourceService : public BS_Service {
public:
BS_ResourceService(BS_Kernel* pKernel) : BS_Service(pKernel)
{
BS_ResourceManager* pResource = pKernel->GetResourceManager();
BS_ResourceService(BS_Kernel *pKernel) : BS_Service(pKernel) {
BS_ResourceManager *pResource = pKernel->GetResourceManager();
pResource->RegisterResourceService(this);
}
@ -67,7 +66,7 @@ public:
* @param FileName Dateiname
* @return Returns true if the resource can be loaded.
*/
virtual bool CanLoadResource(const Common::String& FileName) = 0;
virtual bool CanLoadResource(const Common::String &FileName) = 0;
protected:
// Alternative methods for classes BS_ResourceService
@ -89,7 +88,9 @@ private:
if (*Pattern == '*') {
// Use a copy of the pattern pointer so as not to destroy the current state
const char *PatternCopy = Pattern;
while (*PatternCopy == '*') { PatternCopy++; }
while (*PatternCopy == '*') {
PatternCopy++;
}
if (!*PatternCopy) return true;
}
// 2. The string is over, but the patern is not -> FALSE

6
engines/sword25/kernel/service.h
View file

@ -57,12 +57,14 @@ class BS_Kernel;
class BS_Service {
private:
BS_Kernel * _pKernel;
BS_Kernel *_pKernel;
protected:
BS_Service(BS_Kernel *pKernel) : _pKernel(pKernel) {};
BS_Kernel* GetKernel() const { return _pKernel; }
BS_Kernel *GetKernel() const {
return _pKernel;
}
public:
virtual ~BS_Service() {};

17
engines/sword25/kernel/string.h
View file

@ -52,7 +52,9 @@ inline bool ToInt(const Common::String &Str, int &Result) {
Common::String::const_iterator Iter = Str.begin();
// Skip whitespaces
while (*Iter && (*Iter == ' ' || *Iter == '\t')) { ++Iter; }
while (*Iter && (*Iter == ' ' || *Iter == '\t')) {
++Iter;
}
if (Iter == Str.end()) return false;
// Read sign, if available
@ -60,19 +62,22 @@ inline bool ToInt(const Common::String &Str, int &Result) {
if (*Iter == '-') {
IsNegative = true;
++Iter;
}
else if (*Iter == '+')
} else if (*Iter == '+')
++Iter;
// Skip whitespaces
while (*Iter && (*Iter == ' ' || *Iter == '\t')) { ++Iter; }
if (Iter ==Str.end()) return false;
while (*Iter && (*Iter == ' ' || *Iter == '\t')) {
++Iter;
}
if (Iter == Str.end()) return false;
// Convert string to integer
Result = 0;
while (Iter != Str.end()) {
if (*Iter < '0' || *Iter > '9') {
while (*Iter && (*Iter == ' ' || *Iter == '\t')) { ++Iter; }
while (*Iter && (*Iter == ' ' || *Iter == '\t')) {
++Iter;
}
if (Iter != Str.end()) return false;
break;
}

2
engines/sword25/kernel/window.cpp
View file

@ -42,7 +42,7 @@ namespace Sword25 {
// Erstellt ein Fenster des GUI des aktuellen Betriebssystems
BS_Window *BS_Window::CreateBSWindow(int X, int Y, int Width, int Height, bool Visible) {
// Fenster erstellen
BS_Window *pWindow = (BS_Window*) new BS_ScummVMWindow(X, Y, Width, Height, Visible);
BS_Window *pWindow = (BS_Window *) new BS_ScummVMWindow(X, Y, Width, Height, Visible);
// Falls das Fenster erfolgreich initialisiert wurde, wird ein Pointer auf das Fensterobjekt
// zurückgegeben

2
engines/sword25/kernel/window.h
View file

@ -63,7 +63,7 @@ protected:
bool _CloseWanted;
public:
virtual ~BS_Window(){};
virtual ~BS_Window() {};
/**
* Returns the visibility of the window.

46
engines/sword25/math/geometry_script.cpp
View file

@ -67,11 +67,9 @@ namespace Sword25 {
static void *my_checkudata(lua_State *L, int ud, const char *tname) {
int top = lua_gettop(L);
void * p = lua_touserdata(L, ud);
if (p != NULL) /* value is a userdata? */
{
if (lua_getmetatable(L, ud)) /* does it have a metatable? */
{
void *p = lua_touserdata(L, ud);
if (p != NULL) { /* value is a userdata? */
if (lua_getmetatable(L, ud)) { /* does it have a metatable? */
// lua_getfield(L, LUA_REGISTRYINDEX, tname); /* get correct metatable */
BS_LuaBindhelper::GetMetatable(L, tname);
/* does it have the correct mt? */
@ -89,7 +87,7 @@ static void *my_checkudata(lua_State *L, int ud, const char *tname) {
// -----------------------------------------------------------------------------
static void NewUintUserData(lua_State *L, unsigned int Value) {
void * UserData = lua_newuserdata(L, sizeof(Value));
void *UserData = lua_newuserdata(L, sizeof(Value));
memcpy(UserData, &Value, sizeof(Value));
}
@ -157,8 +155,7 @@ static void TablePolygonToPolygon(lua_State *L, BS_Polygon &Polygon) {
Vertecies.reserve(VertexCount);
// Create Vertecies
for (int i = 0; i < VertexCount; i++)
{
for (int i = 0; i < VertexCount; i++) {
// X Value
lua_rawgeti(L, -1, (i * 2) + 1);
int X = static_cast<int>(lua_tonumber(L, -1));
@ -220,7 +217,7 @@ static unsigned int TableRegionToRegion(lua_State *L, const char *ClassName) {
int FirstElementType = lua_type(L, -1);
lua_pop(L, 1);
switch(FirstElementType) {
switch (FirstElementType) {
case LUA_TNUMBER: {
BS_Polygon Polygon;
TablePolygonToPolygon(L, Polygon);
@ -268,8 +265,7 @@ static unsigned int TableRegionToRegion(lua_State *L, const char *ClassName) {
// -----------------------------------------------------------------------------
static void NewUserdataRegion(lua_State *L, const char *ClassName)
{
static void NewUserdataRegion(lua_State *L, const char *ClassName) {
// Region due to the Lua code to create
// Any errors that occur will be intercepted to the luaL_error
unsigned int RegionHandle = TableRegionToRegion(L, ClassName);
@ -308,7 +304,7 @@ static const luaL_reg GEO_FUNCTIONS[] = {
// -----------------------------------------------------------------------------
static BS_Region * CheckRegion(lua_State *L) {
static BS_Region *CheckRegion(lua_State *L) {
// The first parameter must be of type 'userdata', and the Metatable class Geo.Region or Geo.WalkRegion
unsigned int *RegionHandlePtr;
if ((RegionHandlePtr = reinterpret_cast<unsigned int *>(my_checkudata(L, 1, REGION_CLASS_NAME))) != 0 ||
@ -325,7 +321,7 @@ static BS_Region * CheckRegion(lua_State *L) {
// -----------------------------------------------------------------------------
static int R_IsValid(lua_State *L) {
BS_Region * pR = CheckRegion(L);
BS_Region *pR = CheckRegion(L);
BS_ASSERT(pR);
lua_pushbooleancpp(L, pR->IsValid());
@ -335,7 +331,7 @@ static int R_IsValid(lua_State *L) {
// -----------------------------------------------------------------------------
static int R_GetX(lua_State *L) {
BS_Region * pR = CheckRegion(L);
BS_Region *pR = CheckRegion(L);
BS_ASSERT(pR);
lua_pushnumber(L, pR->GetPosX());
@ -345,7 +341,7 @@ static int R_GetX(lua_State *L) {
// -----------------------------------------------------------------------------
static int R_GetY(lua_State *L) {
BS_Region * pR = CheckRegion(L);
BS_Region *pR = CheckRegion(L);
BS_ASSERT(pR);
lua_pushnumber(L, pR->GetPosY());
@ -355,7 +351,7 @@ static int R_GetY(lua_State *L) {
// -----------------------------------------------------------------------------
static int R_GetPos(lua_State *L) {
BS_Region * pR = CheckRegion(L);
BS_Region *pR = CheckRegion(L);
BS_ASSERT(pR);
BS_Vertex::VertexToLuaVertex(L, pR->GetPosition());
@ -365,7 +361,7 @@ static int R_GetPos(lua_State *L) {
// -----------------------------------------------------------------------------
static int R_IsPointInRegion(lua_State *L) {
BS_Region * pR = CheckRegion(L);
BS_Region *pR = CheckRegion(L);
BS_ASSERT(pR);
BS_Vertex Vertex;
@ -377,7 +373,7 @@ static int R_IsPointInRegion(lua_State *L) {
// -----------------------------------------------------------------------------
static int R_SetPos(lua_State *L) {
BS_Region * pR = CheckRegion(L);
BS_Region *pR = CheckRegion(L);
BS_ASSERT(pR);
BS_Vertex Vertex;
@ -390,7 +386,7 @@ static int R_SetPos(lua_State *L) {
// -----------------------------------------------------------------------------
static int R_SetX(lua_State *L) {
BS_Region * pR = CheckRegion(L);
BS_Region *pR = CheckRegion(L);
BS_ASSERT(pR);
pR->SetPosX(static_cast<int>(luaL_checknumber(L, 2)));
@ -401,7 +397,7 @@ static int R_SetX(lua_State *L) {
// -----------------------------------------------------------------------------
static int R_SetY(lua_State *L) {
BS_Region * pR = CheckRegion(L);
BS_Region *pR = CheckRegion(L);
BS_ASSERT(pR);
pR->SetPosY(static_cast<int>(luaL_checknumber(L, 2)));
@ -432,7 +428,7 @@ static void DrawRegion(const BS_Region &Region, unsigned int Color, const BS_Ver
// -----------------------------------------------------------------------------
static int R_Draw(lua_State *L) {
BS_Region * pR = CheckRegion(L);
BS_Region *pR = CheckRegion(L);
BS_ASSERT(pR);
switch (lua_gettop(L)) {
@ -457,7 +453,7 @@ static int R_Draw(lua_State *L) {
// -----------------------------------------------------------------------------
static int R_GetCentroid(lua_State *L) {
BS_Region * RPtr = CheckRegion(L);
BS_Region *RPtr = CheckRegion(L);
BS_ASSERT(RPtr);
BS_Vertex::VertexToLuaVertex(L, RPtr->GetCentroid());
@ -468,7 +464,7 @@ static int R_GetCentroid(lua_State *L) {
// -----------------------------------------------------------------------------
static int R_Delete(lua_State *L) {
BS_Region * pR = CheckRegion(L);
BS_Region *pR = CheckRegion(L);
BS_ASSERT(pR);
delete pR;
return 0;
@ -540,9 +536,9 @@ static const luaL_reg WALKREGION_METHODS[] = {
// -----------------------------------------------------------------------------
bool BS_Geometry::_RegisterScriptBindings() {
BS_Kernel * pKernel = BS_Kernel::GetInstance();
BS_Kernel *pKernel = BS_Kernel::GetInstance();
BS_ASSERT(pKernel);
BS_ScriptEngine * pScript = static_cast<BS_ScriptEngine *>(pKernel->GetService("script"));
BS_ScriptEngine *pScript = static_cast<BS_ScriptEngine *>(pKernel->GetService("script"));
BS_ASSERT(pScript);
lua_State *L = static_cast< lua_State *>(pScript->GetScriptObject());
BS_ASSERT(L);

2
engines/sword25/math/line.h
View file

@ -140,7 +140,7 @@ public:
if (Class1 == ON || Class2 == ON || Class3 == ON || Class4 == ON) return false;
return ((Class1 == LEFT) ^ (Class2 == LEFT)) && ((Class3 == LEFT) ^ (Class4 == LEFT));
return ((Class1 == LEFT) ^(Class2 == LEFT)) && ((Class3 == LEFT) ^(Class4 == LEFT));
}
/**

2
engines/sword25/math/polygon.cpp
View file

@ -407,7 +407,7 @@ bool BS_Polygon::IsPointInPolygon(const BS_Vertex &Point, bool EdgesBelongToPoly
}
// The point is on an adge, if the number of left and right intersections have the same even numbers
if ((Rcross % 2 ) != (Lcross % 2 )) return EdgesBelongToPolygon;
if ((Rcross % 2) != (Lcross % 2)) return EdgesBelongToPolygon;
// The point is strictly inside the polygon if and only if the number of overlaps is odd
if ((Rcross % 2) == 1) return true;

44
engines/sword25/math/rect.h
View file

@ -54,9 +54,13 @@ public:
BS_Rect(int16 w, int16 h) : Common::Rect(w, h) {}
BS_Rect(int16 x1, int16 y1, int16 x2, int16 y2) : Common::Rect(x1, y1, x2, y2) {}
void Move(int DeltaX, int DeltaY) { translate(DeltaX, DeltaY); }
void Move(int DeltaX, int DeltaY) {
translate(DeltaX, DeltaY);
}
bool DoesIntersect(const BS_Rect &Rect_) const { return intersects(Rect_); }
bool DoesIntersect(const BS_Rect &Rect_) const {
return intersects(Rect_);
}
bool Intersect(const BS_Rect &Rect_, BS_Rect &Result) const {
Result = Rect_;
@ -70,23 +74,41 @@ public:
Result.extend(*this);
}
int GetWidth() const { return width(); }
int GetWidth() const {
return width();
}
int GetHeight() const { return height(); }
int GetHeight() const {
return height();
}
int GetArea() const { return width() * height(); }
int GetArea() const {
return width() * height();
}
bool operator==(const BS_Rect &rhs) const { return equals(rhs); }
bool operator==(const BS_Rect &rhs) const {
return equals(rhs);
}
bool operator!= (const BS_Rect &rhs) const { return !equals(rhs); }
bool operator!= (const BS_Rect &rhs) const {
return !equals(rhs);
}
bool IsValid() const { return isValidRect(); }
bool IsValid() const {
return isValidRect();
}
bool IsPointInRect(const BS_Vertex &Vertex) const { return contains(Vertex.X, Vertex.Y); }
bool IsPointInRect(const BS_Vertex &Vertex) const {
return contains(Vertex.X, Vertex.Y);
}
bool IsPointInRect(int X, int Y) const { return contains(X, Y); }
bool IsPointInRect(int X, int Y) const {
return contains(X, Y);
}
bool ContainsRect(const BS_Rect &OtherRect) const { return contains(OtherRect); }
bool ContainsRect(const BS_Rect &OtherRect) const {
return contains(OtherRect);
}
};
} // End of namespace Sword25

12
engines/sword25/math/region.cpp
View file

@ -60,7 +60,7 @@ BS_Region::BS_Region(BS_InputPersistenceBlock &Reader, unsigned int Handle) : m_
// -----------------------------------------------------------------------------
unsigned int BS_Region::Create(REGION_TYPE Type) {
BS_Region * RegionPtr = NULL;
BS_Region *RegionPtr = NULL;
switch (Type) {
case RT_REGION:
RegionPtr = new BS_Region();
@ -79,7 +79,7 @@ unsigned int BS_Region::Create(REGION_TYPE Type) {
// -----------------------------------------------------------------------------
unsigned int BS_Region::Create(BS_InputPersistenceBlock & Reader, unsigned int Handle) {
unsigned int BS_Region::Create(BS_InputPersistenceBlock &Reader, unsigned int Handle) {
// Read type
unsigned int Type;
Reader.Read(Type);
@ -105,7 +105,7 @@ BS_Region::~BS_Region() {
// -----------------------------------------------------------------------------
bool BS_Region::Init(const BS_Polygon& Contour, const Common::Array<BS_Polygon> *pHoles) {
bool BS_Region::Init(const BS_Polygon &Contour, const Common::Array<BS_Polygon> *pHoles) {
// Reset object state
m_Valid = false;
m_Position = BS_Vertex(0, 0);
@ -125,7 +125,7 @@ bool BS_Region::Init(const BS_Polygon& Contour, const Common::Array<BS_Polygon>
// Place the hole polygons in the following positions
if (pHoles) {
for (unsigned int i = 0; i< pHoles->size(); ++i) {
for (unsigned int i = 0; i < pHoles->size(); ++i) {
m_Polygons.push_back(BS_Polygon());
m_Polygons[i + 1].Init((*pHoles)[i].VertexCount, (*pHoles)[i].Vertecies);
m_Polygons[i + 1].EnsureCWOrder();
@ -201,7 +201,7 @@ bool BS_Region::IsPointInRegion(int X, int Y) const {
if (m_Polygons[0].IsPointInPolygon(X, Y, true)) {
// Test whether the point is in a hole
for (unsigned int i = 1; i < m_Polygons.size(); i++) {
if (m_Polygons[i].IsPointInPolygon(X,Y, false))
if (m_Polygons[i].IsPointInPolygon(X, Y, false))
return false;
}
@ -233,7 +233,7 @@ BS_Vertex BS_Region::FindClosestRegionPoint(const BS_Vertex &Point) const {
}
}
const BS_Polygon & Polygon = m_Polygons[PolygonIdx];
const BS_Polygon &Polygon = m_Polygons[PolygonIdx];
BS_ASSERT(Polygon.VertexCount > 1);

24
engines/sword25/math/region.h
View file

@ -94,22 +94,30 @@ public:
* @return Returns true if the object is in a valid state, otherwise false.
* @remark Invalid objects can be made valid by calling Init with a valid state.
*/
bool IsValid() const { return m_Valid; }
bool IsValid() const {
return m_Valid;
}
/**
* Returns the position of the region
*/
const BS_Vertex &GetPosition() const { return m_Position; }
const BS_Vertex &GetPosition() const {
return m_Position;
}
/**
* Returns the X position of the region
*/
int GetPosX() const { return m_Position.X; }
int GetPosX() const {
return m_Position.X;
}
/**
* Returns the Y position of the region
*/
int GetPosY() const { return m_Position.Y; }
int GetPosY() const {
return m_Position.Y;
}
/**
* Indicates whether a point is inside the region
@ -129,12 +137,16 @@ public:
/**
* Returns the countour of the region
*/
const BS_Polygon &GetContour() const { return m_Polygons[0]; }
const BS_Polygon &GetContour() const {
return m_Polygons[0];
}
/**
* Returns the number of polygons in the hole region
*/
int GetHoleCount() const { return static_cast<int>(m_Polygons.size() - 1); }
int GetHoleCount() const {
return static_cast<int>(m_Polygons.size() - 1);
}
/**
* Returns a specific hole polygon in the region

Some files were not shown because too many files have changed in this diff Show more