SWORD25: Mass-eliminating of BS_ prefix in fmv/ and gfx/

svn-id: r53258

1 files changed, 144 insertions, 144 deletions

diff --git a/engines/sword25/gfx/graphicengine_script.cpp b/engines/sword25/gfx/graphicengine_script.cpp
index 07a867bf6c..7447e0237b 100644
--- a/engines/sword25/gfx/graphicengine_script.cpp
+++ b/engines/sword25/gfx/graphicengine_script.cpp
@@ -143,11 +143,11 @@ static void NewUintUserData(lua_State *L, unsigned int Value) {
 
 // -----------------------------------------------------------------------------
 
-static BS_AnimationTemplate *CheckAnimationTemplate(lua_State *L, int idx = 1) {
+static AnimationTemplate *CheckAnimationTemplate(lua_State *L, int idx = 1) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.AnimationTemplate
 	unsigned int AnimationTemplateHandle;
 	if ((AnimationTemplateHandle = *reinterpret_cast<unsigned int *>(my_checkudata(L, idx, ANIMATION_TEMPLATE_CLASS_NAME))) != 0) {
-		BS_AnimationTemplate *AnimationTemplatePtr = BS_AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle);
+		AnimationTemplate *AnimationTemplatePtr = AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle);
 		if (!AnimationTemplatePtr)
 			luaL_error(L, "The animation template with the handle %d does no longer exist.", AnimationTemplateHandle);
 		return AnimationTemplatePtr;
@@ -161,8 +161,8 @@ static BS_AnimationTemplate *CheckAnimationTemplate(lua_State *L, int idx = 1) {
 // -----------------------------------------------------------------------------
 
 static int NewAnimationTemplate(lua_State *L) {
-	unsigned int AnimationTemplateHandle = BS_AnimationTemplate::Create(luaL_checkstring(L, 1));
-	BS_AnimationTemplate *AnimationTemplatePtr = BS_AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle);
+	unsigned int AnimationTemplateHandle = AnimationTemplate::Create(luaL_checkstring(L, 1));
+	AnimationTemplate *AnimationTemplatePtr = AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle);
 	if (AnimationTemplatePtr && AnimationTemplatePtr->IsValid()) {
 		NewUintUserData(L, AnimationTemplateHandle);
 		//luaL_getmetatable(L, ANIMATION_TEMPLATE_CLASS_NAME);
@@ -179,7 +179,7 @@ static int NewAnimationTemplate(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int AT_AddFrame(lua_State *L) {
-	BS_AnimationTemplate *pAT = CheckAnimationTemplate(L);
+	AnimationTemplate *pAT = CheckAnimationTemplate(L);
 	pAT->AddFrame(static_cast<int>(luaL_checknumber(L, 2)));
 	return 0;
 }
@@ -187,22 +187,22 @@ static int AT_AddFrame(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int AT_SetFrame(lua_State *L) {
-	BS_AnimationTemplate *pAT = CheckAnimationTemplate(L);
+	AnimationTemplate *pAT = CheckAnimationTemplate(L);
 	pAT->SetFrame(static_cast<int>(luaL_checknumber(L, 2)), static_cast<int>(luaL_checknumber(L, 3)));
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-static bool AnimationTypeStringToNumber(const char *TypeString, BS_Animation::ANIMATION_TYPES &Result) {
+static bool AnimationTypeStringToNumber(const char *TypeString, Animation::ANIMATION_TYPES &Result) {
 	if (strcmp(TypeString, "jojo") == 0) {
-		Result = BS_Animation::AT_JOJO;
+		Result = Animation::AT_JOJO;
 		return true;
 	} else if (strcmp(TypeString, "loop") == 0) {
-		Result = BS_Animation::AT_LOOP;
+		Result = Animation::AT_LOOP;
 		return true;
 	} else if (strcmp(TypeString, "oneshot") == 0) {
-		Result = BS_Animation::AT_ONESHOT;
+		Result = Animation::AT_ONESHOT;
 		return true;
 	} else
 		return false;
@@ -211,8 +211,8 @@ static bool AnimationTypeStringToNumber(const char *TypeString, BS_Animation::AN
 // -----------------------------------------------------------------------------
 
 static int AT_SetAnimationType(lua_State *L) {
-	BS_AnimationTemplate *pAT = CheckAnimationTemplate(L);
-	BS_Animation::ANIMATION_TYPES AnimationType;
+	AnimationTemplate *pAT = CheckAnimationTemplate(L);
+	Animation::ANIMATION_TYPES AnimationType;
 	if (AnimationTypeStringToNumber(luaL_checkstring(L, 2), AnimationType)) {
 		pAT->SetAnimationType(AnimationType);
 	} else {
@@ -225,7 +225,7 @@ static int AT_SetAnimationType(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int AT_SetFPS(lua_State *L) {
-	BS_AnimationTemplate *pAT = CheckAnimationTemplate(L);
+	AnimationTemplate *pAT = CheckAnimationTemplate(L);
 	pAT->SetFPS(static_cast<int>(luaL_checknumber(L, 2)));
 	return 0;
 }
@@ -233,7 +233,7 @@ static int AT_SetFPS(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int AT_Finalize(lua_State *L) {
-	BS_AnimationTemplate *pAT = CheckAnimationTemplate(L);
+	AnimationTemplate *pAT = CheckAnimationTemplate(L);
 	delete pAT;
 	return 0;
 }
@@ -251,10 +251,10 @@ static const luaL_reg ANIMATION_TEMPLATE_METHODS[] = {
 
 // -----------------------------------------------------------------------------
 
-static BS_GraphicEngine *GetGE() {
+static GraphicEngine *GetGE() {
 	BS_Kernel *pKernel = BS_Kernel::GetInstance();
 	BS_ASSERT(pKernel);
-	BS_GraphicEngine *pGE = static_cast<BS_GraphicEngine *>(pKernel->GetService("gfx"));
+	GraphicEngine *pGE = static_cast<GraphicEngine *>(pKernel->GetService("gfx"));
 	BS_ASSERT(pGE);
 	return pGE;
 }
@@ -262,7 +262,7 @@ static BS_GraphicEngine *GetGE() {
 // -----------------------------------------------------------------------------
 
 static int Init(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	switch (lua_gettop(L)) {
 	case 0:
@@ -294,7 +294,7 @@ static int Init(lua_State *L) {
 #endif
 
 	// Main-Panel zum Gfx-Modul hinzufügen
-	BS_RenderObjectPtr<BS_Panel> MainPanelPtr(GetGE()->GetMainPanel());
+	RenderObjectPtr<Panel> MainPanelPtr(GetGE()->GetMainPanel());
 	BS_ASSERT(MainPanelPtr.IsValid());
 
 	lua_pushstring(L, GFX_LIBRARY_NAME);
@@ -324,7 +324,7 @@ static int Init(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int StartFrame(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	if (lua_gettop(L) == 0)
 		lua_pushbooleancpp(L, pGE->StartFrame());
@@ -337,7 +337,7 @@ static int StartFrame(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int EndFrame(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	lua_pushbooleancpp(L, pGE->EndFrame());
 
@@ -347,13 +347,13 @@ static int EndFrame(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int DrawDebugLine(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	BS_Vertex Start;
 	BS_Vertex End;
 	BS_Vertex::LuaVertexToVertex(L, 1, Start);
 	BS_Vertex::LuaVertexToVertex(L, 2, End);
-	pGE->DrawDebugLine(Start, End, BS_GraphicEngine::LuaColorToARGBColor(L, 3));
+	pGE->DrawDebugLine(Start, End, GraphicEngine::LuaColorToARGBColor(L, 3));
 
 	return 0;
 }
@@ -361,7 +361,7 @@ static int DrawDebugLine(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int GetDisplayWidth(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetDisplayWidth());
 
@@ -371,7 +371,7 @@ static int GetDisplayWidth(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int GetDisplayHeight(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetDisplayHeight());
 
@@ -381,7 +381,7 @@ static int GetDisplayHeight(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int GetBitDepth(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetBitDepth());
 
@@ -391,7 +391,7 @@ static int GetBitDepth(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int SetVsync(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	pGE->SetVsync(lua_tobooleancpp(L, 1));
 
@@ -401,7 +401,7 @@ static int SetVsync(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int IsVsync(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	lua_pushbooleancpp(L, pGE->GetVsync());
 
@@ -411,7 +411,7 @@ static int IsVsync(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int IsWindowed(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	lua_pushbooleancpp(L, pGE->IsWindowed());
 
@@ -421,7 +421,7 @@ static int IsWindowed(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int GetFPSCount(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetFPSCount());
 
@@ -431,7 +431,7 @@ static int GetFPSCount(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int GetLastFrameDuration(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetLastFrameDuration());
 
@@ -441,7 +441,7 @@ static int GetLastFrameDuration(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int StopMainTimer(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 	pGE->StopMainTimer();
 	return 0;
 }
@@ -449,7 +449,7 @@ static int StopMainTimer(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int ResumeMainTimer(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 	pGE->ResumeMainTimer();
 	return 0;
 }
@@ -457,7 +457,7 @@ static int ResumeMainTimer(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int GetSecondaryFrameDuration(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetSecondaryFrameDuration());
 
@@ -467,7 +467,7 @@ static int GetSecondaryFrameDuration(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int SaveScreenshot(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 	lua_pushbooleancpp(L, pGE->SaveScreenshot(luaL_checkstring(L, 1)));
 	return 1;
 }
@@ -475,7 +475,7 @@ static int SaveScreenshot(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int SaveThumbnailScreenshot(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 	lua_pushbooleancpp(L, pGE->SaveThumbnailScreenshot(luaL_checkstring(L, 1)));
 	return 1;
 }
@@ -483,7 +483,7 @@ static int SaveThumbnailScreenshot(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int GetRepaintedPixels(lua_State *L) {
-	BS_GraphicEngine *pGE = GetGE();
+	GraphicEngine *pGE = GetGE();
 	lua_pushnumber(L, static_cast<lua_Number>(pGE->GetRepaintedPixels()));
 	return 1;
 }
@@ -515,14 +515,14 @@ static const luaL_reg GFX_FUNCTIONS[] = {
 
 // -----------------------------------------------------------------------------
 
-static BS_RenderObjectPtr<BS_RenderObject> CheckRenderObject(lua_State *L, bool ErrorIfRemoved = true) {
+static RenderObjectPtr<RenderObject> CheckRenderObject(lua_State *L, bool ErrorIfRemoved = true) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable einer Klasse haben, die von Gfx.RenderObject "erbt".
 	unsigned int *UserDataPtr;
 	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, BITMAP_CLASS_NAME)) != 0 ||
 	        (UserDataPtr = (unsigned int *) my_checkudata(L, 1, ANIMATION_CLASS_NAME)) != 0 ||
 	        (UserDataPtr = (unsigned int *) my_checkudata(L, 1, PANEL_CLASS_NAME)) != 0 ||
 	        (UserDataPtr = (unsigned int *) my_checkudata(L, 1, TEXT_CLASS_NAME)) != 0) {
-		BS_RenderObjectPtr<BS_RenderObject> ROPtr(* UserDataPtr);
+		RenderObjectPtr<RenderObject> ROPtr(* UserDataPtr);
 		if (ROPtr.IsValid())
 			return ROPtr;
 		else {
@@ -533,13 +533,13 @@ static BS_RenderObjectPtr<BS_RenderObject> CheckRenderObject(lua_State *L, bool
 		luaL_argcheck(L, 0, 1, "'" RENDEROBJECT_CLASS_NAME "' expected");
 	}
 
-	return BS_RenderObjectPtr<BS_RenderObject>();
+	return RenderObjectPtr<RenderObject>();
 }
 
 // -----------------------------------------------------------------------------
 
 static int RO_SetPos(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	BS_Vertex Pos;
 	BS_Vertex::LuaVertexToVertex(L, 2, Pos);
@@ -550,7 +550,7 @@ static int RO_SetPos(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_SetX(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr->SetX(static_cast<int>(luaL_checknumber(L, 2)));
 	return 0;
@@ -559,7 +559,7 @@ static int RO_SetX(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_SetY(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr->SetY(static_cast<int>(luaL_checknumber(L, 2)));
 	return 0;
@@ -568,7 +568,7 @@ static int RO_SetY(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_SetZ(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr->SetZ(static_cast<int>(luaL_checknumber(L, 2)));
 	return 0;
@@ -577,7 +577,7 @@ static int RO_SetZ(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_SetVisible(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr->SetVisible(lua_tobooleancpp(L, 2));
 	return 0;
@@ -586,7 +586,7 @@ static int RO_SetVisible(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_GetX(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetX());
 
@@ -596,7 +596,7 @@ static int RO_GetX(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_GetY(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetY());
 
@@ -606,7 +606,7 @@ static int RO_GetY(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_GetZ(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetZ());
 
@@ -616,7 +616,7 @@ static int RO_GetZ(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_GetAbsoluteX(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetAbsoluteX());
 
@@ -626,7 +626,7 @@ static int RO_GetAbsoluteX(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_GetAbsoluteY(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetAbsoluteY());
 
@@ -636,7 +636,7 @@ static int RO_GetAbsoluteY(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_GetWidth(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetWidth());
 
@@ -646,7 +646,7 @@ static int RO_GetWidth(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_GetHeight(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetHeight());
 
@@ -656,7 +656,7 @@ static int RO_GetHeight(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_IsVisible(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushbooleancpp(L, ROPtr->IsVisible());
 
@@ -666,11 +666,11 @@ static int RO_IsVisible(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_AddPanel(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
-	BS_RenderObjectPtr<BS_Panel> PanelPtr = ROPtr->AddPanel(static_cast<int>(luaL_checknumber(L, 2)),
+	RenderObjectPtr<Panel> PanelPtr = ROPtr->AddPanel(static_cast<int>(luaL_checknumber(L, 2)),
 	                                        static_cast<int>(luaL_checknumber(L, 3)),
-	                                        BS_GraphicEngine::LuaColorToARGBColor(L, 4));
+	                                        GraphicEngine::LuaColorToARGBColor(L, 4));
 	if (PanelPtr.IsValid()) {
 		NewUintUserData(L, PanelPtr->GetHandle());
 		// luaL_getmetatable(L, PANEL_CLASS_NAME);
@@ -686,9 +686,9 @@ static int RO_AddPanel(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_AddBitmap(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
-	BS_RenderObjectPtr<BS_Bitmap> BitmaPtr = ROPtr->AddBitmap(luaL_checkstring(L, 2));
+	RenderObjectPtr<Bitmap> BitmaPtr = ROPtr->AddBitmap(luaL_checkstring(L, 2));
 	if (BitmaPtr.IsValid()) {
 		NewUintUserData(L, BitmaPtr->GetHandle());
 		// luaL_getmetatable(L, BITMAP_CLASS_NAME);
@@ -704,10 +704,10 @@ static int RO_AddBitmap(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_AddText(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 
-	BS_RenderObjectPtr<BS_Text> TextPtr;
+	RenderObjectPtr<Text> TextPtr;
 	if (lua_gettop(L) >= 3) TextPtr = ROPtr->AddText(luaL_checkstring(L, 2), luaL_checkstring(L, 3));
 	else TextPtr = ROPtr->AddText(luaL_checkstring(L, 2));
 
@@ -726,10 +726,10 @@ static int RO_AddText(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int RO_AddAnimation(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr;
+	RenderObjectPtr<Animation> AnimationPtr;
 	if (lua_type(L, 2) == LUA_TUSERDATA)
 		AnimationPtr = ROPtr->AddAnimation(*CheckAnimationTemplate(L, 2));
 	else
@@ -777,11 +777,11 @@ static const luaL_reg RENDEROBJECT_METHODS[] = {
 
 // -----------------------------------------------------------------------------
 
-static BS_RenderObjectPtr<BS_Panel> CheckPanel(lua_State *L) {
+static RenderObjectPtr<Panel> CheckPanel(lua_State *L) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Panel
 	unsigned int *UserDataPtr;
 	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, PANEL_CLASS_NAME)) != 0) {
-		BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr);
+		RenderObjectPtr<RenderObject> ROPtr(*UserDataPtr);
 		if (ROPtr.IsValid()) {
 			return ROPtr->ToPanel();
 		} else
@@ -790,15 +790,15 @@ static BS_RenderObjectPtr<BS_Panel> CheckPanel(lua_State *L) {
 		luaL_argcheck(L, 0, 1, "'" PANEL_CLASS_NAME "' expected");
 	}
 
-	return BS_RenderObjectPtr<BS_Panel>();
+	return RenderObjectPtr<Panel>();
 }
 
 // -----------------------------------------------------------------------------
 
 static int P_GetColor(lua_State *L) {
-	BS_RenderObjectPtr<BS_Panel> PanelPtr = CheckPanel(L);
+	RenderObjectPtr<Panel> PanelPtr = CheckPanel(L);
 	BS_ASSERT(PanelPtr.IsValid());
-	BS_GraphicEngine::ARGBColorToLuaColor(L, PanelPtr->GetColor());
+	GraphicEngine::ARGBColorToLuaColor(L, PanelPtr->GetColor());
 
 	return 1;
 }
@@ -806,16 +806,16 @@ static int P_GetColor(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int P_SetColor(lua_State *L) {
-	BS_RenderObjectPtr<BS_Panel> PanelPtr = CheckPanel(L);
+	RenderObjectPtr<Panel> PanelPtr = CheckPanel(L);
 	BS_ASSERT(PanelPtr.IsValid());
-	PanelPtr->SetColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2));
+	PanelPtr->SetColor(GraphicEngine::LuaColorToARGBColor(L, 2));
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
 static int P_Remove(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr.Erase();
 	return 0;
@@ -832,11 +832,11 @@ static const luaL_reg PANEL_METHODS[] = {
 
 // -----------------------------------------------------------------------------
 
-static BS_RenderObjectPtr<BS_Bitmap> CheckBitmap(lua_State *L) {
+static RenderObjectPtr<Bitmap> CheckBitmap(lua_State *L) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Bitmap
 	unsigned int *UserDataPtr;
 	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, BITMAP_CLASS_NAME)) != 0) {
-		BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr);
+		RenderObjectPtr<RenderObject> ROPtr(*UserDataPtr);
 		if (ROPtr.IsValid()) {
 			return ROPtr->ToBitmap();
 		} else
@@ -845,13 +845,13 @@ static BS_RenderObjectPtr<BS_Bitmap> CheckBitmap(lua_State *L) {
 		luaL_argcheck(L, 0, 1, "'" BITMAP_CLASS_NAME "' expected");
 	}
 
-	return BS_RenderObjectPtr<BS_Bitmap>();
+	return RenderObjectPtr<Bitmap>();
 }
 
 // -----------------------------------------------------------------------------
 
 static int B_SetAlpha(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetAlpha(static_cast<unsigned int>(luaL_checknumber(L, 2)));
 	return 0;
@@ -860,16 +860,16 @@ static int B_SetAlpha(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_SetTintColor(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
-	BitmapPtr->SetModulationColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2));
+	BitmapPtr->SetModulationColor(GraphicEngine::LuaColorToARGBColor(L, 2));
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
 static int B_SetScaleFactor(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetScaleFactor(static_cast<float>(luaL_checknumber(L, 2)));
 	return 0;
@@ -878,7 +878,7 @@ static int B_SetScaleFactor(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_SetScaleFactorX(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetScaleFactorX(static_cast<float>(luaL_checknumber(L, 2)));
 	return 0;
@@ -887,7 +887,7 @@ static int B_SetScaleFactorX(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_SetScaleFactorY(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetScaleFactorY(static_cast<float>(luaL_checknumber(L, 2)));
 	return 0;
@@ -896,7 +896,7 @@ static int B_SetScaleFactorY(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_SetFlipH(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetFlipH(lua_tobooleancpp(L, 2));
 	return 0;
@@ -905,7 +905,7 @@ static int B_SetFlipH(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_SetFlipV(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetFlipV(lua_tobooleancpp(L, 2));
 	return 0;
@@ -914,7 +914,7 @@ static int B_SetFlipV(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_GetAlpha(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushnumber(L, BitmapPtr->GetAlpha());
 	return 1;
@@ -923,16 +923,16 @@ static int B_GetAlpha(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_GetTintColor(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
-	BS_GraphicEngine::ARGBColorToLuaColor(L, BitmapPtr->GetModulationColor());
+	GraphicEngine::ARGBColorToLuaColor(L, BitmapPtr->GetModulationColor());
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
 static int B_GetScaleFactorX(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushnumber(L, BitmapPtr->GetScaleFactorX());
 	return 1;
@@ -941,7 +941,7 @@ static int B_GetScaleFactorX(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_GetScaleFactorY(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushnumber(L, BitmapPtr->GetScaleFactorY());
 	return 1;
@@ -950,7 +950,7 @@ static int B_GetScaleFactorY(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_IsFlipH(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushbooleancpp(L, BitmapPtr->IsFlipH());
 	return 1;
@@ -959,7 +959,7 @@ static int B_IsFlipH(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_IsFlipV(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushbooleancpp(L, BitmapPtr->IsFlipV());
 	return 1;
@@ -968,18 +968,18 @@ static int B_IsFlipV(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_GetPixel(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BS_Vertex Pos;
 	BS_Vertex::LuaVertexToVertex(L, 2, Pos);
-	BS_GraphicEngine::ARGBColorToLuaColor(L, BitmapPtr->GetPixel(Pos.X, Pos.Y));
+	GraphicEngine::ARGBColorToLuaColor(L, BitmapPtr->GetPixel(Pos.X, Pos.Y));
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
 static int B_IsScalingAllowed(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushbooleancpp(L, BitmapPtr->IsScalingAllowed());
 	return 1;
@@ -988,7 +988,7 @@ static int B_IsScalingAllowed(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_IsAlphaAllowed(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushbooleancpp(L, BitmapPtr->IsAlphaAllowed());
 	return 1;
@@ -997,7 +997,7 @@ static int B_IsAlphaAllowed(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_IsTintingAllowed(lua_State *L) {
-	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
+	RenderObjectPtr<Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushbooleancpp(L, BitmapPtr->IsColorModulationAllowed());
 	return 1;
@@ -1005,7 +1005,7 @@ static int B_IsTintingAllowed(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int B_Remove(lua_State *L) {
-	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
+	RenderObjectPtr<RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr.Erase();
 	return 0;
@@ -1037,11 +1037,11 @@ static const luaL_reg BITMAP_METHODS[] = {
 
 // -----------------------------------------------------------------------------
 
-static BS_RenderObjectPtr<BS_Animation> CheckAnimation(lua_State *L) {
+static RenderObjectPtr<Animation> CheckAnimation(lua_State *L) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Animation
 	unsigned int *UserDataPtr;
 	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, ANIMATION_CLASS_NAME)) != 0) {
-		BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr);
+		RenderObjectPtr<RenderObject> ROPtr(*UserDataPtr);
 		if (ROPtr.IsValid())
 			return ROPtr->ToAnimation();
 		else {
@@ -1051,13 +1051,13 @@ static BS_RenderObjectPtr<BS_Animation> CheckAnimation(lua_State *L) {
 		luaL_argcheck(L, 0, 1, "'" ANIMATION_CLASS_NAME "' expected");
 	}
 
-	return BS_RenderObjectPtr<BS_Animation>();
+	return RenderObjectPtr<Animation>();
 }
 
 // -----------------------------------------------------------------------------
 
 static int A_Play(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->Play();
 	return 0;
@@ -1066,7 +1066,7 @@ static int A_Play(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_Pause(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->Pause();
 	return 0;
@@ -1075,7 +1075,7 @@ static int A_Pause(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_Stop(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->Stop();
 	return 0;
@@ -1084,7 +1084,7 @@ static int A_Stop(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_SetFrame(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetFrame(static_cast<unsigned int>(luaL_checknumber(L, 2)));
 	return 0;
@@ -1093,7 +1093,7 @@ static int A_SetFrame(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_SetAlpha(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetAlpha(static_cast<int>(luaL_checknumber(L, 2)));
 	return 0;
@@ -1101,16 +1101,16 @@ static int A_SetAlpha(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_SetTintColor(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
-	AnimationPtr->SetModulationColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2));
+	AnimationPtr->SetModulationColor(GraphicEngine::LuaColorToARGBColor(L, 2));
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
 static int A_SetScaleFactor(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetScaleFactor(static_cast<float>(luaL_checknumber(L, 2)));
 	return 0;
@@ -1119,7 +1119,7 @@ static int A_SetScaleFactor(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_SetScaleFactorX(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetScaleFactorX(static_cast<float>(luaL_checknumber(L, 2)));
 	return 0;
@@ -1128,7 +1128,7 @@ static int A_SetScaleFactorX(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_SetScaleFactorY(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetScaleFactorY(static_cast<float>(luaL_checknumber(L, 2)));
 	return 0;
@@ -1137,7 +1137,7 @@ static int A_SetScaleFactorY(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_GetScaleFactorX(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushnumber(L, AnimationPtr->GetScaleFactorX());
 	return 1;
@@ -1146,7 +1146,7 @@ static int A_GetScaleFactorX(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_GetScaleFactorY(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushnumber(L, AnimationPtr->GetScaleFactorY());
 	return 1;
@@ -1155,16 +1155,16 @@ static int A_GetScaleFactorY(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_GetAnimationType(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	switch (AnimationPtr->GetAnimationType()) {
-	case BS_Animation::AT_JOJO:
+	case Animation::AT_JOJO:
 		lua_pushstring(L, "jojo");
 		break;
-	case BS_Animation::AT_LOOP:
+	case Animation::AT_LOOP:
 		lua_pushstring(L, "loop");
 		break;
-	case BS_Animation::AT_ONESHOT:
+	case Animation::AT_ONESHOT:
 		lua_pushstring(L, "oneshot");
 		break;
 	default:
@@ -1176,7 +1176,7 @@ static int A_GetAnimationType(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_GetFPS(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushnumber(L, AnimationPtr->GetFPS());
 	return 1;
@@ -1186,7 +1186,7 @@ static int A_GetFPS(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_GetFrameCount(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushnumber(L, AnimationPtr->GetFrameCount());
 	return 1;
@@ -1195,7 +1195,7 @@ static int A_GetFrameCount(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_IsScalingAllowed(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushbooleancpp(L, AnimationPtr->IsScalingAllowed());
 	return 1;
@@ -1204,7 +1204,7 @@ static int A_IsScalingAllowed(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_IsAlphaAllowed(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushbooleancpp(L, AnimationPtr->IsAlphaAllowed());
 	return 1;
@@ -1213,7 +1213,7 @@ static int A_IsAlphaAllowed(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_IsTintingAllowed(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushbooleancpp(L, AnimationPtr->IsColorModulationAllowed());
 	return 1;
@@ -1222,7 +1222,7 @@ static int A_IsTintingAllowed(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_GetCurrentFrame(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushnumber(L, AnimationPtr->GetCurrentFrame());
 	return 1;
@@ -1231,7 +1231,7 @@ static int A_GetCurrentFrame(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_GetCurrentAction(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushstring(L, AnimationPtr->GetCurrentAction().c_str());
 	return 1;
@@ -1240,7 +1240,7 @@ static int A_GetCurrentAction(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_IsPlaying(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushbooleancpp(L, AnimationPtr->IsRunning());
 	return 1;
@@ -1258,7 +1258,7 @@ static bool AnimationLoopPointCallback(unsigned int Handle) {
 // -----------------------------------------------------------------------------
 
 static int A_RegisterLoopPointCallback(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	luaL_checktype(L, 2, LUA_TFUNCTION);
 
@@ -1271,7 +1271,7 @@ static int A_RegisterLoopPointCallback(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_UnregisterLoopPointCallback(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	luaL_checktype(L, 2, LUA_TFUNCTION);
 
@@ -1284,7 +1284,7 @@ static int A_UnregisterLoopPointCallback(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static bool AnimationActionCallback(unsigned int Handle) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr(Handle);
+	RenderObjectPtr<Animation> AnimationPtr(Handle);
 	if (AnimationPtr.IsValid()) {
 		ActionCallbackPtr->Action = AnimationPtr->GetCurrentAction();
 		lua_State *L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
@@ -1297,7 +1297,7 @@ static bool AnimationActionCallback(unsigned int Handle) {
 // -----------------------------------------------------------------------------
 
 static int A_RegisterActionCallback(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	luaL_checktype(L, 2, LUA_TFUNCTION);
 
@@ -1310,7 +1310,7 @@ static int A_RegisterActionCallback(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int A_UnregisterActionCallback(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	luaL_checktype(L, 2, LUA_TFUNCTION);
 
@@ -1332,7 +1332,7 @@ static bool AnimationDeleteCallback(unsigned int Handle) {
 // -----------------------------------------------------------------------------
 
 static int A_Remove(lua_State *L) {
-	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
+	RenderObjectPtr<Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr.Erase();
 	return 0;
@@ -1371,11 +1371,11 @@ static const luaL_reg ANIMATION_METHODS[] = {
 
 // -----------------------------------------------------------------------------
 
-static BS_RenderObjectPtr<BS_Text> CheckText(lua_State *L) {
+static RenderObjectPtr<Text> CheckText(lua_State *L) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Text
 	unsigned int *UserDataPtr;
 	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, TEXT_CLASS_NAME)) != 0) {
-		BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr);
+		RenderObjectPtr<RenderObject> ROPtr(*UserDataPtr);
 		if (ROPtr.IsValid())
 			return ROPtr->ToText();
 		else
@@ -1384,13 +1384,13 @@ static BS_RenderObjectPtr<BS_Text> CheckText(lua_State *L) {
 		luaL_argcheck(L, 0, 1, "'" TEXT_CLASS_NAME "' expected");
 	}
 
-	return BS_RenderObjectPtr<BS_Text>();
+	return RenderObjectPtr<Text>();
 }
 
 // -----------------------------------------------------------------------------
 
 static int T_SetFont(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetFont(luaL_checkstring(L, 2));
 	return 0;
@@ -1399,7 +1399,7 @@ static int T_SetFont(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_SetText(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetText(luaL_checkstring(L, 2));
 	return 0;
@@ -1408,7 +1408,7 @@ static int T_SetText(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_SetAlpha(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetAlpha(static_cast<int>(luaL_checknumber(L, 2)));
 	return 0;
@@ -1417,16 +1417,16 @@ static int T_SetAlpha(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_SetColor(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
-	TextPtr->SetColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2));
+	TextPtr->SetColor(GraphicEngine::LuaColorToARGBColor(L, 2));
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
 static int T_SetAutoWrap(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetAutoWrap(lua_tobooleancpp(L, 2));
 	return 0;
@@ -1435,7 +1435,7 @@ static int T_SetAutoWrap(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_SetAutoWrapThreshold(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetAutoWrapThreshold(static_cast<unsigned int>(luaL_checknumber(L, 2)));
 	return 0;
@@ -1444,7 +1444,7 @@ static int T_SetAutoWrapThreshold(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_GetText(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushstring(L, TextPtr->GetText().c_str());
 	return 1;
@@ -1453,7 +1453,7 @@ static int T_GetText(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_GetFont(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushstring(L, TextPtr->GetFont().c_str());
 	return 1;
@@ -1462,7 +1462,7 @@ static int T_GetFont(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_GetAlpha(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushnumber(L, TextPtr->GetAlpha());
 	return 1;
@@ -1471,7 +1471,7 @@ static int T_GetAlpha(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_GetColor(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushnumber(L, TextPtr->GetColor());
 	return 1;
@@ -1480,7 +1480,7 @@ static int T_GetColor(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_IsAutoWrap(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushbooleancpp(L, TextPtr->IsAutoWrapActive());
 	return 1;
@@ -1489,7 +1489,7 @@ static int T_IsAutoWrap(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_GetAutoWrapThreshold(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushnumber(L, TextPtr->GetAutoWrapThreshold());
 	return 1;
@@ -1498,7 +1498,7 @@ static int T_GetAutoWrapThreshold(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static int T_Remove(lua_State *L) {
-	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
+	RenderObjectPtr<Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr.Erase();
 	return 0;
@@ -1525,7 +1525,7 @@ static const luaL_reg TEXT_METHODS[] = {
 
 // -----------------------------------------------------------------------------
 
-bool BS_GraphicEngine::RegisterScriptBindings() {
+bool GraphicEngine::RegisterScriptBindings() {
 	BS_Kernel *pKernel = BS_Kernel::GetInstance();
 	BS_ASSERT(pKernel);
 	BS_ScriptEngine *pScript = static_cast<BS_ScriptEngine *>(pKernel->GetService("script"));