diff --git a/LEGO1/lego/sources/3dmanager/tglsurface.cpp b/LEGO1/lego/sources/3dmanager/tglsurface.cpp
index 2554d975..f9b2ab42 100644
--- a/LEGO1/lego/sources/3dmanager/tglsurface.cpp
+++ b/LEGO1/lego/sources/3dmanager/tglsurface.cpp
@@ -84,7 +84,7 @@ BOOL TglSurface::Create(const CreateStruct& rCreateStruct, Renderer* pRenderer,
 	BOOL dither = TRUE;
 	int textureShadeCount = -1;
 	int textureColorCount = -1;
-	Tgl::Result result;
+	Result result;
 
 	m_pRenderer = pRenderer;
 	m_pScene = pScene;
@@ -181,7 +181,7 @@ double TglSurface::Render()
 	MxStopWatch renderTimer;
 
 	if (m_isInitialized && !m_stopRendering) {
-		Tgl::Result result;
+		Result result;
 
 #ifdef _DEBUG
 		m_triangleRateMeter.StartOperation();
diff --git a/LEGO1/tgl/d3drm/camera.cpp b/LEGO1/tgl/d3drm/camera.cpp
index 238229d8..14472098 100644
--- a/LEGO1/tgl/d3drm/camera.cpp
+++ b/LEGO1/tgl/d3drm/camera.cpp
@@ -15,14 +15,14 @@ void* CameraImpl::ImplementationDataPtr()
 }
 
 // FUNCTION: BETA10 0x1016f390
-inline Tgl::Result CameraSetTransformation(IDirect3DRMFrame2* pCamera, FloatMatrix4& matrix)
+inline Result CameraSetTransformation(IDirect3DRMFrame2* pCamera, FloatMatrix4& matrix)
 {
 	D3DRMMATRIX4D helper;
 	D3DRMMATRIX4D* pTransformation = Translate(matrix, helper);
 
 	D3DVECTOR position;
-	Tgl::Result result;
-	Tgl::Result result2;
+	Result result;
+	Result result2;
 
 	result2 = ResultVal(pCamera->GetPosition(NULL, &position));
 	assert(Succeeded(result2));
@@ -38,7 +38,7 @@ inline Tgl::Result CameraSetTransformation(IDirect3DRMFrame2* pCamera, FloatMatr
 
 // FUNCTION: LEGO1 0x100a3700
 // FUNCTION: BETA10 0x1016f330
-Tgl::Result CameraImpl::SetTransformation(FloatMatrix4& matrix)
+Result CameraImpl::SetTransformation(FloatMatrix4& matrix)
 {
 	assert(m_data);
 
diff --git a/LEGO1/tgl/d3drm/device.cpp b/LEGO1/tgl/d3drm/device.cpp
index 2cc100a8..053f4c85 100644
--- a/LEGO1/tgl/d3drm/device.cpp
+++ b/LEGO1/tgl/d3drm/device.cpp
@@ -47,14 +47,14 @@ unsigned int DeviceImpl::GetHeight()
 }
 
 // FUNCTION: BETA10 0x1016dfa0
-inline Tgl::Result DeviceSetColorModel(IDirect3DRMDevice2* pDevice, ColorModel)
+inline Result DeviceSetColorModel(IDirect3DRMDevice2* pDevice, ColorModel)
 {
 	return Success;
 }
 
 // FUNCTION: LEGO1 0x100a2c20
 // FUNCTION: BETA10 0x1016df40
-Tgl::Result DeviceImpl::SetColorModel(ColorModel p_model)
+Result DeviceImpl::SetColorModel(ColorModel p_model)
 {
 	assert(m_data);
 
@@ -62,7 +62,7 @@ Tgl::Result DeviceImpl::SetColorModel(ColorModel p_model)
 }
 
 // FUNCTION: BETA10 0x1016e020
-inline Tgl::Result DeviceSetShadingModel(IDirect3DRMDevice2* pDevice, ShadingModel model)
+inline Result DeviceSetShadingModel(IDirect3DRMDevice2* pDevice, ShadingModel model)
 {
 	D3DRMRENDERQUALITY renderQuality = Translate(model);
 	return ResultVal(pDevice->SetQuality(renderQuality));
@@ -70,7 +70,7 @@ inline Tgl::Result DeviceSetShadingModel(IDirect3DRMDevice2* pDevice, ShadingMod
 
 // FUNCTION: LEGO1 0x100a2c30
 // FUNCTION: BETA10 0x1016dfc0
-Tgl::Result DeviceImpl::SetShadingModel(ShadingModel model)
+Result DeviceImpl::SetShadingModel(ShadingModel model)
 {
 	assert(m_data);
 
@@ -78,14 +78,14 @@ Tgl::Result DeviceImpl::SetShadingModel(ShadingModel model)
 }
 
 // FUNCTION: BETA10 0x1016e140
-inline Tgl::Result DeviceSetShadeCount(IDirect3DRMDevice2* pDevice, unsigned int shadeCount)
+inline Result DeviceSetShadeCount(IDirect3DRMDevice2* pDevice, unsigned int shadeCount)
 {
 	return ResultVal(pDevice->SetShades(shadeCount));
 }
 
 // FUNCTION: LEGO1 0x100a2ca0
 // FUNCTION: BETA10 0x1016e0e0
-Tgl::Result DeviceImpl::SetShadeCount(unsigned int shadeCount)
+Result DeviceImpl::SetShadeCount(unsigned int shadeCount)
 {
 	assert(m_data);
 
@@ -93,14 +93,14 @@ Tgl::Result DeviceImpl::SetShadeCount(unsigned int shadeCount)
 }
 
 // FUNCTION: BETA10 0x1016e1d0
-inline Tgl::Result DeviceSetDither(IDirect3DRMDevice2* pDevice, int dither)
+inline Result DeviceSetDither(IDirect3DRMDevice2* pDevice, int dither)
 {
 	return ResultVal(pDevice->SetDither(dither));
 }
 
 // FUNCTION: LEGO1 0x100a2cc0
 // FUNCTION: BETA10 0x1016e170
-Tgl::Result DeviceImpl::SetDither(int dither)
+Result DeviceImpl::SetDither(int dither)
 {
 	assert(m_data);
 
@@ -112,7 +112,7 @@ inline void DeviceHandleActivate(IDirect3DRMDevice2* pDevice, WORD wParam)
 {
 	IDirect3DRMWinDevice* winDevice;
 
-	Tgl::Result result = ResultVal(pDevice->QueryInterface(IID_IDirect3DRMWinDevice, (LPVOID*) &winDevice));
+	Result result = ResultVal(pDevice->QueryInterface(IID_IDirect3DRMWinDevice, (LPVOID*) &winDevice));
 	if (Succeeded(result)) {
 		winDevice->HandleActivate(wParam);
 		int refCount = winDevice->Release();
@@ -134,7 +134,7 @@ inline void DeviceHandlePaint(IDirect3DRMDevice2* pDevice, void* p_data)
 {
 	IDirect3DRMWinDevice* winDevice;
 
-	Tgl::Result result = ResultVal(pDevice->QueryInterface(IID_IDirect3DRMWinDevice, (LPVOID*) &winDevice));
+	Result result = ResultVal(pDevice->QueryInterface(IID_IDirect3DRMWinDevice, (LPVOID*) &winDevice));
 	if (Succeeded(result)) {
 		HDC hdc = (HDC) p_data;
 		winDevice->HandlePaint(hdc);
@@ -153,14 +153,14 @@ void DeviceImpl::HandlePaint(void* p_data)
 }
 
 // FUNCTION: BETA10 0x1016e460
-inline Tgl::Result DeviceUpdate(IDirect3DRMDevice2* pDevice)
+inline Result DeviceUpdate(IDirect3DRMDevice2* pDevice)
 {
 	return ResultVal(pDevice->Update());
 }
 
 // FUNCTION: LEGO1 0x100a2d60
 // FUNCTION: BETA10 0x1016e400
-Tgl::Result DeviceImpl::Update()
+Result DeviceImpl::Update()
 {
 	assert(m_data);
 
diff --git a/LEGO1/tgl/d3drm/group.cpp b/LEGO1/tgl/d3drm/group.cpp
index 330f7948..6df5af8f 100644
--- a/LEGO1/tgl/d3drm/group.cpp
+++ b/LEGO1/tgl/d3drm/group.cpp
@@ -12,7 +12,7 @@ void* GroupImpl::ImplementationDataPtr()
 }
 
 // FUNCTION: BETA10 0x1016c340
-inline Tgl::Result GroupSetTransformation(IDirect3DRMFrame2* pGroup, FloatMatrix4& matrix)
+inline Result GroupSetTransformation(IDirect3DRMFrame2* pGroup, FloatMatrix4& matrix)
 {
 	D3DRMMATRIX4D helper;
 	D3DRMMATRIX4D* d3dMatrix = Translate(matrix, helper);
@@ -21,7 +21,7 @@ inline Tgl::Result GroupSetTransformation(IDirect3DRMFrame2* pGroup, FloatMatrix
 
 // FUNCTION: LEGO1 0x100a31e0
 // FUNCTION: BETA10 0x1016a4d0
-Tgl::Result GroupImpl::SetTransformation(FloatMatrix4& matrix)
+Result GroupImpl::SetTransformation(FloatMatrix4& matrix)
 {
 	assert(m_data);
 
@@ -29,7 +29,7 @@ Tgl::Result GroupImpl::SetTransformation(FloatMatrix4& matrix)
 }
 
 // FUNCTION: BETA10 0x1016c400
-inline Tgl::Result GroupSetColor(IDirect3DRMFrame2* pGroup, float r, float g, float b, float a)
+inline Result GroupSetColor(IDirect3DRMFrame2* pGroup, float r, float g, float b, float a)
 {
 	if (a > 0) {
 		D3DCOLOR color = D3DRMCreateColorRGBA(r, g, b, a);
@@ -42,7 +42,7 @@ inline Tgl::Result GroupSetColor(IDirect3DRMFrame2* pGroup, float r, float g, fl
 
 // FUNCTION: LEGO1 0x100a3240
 // FUNCTION: BETA10 0x1016a530
-Tgl::Result GroupImpl::SetColor(float r, float g, float b, float a)
+Result GroupImpl::SetColor(float r, float g, float b, float a)
 {
 	assert(m_data);
 
@@ -50,13 +50,13 @@ Tgl::Result GroupImpl::SetColor(float r, float g, float b, float a)
 }
 
 // FUNCTION: BETA10 0x1016c5a0
-inline Tgl::Result GroupSetTexture(IDirect3DRMFrame2* pGroup, IDirect3DRMTexture* pD3DTexture)
+inline Result GroupSetTexture(IDirect3DRMFrame2* pGroup, IDirect3DRMTexture* pD3DTexture)
 {
 	return ResultVal(pGroup->SetTexture(pD3DTexture));
 }
 
 // FUNCTION: BETA10 0x1016bcc0
-inline Tgl::Result GroupImpl::SetTexture(const TextureImpl* pTexture)
+inline Result GroupImpl::SetTexture(const TextureImpl* pTexture)
 {
 	assert(m_data);
 	assert(!pTexture || pTexture->ImplementationData());
@@ -67,7 +67,7 @@ inline Tgl::Result GroupImpl::SetTexture(const TextureImpl* pTexture)
 
 // FUNCTION: LEGO1 0x100a32b0
 // FUNCTION: BETA10 0x1016a5a0
-Tgl::Result GroupImpl::SetTexture(const Texture* pTexture)
+Result GroupImpl::SetTexture(const Texture* pTexture)
 {
 	assert(m_data);
 
@@ -75,13 +75,13 @@ Tgl::Result GroupImpl::SetTexture(const Texture* pTexture)
 }
 
 // FUNCTION: BETA10 0x1016c640
-inline Tgl::Result GroupGetTexture(IDirect3DRMFrame2* pGroup, IDirect3DRMTexture** pD3DTexture)
+inline Result GroupGetTexture(IDirect3DRMFrame2* pGroup, IDirect3DRMTexture** pD3DTexture)
 {
 	return ResultVal(pGroup->GetTexture(pD3DTexture));
 }
 
 // FUNCTION: BETA10 0x1016beb0
-inline Tgl::Result GroupImpl::GetTexture(TextureImpl** ppTexture)
+inline Result GroupImpl::GetTexture(TextureImpl** ppTexture)
 {
 	assert(m_data);
 	assert(ppTexture);
@@ -91,7 +91,7 @@ inline Tgl::Result GroupImpl::GetTexture(TextureImpl** ppTexture)
 
 	// TODO: This helps retail match, but it adds to the stack
 	IDirect3DRMTexture* tex;
-	Tgl::Result result = GroupGetTexture(m_data, &tex);
+	Result result = GroupGetTexture(m_data, &tex);
 
 #ifndef BETA10
 	if (Succeeded(result)) {
@@ -106,7 +106,7 @@ inline Tgl::Result GroupImpl::GetTexture(TextureImpl** ppTexture)
 
 // FUNCTION: LEGO1 0x100a32e0
 // FUNCTION: BETA10 0x1016a600
-Tgl::Result GroupImpl::GetTexture(Texture*& pTexture)
+Result GroupImpl::GetTexture(Texture*& pTexture)
 {
 	assert(m_data);
 
@@ -114,7 +114,7 @@ Tgl::Result GroupImpl::GetTexture(Texture*& pTexture)
 }
 
 // FUNCTION: BETA10 0x1016c500
-inline Tgl::Result GroupSetMaterialMode(IDirect3DRMFrame2* pGroup, MaterialMode mode)
+inline Result GroupSetMaterialMode(IDirect3DRMFrame2* pGroup, MaterialMode mode)
 {
 	D3DRMMATERIALMODE d3dMode = Translate(mode);
 	return ResultVal(pGroup->SetMaterialMode(d3dMode));
@@ -122,7 +122,7 @@ inline Tgl::Result GroupSetMaterialMode(IDirect3DRMFrame2* pGroup, MaterialMode
 
 // FUNCTION: LEGO1 0x100a33c0
 // FUNCTION: BETA10 0x1016a660
-Tgl::Result GroupImpl::SetMaterialMode(MaterialMode mode)
+Result GroupImpl::SetMaterialMode(MaterialMode mode)
 {
 	assert(m_data);
 
@@ -130,13 +130,13 @@ Tgl::Result GroupImpl::SetMaterialMode(MaterialMode mode)
 }
 
 // FUNCTION: BETA10 0x1016c670
-inline Tgl::Result GroupAddGroup(IDirect3DRMFrame2* pGroup, const IDirect3DRMFrame* pChildGroup)
+inline Result GroupAddGroup(IDirect3DRMFrame2* pGroup, const IDirect3DRMFrame* pChildGroup)
 {
 	return ResultVal(pGroup->AddVisual(const_cast<IDirect3DRMFrame*>(pChildGroup)));
 }
 
 // FUNCTION: BETA10 0x1016c090
-inline Tgl::Result GroupImpl::Add(const GroupImpl& rGroup)
+inline Result GroupImpl::Add(const GroupImpl& rGroup)
 {
 	assert(m_data);
 	assert(rGroup.ImplementationData());
@@ -146,7 +146,7 @@ inline Tgl::Result GroupImpl::Add(const GroupImpl& rGroup)
 
 // FUNCTION: LEGO1 0x100a3410
 // FUNCTION: BETA10 0x1016a6c0
-Tgl::Result GroupImpl::Add(const Group* pGroup)
+Result GroupImpl::Add(const Group* pGroup)
 {
 	assert(m_data);
 	assert(pGroup);
@@ -155,13 +155,13 @@ Tgl::Result GroupImpl::Add(const Group* pGroup)
 }
 
 // FUNCTION: BETA10 0x1016c700
-inline Tgl::Result GroupAddMeshBuilder(IDirect3DRMFrame2* pGroup, const IDirect3DRMMesh* pMesh)
+inline Result GroupAddMeshBuilder(IDirect3DRMFrame2* pGroup, const IDirect3DRMMesh* pMesh)
 {
 	return ResultVal(pGroup->AddVisual(const_cast<IDirect3DRMMesh*>(pMesh)));
 }
 
 // FUNCTION: BETA10 0x1016bff0
-inline Tgl::Result GroupImpl::Add(const MeshBuilderImpl& rMesh)
+inline Result GroupImpl::Add(const MeshBuilderImpl& rMesh)
 {
 	assert(m_data);
 	assert(rMesh.ImplementationData());
@@ -171,7 +171,7 @@ inline Tgl::Result GroupImpl::Add(const MeshBuilderImpl& rMesh)
 
 // FUNCTION: LEGO1 0x100a3430
 // FUNCTION: BETA10 0x1016a740
-Tgl::Result GroupImpl::Add(const MeshBuilder* pMeshBuilder)
+Result GroupImpl::Add(const MeshBuilder* pMeshBuilder)
 {
 	assert(m_data);
 	assert(pMeshBuilder);
@@ -180,13 +180,13 @@ Tgl::Result GroupImpl::Add(const MeshBuilder* pMeshBuilder)
 }
 
 // FUNCTION: BETA10 0x1016c7b0
-inline Tgl::Result GroupRemoveMeshBuilder(IDirect3DRMFrame2* pGroup, const IDirect3DRMMesh* pMesh)
+inline Result GroupRemoveMeshBuilder(IDirect3DRMFrame2* pGroup, const IDirect3DRMMesh* pMesh)
 {
 	return ResultVal(pGroup->DeleteVisual(const_cast<IDirect3DRMMesh*>(pMesh)));
 }
 
 // FUNCTION: BETA10 0x1016c130
-inline Tgl::Result GroupImpl::Remove(const MeshBuilderImpl& rMesh)
+inline Result GroupImpl::Remove(const MeshBuilderImpl& rMesh)
 {
 	assert(m_data);
 	assert(rMesh.ImplementationData());
@@ -196,7 +196,7 @@ inline Tgl::Result GroupImpl::Remove(const MeshBuilderImpl& rMesh)
 
 // FUNCTION: LEGO1 0x100a3450
 // FUNCTION: BETA10 0x1016a7c0
-Tgl::Result GroupImpl::Remove(const MeshBuilder* pMeshBuilder)
+Result GroupImpl::Remove(const MeshBuilder* pMeshBuilder)
 {
 	assert(m_data);
 	assert(pMeshBuilder);
@@ -205,13 +205,13 @@ Tgl::Result GroupImpl::Remove(const MeshBuilder* pMeshBuilder)
 }
 
 // FUNCTION: BETA10 0x1016c730
-inline Tgl::Result GroupRemoveGroup(IDirect3DRMFrame2* pGroup, const IDirect3DRMFrame* pChildGroup)
+inline Result GroupRemoveGroup(IDirect3DRMFrame2* pGroup, const IDirect3DRMFrame* pChildGroup)
 {
 	return ResultVal(pGroup->DeleteVisual(const_cast<IDirect3DRMFrame*>(pChildGroup)));
 }
 
 // FUNCTION: BETA10 0x1016c1d0
-inline Tgl::Result GroupImpl::Remove(const GroupImpl& rGroup)
+inline Result GroupImpl::Remove(const GroupImpl& rGroup)
 {
 	assert(m_data);
 	assert(rGroup.ImplementationData());
@@ -221,7 +221,7 @@ inline Tgl::Result GroupImpl::Remove(const GroupImpl& rGroup)
 
 // FUNCTION: LEGO1 0x100a3480
 // FUNCTION: BETA10 0x1016a840
-Tgl::Result GroupImpl::Remove(const Group* pGroup)
+Result GroupImpl::Remove(const Group* pGroup)
 {
 	assert(m_data);
 	assert(pGroup);
@@ -230,12 +230,12 @@ Tgl::Result GroupImpl::Remove(const Group* pGroup)
 }
 
 // FUNCTION: BETA10 0x1016c850
-inline Tgl::Result GroupRemoveAll(IDirect3DRMFrame2* pFrame)
+inline Result GroupRemoveAll(IDirect3DRMFrame2* pFrame)
 {
 	IDirect3DRMVisualArray* visuals;
 	int refCount;
 
-	Tgl::Result result = ResultVal(pFrame->GetVisuals(&visuals));
+	Result result = ResultVal(pFrame->GetVisuals(&visuals));
 	assert(Succeeded(result));
 
 	if (Succeeded(result)) {
@@ -260,7 +260,7 @@ inline Tgl::Result GroupRemoveAll(IDirect3DRMFrame2* pFrame)
 
 // FUNCTION: LEGO1 0x100a34b0
 // FUNCTION: BETA10 0x1016a8c0
-Tgl::Result GroupImpl::RemoveAll()
+Result GroupImpl::RemoveAll()
 {
 	assert(m_data);
 
@@ -268,7 +268,7 @@ Tgl::Result GroupImpl::RemoveAll()
 }
 
 // FUNCTION: BETA10 0x1016cb70
-inline Tgl::Result GroupBounds(IDirect3DRMFrame2* pFrame, D3DVECTOR* p_min, D3DVECTOR* p_max)
+inline Result GroupBounds(IDirect3DRMFrame2* pFrame, D3DVECTOR* p_min, D3DVECTOR* p_max)
 {
 	D3DRMBOX size;
 	int refCount;
@@ -277,7 +277,7 @@ inline Tgl::Result GroupBounds(IDirect3DRMFrame2* pFrame, D3DVECTOR* p_min, D3DV
 	size.max.x = size.max.y = size.max.z = -88888.f;
 
 	IDirect3DRMVisualArray* visuals;
-	Tgl::Result result = ResultVal(pFrame->GetVisuals(&visuals));
+	Result result = ResultVal(pFrame->GetVisuals(&visuals));
 	assert(Succeeded(result));
 
 	if (Succeeded(result)) {
@@ -337,7 +337,7 @@ inline Tgl::Result GroupBounds(IDirect3DRMFrame2* pFrame, D3DVECTOR* p_min, D3DV
 
 // FUNCTION: LEGO1 0x100a3540
 // FUNCTION: BETA10 0x1016a920
-Tgl::Result GroupImpl::Bounds(D3DVECTOR* p_min, D3DVECTOR* p_max)
+Result GroupImpl::Bounds(D3DVECTOR* p_min, D3DVECTOR* p_max)
 {
 	assert(m_data);
 
diff --git a/LEGO1/tgl/d3drm/impl.h b/LEGO1/tgl/d3drm/impl.h
index 74217b4a..92f886f8 100644
--- a/LEGO1/tgl/d3drm/impl.h
+++ b/LEGO1/tgl/d3drm/impl.h
@@ -30,7 +30,7 @@ using namespace Tgl;
 
 // Utility function used by implementations
 // FUNCTION: BETA10 0x10169cf0
-inline Tgl::Result ResultVal(HRESULT result)
+inline Result ResultVal(HRESULT result)
 {
 	return SUCCEEDED(result) ? Success : Error;
 }
@@ -88,10 +88,10 @@ class RendererImpl : public Renderer {
 	) override;
 	Texture* CreateTexture() override;
 
-	Tgl::Result SetTextureDefaultShadeCount(unsigned int) override;
+	Result SetTextureDefaultShadeCount(unsigned int) override;
 
 	// vtable+0x30
-	Tgl::Result SetTextureDefaultColorCount(unsigned int) override;
+	Result SetTextureDefaultColorCount(unsigned int) override;
 
 	HRESULT CreateTextureFromSurface(LPDIRECTDRAWSURFACE pSurface, LPDIRECT3DRMTEXTURE2* pTexture2)
 	{
@@ -106,11 +106,11 @@ class RendererImpl : public Renderer {
 	RendererDataType& ImplementationData() { return m_data; }
 
 public:
-	inline Tgl::Result Create();
+	inline Result Create();
 	inline void Destroy();
-	inline Tgl::Result CreateLight(LightType type, float r, float g, float b, LightImpl& rLight);
-	inline Tgl::Result CreateGroup(const GroupImpl* pParentGroup, GroupImpl& rpGroup);
-	inline Tgl::Result CreateView(
+	inline Result CreateLight(LightType type, float r, float g, float b, LightImpl& rLight);
+	inline Result CreateGroup(const GroupImpl* pParentGroup, GroupImpl& rpGroup);
+	inline Result CreateView(
 		const DeviceImpl& rDevice,
 		const CameraImpl& rCamera,
 		unsigned int x,
@@ -119,10 +119,10 @@ class RendererImpl : public Renderer {
 		unsigned int height,
 		ViewImpl& rView
 	);
-	inline Tgl::Result CreateMeshBuilder(MeshBuilderImpl& rMesh);
-	inline Tgl::Result CreateCamera(CameraImpl& rCamera);
-	inline Tgl::Result CreateTexture(TextureImpl& rTexture);
-	inline Tgl::Result CreateTexture(
+	inline Result CreateMeshBuilder(MeshBuilderImpl& rMesh);
+	inline Result CreateCamera(CameraImpl& rCamera);
+	inline Result CreateTexture(TextureImpl& rTexture);
+	inline Result CreateTexture(
 		TextureImpl& rTexture,
 		int width,
 		int height,
@@ -132,8 +132,8 @@ class RendererImpl : public Renderer {
 		int paletteEntryCount,
 		const PaletteEntry* pEntries
 	);
-	inline Tgl::Result CreateDevice(const DeviceDirect3DCreateData& rCreateData, DeviceImpl& rDevice);
-	inline Tgl::Result CreateDevice(const DeviceDirectDrawCreateData& rCreateData, DeviceImpl& rDevice);
+	inline Result CreateDevice(const DeviceDirect3DCreateData& rCreateData, DeviceImpl& rDevice);
+	inline Result CreateDevice(const DeviceDirectDrawCreateData& rCreateData, DeviceImpl& rDevice);
 
 private:
 	RendererDataType m_data;
@@ -177,13 +177,13 @@ class DeviceImpl : public Device {
 	unsigned int GetHeight() override;
 
 	// vtable+0x10
-	Tgl::Result SetColorModel(ColorModel) override;
-	Tgl::Result SetShadingModel(ShadingModel) override;
-	Tgl::Result SetShadeCount(unsigned int) override;
-	Tgl::Result SetDither(int) override;
+	Result SetColorModel(ColorModel) override;
+	Result SetShadingModel(ShadingModel) override;
+	Result SetShadeCount(unsigned int) override;
+	Result SetDither(int) override;
 
 	// vtable+0x20
-	Tgl::Result Update() override;
+	Result Update() override;
 	void HandleActivate(WORD) override;
 	void HandlePaint(void*) override;
 
@@ -233,25 +233,25 @@ class ViewImpl : public View {
 	void* ImplementationDataPtr() override;
 
 	// vtable+0x08
-	Tgl::Result Add(const Light*) override;
-	Tgl::Result Remove(const Light*) override;
+	Result Add(const Light*) override;
+	Result Remove(const Light*) override;
 
 	// vtable+0x10
-	Tgl::Result SetCamera(const Camera*) override;
-	Tgl::Result SetProjection(ProjectionType) override;
-	Tgl::Result SetFrustrum(float frontClippingDistance, float backClippingDistance, float degrees) override;
-	Tgl::Result SetBackgroundColor(float r, float g, float b) override;
+	Result SetCamera(const Camera*) override;
+	Result SetProjection(ProjectionType) override;
+	Result SetFrustrum(float frontClippingDistance, float backClippingDistance, float degrees) override;
+	Result SetBackgroundColor(float r, float g, float b) override;
 
 	// vtable+0x20
-	Tgl::Result GetBackgroundColor(float* r, float* g, float* b) override;
-	Tgl::Result Clear() override;
-	Tgl::Result Render(const Group*) override;
-	Tgl::Result ForceUpdate(unsigned int x, unsigned int y, unsigned int width, unsigned int height) override;
+	Result GetBackgroundColor(float* r, float* g, float* b) override;
+	Result Clear() override;
+	Result Render(const Group*) override;
+	Result ForceUpdate(unsigned int x, unsigned int y, unsigned int width, unsigned int height) override;
 
 	// vtable+0x30
-	Tgl::Result TransformWorldToScreen(const float world[3], float screen[4]) override;
-	Tgl::Result TransformScreenToWorld(const float screen[4], float world[3]) override;
-	Tgl::Result Pick(
+	Result TransformWorldToScreen(const float world[3], float screen[4]) override;
+	Result TransformScreenToWorld(const float screen[4], float world[3]) override;
+	Result Pick(
 		unsigned int x,
 		unsigned int y,
 		const Group** ppGroupsToPickFrom,
@@ -269,14 +269,14 @@ class ViewImpl : public View {
 
 	void SetImplementationData(IDirect3DRMViewport* viewport) { m_data = viewport; }
 
-	static Tgl::Result ViewportCreateAppData(IDirect3DRM2*, IDirect3DRMViewport*, IDirect3DRMFrame2*);
+	static Result ViewportCreateAppData(IDirect3DRM2*, IDirect3DRMViewport*, IDirect3DRMFrame2*);
 
 	inline void Destroy();
-	Tgl::Result Add(const LightImpl& rLight);
-	Tgl::Result Remove(const LightImpl& rLight);
-	Tgl::Result SetCamera(const CameraImpl& rCamera);
-	Tgl::Result Render(const GroupImpl& rScene);
-	Tgl::Result Pick(
+	Result Add(const LightImpl& rLight);
+	Result Remove(const LightImpl& rLight);
+	Result SetCamera(const CameraImpl& rCamera);
+	Result Render(const GroupImpl& rScene);
+	Result Pick(
 		unsigned int x,
 		unsigned int y,
 		const GroupImpl** ppGroupsToPickFrom,
@@ -319,7 +319,7 @@ class CameraImpl : public Camera {
 	void* ImplementationDataPtr() override;
 
 	// vtable+0x08
-	Tgl::Result SetTransformation(FloatMatrix4&) override;
+	Result SetTransformation(FloatMatrix4&) override;
 
 	typedef IDirect3DRMFrame2* CameraDataType;
 
@@ -365,8 +365,8 @@ class LightImpl : public Light {
 	void* ImplementationDataPtr() override;
 
 	// vtable+0x08
-	Tgl::Result SetTransformation(FloatMatrix4&) override;
-	Tgl::Result SetColor(float r, float g, float b) override;
+	Result SetTransformation(FloatMatrix4&) override;
+	Result SetColor(float r, float g, float b) override;
 
 	typedef IDirect3DRMFrame2* LightDataType;
 
@@ -412,13 +412,13 @@ class MeshImpl : public Mesh {
 	void* ImplementationDataPtr() override;
 
 	// vtable+0x08
-	Tgl::Result SetColor(float r, float g, float b, float a) override;
-	Tgl::Result SetTexture(const Texture*) override;
+	Result SetColor(float r, float g, float b, float a) override;
+	Result SetTexture(const Texture*) override;
 
 	// vtable+0x10
-	Tgl::Result GetTexture(Texture*&) override;
-	Tgl::Result SetTextureMappingMode(TextureMappingMode) override;
-	Tgl::Result SetShadingModel(ShadingModel) override;
+	Result GetTexture(Texture*&) override;
+	Result SetTextureMappingMode(TextureMappingMode) override;
+	Result SetShadingModel(ShadingModel) override;
 	Mesh* DeepClone(MeshBuilder*) override;
 
 	// vtable+0x20
@@ -438,8 +438,8 @@ class MeshImpl : public Mesh {
 
 	inline void Destroy();
 	inline Mesh* DeepClone(const MeshBuilderImpl& rMesh);
-	inline Tgl::Result GetTexture(TextureImpl** ppTexture);
-	inline Tgl::Result SetTexture(const TextureImpl* pTexture);
+	inline Result GetTexture(TextureImpl** ppTexture);
+	inline Result SetTexture(const TextureImpl* pTexture);
 	inline Mesh* ShallowClone(const MeshBuilderImpl& rMesh);
 
 	friend class RendererImpl;
@@ -476,23 +476,23 @@ class GroupImpl : public Group {
 	void* ImplementationDataPtr() override;
 
 	// vtable+0x08
-	Tgl::Result SetTransformation(FloatMatrix4&) override;
-	Tgl::Result SetColor(float r, float g, float b, float a) override;
+	Result SetTransformation(FloatMatrix4&) override;
+	Result SetColor(float r, float g, float b, float a) override;
 
 	// vtable+0x10
-	Tgl::Result SetTexture(const Texture*) override;
-	Tgl::Result GetTexture(Texture*&) override;
-	Tgl::Result SetMaterialMode(MaterialMode) override;
-	Tgl::Result Add(const Group*) override;
+	Result SetTexture(const Texture*) override;
+	Result GetTexture(Texture*&) override;
+	Result SetMaterialMode(MaterialMode) override;
+	Result Add(const Group*) override;
 
 	// vtable+0x20
-	Tgl::Result Add(const MeshBuilder*) override;
-	Tgl::Result Remove(const Group*) override;
-	Tgl::Result Remove(const MeshBuilder*) override;
-	Tgl::Result RemoveAll() override;
+	Result Add(const MeshBuilder*) override;
+	Result Remove(const Group*) override;
+	Result Remove(const MeshBuilder*) override;
+	Result RemoveAll() override;
 
 	// vtable+0x30
-	Tgl::Result Bounds(D3DVECTOR* p_min, D3DVECTOR* p_max) override;
+	Result Bounds(D3DVECTOR* p_min, D3DVECTOR* p_max) override;
 
 	typedef IDirect3DRMFrame2* GroupDataType;
 
@@ -503,12 +503,12 @@ class GroupImpl : public Group {
 	GroupDataType& ImplementationData() { return m_data; }
 
 	inline void Destroy();
-	inline Tgl::Result SetTexture(const TextureImpl* pTexture);
-	inline Tgl::Result GetTexture(TextureImpl** ppTexture);
-	inline Tgl::Result Add(const GroupImpl& rGroup);
-	inline Tgl::Result Add(const MeshBuilderImpl& rMesh);
-	inline Tgl::Result Remove(const GroupImpl& rGroup);
-	inline Tgl::Result Remove(const MeshBuilderImpl& rMesh);
+	inline Result SetTexture(const TextureImpl* pTexture);
+	inline Result GetTexture(TextureImpl** ppTexture);
+	inline Result Add(const GroupImpl& rGroup);
+	inline Result Add(const MeshBuilderImpl& rMesh);
+	inline Result Remove(const GroupImpl& rGroup);
+	inline Result Remove(const MeshBuilderImpl& rMesh);
 
 	friend class RendererImpl;
 
@@ -554,7 +554,7 @@ class MeshBuilderImpl : public MeshBuilder {
 		unsigned int (*pTextureIndices)[3],
 		ShadingModel shadingModel
 	) override;
-	Tgl::Result GetBoundingBox(float min[3], float max[3]) const override;
+	Result GetBoundingBox(float min[3], float max[3]) const override;
 
 	// vtable+0x10
 	MeshBuilder* Clone() override;
@@ -572,7 +572,7 @@ class MeshBuilderImpl : public MeshBuilder {
 	friend class RendererImpl;
 
 private:
-	inline Tgl::Result CreateMeshImpl(
+	inline Result CreateMeshImpl(
 		MeshImpl* pMeshImpl,
 		unsigned int faceCount,
 		unsigned int vertexCount,
@@ -616,10 +616,10 @@ class TglD3DRMIMAGE {
 	);
 	~TglD3DRMIMAGE();
 
-	Tgl::Result CreateBuffer(int width, int height, int depth, void* pBuffer, int useBuffer);
+	Result CreateBuffer(int width, int height, int depth, void* pBuffer, int useBuffer);
 	void Destroy();
-	Tgl::Result FillRowsOfTexture(int y, int height, char* content);
-	Tgl::Result InitializePalette(int paletteSize, PaletteEntry* pEntries);
+	Result FillRowsOfTexture(int y, int height, char* content);
+	Result InitializePalette(int paletteSize, PaletteEntry* pEntries);
 
 	D3DRMIMAGE m_image;
 	int m_texelsAllocatedByClient;
@@ -641,12 +641,12 @@ class TextureImpl : public Texture {
 	void* ImplementationDataPtr() override;
 
 	// vtable+0x08
-	Tgl::Result SetTexels(int width, int height, int bitsPerTexel, void* pTexels, int pTexelsArePersistent) override;
+	Result SetTexels(int width, int height, int bitsPerTexel, void* pTexels, int pTexelsArePersistent) override;
 	void FillRowsOfTexture(int y, int height, void* pBuffer) override;
 
 	// vtable+0x10
-	Tgl::Result Changed(int texelsChanged, int paletteChanged) override;
-	Tgl::Result GetBufferAndPalette(
+	Result Changed(int texelsChanged, int paletteChanged) override;
+	Result GetBufferAndPalette(
 		int* pWidth,
 		int* pHeight,
 		int* pDepth,
@@ -654,7 +654,7 @@ class TextureImpl : public Texture {
 		int* ppPaletteSize,
 		unsigned char (*pEntries)[3]
 	) override;
-	Tgl::Result SetPalette(int entryCount, PaletteEntry* entries) override;
+	Result SetPalette(int entryCount, PaletteEntry* entries) override;
 
 	typedef IDirect3DRMTexture* TextureDataType;
 
@@ -670,7 +670,7 @@ class TextureImpl : public Texture {
 
 	friend class RendererImpl;
 
-	static Tgl::Result SetImage(IDirect3DRMTexture* pSelf, TglD3DRMIMAGE* pImage);
+	static Result SetImage(IDirect3DRMTexture* pSelf, TglD3DRMIMAGE* pImage);
 
 private:
 	TextureDataType m_data;
@@ -693,7 +693,7 @@ void TextureImpl::Destroy()
 
 // Used by both Mesh and MeshBuilder
 // FUNCTION: BETA10 0x10170270
-inline Tgl::Result MeshSetTextureMappingMode(MeshImpl::MeshData* pMesh, TextureMappingMode mode)
+inline Result MeshSetTextureMappingMode(MeshImpl::MeshData* pMesh, TextureMappingMode mode)
 {
 	if (mode == PerspectiveCorrect) {
 		return ResultVal(pMesh->groupMesh->SetGroupMapping(pMesh->groupIndex, D3DRMMAP_PERSPCORRECT));
diff --git a/LEGO1/tgl/d3drm/light.cpp b/LEGO1/tgl/d3drm/light.cpp
index 161bace6..cdb577f1 100644
--- a/LEGO1/tgl/d3drm/light.cpp
+++ b/LEGO1/tgl/d3drm/light.cpp
@@ -15,7 +15,7 @@ void* LightImpl::ImplementationDataPtr()
 }
 
 // FUNCTION: BETA10 0x1016f6e0
-inline Tgl::Result LightSetTransformation(IDirect3DRMFrame2* pLight, FloatMatrix4& matrix)
+inline Result LightSetTransformation(IDirect3DRMFrame2* pLight, FloatMatrix4& matrix)
 {
 	D3DRMMATRIX4D helper;
 	D3DRMMATRIX4D* d3dMatrix = Translate(matrix, helper);
@@ -24,7 +24,7 @@ inline Tgl::Result LightSetTransformation(IDirect3DRMFrame2* pLight, FloatMatrix
 
 // FUNCTION: LEGO1 0x100a3780
 // FUNCTION: BETA10 0x1016f680
-Tgl::Result LightImpl::SetTransformation(FloatMatrix4& matrix)
+Result LightImpl::SetTransformation(FloatMatrix4& matrix)
 {
 	assert(m_data);
 
@@ -32,11 +32,11 @@ Tgl::Result LightImpl::SetTransformation(FloatMatrix4& matrix)
 }
 
 // FUNCTION: BETA10 0x1016f860
-inline Tgl::Result LightSetColor(IDirect3DRMFrame2* pLight, float r, float g, float b)
+inline Result LightSetColor(IDirect3DRMFrame2* pLight, float r, float g, float b)
 {
 	IDirect3DRMLightArray* lights;
 	IDirect3DRMLight* light;
-	Tgl::Result result = ResultVal(pLight->GetLights(&lights));
+	Result result = ResultVal(pLight->GetLights(&lights));
 	assert(Succeeded(result));
 	assert(lights->GetSize() == 1);
 
@@ -48,7 +48,7 @@ inline Tgl::Result LightSetColor(IDirect3DRMFrame2* pLight, float r, float g, fl
 
 // FUNCTION: LEGO1 0x100a37e0
 // FUNCTION: BETA10 0x1016f7f0
-Tgl::Result LightImpl::SetColor(float r, float g, float b)
+Result LightImpl::SetColor(float r, float g, float b)
 {
 	assert(m_data);
 
diff --git a/LEGO1/tgl/d3drm/mesh.cpp b/LEGO1/tgl/d3drm/mesh.cpp
index 2fdad9d5..8d20acae 100644
--- a/LEGO1/tgl/d3drm/mesh.cpp
+++ b/LEGO1/tgl/d3drm/mesh.cpp
@@ -17,7 +17,7 @@ void* MeshImpl::ImplementationDataPtr()
 }
 
 // FUNCTION: BETA10 0x10170590
-inline Tgl::Result MeshSetColor(MeshImpl::MeshData* pMesh, float r, float g, float b, float a)
+inline Result MeshSetColor(MeshImpl::MeshData* pMesh, float r, float g, float b, float a)
 {
 	if (a > 0) {
 		D3DCOLOR color = D3DRMCreateColorRGBA(r, g, b, a);
@@ -30,7 +30,7 @@ inline Tgl::Result MeshSetColor(MeshImpl::MeshData* pMesh, float r, float g, flo
 
 // FUNCTION: LEGO1 0x100a3ee0
 // FUNCTION: BETA10 0x10170520
-Tgl::Result MeshImpl::SetColor(float r, float g, float b, float a)
+Result MeshImpl::SetColor(float r, float g, float b, float a)
 {
 	assert(m_data);
 
@@ -38,14 +38,14 @@ Tgl::Result MeshImpl::SetColor(float r, float g, float b, float a)
 }
 
 // FUNCTION: BETA10 0x10171320
-inline Tgl::Result MeshSetTexture(MeshImpl::MeshData* pMesh, IDirect3DRMTexture* pD3DTexture)
+inline Result MeshSetTexture(MeshImpl::MeshData* pMesh, IDirect3DRMTexture* pD3DTexture)
 {
-	Tgl::Result result = ResultVal(pMesh->groupMesh->SetGroupTexture(pMesh->groupIndex, pD3DTexture));
+	Result result = ResultVal(pMesh->groupMesh->SetGroupTexture(pMesh->groupIndex, pD3DTexture));
 	return result;
 }
 
 // FUNCTION: BETA10 0x10171260
-inline Tgl::Result MeshImpl::SetTexture(const TextureImpl* pTexture)
+inline Result MeshImpl::SetTexture(const TextureImpl* pTexture)
 {
 	assert(m_data);
 	assert(!pTexture || pTexture->ImplementationData());
@@ -56,7 +56,7 @@ inline Tgl::Result MeshImpl::SetTexture(const TextureImpl* pTexture)
 
 // FUNCTION: LEGO1 0x100a3f50
 // FUNCTION: BETA10 0x10170630
-Tgl::Result MeshImpl::SetTexture(const Texture* pTexture)
+Result MeshImpl::SetTexture(const Texture* pTexture)
 {
 	assert(m_data);
 
@@ -65,7 +65,7 @@ Tgl::Result MeshImpl::SetTexture(const Texture* pTexture)
 
 // FUNCTION: LEGO1 0x100a3f80
 // FUNCTION: BETA10 0x10170690
-Tgl::Result MeshImpl::SetTextureMappingMode(TextureMappingMode mode)
+Result MeshImpl::SetTextureMappingMode(TextureMappingMode mode)
 {
 	assert(m_data);
 
@@ -73,7 +73,7 @@ Tgl::Result MeshImpl::SetTextureMappingMode(TextureMappingMode mode)
 }
 
 // FUNCTION: BETA10 0x10170750
-inline Tgl::Result MeshSetShadingModel(MeshImpl::MeshData* pMesh, ShadingModel model)
+inline Result MeshSetShadingModel(MeshImpl::MeshData* pMesh, ShadingModel model)
 {
 	D3DRMRENDERQUALITY mode = Translate(model);
 	return ResultVal(pMesh->groupMesh->SetGroupQuality(pMesh->groupIndex, mode));
@@ -81,27 +81,23 @@ inline Tgl::Result MeshSetShadingModel(MeshImpl::MeshData* pMesh, ShadingModel m
 
 // FUNCTION: LEGO1 0x100a3fc0
 // FUNCTION: BETA10 0x101706f0
-Tgl::Result MeshImpl::SetShadingModel(ShadingModel model)
+Result MeshImpl::SetShadingModel(ShadingModel model)
 {
 	assert(m_data);
 	return MeshSetShadingModel(m_data, model);
 }
 
 // FUNCTION: BETA10 0x101714e0
-inline Tgl::Result MeshDeepClone(MeshImpl::MeshData* pSource, MeshImpl::MeshData*& rpTarget, IDirect3DRMMesh* pMesh)
+inline Result MeshDeepClone(MeshImpl::MeshData* pSource, MeshImpl::MeshData*& rpTarget, IDirect3DRMMesh* pMesh)
 {
 	rpTarget = new MeshImpl::MeshData();
 	rpTarget->groupMesh = pMesh;
 
 	// Query information from old group
 	DWORD dataSize;
-#if defined(__3DS__)
-	unsigned long vcount, fcount, vperface;
-#else
-	unsigned int vcount, fcount, vperface;
-#endif
+	DWORD vcount, fcount, vperface;
 
-	Tgl::Result result =
+	Result result =
 		ResultVal(pSource->groupMesh->GetGroup(pSource->groupIndex, &vcount, &fcount, &vperface, &dataSize, NULL));
 	assert(Succeeded(result));
 
@@ -189,9 +185,9 @@ Mesh* MeshImpl::DeepClone(MeshBuilder* pMesh)
 	return DeepClone(*static_cast<MeshBuilderImpl*>(pMesh));
 }
 
-inline Tgl::Result MeshShallowClone(MeshImpl::MeshData* pSource, MeshImpl::MeshData*& rpTarget, IDirect3DRMMesh* pMesh)
+inline Result MeshShallowClone(MeshImpl::MeshData* pSource, MeshImpl::MeshData*& rpTarget, IDirect3DRMMesh* pMesh)
 {
-	Tgl::Result result = Error;
+	Result result = Error;
 	rpTarget = new MeshImpl::MeshData();
 
 	if (rpTarget) {
@@ -229,13 +225,13 @@ Mesh* MeshImpl::ShallowClone(MeshBuilder* pMeshBuilder)
 }
 
 // FUNCTION: BETA10 0x10171ac0
-inline Tgl::Result MeshGetTexture(MeshImpl::MeshData* pMesh, IDirect3DRMTexture** pD3DTexture)
+inline Result MeshGetTexture(MeshImpl::MeshData* pMesh, IDirect3DRMTexture** pD3DTexture)
 {
 	return ResultVal(pMesh->groupMesh->GetGroupTexture(pMesh->groupIndex, pD3DTexture));
 }
 
 // FUNCTION: BETA10 0x10171980
-inline Tgl::Result MeshImpl::GetTexture(TextureImpl** ppTexture)
+inline Result MeshImpl::GetTexture(TextureImpl** ppTexture)
 {
 	assert(m_data);
 	assert(ppTexture);
@@ -245,7 +241,7 @@ inline Tgl::Result MeshImpl::GetTexture(TextureImpl** ppTexture)
 
 	// TODO: This helps retail match, but it adds to the stack
 	IDirect3DRMTexture* tex;
-	Tgl::Result result = MeshGetTexture(m_data, &tex);
+	Result result = MeshGetTexture(m_data, &tex);
 
 #ifndef BETA10
 	if (Succeeded(result)) {
@@ -260,7 +256,7 @@ inline Tgl::Result MeshImpl::GetTexture(TextureImpl** ppTexture)
 
 // FUNCTION: LEGO1 0x100a4330
 // FUNCTION: BETA10 0x10170820
-Tgl::Result MeshImpl::GetTexture(Texture*& rpTexture)
+Result MeshImpl::GetTexture(Texture*& rpTexture)
 {
 	assert(m_data);
 
diff --git a/LEGO1/tgl/d3drm/meshbuilder.cpp b/LEGO1/tgl/d3drm/meshbuilder.cpp
index 8981e556..d152e5aa 100644
--- a/LEGO1/tgl/d3drm/meshbuilder.cpp
+++ b/LEGO1/tgl/d3drm/meshbuilder.cpp
@@ -45,7 +45,7 @@ Mesh* MeshBuilderImpl::CreateMesh(
 	return pMeshImpl;
 }
 
-inline Tgl::Result CreateMesh(
+inline Result CreateMesh(
 	IDirect3DRMMesh* pD3DRM,
 	unsigned int faceCount,
 	unsigned int vertexCount,
@@ -100,7 +100,7 @@ inline Tgl::Result CreateMesh(
 		}
 	}
 
-	Tgl::Result result;
+	Result result;
 	result = ResultVal(pD3DRM->AddGroup(vertexCount, faceCount, 3, fData, &groupIndex));
 
 	if (Succeeded(result)) {
@@ -129,7 +129,7 @@ inline Tgl::Result CreateMesh(
 	return result;
 }
 
-inline Tgl::Result MeshBuilderImpl::CreateMeshImpl(
+inline Result MeshBuilderImpl::CreateMeshImpl(
 	MeshImpl* pMeshImpl,
 	unsigned int faceCount,
 	unsigned int vertexCount,
@@ -156,10 +156,10 @@ inline Tgl::Result MeshBuilderImpl::CreateMeshImpl(
 }
 
 // FUNCTION: BETA10 0x1016e060
-inline Tgl::Result MeshBuilderGetBoundingBox(IDirect3DRMMesh* pMesh, float min[3], float max[3])
+inline Result MeshBuilderGetBoundingBox(IDirect3DRMMesh* pMesh, float min[3], float max[3])
 {
 	D3DRMBOX box;
-	Tgl::Result result = ResultVal(pMesh->GetBox(&box));
+	Result result = ResultVal(pMesh->GetBox(&box));
 	if (Succeeded(result)) {
 		min[0] = box.min.x;
 		min[1] = box.min.y;
@@ -173,7 +173,7 @@ inline Tgl::Result MeshBuilderGetBoundingBox(IDirect3DRMMesh* pMesh, float min[3
 
 // FUNCTION: LEGO1 0x100a3ae0
 // FUNCTION: BETA10 0x1016ce00
-Tgl::Result MeshBuilderImpl::GetBoundingBox(float min[3], float max[3]) const
+Result MeshBuilderImpl::GetBoundingBox(float min[3], float max[3]) const
 {
 	assert(m_data);
 
diff --git a/LEGO1/tgl/d3drm/renderer.cpp b/LEGO1/tgl/d3drm/renderer.cpp
index 61201c81..cd6524f1 100644
--- a/LEGO1/tgl/d3drm/renderer.cpp
+++ b/LEGO1/tgl/d3drm/renderer.cpp
@@ -22,7 +22,7 @@ IDirect3DRM2* g_pD3DRM = NULL;
 } // namespace TglImpl
 
 // Inlined only
-Tgl::Result RendererImpl::Create()
+Result RendererImpl::Create()
 {
 	if (g_pD3DRM) {
 		g_pD3DRM->AddRef();
@@ -37,19 +37,19 @@ Tgl::Result RendererImpl::Create()
 }
 
 // FUNCTION: BETA10 0x1016cf00
-inline Tgl::Result RendererCreateDevice(
+inline Result RendererCreateDevice(
 	IDirect3DRM2* pD3DRM,
 	const DeviceDirect3DCreateData& rCreateData,
 	IDirect3DRMDevice2*& rpDevice
 )
 {
-	Tgl::Result result =
+	Result result =
 		ResultVal(pD3DRM->CreateDeviceFromD3D(rCreateData.m_pDirect3D, rCreateData.m_pDirect3DDevice, &rpDevice));
 	return result;
 }
 
 // FUNCTION: BETA10 0x1016ce60
-inline Tgl::Result RendererImpl::CreateDevice(const DeviceDirect3DCreateData& rCreateData, DeviceImpl& rDevice)
+inline Result RendererImpl::CreateDevice(const DeviceDirect3DCreateData& rCreateData, DeviceImpl& rDevice)
 {
 	assert(m_data);
 	assert(!rDevice.ImplementationData());
@@ -73,13 +73,13 @@ Device* RendererImpl::CreateDevice(const DeviceDirect3DCreateData& data)
 }
 
 // FUNCTION: BETA10 0x1016cfe0
-inline Tgl::Result RendererCreateDevice(
+inline Result RendererCreateDevice(
 	IDirect3DRM2* pD3DRM,
 	const DeviceDirectDrawCreateData& rCreateData,
 	IDirect3DRMDevice2*& rpDevice
 )
 {
-	Tgl::Result result = ResultVal(pD3DRM->CreateDeviceFromSurface(
+	Result result = ResultVal(pD3DRM->CreateDeviceFromSurface(
 		const_cast<GUID*>(rCreateData.m_driverGUID),
 		rCreateData.m_pDirectDraw,
 		rCreateData.m_pBackBuffer,
@@ -92,7 +92,7 @@ inline Tgl::Result RendererCreateDevice(
 			// GLOBAL: BETA10 0x102055f4
 			static int g_setBufferCount = 1;
 			if (g_setBufferCount) {
-				Tgl::Result result2 = ResultVal(rpDevice->SetBufferCount(2));
+				Result result2 = ResultVal(rpDevice->SetBufferCount(2));
 				assert(Succeeded(result));
 			}
 		}
@@ -102,7 +102,7 @@ inline Tgl::Result RendererCreateDevice(
 }
 
 // FUNCTION: BETA10 0x1016cf40
-inline Tgl::Result RendererImpl::CreateDevice(const DeviceDirectDrawCreateData& rCreateData, DeviceImpl& rDevice)
+inline Result RendererImpl::CreateDevice(const DeviceDirectDrawCreateData& rCreateData, DeviceImpl& rDevice)
 {
 	assert(m_data);
 	assert(!rDevice.ImplementationData());
@@ -126,7 +126,7 @@ Device* RendererImpl::CreateDevice(const DeviceDirectDrawCreateData& data)
 }
 
 // FUNCTION: BETA10 0x1016d1d0
-inline Tgl::Result RendererCreateView(
+inline Result RendererCreateView(
 	IDirect3DRM2* pRenderer,
 	const IDirect3DRMDevice2* pDevice,
 	const IDirect3DRMFrame2* pCamera,
@@ -137,7 +137,7 @@ inline Tgl::Result RendererCreateView(
 	IDirect3DRMViewport*& rpView
 )
 {
-	Tgl::Result result = ResultVal(pRenderer->CreateViewport(
+	Result result = ResultVal(pRenderer->CreateViewport(
 		const_cast<IDirect3DRMDevice2*>(pDevice),
 		const_cast<IDirect3DRMFrame2*>(pCamera),
 		x,
@@ -159,7 +159,7 @@ inline Tgl::Result RendererCreateView(
 }
 
 // FUNCTION: BETA10 0x1016d0b0
-inline Tgl::Result RendererImpl::CreateView(
+inline Result RendererImpl::CreateView(
 	const DeviceImpl& rDevice,
 	const CameraImpl& rCamera,
 	unsigned int x,
@@ -219,13 +219,13 @@ View* RendererImpl::CreateView(
 }
 
 // FUNCTION: BETA10 0x1016d380
-inline Tgl::Result RendererCreateGroup(
+inline Result RendererCreateGroup(
 	IDirect3DRM2* pRenderer,
 	const IDirect3DRMFrame2* pParent,
 	IDirect3DRMFrame2*& rpGroup
 )
 {
-	Tgl::Result result = ResultVal(pRenderer->CreateFrame(NULL, &rpGroup));
+	Result result = ResultVal(pRenderer->CreateFrame(NULL, &rpGroup));
 	if (Succeeded(result) && pParent) {
 		result = ResultVal(const_cast<IDirect3DRMFrame2*>(pParent)->AddVisual(rpGroup));
 		if (!Succeeded(result)) {
@@ -237,7 +237,7 @@ inline Tgl::Result RendererCreateGroup(
 }
 
 // FUNCTION: BETA10 0x1016d280
-inline Tgl::Result RendererImpl::CreateGroup(const GroupImpl* pParentGroup, GroupImpl& rGroup)
+inline Result RendererImpl::CreateGroup(const GroupImpl* pParentGroup, GroupImpl& rGroup)
 {
 	assert(m_data);
 	assert(!pParentGroup || pParentGroup->ImplementationData());
@@ -265,13 +265,13 @@ Group* RendererImpl::CreateGroup(const Group* pParent)
 }
 
 // FUNCTION: BETA10 0x1016d4b0
-inline Tgl::Result RendererCreateCamera(IDirect3DRM2* pD3DRM, IDirect3DRMFrame2*& rpCamera)
+inline Result RendererCreateCamera(IDirect3DRM2* pD3DRM, IDirect3DRMFrame2*& rpCamera)
 {
 	return ResultVal(pD3DRM->CreateFrame(NULL, &rpCamera));
 }
 
 // FUNCTION: BETA10 0x1016d420
-inline Tgl::Result RendererImpl::CreateCamera(CameraImpl& rCamera)
+inline Result RendererImpl::CreateCamera(CameraImpl& rCamera)
 {
 	assert(m_data);
 	assert(!rCamera.ImplementationData());
@@ -295,7 +295,7 @@ Camera* RendererImpl::CreateCamera()
 }
 
 // FUNCTION: BETA10 0x1016d580
-inline Tgl::Result RendererCreateLight(
+inline Result RendererCreateLight(
 	IDirect3DRM2* pD3DRM,
 	LightType type,
 	float r,
@@ -307,7 +307,7 @@ inline Tgl::Result RendererCreateLight(
 	D3DRMLIGHTTYPE lightType = Translate(type);
 	IDirect3DRMFrame2* pLightFrame;
 	IDirect3DRMLight* pLight;
-	Tgl::Result result;
+	Result result;
 
 	result = ResultVal(pD3DRM->CreateFrame(NULL, &pLightFrame));
 	assert(Succeeded(result));
@@ -348,7 +348,7 @@ inline Tgl::Result RendererCreateLight(
 }
 
 // FUNCTION: BETA10 0x1016d4e0
-inline Tgl::Result RendererImpl::CreateLight(LightType type, float r, float g, float b, LightImpl& rLight)
+inline Result RendererImpl::CreateLight(LightType type, float r, float g, float b, LightImpl& rLight)
 {
 	assert(m_data);
 	assert(!rLight.ImplementationData());
@@ -373,13 +373,13 @@ Light* RendererImpl::CreateLight(LightType type, float r, float g, float b)
 }
 
 // FUNCTION: BETA10 0x1016d8e0
-inline Tgl::Result RendererCreateMeshBuilder(IDirect3DRM2* pD3DRM, IDirect3DRMMesh*& rpMesh)
+inline Result RendererCreateMeshBuilder(IDirect3DRM2* pD3DRM, IDirect3DRMMesh*& rpMesh)
 {
 	return ResultVal(pD3DRM->CreateMesh(&rpMesh));
 }
 
 // FUNCTION: BETA10 0x1016d850
-inline Tgl::Result RendererImpl::CreateMeshBuilder(MeshBuilderImpl& rMesh)
+inline Result RendererImpl::CreateMeshBuilder(MeshBuilderImpl& rMesh)
 {
 	assert(m_data);
 	assert(!rMesh.ImplementationData());
@@ -403,7 +403,7 @@ MeshBuilder* RendererImpl::CreateMeshBuilder()
 }
 
 // FUNCTION: BETA10 0x1016d9c0
-inline Tgl::Result RendererCreateTexture(
+inline Result RendererCreateTexture(
 	IDirect3DRM2* pRenderer,
 	int width,
 	int height,
@@ -415,7 +415,7 @@ inline Tgl::Result RendererCreateTexture(
 	IDirect3DRMTexture*& rpTexture
 )
 {
-	Tgl::Result result;
+	Result result;
 
 	TglD3DRMIMAGE* pImage = new TglD3DRMIMAGE(width, height, bytesPerPixel, pBuffer, useBuffer, paletteSize, pEntries);
 	assert(pImage);
@@ -443,7 +443,7 @@ inline Tgl::Result RendererCreateTexture(
 }
 
 // FUNCTION: BETA10 0x1016d910
-inline Tgl::Result RendererImpl::CreateTexture(
+inline Result RendererImpl::CreateTexture(
 	TextureImpl& rTexture,
 	int width,
 	int height,
@@ -502,13 +502,13 @@ Texture* RendererImpl::CreateTexture(
 }
 
 // FUNCTION: BETA10 0x1016dcb0
-inline Tgl::Result RendererCreateTexture(IDirect3DRM2* pRenderer, IDirect3DRMTexture*& rpTexture)
+inline Result RendererCreateTexture(IDirect3DRM2* pRenderer, IDirect3DRMTexture*& rpTexture)
 {
 	return RendererCreateTexture(pRenderer, 0, 0, 0, NULL, FALSE, 0, NULL, rpTexture);
 }
 
 // FUNCTION: BETA10 0x1016dc20
-inline Tgl::Result RendererImpl::CreateTexture(TextureImpl& rTexture)
+inline Result RendererImpl::CreateTexture(TextureImpl& rTexture)
 {
 	assert(m_data);
 	assert(!rTexture.ImplementationData());
@@ -532,14 +532,14 @@ Texture* RendererImpl::CreateTexture()
 }
 
 // FUNCTION: BETA10 0x1016af90
-inline Tgl::Result RendererSetTextureDefaultShadeCount(IDirect3DRM2* pRenderer, unsigned long shadeCount)
+inline Result RendererSetTextureDefaultShadeCount(IDirect3DRM2* pRenderer, unsigned long shadeCount)
 {
 	return ResultVal(pRenderer->SetDefaultTextureShades(shadeCount));
 }
 
 // FUNCTION: LEGO1 0x100a2270
 // FUNCTION: BETA10 0x1016af30
-Tgl::Result RendererImpl::SetTextureDefaultShadeCount(unsigned int shadeCount)
+Result RendererImpl::SetTextureDefaultShadeCount(unsigned int shadeCount)
 {
 	assert(m_data);
 
@@ -547,14 +547,14 @@ Tgl::Result RendererImpl::SetTextureDefaultShadeCount(unsigned int shadeCount)
 }
 
 // FUNCTION: BETA10 0x1016b020
-inline Tgl::Result RendererSetTextureDefaultColorCount(IDirect3DRM2* pRenderer, unsigned long colorCount)
+inline Result RendererSetTextureDefaultColorCount(IDirect3DRM2* pRenderer, unsigned long colorCount)
 {
 	return ResultVal(pRenderer->SetDefaultTextureColors(colorCount));
 }
 
 // FUNCTION: LEGO1 0x100a2290
 // FUNCTION: BETA10 0x1016afc0
-Tgl::Result RendererImpl::SetTextureDefaultColorCount(unsigned int colorCount)
+Result RendererImpl::SetTextureDefaultColorCount(unsigned int colorCount)
 {
 	assert(m_data);
 
diff --git a/LEGO1/tgl/d3drm/texture.cpp b/LEGO1/tgl/d3drm/texture.cpp
index 37d8a0d3..0a19c8c4 100644
--- a/LEGO1/tgl/d3drm/texture.cpp
+++ b/LEGO1/tgl/d3drm/texture.cpp
@@ -17,10 +17,10 @@ void TextureDestroyCallback(IDirect3DRMObject* pObject, void* pArg);
 
 // FUNCTION: LEGO1 0x100a12a0
 // FUNCTION: BETA10 0x10169113
-Tgl::Result TextureImpl::SetImage(IDirect3DRMTexture* pSelf, TglD3DRMIMAGE* pImage)
+Result TextureImpl::SetImage(IDirect3DRMTexture* pSelf, TglD3DRMIMAGE* pImage)
 {
 	void* appData;
-	Tgl::Result result;
+	Result result;
 
 	appData = pImage;
 	assert(reinterpret_cast<TglD3DRMIMAGE*>(appData) == pImage);
@@ -84,7 +84,7 @@ TglD3DRMIMAGE::TglD3DRMIMAGE(
 	m_image.palette = NULL;
 	m_texelsAllocatedByClient = 0;
 
-	Tgl::Result result;
+	Result result;
 	if (pBuffer != NULL) {
 		result = CreateBuffer(width, height, depth, pBuffer, useBuffer);
 		assert(Succeeded(result));
@@ -122,7 +122,7 @@ inline static int IsPowerOfTwo(int v)
 
 // FUNCTION: LEGO1 0x100a13e0
 // FUNCTION: BETA10 0x101694a4
-Tgl::Result TglD3DRMIMAGE::CreateBuffer(int width, int height, int depth, void* pBuffer, int useBuffer)
+Result TglD3DRMIMAGE::CreateBuffer(int width, int height, int depth, void* pBuffer, int useBuffer)
 {
 	int bytesPerScanline = width;
 
@@ -162,7 +162,7 @@ Tgl::Result TglD3DRMIMAGE::CreateBuffer(int width, int height, int depth, void*
 
 // FUNCTION: LEGO1 0x100a1510
 // FUNCTION: BETA10 0x1016969c
-Tgl::Result TglD3DRMIMAGE::FillRowsOfTexture(int destVOffset, int srcHeight, char* pTexels)
+Result TglD3DRMIMAGE::FillRowsOfTexture(int destVOffset, int srcHeight, char* pTexels)
 {
 	assert(m_image.buffer1 && pTexels);
 	assert((destVOffset + srcHeight) <= m_image.height);
@@ -175,7 +175,7 @@ Tgl::Result TglD3DRMIMAGE::FillRowsOfTexture(int destVOffset, int srcHeight, cha
 
 // FUNCTION: LEGO1 0x100a1550
 // FUNCTION: BETA10 0x10169758
-Tgl::Result TglD3DRMIMAGE::InitializePalette(int paletteSize, PaletteEntry* pEntries)
+Result TglD3DRMIMAGE::InitializePalette(int paletteSize, PaletteEntry* pEntries)
 {
 	// This function is a 100% match if the PaletteEntry class is copied
 	// into into the TglD3DRMIMAGE class instead of being a global struct.
@@ -204,7 +204,7 @@ Tgl::Result TglD3DRMIMAGE::InitializePalette(int paletteSize, PaletteEntry* pEnt
 }
 
 // FUNCTION: BETA10 0x1016ee80
-inline Tgl::Result TextureSetTexels(
+inline Result TextureSetTexels(
 	IDirect3DRMTexture* pTexture,
 	int width,
 	int height,
@@ -216,7 +216,7 @@ inline Tgl::Result TextureSetTexels(
 	TglD3DRMIMAGE* pImage = TextureGetImage(pTexture);
 	assert(pImage);
 
-	Tgl::Result result = pImage->CreateBuffer(width, height, bitsPerTexel, pTexels, pTexelsArePersistent);
+	Result result = pImage->CreateBuffer(width, height, bitsPerTexel, pTexels, pTexelsArePersistent);
 	assert(Succeeded(result));
 
 	if (Succeeded(result)) {
@@ -229,7 +229,7 @@ inline Tgl::Result TextureSetTexels(
 
 // FUNCTION: LEGO1 0x100a3c10
 // FUNCTION: BETA10 0x1016c390
-Tgl::Result TextureImpl::SetTexels(int width, int height, int bitsPerTexel, void* pTexels, int pTexelsArePersistent)
+Result TextureImpl::SetTexels(int width, int height, int bitsPerTexel, void* pTexels, int pTexelsArePersistent)
 {
 	assert(m_data);
 
@@ -237,12 +237,12 @@ Tgl::Result TextureImpl::SetTexels(int width, int height, int bitsPerTexel, void
 }
 
 // FUNCTION: BETA10 0x1016f160
-inline Tgl::Result TextureFillRowsOfTexture(IDirect3DRMTexture* pTexture, int y, int height, void* pBuffer)
+inline Result TextureFillRowsOfTexture(IDirect3DRMTexture* pTexture, int y, int height, void* pBuffer)
 {
 	TglD3DRMIMAGE* pImage = TextureGetImage(pTexture);
 	assert(pImage);
 
-	Tgl::Result result = pImage->FillRowsOfTexture(y, height, (char*) pBuffer);
+	Result result = pImage->FillRowsOfTexture(y, height, (char*) pBuffer);
 	assert(Succeeded(result));
 
 	return result;
@@ -258,16 +258,16 @@ void TextureImpl::FillRowsOfTexture(int y, int height, void* pBuffer)
 }
 
 // FUNCTION: BETA10 0x1016f270
-inline Tgl::Result TextureChanged(IDirect3DRMTexture* pTexture, int texelsChanged, int paletteChanged)
+inline Result TextureChanged(IDirect3DRMTexture* pTexture, int texelsChanged, int paletteChanged)
 {
-	Tgl::Result result = ResultVal(pTexture->Changed(texelsChanged, paletteChanged));
+	Result result = ResultVal(pTexture->Changed(texelsChanged, paletteChanged));
 	assert(Succeeded(result));
 	return result;
 }
 
 // FUNCTION: LEGO1 0x100a3c90
 // FUNCTION: BETA10 0x1016c540
-Tgl::Result TextureImpl::Changed(int texelsChanged, int paletteChanged)
+Result TextureImpl::Changed(int texelsChanged, int paletteChanged)
 {
 	assert(m_data);
 
@@ -275,7 +275,7 @@ Tgl::Result TextureImpl::Changed(int texelsChanged, int paletteChanged)
 }
 
 // FUNCTION: BETA10 0x1016f4c0
-inline Tgl::Result TextureGetBufferAndPalette(
+inline Result TextureGetBufferAndPalette(
 	IDirect3DRMTexture* pTexture,
 	int* width,
 	int* height,
@@ -305,7 +305,7 @@ inline Tgl::Result TextureGetBufferAndPalette(
 
 // FUNCTION: LEGO1 0x100a3cc0
 // FUNCTION: BETA10 0x1016c5d0
-Tgl::Result TextureImpl::GetBufferAndPalette(
+Result TextureImpl::GetBufferAndPalette(
 	int* width,
 	int* height,
 	int* depth,
@@ -320,13 +320,13 @@ Tgl::Result TextureImpl::GetBufferAndPalette(
 }
 
 // FUNCTION: BETA10 0x1016f730
-inline Tgl::Result TextureSetPalette(IDirect3DRMTexture* pTexture, int entryCount, PaletteEntry* pEntries)
+inline Result TextureSetPalette(IDirect3DRMTexture* pTexture, int entryCount, PaletteEntry* pEntries)
 {
 	TglD3DRMIMAGE* pImage = TextureGetImage(pTexture);
 	assert(pImage);
 
 	pImage->InitializePalette(entryCount, pEntries);
-	Tgl::Result result = ResultVal(pTexture->Changed(FALSE, TRUE));
+	Result result = ResultVal(pTexture->Changed(FALSE, TRUE));
 	assert(Succeeded(result));
 
 	return Success;
@@ -334,7 +334,7 @@ inline Tgl::Result TextureSetPalette(IDirect3DRMTexture* pTexture, int entryCoun
 
 // FUNCTION: LEGO1 0x100a3d40
 // FUNCTION: BETA10 0x1016c6a0
-Tgl::Result TextureImpl::SetPalette(int entryCount, PaletteEntry* pEntries)
+Result TextureImpl::SetPalette(int entryCount, PaletteEntry* pEntries)
 {
 	assert(m_data);
 
diff --git a/LEGO1/tgl/d3drm/view.cpp b/LEGO1/tgl/d3drm/view.cpp
index 74a83d7c..4a000178 100644
--- a/LEGO1/tgl/d3drm/view.cpp
+++ b/LEGO1/tgl/d3drm/view.cpp
@@ -22,7 +22,7 @@ DECOMP_SIZE_ASSERT(ViewportAppData, 0x18);
 // FUNCTION: BETA10 0x10168920
 ViewportAppData::ViewportAppData(IDirect3DRM2* pRenderer)
 {
-	Tgl::Result result = ResultVal(pRenderer->CreateFrame(NULL, &m_pLightFrame));
+	Result result = ResultVal(pRenderer->CreateFrame(NULL, &m_pLightFrame));
 	assert(Succeeded(result));
 
 	m_pCamera = NULL;
@@ -39,7 +39,7 @@ ViewportAppData::~ViewportAppData()
 	int refCount;
 	IDirect3DRMFrameArray* pChildFrames;
 	IDirect3DRMFrame* pChildFrame = NULL;
-	Tgl::Result result = ResultVal(m_pLightFrame->GetChildren(&pChildFrames));
+	Result result = ResultVal(m_pLightFrame->GetChildren(&pChildFrames));
 	assert(Succeeded(result));
 
 	for (int i = 0; i < (int) pChildFrames->GetSize(); i++) {
@@ -65,7 +65,7 @@ void ViewportDestroyCallback(IDirect3DRMObject* pObject, void* pArg);
 
 // FUNCTION: LEGO1 0x100a1160
 // FUNCTION: BETA10 0x10168ba5
-Tgl::Result ViewImpl::ViewportCreateAppData(
+Result ViewImpl::ViewportCreateAppData(
 	IDirect3DRM2* pDevice,
 	IDirect3DRMViewport* pViewport,
 	IDirect3DRMFrame2* pCamera
@@ -77,7 +77,7 @@ Tgl::Result ViewImpl::ViewportCreateAppData(
 	pViewportAppData->m_pCamera = pCamera;
 	assert(!pViewport->GetAppData());
 
-	Tgl::Result result = ResultVal(pViewport->SetAppData(reinterpret_cast<LPD3DRM_APPDATA>(pViewportAppData)));
+	Result result = ResultVal(pViewport->SetAppData(reinterpret_cast<LPD3DRM_APPDATA>(pViewportAppData)));
 	assert(Succeeded(result));
 	assert(reinterpret_cast<ViewportAppData*>(pViewport->GetAppData()) == pViewportAppData);
 
@@ -95,13 +95,13 @@ Tgl::Result ViewImpl::ViewportCreateAppData(
 }
 
 // FUNCTION: BETA10 0x1016bd80
-inline Tgl::Result ViewRestoreFrameAfterRender(
+inline Result ViewRestoreFrameAfterRender(
 	IDirect3DRMFrame* pFrame,
 	IDirect3DRMFrame* pCamera,
 	IDirect3DRMFrame* pLightFrame
 )
 {
-	Tgl::Result result = Success;
+	Result result = Success;
 	if (pFrame) {
 		// remove camera and light frame from frame that was rendered
 		// this doesn't destroy the camera as it is still the camera of the viewport...
@@ -128,7 +128,7 @@ void ViewportDestroyCallback(IDirect3DRMObject* pObject, void* pArg)
 	assert(static_cast<ViewImpl::ViewDataType>(pObject));
 	assert(pViewportAppData);
 
-	Tgl::Result result = ViewRestoreFrameAfterRender(
+	Result result = ViewRestoreFrameAfterRender(
 		pViewportAppData->m_pLastRenderedFrame,
 		pViewportAppData->m_pCamera,
 		pViewportAppData->m_pLightFrame
@@ -141,7 +141,7 @@ void ViewportDestroyCallback(IDirect3DRMObject* pObject, void* pArg)
 
 // FUNCTION: LEGO1 0x100a1290
 // FUNCTION: BETA10 0x10168eab
-Tgl::Result ViewportPickImpl(
+Result ViewportPickImpl(
 	IDirect3DRMViewport* pViewport,
 	int x,
 	int y,
@@ -175,7 +175,7 @@ void* ViewImpl::ImplementationDataPtr()
 }
 
 // FUNCTION: BETA10 0x10170a40
-inline Tgl::Result ViewAddLight(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame* pLight)
+inline Result ViewAddLight(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame* pLight)
 {
 	IDirect3DRMFrame* pLightFrame = ViewportGetLightFrame(pViewport);
 
@@ -184,7 +184,7 @@ inline Tgl::Result ViewAddLight(IDirect3DRMViewport* pViewport, const IDirect3DR
 }
 
 // FUNCTION: BETA10 0x101709a0
-inline Tgl::Result ViewImpl::Add(const LightImpl& rLight)
+inline Result ViewImpl::Add(const LightImpl& rLight)
 {
 	assert(m_data);
 	assert(rLight.ImplementationData());
@@ -194,7 +194,7 @@ inline Tgl::Result ViewImpl::Add(const LightImpl& rLight)
 
 // FUNCTION: LEGO1 0x100a2d90
 // FUNCTION: BETA10 0x1016e690
-Tgl::Result ViewImpl::Add(const Light* pLight)
+Result ViewImpl::Add(const Light* pLight)
 {
 	assert(m_data);
 	assert(pLight);
@@ -203,7 +203,7 @@ Tgl::Result ViewImpl::Add(const Light* pLight)
 }
 
 // FUNCTION: BETA10 0x10170bb0
-inline Tgl::Result ViewRemoveLight(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame* pLight)
+inline Result ViewRemoveLight(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame* pLight)
 {
 	IDirect3DRMFrame* pLightFrame = ViewportGetLightFrame(pViewport);
 
@@ -212,7 +212,7 @@ inline Tgl::Result ViewRemoveLight(IDirect3DRMViewport* pViewport, const IDirect
 }
 
 // FUNCTION: BETA10 0x10170b10
-inline Tgl::Result ViewImpl::Remove(const LightImpl& rLight)
+inline Result ViewImpl::Remove(const LightImpl& rLight)
 {
 	assert(m_data);
 	assert(rLight.ImplementationData());
@@ -222,7 +222,7 @@ inline Tgl::Result ViewImpl::Remove(const LightImpl& rLight)
 
 // FUNCTION: LEGO1 0x100a2dc0
 // FUNCTION: BETA10 0x1016e710
-Tgl::Result ViewImpl::Remove(const Light* pLight)
+Result ViewImpl::Remove(const Light* pLight)
 {
 	assert(m_data);
 	assert(pLight);
@@ -231,10 +231,10 @@ Tgl::Result ViewImpl::Remove(const Light* pLight)
 }
 
 // FUNCTION: BETA10 0x10170cc0
-inline Tgl::Result ViewSetCamera(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame2* pCamera)
+inline Result ViewSetCamera(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame2* pCamera)
 {
 	ViewportAppData* pViewportAppData;
-	Tgl::Result result;
+	Result result;
 
 	pViewportAppData = reinterpret_cast<ViewportAppData*>(pViewport->GetAppData());
 	assert(pViewportAppData);
@@ -252,7 +252,7 @@ inline Tgl::Result ViewSetCamera(IDirect3DRMViewport* pViewport, const IDirect3D
 }
 
 // FUNCTION: BETA10 0x10170c20
-inline Tgl::Result ViewImpl::SetCamera(const CameraImpl& rCamera)
+inline Result ViewImpl::SetCamera(const CameraImpl& rCamera)
 {
 	assert(m_data);
 	assert(rCamera.ImplementationData());
@@ -262,7 +262,7 @@ inline Tgl::Result ViewImpl::SetCamera(const CameraImpl& rCamera)
 
 // FUNCTION: LEGO1 0x100a2df0
 // FUNCTION: BETA10 0x1016e790
-Tgl::Result ViewImpl::SetCamera(const Camera* pCamera)
+Result ViewImpl::SetCamera(const Camera* pCamera)
 {
 	assert(m_data);
 	assert(pCamera);
@@ -271,7 +271,7 @@ Tgl::Result ViewImpl::SetCamera(const Camera* pCamera)
 }
 
 // FUNCTION: BETA10 0x1016e870
-inline Tgl::Result ViewSetProjection(IDirect3DRMViewport* pViewport, ProjectionType type)
+inline Result ViewSetProjection(IDirect3DRMViewport* pViewport, ProjectionType type)
 {
 	D3DRMPROJECTIONTYPE projectionType = Translate(type);
 
@@ -280,7 +280,7 @@ inline Tgl::Result ViewSetProjection(IDirect3DRMViewport* pViewport, ProjectionT
 
 // FUNCTION: LEGO1 0x100a2e70
 // FUNCTION: BETA10 0x1016e810
-Tgl::Result ViewImpl::SetProjection(ProjectionType type)
+Result ViewImpl::SetProjection(ProjectionType type)
 {
 	assert(m_data);
 
@@ -288,7 +288,7 @@ Tgl::Result ViewImpl::SetProjection(ProjectionType type)
 }
 
 // FUNCTION: BETA10 0x1016e920
-inline Tgl::Result ViewSetFrustrum(
+inline Result ViewSetFrustrum(
 	IDirect3DRMViewport* pViewport,
 	float frontClippingDistance,
 	float backClippingDistance,
@@ -296,7 +296,7 @@ inline Tgl::Result ViewSetFrustrum(
 )
 {
 	float field = frontClippingDistance * tan(DegreesToRadians(degrees / 2));
-	Tgl::Result result;
+	Result result;
 	result = ResultVal(pViewport->SetFront(frontClippingDistance));
 	if (Succeeded(result)) {
 		result = ResultVal(pViewport->SetBack(backClippingDistance));
@@ -310,7 +310,7 @@ inline Tgl::Result ViewSetFrustrum(
 
 // FUNCTION: LEGO1 0x100a2eb0
 // FUNCTION: BETA10 0x1016e8b0
-Tgl::Result ViewImpl::SetFrustrum(float frontClippingDistance, float backClippingDistance, float degrees)
+Result ViewImpl::SetFrustrum(float frontClippingDistance, float backClippingDistance, float degrees)
 {
 	assert(m_data);
 
@@ -318,9 +318,9 @@ Tgl::Result ViewImpl::SetFrustrum(float frontClippingDistance, float backClippin
 }
 
 // FUNCTION: BETA10 0x1016ea70
-inline Tgl::Result ViewSetBackgroundColor(IDirect3DRMViewport* pViewport, float r, float g, float b)
+inline Result ViewSetBackgroundColor(IDirect3DRMViewport* pViewport, float r, float g, float b)
 {
-	Tgl::Result result = Success;
+	Result result = Success;
 
 	ViewportAppData* pViewportAppData = reinterpret_cast<ViewportAppData*>(pViewport->GetAppData());
 	assert(pViewportAppData);
@@ -339,7 +339,7 @@ inline Tgl::Result ViewSetBackgroundColor(IDirect3DRMViewport* pViewport, float
 
 // FUNCTION: LEGO1 0x100a2f30
 // FUNCTION: BETA10 0x1016ea00
-Tgl::Result ViewImpl::SetBackgroundColor(float r, float g, float b)
+Result ViewImpl::SetBackgroundColor(float r, float g, float b)
 {
 	assert(m_data);
 
@@ -347,7 +347,7 @@ Tgl::Result ViewImpl::SetBackgroundColor(float r, float g, float b)
 }
 
 // FUNCTION: BETA10 0x1016ebd0
-inline Tgl::Result ViewGetBackgroundColor(IDirect3DRMViewport* pViewport, float* r, float* g, float* b)
+inline Result ViewGetBackgroundColor(IDirect3DRMViewport* pViewport, float* r, float* g, float* b)
 {
 	ViewportAppData* pViewportAppData = reinterpret_cast<ViewportAppData*>(pViewport->GetAppData());
 	assert(pViewportAppData);
@@ -361,7 +361,7 @@ inline Tgl::Result ViewGetBackgroundColor(IDirect3DRMViewport* pViewport, float*
 
 // FUNCTION: LEGO1 0x100a2f80
 // FUNCTION: BETA10 0x1016eb60
-Tgl::Result ViewImpl::GetBackgroundColor(float* r, float* g, float* b)
+Result ViewImpl::GetBackgroundColor(float* r, float* g, float* b)
 {
 	assert(m_data);
 
@@ -369,14 +369,14 @@ Tgl::Result ViewImpl::GetBackgroundColor(float* r, float* g, float* b)
 }
 
 // FUNCTION: BETA10 0x1016ecb0
-inline Tgl::Result ViewClear(IDirect3DRMViewport* pViewport)
+inline Result ViewClear(IDirect3DRMViewport* pViewport)
 {
 	return ResultVal(pViewport->Clear());
 }
 
 // FUNCTION: LEGO1 0x100a2fb0
 // FUNCTION: BETA10 0x1016ec50
-Tgl::Result ViewImpl::Clear()
+Result ViewImpl::Clear()
 {
 	assert(m_data);
 
@@ -384,7 +384,7 @@ Tgl::Result ViewImpl::Clear()
 }
 
 // FUNCTION: BETA10 0x10170fb0
-inline Tgl::Result ViewPrepareFrameForRender(
+inline Result ViewPrepareFrameForRender(
 	IDirect3DRMFrame* pFrame,
 	IDirect3DRMFrame* pCamera,
 	IDirect3DRMFrame* pLightFrame,
@@ -393,7 +393,7 @@ inline Tgl::Result ViewPrepareFrameForRender(
 	float backgroundBlue
 )
 {
-	Tgl::Result result = Success;
+	Result result = Success;
 
 	if (pFrame) {
 		// set background color
@@ -416,10 +416,10 @@ inline Tgl::Result ViewPrepareFrameForRender(
 }
 
 // FUNCTION: BETA10 0x10170e30
-inline Tgl::Result ViewRender(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame2* pGroup)
+inline Result ViewRender(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame2* pGroup)
 {
 	ViewportAppData* pViewportAppData;
-	Tgl::Result result;
+	Result result;
 
 	pViewportAppData = reinterpret_cast<ViewportAppData*>(pViewport->GetAppData());
 	assert(pViewportAppData);
@@ -454,7 +454,7 @@ inline Tgl::Result ViewRender(IDirect3DRMViewport* pViewport, const IDirect3DRMF
 }
 
 // FUNCTION: BETA10 0x10170d90
-inline Tgl::Result ViewImpl::Render(const GroupImpl& rScene)
+inline Result ViewImpl::Render(const GroupImpl& rScene)
 {
 	assert(m_data);
 	assert(rScene.ImplementationData());
@@ -464,7 +464,7 @@ inline Tgl::Result ViewImpl::Render(const GroupImpl& rScene)
 
 // FUNCTION: LEGO1 0x100a2fd0
 // FUNCTION: BETA10 0x1016ece0
-Tgl::Result ViewImpl::Render(const Group* pGroup)
+Result ViewImpl::Render(const Group* pGroup)
 {
 	assert(m_data);
 	assert(pGroup);
@@ -473,7 +473,7 @@ Tgl::Result ViewImpl::Render(const Group* pGroup)
 }
 
 // FUNCTION: BETA10 0x1016edd0
-inline Tgl::Result ViewForceUpdate(
+inline Result ViewForceUpdate(
 	IDirect3DRMViewport* pViewport,
 	unsigned int x,
 	unsigned int y,
@@ -486,7 +486,7 @@ inline Tgl::Result ViewForceUpdate(
 
 // FUNCTION: LEGO1 0x100a3080
 // FUNCTION: BETA10 0x1016ed60
-Tgl::Result ViewImpl::ForceUpdate(unsigned int x, unsigned int y, unsigned int width, unsigned int height)
+Result ViewImpl::ForceUpdate(unsigned int x, unsigned int y, unsigned int width, unsigned int height)
 {
 	assert(m_data);
 
@@ -494,7 +494,7 @@ Tgl::Result ViewImpl::ForceUpdate(unsigned int x, unsigned int y, unsigned int w
 }
 
 // FUNCTION: BETA10 0x101710f0
-inline Tgl::Result ViewImpl::Pick(
+inline Result ViewImpl::Pick(
 	unsigned int x,
 	unsigned int y,
 	const GroupImpl** ppGroupsToPickFrom,
@@ -518,7 +518,7 @@ inline Tgl::Result ViewImpl::Pick(
 
 // FUNCTION: LEGO1 0x100a30c0
 // FUNCTION: BETA10 0x1016ee10
-Tgl::Result ViewImpl::Pick(
+Result ViewImpl::Pick(
 	unsigned int x,
 	unsigned int y,
 	const Group** ppGroupsToPickFrom,
@@ -540,12 +540,12 @@ Tgl::Result ViewImpl::Pick(
 }
 
 // FUNCTION: BETA10 0x1016eff0
-inline Tgl::Result ViewTransformWorldToScreen(IDirect3DRMViewport* pViewport, const float world[3], float screen[4])
+inline Result ViewTransformWorldToScreen(IDirect3DRMViewport* pViewport, const float world[3], float screen[4])
 {
 	D3DRMVECTOR4D d3dRMScreen;
 	D3DVECTOR d3dRMWorld;
 	D3DVECTOR* pD3DRMWorld = Translate(world, d3dRMWorld);
-	Tgl::Result result;
+	Result result;
 
 	result = ResultVal(pViewport->Transform(&d3dRMScreen, pD3DRMWorld));
 
@@ -561,7 +561,7 @@ inline Tgl::Result ViewTransformWorldToScreen(IDirect3DRMViewport* pViewport, co
 
 // FUNCTION: LEGO1 0x100a30f0
 // FUNCTION: BETA10 0x1016ef90
-Tgl::Result ViewImpl::TransformWorldToScreen(const float world[3], float screen[4])
+Result ViewImpl::TransformWorldToScreen(const float world[3], float screen[4])
 {
 	assert(m_data);
 
@@ -569,7 +569,7 @@ Tgl::Result ViewImpl::TransformWorldToScreen(const float world[3], float screen[
 }
 
 // FUNCTION: BETA10 0x1016f0d0
-inline Tgl::Result ViewTransformScreenToWorld(IDirect3DRMViewport* pViewport, const float screen[4], float world[3])
+inline Result ViewTransformScreenToWorld(IDirect3DRMViewport* pViewport, const float screen[4], float world[3])
 {
 	D3DVECTOR d3dRMWorld;
 	D3DRMVECTOR4D d3dScreen;
@@ -577,7 +577,7 @@ inline Tgl::Result ViewTransformScreenToWorld(IDirect3DRMViewport* pViewport, co
 	d3dScreen.y = screen[1];
 	d3dScreen.z = screen[2];
 	d3dScreen.w = screen[3];
-	Tgl::Result result;
+	Result result;
 
 	result = ResultVal(pViewport->InverseTransform(&d3dRMWorld, &d3dScreen));
 
@@ -592,7 +592,7 @@ inline Tgl::Result ViewTransformScreenToWorld(IDirect3DRMViewport* pViewport, co
 
 // FUNCTION: LEGO1 0x100a3160
 // FUNCTION: BETA10 0x1016f070
-Tgl::Result ViewImpl::TransformScreenToWorld(const float screen[4], float world[3])
+Result ViewImpl::TransformScreenToWorld(const float screen[4], float world[3])
 {
 	assert(m_data);
 
diff --git a/miniwin/include/miniwin/windows.h b/miniwin/include/miniwin/windows.h
index 32634a8e..bd54249d 100644
--- a/miniwin/include/miniwin/windows.h
+++ b/miniwin/include/miniwin/windows.h
@@ -1,8 +1,5 @@
 #pragma once
 
-#if defined(__3DS__)
-	#include <3ds/types.h>
-#endif
 #include <SDL3/SDL_video.h>
 #include <limits.h>
 #include <stdint.h>