WINTERMUTE: Rename FuncName->funcName in Brenderer/BrendererSDL

11 files changed, 129 insertions, 129 deletions

diff --git a/engines/wintermute/Base/BFader.cpp b/engines/wintermute/Base/BFader.cpp
index a1e551df3f..55937dbcfa 100644
--- a/engines/wintermute/Base/BFader.cpp
+++ b/engines/wintermute/Base/BFader.cpp
@@ -87,7 +87,7 @@ HRESULT CBFader::update() {
 HRESULT CBFader::display() {

 	if (!_active) return S_OK;

 

-	if (_currentAlpha > 0x00) return Game->_renderer->FadeToColor(DRGBA(_red, _green, _blue, _currentAlpha));

+	if (_currentAlpha > 0x00) return Game->_renderer->fadeToColor(DRGBA(_red, _green, _blue, _currentAlpha));

 	else return S_OK;

 }

 

diff --git a/engines/wintermute/Base/BFontBitmap.cpp b/engines/wintermute/Base/BFontBitmap.cpp
index e88a6f0589..31a667bcbe 100644
--- a/engines/wintermute/Base/BFontBitmap.cpp
+++ b/engines/wintermute/Base/BFontBitmap.cpp
@@ -138,11 +138,11 @@ int CBFontBitmap::TextHeightDraw(byte  *text, int x, int y, int width, TTextAlig
 	bool new_line = false;

 	bool long_line = false;

 

-	if (draw) Game->_renderer->StartSpriteBatch();

+	if (draw) Game->_renderer->startSpriteBatch();

 

 	while (!done) {

 		if (max_height > 0 && (NumLines + 1)*_tileHeight > max_height) {

-			if (draw) Game->_renderer->EndSpriteBatch();

+			if (draw) Game->_renderer->endSpriteBatch();

 			return NumLines * _tileHeight;

 		}

 

@@ -208,7 +208,7 @@ int CBFontBitmap::TextHeightDraw(byte  *text, int x, int y, int width, TTextAlig
 		}

 	}

 

-	if (draw) Game->_renderer->EndSpriteBatch();

+	if (draw) Game->_renderer->endSpriteBatch();

 

 	return NumLines * _tileHeight;

 }

diff --git a/engines/wintermute/Base/BGame.cpp b/engines/wintermute/Base/BGame.cpp
index 05dfcf6abb..994dd48b2c 100644
--- a/engines/wintermute/Base/BGame.cpp
+++ b/engines/wintermute/Base/BGame.cpp
@@ -610,7 +610,7 @@ HRESULT CBGame::InitLoop() {
 	_currentTime = CBPlatform::GetTime();

 

 	GetDebugMgr()->OnGameTick();

-	_renderer->InitLoop();

+	_renderer->initLoop();

 	_soundMgr->initLoop();

 	UpdateMusicCrossfade();

 

@@ -1806,7 +1806,7 @@ HRESULT CBGame::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisS
 		}

 

 		bool ret = false;

-		CBImage *Image = Game->_renderer->TakeScreenshot();

+		CBImage *Image = Game->_renderer->takeScreenshot();

 		if (Image) {

 			ret = SUCCEEDED(Image->SaveBMPFile(Filename));

 			delete Image;

@@ -1826,7 +1826,7 @@ HRESULT CBGame::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisS
 		int SizeY = Stack->Pop()->GetInt(_renderer->_height);

 

 		bool ret = false;

-		CBImage *Image = Game->_renderer->TakeScreenshot();

+		CBImage *Image = Game->_renderer->takeScreenshot();

 		if (Image) {

 			ret = SUCCEEDED(Image->Resize(SizeX, SizeY));

 			if (ret) ret = SUCCEEDED(Image->SaveBMPFile(Filename));

@@ -1999,8 +1999,8 @@ HRESULT CBGame::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisS
 			_loadingIcon = NULL;

 		} else {

 			DisplayContent(false, true);

-			Game->_renderer->Flip();

-			Game->_renderer->InitLoop();

+			Game->_renderer->flip();

+			Game->_renderer->initLoop();

 		}

 		Stack->PushNULL();

 

@@ -2025,7 +2025,7 @@ HRESULT CBGame::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisS
 		Stack->CorrectParams(1);

 		const char *Filename = Stack->Pop()->GetString();

 

-		_renderer->DumpData(Filename);

+		_renderer->dumpData(Filename);

 

 		Stack->PushNULL();

 		return S_OK;

@@ -3321,7 +3321,7 @@ HRESULT CBGame::LoadGame(const char *Filename) {
 	Game->applyEvent("AfterLoad", true);

 

 	DisplayContent(true, false);

-	//_renderer->Flip();

+	//_renderer->flip();

 

 	GetDebugMgr()->OnGameInit();

 

@@ -3786,7 +3786,7 @@ bool CBGame::handleKeypress(Common::Event *event, bool printable) {
 

 	if (event->type == Common::EVENT_KEYDOWN && event->kbd.keycode == Common::KEYCODE_RETURN && (event->kbd.flags == Common::KBD_ALT)) {

 		// TODO: Handle alt-enter as well as alt-return.

-		_renderer->SwitchFullscreen();

+		_renderer->switchFullscreen();

 		return true;

 	}

 

@@ -3983,7 +3983,7 @@ HRESULT CBGame::PushViewport(CBViewport *Viewport) {
 	if (_viewportSP >= _viewportStack.GetSize()) _viewportStack.Add(Viewport);

 	else _viewportStack[_viewportSP] = Viewport;

 

-	_renderer->SetViewport(Viewport->getRect());

+	_renderer->setViewport(Viewport->getRect());

 

 	return S_OK;

 }

@@ -3994,8 +3994,8 @@ HRESULT CBGame::PopViewport() {
 	_viewportSP--;

 	if (_viewportSP < -1) Game->LOG(0, "Fatal: Viewport stack underflow!");

 

-	if (_viewportSP >= 0 && _viewportSP < _viewportStack.GetSize()) _renderer->SetViewport(_viewportStack[_viewportSP]->getRect());

-	else _renderer->SetViewport(_renderer->_drawOffsetX,

+	if (_viewportSP >= 0 && _viewportSP < _viewportStack.GetSize()) _renderer->setViewport(_viewportStack[_viewportSP]->getRect());

+	else _renderer->setViewport(_renderer->_drawOffsetX,

 		                            _renderer->_drawOffsetY,

 		                            _renderer->_width + _renderer->_drawOffsetX,

 		                            _renderer->_height + _renderer->_drawOffsetY);

@@ -4082,7 +4082,7 @@ HRESULT CBGame::DisplayContent(bool update, bool displayAll) {
 //////////////////////////////////////////////////////////////////////////

 HRESULT CBGame::DisplayContentSimple() {

 	// fill black

-	_renderer->Fill(0, 0, 0);

+	_renderer->fill(0, 0, 0);

 	if (_indicatorDisplay) DisplayIndicator();

 

 	return S_OK;

@@ -4099,11 +4099,11 @@ HRESULT CBGame::DisplayIndicator() {
 	}

 

 	if ((!_indicatorDisplay && _indicatorWidth <= 0) || _indicatorHeight <= 0) return S_OK;

-	_renderer->SetupLines();

+	_renderer->setupLines();

 	for (int i = 0; i < _indicatorHeight; i++)

-		_renderer->DrawLine(_indicatorX, _indicatorY + i, _indicatorX + (int)(_indicatorWidth * (float)((float)_indicatorProgress / 100.0f)), _indicatorY + i, _indicatorColor);

+		_renderer->drawLine(_indicatorX, _indicatorY + i, _indicatorX + (int)(_indicatorWidth * (float)((float)_indicatorProgress / 100.0f)), _indicatorY + i, _indicatorColor);

 

-	_renderer->Setup2D();

+	_renderer->setup2D();

 	return S_OK;

 }

 

@@ -4255,7 +4255,7 @@ HRESULT CBGame::OnActivate(bool Activate, bool RefreshMouse) {
 	if (RefreshMouse) {

 		POINT p;

 		GetMousePos(&p);

-		SetActiveObject(_renderer->GetObjectAt(p.x, p.y));

+		SetActiveObject(_renderer->getObjectAt(p.x, p.y));

 	}

 

 	if (Activate) _soundMgr->resumeAll();

@@ -4386,10 +4386,10 @@ HRESULT CBGame::OnMouseMiddleUp() {
 //////////////////////////////////////////////////////////////////////////

 HRESULT CBGame::OnPaint() {

 	if (_renderer && _renderer->_windowed && _renderer->_ready) {

-		_renderer->InitLoop();

+		_renderer->initLoop();

 		DisplayContent(false, true);

 		DisplayDebugInfo();

-		_renderer->WindowedBlt();

+		_renderer->windowedBlt();

 	}

 	return S_OK;

 }

@@ -4418,11 +4418,11 @@ HRESULT CBGame::DisplayDebugInfo() {
 			sprintf(str, "Mode: %dx%d windowed", _renderer->_width, _renderer->_height);

 

 		strcat(str, " (");

-		strcat(str, _renderer->GetName());

+		strcat(str, _renderer->getName());

 		strcat(str, ")");

 		_systemFont->DrawText((byte *)str, 0, 0, _renderer->_width, TAL_RIGHT);

 

-		_renderer->DisplayDebugInfo();

+		_renderer->displayDebugInfo();

 

 		int ScrTotal, ScrRunning, ScrWaiting, ScrPersistent;

 		ScrTotal = _scEngine->GetNumScripts(&ScrRunning, &ScrWaiting, &ScrPersistent);

diff --git a/engines/wintermute/Base/BRenderSDL.cpp b/engines/wintermute/Base/BRenderSDL.cpp
index f372335cf1..6ddf200b9e 100644
--- a/engines/wintermute/Base/BRenderSDL.cpp
+++ b/engines/wintermute/Base/BRenderSDL.cpp
@@ -66,7 +66,7 @@ CBRenderSDL::~CBRenderSDL() {
 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderSDL::InitRenderer(int width, int height, bool windowed) {

+HRESULT CBRenderSDL::initRenderer(int width, int height, bool windowed) {

 	//if (SDL_Init(SDL_INIT_VIDEO) < 0) return E_FAIL;

 

 #if 0

@@ -193,7 +193,7 @@ void CBRenderSDL::setColorMod(byte r, byte g, byte b) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderSDL::Flip() {

+HRESULT CBRenderSDL::flip() {

 

 #ifdef __IPHONEOS__

 	// hack: until viewports work correctly, we just paint black bars instead

@@ -242,7 +242,7 @@ HRESULT CBRenderSDL::Flip() {
 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderSDL::Fill(byte r, byte g, byte b, Common::Rect *rect) {

+HRESULT CBRenderSDL::fill(byte r, byte g, byte b, Common::Rect *rect) {

 	//SDL_SetRenderDrawColor(_renderer, r, g, b, 0xFF);

 	//SDL_RenderClear(_renderer);

 	uint32 color = _renderSurface->format.ARGBToColor(0xFF, r, g, b);

@@ -260,14 +260,14 @@ HRESULT CBRenderSDL::Fill(byte r, byte g, byte b, Common::Rect *rect) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderSDL::Fade(uint16 Alpha) {

+HRESULT CBRenderSDL::fade(uint16 Alpha) {

 	uint32 dwAlpha = 255 - Alpha;

-	return FadeToColor(dwAlpha << 24);

+	return fadeToColor(dwAlpha << 24);

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderSDL::FadeToColor(uint32 Color, Common::Rect *rect) {

+HRESULT CBRenderSDL::fadeToColor(uint32 Color, Common::Rect *rect) {

 	// This particular warning is rather messy, as this function is called a ton,

 	// thus we avoid printing it more than once.

 	static bool hasWarned = false;

@@ -291,7 +291,7 @@ HRESULT CBRenderSDL::FadeToColor(uint32 Color, Common::Rect *rect) {
 		fillRect.setWidth((int16)(rc.right - rc.left));

 		fillRect.setHeight((int16)(rc.bottom - rc.top));

 	}

-	ModTargetRect(&fillRect);

+	modTargetRect(&fillRect);

 

 	byte r = D3DCOLGetR(Color);

 	byte g = D3DCOLGetG(Color);

@@ -365,7 +365,7 @@ void CBRenderSDL::drawOpaqueFromSurface(Graphics::Surface *surf, Common::Rect *s
 	}

 }

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderSDL::DrawLine(int X1, int Y1, int X2, int Y2, uint32 Color) {

+HRESULT CBRenderSDL::drawLine(int X1, int Y1, int X2, int Y2, uint32 Color) {

 	static bool hasWarned = false;

 	if (!hasWarned) {

 		warning("CBRenderSDL::DrawLine - not fully ported yet");

@@ -382,11 +382,11 @@ HRESULT CBRenderSDL::DrawLine(int X1, int Y1, int X2, int Y2, uint32 Color) {
 	POINT point1, point2;

 	point1.x = X1;

 	point1.y = Y1;

-	PointToScreen(&point1);

+	pointToScreen(&point1);

 

 	point2.x = X2;

 	point2.y = Y2;

-	PointToScreen(&point2);

+	pointToScreen(&point2);

 

 	// TODO: This thing is mostly here until I'm sure about the final color-format.

 	uint32 color = _renderSurface->format.ARGBToColor(a, r, g, b);

@@ -396,7 +396,7 @@ HRESULT CBRenderSDL::DrawLine(int X1, int Y1, int X2, int Y2, uint32 Color) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-CBImage *CBRenderSDL::TakeScreenshot() {

+CBImage *CBRenderSDL::takeScreenshot() {

 // TODO: Fix this

 	warning("CBRenderSDL::TakeScreenshot() - not ported yet");

 	CBImage *screenshot = new CBImage(Game);

@@ -428,7 +428,7 @@ CBImage *CBRenderSDL::TakeScreenshot() {
 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderSDL::SwitchFullscreen() {

+HRESULT CBRenderSDL::switchFullscreen() {

 	/*if (_windowed) SDL_SetWindowFullscreen(_win, SDL_TRUE);

 	else SDL_SetWindowFullscreen(_win, SDL_FALSE);

 

@@ -440,7 +440,7 @@ HRESULT CBRenderSDL::SwitchFullscreen() {
 }

 

 //////////////////////////////////////////////////////////////////////////

-const char *CBRenderSDL::GetName() {

+const char *CBRenderSDL::getName() {

 	if (_name.empty()) {

 #if 0

 		if (_renderer) {

@@ -454,7 +454,7 @@ const char *CBRenderSDL::GetName() {
 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderSDL::SetViewport(int left, int top, int right, int bottom) {

+HRESULT CBRenderSDL::setViewport(int left, int top, int right, int bottom) {

 	Common::Rect rect;

 	// TODO: Hopefully this is the same logic that ScummVM uses.

 	rect.left = (int16)(left + _borderLeft);

@@ -470,7 +470,7 @@ HRESULT CBRenderSDL::SetViewport(int left, int top, int right, int bottom) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-void CBRenderSDL::ModTargetRect(Common::Rect *rect) {

+void CBRenderSDL::modTargetRect(Common::Rect *rect) {

 #if 0

 	SDL_Rect viewportRect;

 	SDL_RenderGetViewport(GetSdlRenderer(), &viewportRect);

@@ -483,7 +483,7 @@ void CBRenderSDL::ModTargetRect(Common::Rect *rect) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-void CBRenderSDL::PointFromScreen(POINT *point) {

+void CBRenderSDL::pointFromScreen(POINT *point) {

 #if 0

 	SDL_Rect viewportRect;

 	SDL_RenderGetViewport(GetSdlRenderer(), &viewportRect);

@@ -495,7 +495,7 @@ void CBRenderSDL::PointFromScreen(POINT *point) {
 

 

 //////////////////////////////////////////////////////////////////////////

-void CBRenderSDL::PointToScreen(POINT *point) {

+void CBRenderSDL::pointToScreen(POINT *point) {

 #if 0

 	SDL_Rect viewportRect;

 	SDL_RenderGetViewport(GetSdlRenderer(), &viewportRect);

@@ -506,7 +506,7 @@ void CBRenderSDL::PointToScreen(POINT *point) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-void CBRenderSDL::DumpData(const char *Filename) {

+void CBRenderSDL::dumpData(const char *Filename) {

 	warning("CBRenderSDL::DumpData(%s) - not reimplemented yet", Filename); // TODO

 #if 0

 	FILE *f = fopen(Filename, "wt");

diff --git a/engines/wintermute/Base/BRenderSDL.h b/engines/wintermute/Base/BRenderSDL.h
index 2a1910790a..e9ca53610a 100644
--- a/engines/wintermute/Base/BRenderSDL.h
+++ b/engines/wintermute/Base/BRenderSDL.h
@@ -43,38 +43,38 @@ public:
 	CBRenderSDL(CBGame *inGame);

 	~CBRenderSDL();

 

-	const char *GetName();

+	const char *getName();

 

-	HRESULT InitRenderer(int width, int height, bool windowed);

-	HRESULT Flip();

-	HRESULT Fill(byte  r, byte g, byte b, Common::Rect *rect = NULL);

+	HRESULT initRenderer(int width, int height, bool windowed);

+	HRESULT flip();

+	HRESULT fill(byte  r, byte g, byte b, Common::Rect *rect = NULL);

 

-	HRESULT Fade(uint16 Alpha);

-	HRESULT FadeToColor(uint32 Color, Common::Rect *rect = NULL);

+	HRESULT fade(uint16 Alpha);

+	HRESULT fadeToColor(uint32 Color, Common::Rect *rect = NULL);

 

-	HRESULT SwitchFullscreen();

+	HRESULT switchFullscreen();

 

-	HRESULT DrawLine(int X1, int Y1, int X2, int Y2, uint32 Color);

+	HRESULT drawLine(int X1, int Y1, int X2, int Y2, uint32 Color);

 

-	CBImage *TakeScreenshot();

+	CBImage *takeScreenshot();

 

 	void setAlphaMod(byte alpha);

 	void setColorMod(byte r, byte g, byte b);

 	void drawFromSurface(Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRest, bool mirrorX = false, bool mirrorY = false);

 	void drawOpaqueFromSurface(Graphics::Surface *surf, Common::Rect *srcRect, Common::Rect *dstRest, bool mirrorX = false, bool mirrorY = false);

 

-	HRESULT SetViewport(int left, int top, int right, int bottom);

+	HRESULT setViewport(int left, int top, int right, int bottom);

 

-	void ModTargetRect(Common::Rect *rect);

-	void PointFromScreen(POINT *point);

-	void PointToScreen(POINT *point);

+	void modTargetRect(Common::Rect *rect);

+	void pointFromScreen(POINT *point);

+	void pointToScreen(POINT *point);

 

-	void DumpData(const char *Filename);

+	void dumpData(const char *Filename);

 

-	float GetScaleRatioX() const {

+	float getScaleRatioX() const {

 		return _ratioX;

 	}

-	float GetScaleRatioY() const {

+	float getScaleRatioY() const {

 		return _ratioY;

 	}

 

diff --git a/engines/wintermute/Base/BRenderer.cpp b/engines/wintermute/Base/BRenderer.cpp
index fa9bec5f4f..3a58cdefb4 100644
--- a/engines/wintermute/Base/BRenderer.cpp
+++ b/engines/wintermute/Base/BRenderer.cpp
@@ -56,19 +56,19 @@ CBRenderer::CBRenderer(CBGame *inGame): CBBase(inGame) {
 

 //////////////////////////////////////////////////////////////////////

 CBRenderer::~CBRenderer() {

-	DeleteRectList();

-	UnclipCursor();

+	deleteRectList();

+	unclipCursor();

 }

 

 

 //////////////////////////////////////////////////////////////////////

-void CBRenderer::InitLoop() {

-	DeleteRectList();

+void CBRenderer::initLoop() {

+	deleteRectList();

 }

 

 

 //////////////////////////////////////////////////////////////////////

-CBObject *CBRenderer::GetObjectAt(int X, int Y) {

+CBObject *CBRenderer::getObjectAt(int X, int Y) {

 	POINT point;

 	point.x = X;

 	point.y = Y;

@@ -106,7 +106,7 @@ CBObject *CBRenderer::GetObjectAt(int X, int Y) {
 

 

 //////////////////////////////////////////////////////////////////////////

-void CBRenderer::DeleteRectList() {

+void CBRenderer::deleteRectList() {

 	for (int i = 0; i < _rectList.GetSize(); i++) {

 		delete _rectList[i];

 	}

@@ -116,96 +116,96 @@ void CBRenderer::DeleteRectList() {
 

 //////////////////////////////////////////////////////////////////////////

 //////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::SwitchFullscreen() {

+HRESULT CBRenderer::switchFullscreen() {

 	return E_FAIL;

 }

 

 //////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::Flip() {

+HRESULT CBRenderer::flip() {

 	return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::InitRenderer(int width, int height, bool windowed) {

+HRESULT CBRenderer::initRenderer(int width, int height, bool windowed) {

 	return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////

-void CBRenderer::OnWindowChange() {

+void CBRenderer::onWindowChange() {

 }

 

 

 //////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::Fill(byte  r, byte g, byte b, Common::Rect *rect) {

+HRESULT CBRenderer::fill(byte  r, byte g, byte b, Common::Rect *rect) {

 	return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::WindowedBlt() {

+HRESULT CBRenderer::windowedBlt() {

 	return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::Setup2D(bool Force) {

+HRESULT CBRenderer::setup2D(bool Force) {

 	return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::SetupLines() {

+HRESULT CBRenderer::setupLines() {

 	return E_FAIL;

 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::DrawLine(int X1, int Y1, int X2, int Y2, uint32 Color) {

+HRESULT CBRenderer::drawLine(int X1, int Y1, int X2, int Y2, uint32 Color) {

 	return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::DrawRect(int X1, int Y1, int X2, int Y2, uint32 Color, int Width) {

+HRESULT CBRenderer::drawRect(int X1, int Y1, int X2, int Y2, uint32 Color, int Width) {

 	for (int i = 0; i < Width; i++) {

-		DrawLine(X1 + i, Y1 + i, X2 - i,   Y1 + i,   Color); // up

-		DrawLine(X1 + i, Y2 - i, X2 - i + 1, Y2 - i, Color); // down

+		drawLine(X1 + i, Y1 + i, X2 - i,   Y1 + i,   Color); // up

+		drawLine(X1 + i, Y2 - i, X2 - i + 1, Y2 - i, Color); // down

 

-		DrawLine(X1 + i, Y1 + i, X1 + i, Y2 - i,   Color); // left

-		DrawLine(X2 - i, Y1 + i, X2 - i, Y2 - i + 1, Color); // right

+		drawLine(X1 + i, Y1 + i, X1 + i, Y2 - i,   Color); // left

+		drawLine(X2 - i, Y1 + i, X2 - i, Y2 - i + 1, Color); // right

 	}

 	return S_OK;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::Fade(uint16 Alpha) {

+HRESULT CBRenderer::fade(uint16 Alpha) {

 	return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::FadeToColor(uint32 Color, Common::Rect *rect) {

+HRESULT CBRenderer::fadeToColor(uint32 Color, Common::Rect *rect) {

 	return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::SetViewport(int left, int top, int right, int bottom) {

+HRESULT CBRenderer::setViewport(int left, int top, int right, int bottom) {

 	return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::SetScreenViewport() {

-	return SetViewport(_drawOffsetX, _drawOffsetY, _width + _drawOffsetX, _height + _drawOffsetY);

+HRESULT CBRenderer::setScreenViewport() {

+	return setViewport(_drawOffsetX, _drawOffsetY, _width + _drawOffsetX, _height + _drawOffsetY);

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::SetViewport(RECT *Rect) {

-	return SetViewport(Rect->left + _drawOffsetX,

+HRESULT CBRenderer::setViewport(RECT *Rect) {

+	return setViewport(Rect->left + _drawOffsetX,

 	                   Rect->top + _drawOffsetY,

 	                   Rect->right + _drawOffsetX,

 	                   Rect->bottom + _drawOffsetY);

@@ -213,13 +213,13 @@ HRESULT CBRenderer::SetViewport(RECT *Rect) {
 

 

 //////////////////////////////////////////////////////////////////////////

-CBImage *CBRenderer::TakeScreenshot() {

+CBImage *CBRenderer::takeScreenshot() {

 	return NULL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::ClipCursor() {

+HRESULT CBRenderer::clipCursor() {

 	/*

 	if (!_windowed) {

 	    RECT rc;

@@ -238,7 +238,7 @@ HRESULT CBRenderer::ClipCursor() {
 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBRenderer::UnclipCursor() {

+HRESULT CBRenderer::unclipCursor() {

 	/*

 	if (!_windowed) ::ClipCursor(NULL);

 	*/

@@ -246,7 +246,7 @@ HRESULT CBRenderer::UnclipCursor() {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CBRenderer::PointInViewport(POINT *P) {

+bool CBRenderer::pointInViewport(POINT *P) {

 	if (P->x < _drawOffsetX) return false;

 	if (P->y < _drawOffsetY) return false;

 	if (P->x > _drawOffsetX + _width) return false;

diff --git a/engines/wintermute/Base/BRenderer.h b/engines/wintermute/Base/BRenderer.h
index a13082b1b2..38925fc57a 100644
--- a/engines/wintermute/Base/BRenderer.h
+++ b/engines/wintermute/Base/BRenderer.h
@@ -47,61 +47,61 @@ public:
 	int _drawOffsetX;

 	int _drawOffsetY;

 

-	virtual void DumpData(const char *Filename) {};

-	virtual CBImage *TakeScreenshot();

-	virtual HRESULT SetViewport(int left, int top, int right, int bottom);

-	virtual HRESULT SetViewport(RECT *Rect);

-	virtual HRESULT SetScreenViewport();

-	virtual HRESULT Fade(uint16 Alpha);

-	virtual HRESULT FadeToColor(uint32 Color, Common::Rect *rect = NULL);

-	virtual HRESULT DrawLine(int X1, int Y1, int X2, int Y2, uint32 Color);

-	virtual HRESULT DrawRect(int X1, int Y1, int X2, int Y2, uint32 Color, int Width = 1);

+	virtual void dumpData(const char *Filename) {};

+	virtual CBImage *takeScreenshot();

+	virtual HRESULT setViewport(int left, int top, int right, int bottom);

+	virtual HRESULT setViewport(RECT *Rect);

+	virtual HRESULT setScreenViewport();

+	virtual HRESULT fade(uint16 Alpha);

+	virtual HRESULT fadeToColor(uint32 Color, Common::Rect *rect = NULL);

+	virtual HRESULT drawLine(int X1, int Y1, int X2, int Y2, uint32 Color);

+	virtual HRESULT drawRect(int X1, int Y1, int X2, int Y2, uint32 Color, int Width = 1);

 	CBRenderer(CBGame *inGame = NULL);

 	virtual ~CBRenderer();

-	virtual HRESULT SetProjection() {

+	virtual HRESULT setProjection() {

 		return S_OK;

 	};

 

-	virtual HRESULT WindowedBlt();

-	virtual HRESULT Fill(byte  r, byte g, byte b, Common::Rect *rect = NULL);

-	virtual void OnWindowChange();

-	virtual HRESULT InitRenderer(int width, int height, bool windowed);

-	virtual HRESULT Flip();

-	virtual void InitLoop();

-	virtual HRESULT SwitchFullscreen();

-	virtual HRESULT Setup2D(bool Force = false);

-	virtual HRESULT SetupLines();

-

-	virtual const char *GetName() {

+	virtual HRESULT windowedBlt();

+	virtual HRESULT fill(byte  r, byte g, byte b, Common::Rect *rect = NULL);

+	virtual void onWindowChange();

+	virtual HRESULT initRenderer(int width, int height, bool windowed);

+	virtual HRESULT flip();

+	virtual void initLoop();

+	virtual HRESULT switchFullscreen();

+	virtual HRESULT setup2D(bool Force = false);

+	virtual HRESULT setupLines();

+

+	virtual const char *getName() {

 		return "";

 	};

-	virtual HRESULT DisplayDebugInfo() {

+	virtual HRESULT displayDebugInfo() {

 		return E_FAIL;

 	};

-	virtual HRESULT DrawShaderQuad() {

+	virtual HRESULT drawShaderQuad() {

 		return E_FAIL;

 	}

 

-	virtual float GetScaleRatioX() const {

+	virtual float getScaleRatioX() const {

 		return 1.0f;

 	}

-	virtual float GetScaleRatioY() const {

+	virtual float getScaleRatioY() const {

 		return 1.0f;

 	}

 

-	HRESULT ClipCursor();

-	HRESULT UnclipCursor();

+	HRESULT clipCursor();

+	HRESULT unclipCursor();

 

-	CBObject *GetObjectAt(int X, int Y);

-	void DeleteRectList();

+	CBObject *getObjectAt(int X, int Y);

+	void deleteRectList();

 

-	virtual HRESULT StartSpriteBatch() {

+	virtual HRESULT startSpriteBatch() {

 		return S_OK;

 	};

-	virtual HRESULT EndSpriteBatch() {

+	virtual HRESULT endSpriteBatch() {

 		return S_OK;

 	};

-	bool PointInViewport(POINT *P);

+	bool pointInViewport(POINT *P);

 	uint32 _forceAlphaColor;

 	HINSTANCE _instance;

 	HWND _window;

diff --git a/engines/wintermute/Base/BSaveThumbHelper.cpp b/engines/wintermute/Base/BSaveThumbHelper.cpp
index 58ddbe5eca..1e54470924 100644
--- a/engines/wintermute/Base/BSaveThumbHelper.cpp
+++ b/engines/wintermute/Base/BSaveThumbHelper.cpp
@@ -54,13 +54,13 @@ HRESULT CBSaveThumbHelper::StoreThumbnail(bool DoFlip) {
 			// when using opengl on windows it seems to be necessary to do this twice

 			// works normally for direct3d

 			Game->DisplayContent(false);

-			Game->_renderer->Flip();

+			Game->_renderer->flip();

 

 			Game->DisplayContent(false);

-			Game->_renderer->Flip();

+			Game->_renderer->flip();

 		}

 

-		CBImage *Screenshot = Game->_renderer->TakeScreenshot();

+		CBImage *Screenshot = Game->_renderer->takeScreenshot();

 		if (!Screenshot) return E_FAIL;

 

 		// normal thumbnail

diff --git a/engines/wintermute/Base/BSurfaceSDL.cpp b/engines/wintermute/Base/BSurfaceSDL.cpp
index 3bac8ecc78..1a86bf8a90 100644
--- a/engines/wintermute/Base/BSurfaceSDL.cpp
+++ b/engines/wintermute/Base/BSurfaceSDL.cpp
@@ -510,7 +510,7 @@ HRESULT CBSurfaceSDL::drawSprite(int x, int y, RECT *Rect, float ZoomX, float Zo
 	position.setWidth((float)srcRect.width() * ZoomX / 100.f);

 	position.setHeight((float)srcRect.height() * ZoomX / 100.f);

 

-	renderer->ModTargetRect(&position);

+	renderer->modTargetRect(&position);

 

 	/*  position.left += offsetX;

 	    position.top += offsetY;*/

diff --git a/engines/wintermute/Base/BTransitionMgr.cpp b/engines/wintermute/Base/BTransitionMgr.cpp
index f61cd9d518..7ddbf21ec9 100644
--- a/engines/wintermute/Base/BTransitionMgr.cpp
+++ b/engines/wintermute/Base/BTransitionMgr.cpp
@@ -99,7 +99,7 @@ HRESULT CBTransitionMgr::update() {
 		uint32 time = CBPlatform::GetTime() - _lastTime;

 		int Alpha = (int)(255 - (float)time / (float)FADE_DURATION * 255);

 		Alpha = MIN(255, MAX(Alpha, 0));

-		Game->_renderer->Fade((uint16)Alpha);

+		Game->_renderer->fade((uint16)Alpha);

 

 		if (time > FADE_DURATION) _state = TRANS_MGR_READY;

 	}

@@ -109,7 +109,7 @@ HRESULT CBTransitionMgr::update() {
 		uint32 time = CBPlatform::GetTime() - _lastTime;

 		int Alpha = (int)((float)time / (float)FADE_DURATION * 255);

 		Alpha = MIN(255, MAX(Alpha, 0));

-		Game->_renderer->Fade((uint16)Alpha);

+		Game->_renderer->fade((uint16)Alpha);

 

 		if (time > FADE_DURATION) _state = TRANS_MGR_READY;

 	}

diff --git a/engines/wintermute/Base/PartEmitter.cpp b/engines/wintermute/Base/PartEmitter.cpp
index 0c7606b4f0..9809e50695 100644
--- a/engines/wintermute/Base/PartEmitter.cpp
+++ b/engines/wintermute/Base/PartEmitter.cpp
@@ -289,7 +289,7 @@ HRESULT CPartEmitter::updateInternal(uint32 CurrentTime, uint32 TimerDelta) {
 

 //////////////////////////////////////////////////////////////////////////

 HRESULT CPartEmitter::display(CBRegion *Region) {

-	if (_sprites.GetSize() <= 1) Game->_renderer->StartSpriteBatch();

+	if (_sprites.GetSize() <= 1) Game->_renderer->startSpriteBatch();

 

 	for (int i = 0; i < _particles.GetSize(); i++) {

 		if (Region != NULL && _useRegion) {

@@ -299,7 +299,7 @@ HRESULT CPartEmitter::display(CBRegion *Region) {
 		_particles[i]->display(this);

 	}

 

-	if (_sprites.GetSize() <= 1) Game->_renderer->EndSpriteBatch();

+	if (_sprites.GetSize() <= 1) Game->_renderer->endSpriteBatch();

 

 	return S_OK;

 }