isledecomp/isle-portable
1
0
Fork 0
mirror of https://github.com/isledecomp/isle-portable.git synced 2026-02-03 12:31:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert change prefixing Tgl:: to all Tgl Result vars

Browse Source
This commit is contained in:
Joshua Peisach 2025-06-16 14:48:57 -04:00
parent 0bf2ea9011
commit b1dfa61c38
No known key found for this signature in database
GPG Key ID: 41C3D4189AFEDB5A
12 changed files with 248 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
LEGO1/lego/sources/3dmanager/tglsurface.cpp
View File

@ -84,7 +84,7 @@ BOOL TglSurface::Create(const CreateStruct& rCreateStruct, Renderer* pRenderer,
BOOL dither = TRUE; BOOL dither = TRUE;
int textureShadeCount = -1; int textureShadeCount = -1;
int textureColorCount = -1; int textureColorCount = -1;
Tgl::Result result; Result result;
m_pRenderer = pRenderer; m_pRenderer = pRenderer;
m_pScene = pScene; m_pScene = pScene;
@ -181,7 +181,7 @@ double TglSurface::Render()
MxStopWatch renderTimer; MxStopWatch renderTimer;
if (m_isInitialized && !m_stopRendering) { if (m_isInitialized && !m_stopRendering) {
Tgl::Result result; Result result;
#ifdef _DEBUG #ifdef _DEBUG
m_triangleRateMeter.StartOperation(); m_triangleRateMeter.StartOperation();

8
LEGO1/tgl/d3drm/camera.cpp
View File

@ -15,14 +15,14 @@ void* CameraImpl::ImplementationDataPtr()
} }
// FUNCTION: BETA10 0x1016f390 // FUNCTION: BETA10 0x1016f390
inline Tgl::Result CameraSetTransformation(IDirect3DRMFrame2* pCamera, FloatMatrix4& matrix) inline Result CameraSetTransformation(IDirect3DRMFrame2* pCamera, FloatMatrix4& matrix)
{ {
D3DRMMATRIX4D helper; D3DRMMATRIX4D helper;
D3DRMMATRIX4D* pTransformation = Translate(matrix, helper); D3DRMMATRIX4D* pTransformation = Translate(matrix, helper);
D3DVECTOR position; D3DVECTOR position;
Tgl::Result result; Result result;
Tgl::Result result2; Result result2;
result2 = ResultVal(pCamera->GetPosition(NULL, &position)); result2 = ResultVal(pCamera->GetPosition(NULL, &position));
assert(Succeeded(result2)); assert(Succeeded(result2));
@ -38,7 +38,7 @@ inline Tgl::Result CameraSetTransformation(IDirect3DRMFrame2* pCamera, FloatMatr
// FUNCTION: LEGO1 0x100a3700 // FUNCTION: LEGO1 0x100a3700
// FUNCTION: BETA10 0x1016f330 // FUNCTION: BETA10 0x1016f330
Tgl::Result CameraImpl::SetTransformation(FloatMatrix4& matrix) Result CameraImpl::SetTransformation(FloatMatrix4& matrix)
{ {
assert(m_data); assert(m_data);

24
LEGO1/tgl/d3drm/device.cpp
View File

@ -47,14 +47,14 @@ unsigned int DeviceImpl::GetHeight()
} }
// FUNCTION: BETA10 0x1016dfa0 // FUNCTION: BETA10 0x1016dfa0
inline Tgl::Result DeviceSetColorModel(IDirect3DRMDevice2* pDevice, ColorModel) inline Result DeviceSetColorModel(IDirect3DRMDevice2* pDevice, ColorModel)
{ {
return Success; return Success;
} }
// FUNCTION: LEGO1 0x100a2c20 // FUNCTION: LEGO1 0x100a2c20
// FUNCTION: BETA10 0x1016df40 // FUNCTION: BETA10 0x1016df40
Tgl::Result DeviceImpl::SetColorModel(ColorModel p_model) Result DeviceImpl::SetColorModel(ColorModel p_model)
{ {
assert(m_data); assert(m_data);
@ -62,7 +62,7 @@ Tgl::Result DeviceImpl::SetColorModel(ColorModel p_model)
} }
// FUNCTION: BETA10 0x1016e020 // FUNCTION: BETA10 0x1016e020
inline Tgl::Result DeviceSetShadingModel(IDirect3DRMDevice2* pDevice, ShadingModel model) inline Result DeviceSetShadingModel(IDirect3DRMDevice2* pDevice, ShadingModel model)
{ {
D3DRMRENDERQUALITY renderQuality = Translate(model); D3DRMRENDERQUALITY renderQuality = Translate(model);
return ResultVal(pDevice->SetQuality(renderQuality)); return ResultVal(pDevice->SetQuality(renderQuality));
@ -70,7 +70,7 @@ inline Tgl::Result DeviceSetShadingModel(IDirect3DRMDevice2* pDevice, ShadingMod
// FUNCTION: LEGO1 0x100a2c30 // FUNCTION: LEGO1 0x100a2c30
// FUNCTION: BETA10 0x1016dfc0 // FUNCTION: BETA10 0x1016dfc0
Tgl::Result DeviceImpl::SetShadingModel(ShadingModel model) Result DeviceImpl::SetShadingModel(ShadingModel model)
{ {
assert(m_data); assert(m_data);
@ -78,14 +78,14 @@ Tgl::Result DeviceImpl::SetShadingModel(ShadingModel model)
} }
// FUNCTION: BETA10 0x1016e140 // 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)); return ResultVal(pDevice->SetShades(shadeCount));
} }
// FUNCTION: LEGO1 0x100a2ca0 // FUNCTION: LEGO1 0x100a2ca0
// FUNCTION: BETA10 0x1016e0e0 // FUNCTION: BETA10 0x1016e0e0
Tgl::Result DeviceImpl::SetShadeCount(unsigned int shadeCount) Result DeviceImpl::SetShadeCount(unsigned int shadeCount)
{ {
assert(m_data); assert(m_data);
@ -93,14 +93,14 @@ Tgl::Result DeviceImpl::SetShadeCount(unsigned int shadeCount)
} }
// FUNCTION: BETA10 0x1016e1d0 // FUNCTION: BETA10 0x1016e1d0
inline Tgl::Result DeviceSetDither(IDirect3DRMDevice2* pDevice, int dither) inline Result DeviceSetDither(IDirect3DRMDevice2* pDevice, int dither)
{ {
return ResultVal(pDevice->SetDither(dither)); return ResultVal(pDevice->SetDither(dither));
} }
// FUNCTION: LEGO1 0x100a2cc0 // FUNCTION: LEGO1 0x100a2cc0
// FUNCTION: BETA10 0x1016e170 // FUNCTION: BETA10 0x1016e170
Tgl::Result DeviceImpl::SetDither(int dither) Result DeviceImpl::SetDither(int dither)
{ {
assert(m_data); assert(m_data);
@ -112,7 +112,7 @@ inline void DeviceHandleActivate(IDirect3DRMDevice2* pDevice, WORD wParam)
{ {
IDirect3DRMWinDevice* winDevice; IDirect3DRMWinDevice* winDevice;
Tgl::Result result = ResultVal(pDevice->QueryInterface(IID_IDirect3DRMWinDevice, (LPVOID*) &winDevice)); Result result = ResultVal(pDevice->QueryInterface(IID_IDirect3DRMWinDevice, (LPVOID*) &winDevice));
if (Succeeded(result)) { if (Succeeded(result)) {
winDevice->HandleActivate(wParam); winDevice->HandleActivate(wParam);
int refCount = winDevice->Release(); int refCount = winDevice->Release();
@ -134,7 +134,7 @@ inline void DeviceHandlePaint(IDirect3DRMDevice2* pDevice, void* p_data)
{ {
IDirect3DRMWinDevice* winDevice; IDirect3DRMWinDevice* winDevice;
Tgl::Result result = ResultVal(pDevice->QueryInterface(IID_IDirect3DRMWinDevice, (LPVOID*) &winDevice)); Result result = ResultVal(pDevice->QueryInterface(IID_IDirect3DRMWinDevice, (LPVOID*) &winDevice));
if (Succeeded(result)) { if (Succeeded(result)) {
HDC hdc = (HDC) p_data; HDC hdc = (HDC) p_data;
winDevice->HandlePaint(hdc); winDevice->HandlePaint(hdc);
@ -153,14 +153,14 @@ void DeviceImpl::HandlePaint(void* p_data)
} }
// FUNCTION: BETA10 0x1016e460 // FUNCTION: BETA10 0x1016e460
inline Tgl::Result DeviceUpdate(IDirect3DRMDevice2* pDevice) inline Result DeviceUpdate(IDirect3DRMDevice2* pDevice)
{ {
return ResultVal(pDevice->Update()); return ResultVal(pDevice->Update());
} }
// FUNCTION: LEGO1 0x100a2d60 // FUNCTION: LEGO1 0x100a2d60
// FUNCTION: BETA10 0x1016e400 // FUNCTION: BETA10 0x1016e400
Tgl::Result DeviceImpl::Update() Result DeviceImpl::Update()
{ {
assert(m_data); assert(m_data);

62
LEGO1/tgl/d3drm/group.cpp
View File

@ -12,7 +12,7 @@ void* GroupImpl::ImplementationDataPtr()
} }
// FUNCTION: BETA10 0x1016c340 // FUNCTION: BETA10 0x1016c340
inline Tgl::Result GroupSetTransformation(IDirect3DRMFrame2* pGroup, FloatMatrix4& matrix) inline Result GroupSetTransformation(IDirect3DRMFrame2* pGroup, FloatMatrix4& matrix)
{ {
D3DRMMATRIX4D helper; D3DRMMATRIX4D helper;
D3DRMMATRIX4D* d3dMatrix = Translate(matrix, helper); D3DRMMATRIX4D* d3dMatrix = Translate(matrix, helper);
@ -21,7 +21,7 @@ inline Tgl::Result GroupSetTransformation(IDirect3DRMFrame2* pGroup, FloatMatrix
// FUNCTION: LEGO1 0x100a31e0 // FUNCTION: LEGO1 0x100a31e0
// FUNCTION: BETA10 0x1016a4d0 // FUNCTION: BETA10 0x1016a4d0
Tgl::Result GroupImpl::SetTransformation(FloatMatrix4& matrix) Result GroupImpl::SetTransformation(FloatMatrix4& matrix)
{ {
assert(m_data); assert(m_data);
@ -29,7 +29,7 @@ Tgl::Result GroupImpl::SetTransformation(FloatMatrix4& matrix)
} }
// FUNCTION: BETA10 0x1016c400 // 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) { if (a > 0) {
D3DCOLOR color = D3DRMCreateColorRGBA(r, g, b, a); 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: LEGO1 0x100a3240
// FUNCTION: BETA10 0x1016a530 // 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); assert(m_data);
@ -50,13 +50,13 @@ Tgl::Result GroupImpl::SetColor(float r, float g, float b, float a)
} }
// FUNCTION: BETA10 0x1016c5a0 // FUNCTION: BETA10 0x1016c5a0
inline Tgl::Result GroupSetTexture(IDirect3DRMFrame2* pGroup, IDirect3DRMTexture* pD3DTexture) inline Result GroupSetTexture(IDirect3DRMFrame2* pGroup, IDirect3DRMTexture* pD3DTexture)
{ {
return ResultVal(pGroup->SetTexture(pD3DTexture)); return ResultVal(pGroup->SetTexture(pD3DTexture));
} }
// FUNCTION: BETA10 0x1016bcc0 // FUNCTION: BETA10 0x1016bcc0
inline Tgl::Result GroupImpl::SetTexture(const TextureImpl* pTexture) inline Result GroupImpl::SetTexture(const TextureImpl* pTexture)
{ {
assert(m_data); assert(m_data);
assert(!pTexture || pTexture->ImplementationData()); assert(!pTexture || pTexture->ImplementationData());
@ -67,7 +67,7 @@ inline Tgl::Result GroupImpl::SetTexture(const TextureImpl* pTexture)
// FUNCTION: LEGO1 0x100a32b0 // FUNCTION: LEGO1 0x100a32b0
// FUNCTION: BETA10 0x1016a5a0 // FUNCTION: BETA10 0x1016a5a0
Tgl::Result GroupImpl::SetTexture(const Texture* pTexture) Result GroupImpl::SetTexture(const Texture* pTexture)
{ {
assert(m_data); assert(m_data);
@ -75,13 +75,13 @@ Tgl::Result GroupImpl::SetTexture(const Texture* pTexture)
} }
// FUNCTION: BETA10 0x1016c640 // FUNCTION: BETA10 0x1016c640
inline Tgl::Result GroupGetTexture(IDirect3DRMFrame2* pGroup, IDirect3DRMTexture** pD3DTexture) inline Result GroupGetTexture(IDirect3DRMFrame2* pGroup, IDirect3DRMTexture** pD3DTexture)
{ {
return ResultVal(pGroup->GetTexture(pD3DTexture)); return ResultVal(pGroup->GetTexture(pD3DTexture));
} }
// FUNCTION: BETA10 0x1016beb0 // FUNCTION: BETA10 0x1016beb0
inline Tgl::Result GroupImpl::GetTexture(TextureImpl** ppTexture) inline Result GroupImpl::GetTexture(TextureImpl** ppTexture)
{ {
assert(m_data); assert(m_data);
assert(ppTexture); assert(ppTexture);
@ -91,7 +91,7 @@ inline Tgl::Result GroupImpl::GetTexture(TextureImpl** ppTexture)
// TODO: This helps retail match, but it adds to the stack // TODO: This helps retail match, but it adds to the stack
IDirect3DRMTexture* tex; IDirect3DRMTexture* tex;
Tgl::Result result = GroupGetTexture(m_data, &tex); Result result = GroupGetTexture(m_data, &tex);
#ifndef BETA10 #ifndef BETA10
if (Succeeded(result)) { if (Succeeded(result)) {
@ -106,7 +106,7 @@ inline Tgl::Result GroupImpl::GetTexture(TextureImpl** ppTexture)
// FUNCTION: LEGO1 0x100a32e0 // FUNCTION: LEGO1 0x100a32e0
// FUNCTION: BETA10 0x1016a600 // FUNCTION: BETA10 0x1016a600
Tgl::Result GroupImpl::GetTexture(Texture*& pTexture) Result GroupImpl::GetTexture(Texture*& pTexture)
{ {
assert(m_data); assert(m_data);
@ -114,7 +114,7 @@ Tgl::Result GroupImpl::GetTexture(Texture*& pTexture)
} }
// FUNCTION: BETA10 0x1016c500 // FUNCTION: BETA10 0x1016c500
inline Tgl::Result GroupSetMaterialMode(IDirect3DRMFrame2* pGroup, MaterialMode mode) inline Result GroupSetMaterialMode(IDirect3DRMFrame2* pGroup, MaterialMode mode)
{ {
D3DRMMATERIALMODE d3dMode = Translate(mode); D3DRMMATERIALMODE d3dMode = Translate(mode);
return ResultVal(pGroup->SetMaterialMode(d3dMode)); return ResultVal(pGroup->SetMaterialMode(d3dMode));
@ -122,7 +122,7 @@ inline Tgl::Result GroupSetMaterialMode(IDirect3DRMFrame2* pGroup, MaterialMode
// FUNCTION: LEGO1 0x100a33c0 // FUNCTION: LEGO1 0x100a33c0
// FUNCTION: BETA10 0x1016a660 // FUNCTION: BETA10 0x1016a660
Tgl::Result GroupImpl::SetMaterialMode(MaterialMode mode) Result GroupImpl::SetMaterialMode(MaterialMode mode)
{ {
assert(m_data); assert(m_data);
@ -130,13 +130,13 @@ Tgl::Result GroupImpl::SetMaterialMode(MaterialMode mode)
} }
// FUNCTION: BETA10 0x1016c670 // 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))); return ResultVal(pGroup->AddVisual(const_cast<IDirect3DRMFrame*>(pChildGroup)));
} }
// FUNCTION: BETA10 0x1016c090 // FUNCTION: BETA10 0x1016c090
inline Tgl::Result GroupImpl::Add(const GroupImpl& rGroup) inline Result GroupImpl::Add(const GroupImpl& rGroup)
{ {
assert(m_data); assert(m_data);
assert(rGroup.ImplementationData()); assert(rGroup.ImplementationData());
@ -146,7 +146,7 @@ inline Tgl::Result GroupImpl::Add(const GroupImpl& rGroup)
// FUNCTION: LEGO1 0x100a3410 // FUNCTION: LEGO1 0x100a3410
// FUNCTION: BETA10 0x1016a6c0 // FUNCTION: BETA10 0x1016a6c0
Tgl::Result GroupImpl::Add(const Group* pGroup) Result GroupImpl::Add(const Group* pGroup)
{ {
assert(m_data); assert(m_data);
assert(pGroup); assert(pGroup);
@ -155,13 +155,13 @@ Tgl::Result GroupImpl::Add(const Group* pGroup)
} }
// FUNCTION: BETA10 0x1016c700 // 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))); return ResultVal(pGroup->AddVisual(const_cast<IDirect3DRMMesh*>(pMesh)));
} }
// FUNCTION: BETA10 0x1016bff0 // FUNCTION: BETA10 0x1016bff0
inline Tgl::Result GroupImpl::Add(const MeshBuilderImpl& rMesh) inline Result GroupImpl::Add(const MeshBuilderImpl& rMesh)
{ {
assert(m_data); assert(m_data);
assert(rMesh.ImplementationData()); assert(rMesh.ImplementationData());
@ -171,7 +171,7 @@ inline Tgl::Result GroupImpl::Add(const MeshBuilderImpl& rMesh)
// FUNCTION: LEGO1 0x100a3430 // FUNCTION: LEGO1 0x100a3430
// FUNCTION: BETA10 0x1016a740 // FUNCTION: BETA10 0x1016a740
Tgl::Result GroupImpl::Add(const MeshBuilder* pMeshBuilder) Result GroupImpl::Add(const MeshBuilder* pMeshBuilder)
{ {
assert(m_data); assert(m_data);
assert(pMeshBuilder); assert(pMeshBuilder);
@ -180,13 +180,13 @@ Tgl::Result GroupImpl::Add(const MeshBuilder* pMeshBuilder)
} }
// FUNCTION: BETA10 0x1016c7b0 // 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))); return ResultVal(pGroup->DeleteVisual(const_cast<IDirect3DRMMesh*>(pMesh)));
} }
// FUNCTION: BETA10 0x1016c130 // FUNCTION: BETA10 0x1016c130
inline Tgl::Result GroupImpl::Remove(const MeshBuilderImpl& rMesh) inline Result GroupImpl::Remove(const MeshBuilderImpl& rMesh)
{ {
assert(m_data); assert(m_data);
assert(rMesh.ImplementationData()); assert(rMesh.ImplementationData());
@ -196,7 +196,7 @@ inline Tgl::Result GroupImpl::Remove(const MeshBuilderImpl& rMesh)
// FUNCTION: LEGO1 0x100a3450 // FUNCTION: LEGO1 0x100a3450
// FUNCTION: BETA10 0x1016a7c0 // FUNCTION: BETA10 0x1016a7c0
Tgl::Result GroupImpl::Remove(const MeshBuilder* pMeshBuilder) Result GroupImpl::Remove(const MeshBuilder* pMeshBuilder)
{ {
assert(m_data); assert(m_data);
assert(pMeshBuilder); assert(pMeshBuilder);
@ -205,13 +205,13 @@ Tgl::Result GroupImpl::Remove(const MeshBuilder* pMeshBuilder)
} }
// FUNCTION: BETA10 0x1016c730 // 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))); return ResultVal(pGroup->DeleteVisual(const_cast<IDirect3DRMFrame*>(pChildGroup)));
} }
// FUNCTION: BETA10 0x1016c1d0 // FUNCTION: BETA10 0x1016c1d0
inline Tgl::Result GroupImpl::Remove(const GroupImpl& rGroup) inline Result GroupImpl::Remove(const GroupImpl& rGroup)
{ {
assert(m_data); assert(m_data);
assert(rGroup.ImplementationData()); assert(rGroup.ImplementationData());
@ -221,7 +221,7 @@ inline Tgl::Result GroupImpl::Remove(const GroupImpl& rGroup)
// FUNCTION: LEGO1 0x100a3480 // FUNCTION: LEGO1 0x100a3480
// FUNCTION: BETA10 0x1016a840 // FUNCTION: BETA10 0x1016a840
Tgl::Result GroupImpl::Remove(const Group* pGroup) Result GroupImpl::Remove(const Group* pGroup)
{ {
assert(m_data); assert(m_data);
assert(pGroup); assert(pGroup);
@ -230,12 +230,12 @@ Tgl::Result GroupImpl::Remove(const Group* pGroup)
} }
// FUNCTION: BETA10 0x1016c850 // FUNCTION: BETA10 0x1016c850
inline Tgl::Result GroupRemoveAll(IDirect3DRMFrame2* pFrame) inline Result GroupRemoveAll(IDirect3DRMFrame2* pFrame)
{ {
IDirect3DRMVisualArray* visuals; IDirect3DRMVisualArray* visuals;
int refCount; int refCount;
Tgl::Result result = ResultVal(pFrame->GetVisuals(&visuals)); Result result = ResultVal(pFrame->GetVisuals(&visuals));
assert(Succeeded(result)); assert(Succeeded(result));
if (Succeeded(result)) { if (Succeeded(result)) {
@ -260,7 +260,7 @@ inline Tgl::Result GroupRemoveAll(IDirect3DRMFrame2* pFrame)
// FUNCTION: LEGO1 0x100a34b0 // FUNCTION: LEGO1 0x100a34b0
// FUNCTION: BETA10 0x1016a8c0 // FUNCTION: BETA10 0x1016a8c0
Tgl::Result GroupImpl::RemoveAll() Result GroupImpl::RemoveAll()
{ {
assert(m_data); assert(m_data);
@ -268,7 +268,7 @@ Tgl::Result GroupImpl::RemoveAll()
} }
// FUNCTION: BETA10 0x1016cb70 // 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; D3DRMBOX size;
int refCount; 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; size.max.x = size.max.y = size.max.z = -88888.f;
IDirect3DRMVisualArray* visuals; IDirect3DRMVisualArray* visuals;
Tgl::Result result = ResultVal(pFrame->GetVisuals(&visuals)); Result result = ResultVal(pFrame->GetVisuals(&visuals));
assert(Succeeded(result)); assert(Succeeded(result));
if (Succeeded(result)) { if (Succeeded(result)) {
@ -337,7 +337,7 @@ inline Tgl::Result GroupBounds(IDirect3DRMFrame2* pFrame, D3DVECTOR* p_min, D3DV
// FUNCTION: LEGO1 0x100a3540 // FUNCTION: LEGO1 0x100a3540
// FUNCTION: BETA10 0x1016a920 // 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); assert(m_data);

150
LEGO1/tgl/d3drm/impl.h
View File

@ -30,7 +30,7 @@ using namespace Tgl;
// Utility function used by implementations // Utility function used by implementations
// FUNCTION: BETA10 0x10169cf0 // FUNCTION: BETA10 0x10169cf0
inline Tgl::Result ResultVal(HRESULT result) inline Result ResultVal(HRESULT result)
{ {
return SUCCEEDED(result) ? Success : Error; return SUCCEEDED(result) ? Success : Error;
} }
@ -88,10 +88,10 @@ class RendererImpl : public Renderer {
) override; ) override;
Texture* CreateTexture() override; Texture* CreateTexture() override;
Tgl::Result SetTextureDefaultShadeCount(unsigned int) override; Result SetTextureDefaultShadeCount(unsigned int) override;
// vtable+0x30 // vtable+0x30
Tgl::Result SetTextureDefaultColorCount(unsigned int) override; Result SetTextureDefaultColorCount(unsigned int) override;
HRESULT CreateTextureFromSurface(LPDIRECTDRAWSURFACE pSurface, LPDIRECT3DRMTEXTURE2* pTexture2) HRESULT CreateTextureFromSurface(LPDIRECTDRAWSURFACE pSurface, LPDIRECT3DRMTEXTURE2* pTexture2)
{ {
@ -106,11 +106,11 @@ class RendererImpl : public Renderer {
RendererDataType& ImplementationData() { return m_data; } RendererDataType& ImplementationData() { return m_data; }
public: public:
inline Tgl::Result Create(); inline Result Create();
inline void Destroy(); inline void Destroy();
inline Tgl::Result CreateLight(LightType type, float r, float g, float b, LightImpl& rLight); inline Result CreateLight(LightType type, float r, float g, float b, LightImpl& rLight);
inline Tgl::Result CreateGroup(const GroupImpl* pParentGroup, GroupImpl& rpGroup); inline Result CreateGroup(const GroupImpl* pParentGroup, GroupImpl& rpGroup);
inline Tgl::Result CreateView( inline Result CreateView(
const DeviceImpl& rDevice, const DeviceImpl& rDevice,
const CameraImpl& rCamera, const CameraImpl& rCamera,
unsigned int x, unsigned int x,
@ -119,10 +119,10 @@ class RendererImpl : public Renderer {
unsigned int height, unsigned int height,
ViewImpl& rView ViewImpl& rView
); );
inline Tgl::Result CreateMeshBuilder(MeshBuilderImpl& rMesh); inline Result CreateMeshBuilder(MeshBuilderImpl& rMesh);
inline Tgl::Result CreateCamera(CameraImpl& rCamera); inline Result CreateCamera(CameraImpl& rCamera);
inline Tgl::Result CreateTexture(TextureImpl& rTexture); inline Result CreateTexture(TextureImpl& rTexture);
inline Tgl::Result CreateTexture( inline Result CreateTexture(
TextureImpl& rTexture, TextureImpl& rTexture,
int width, int width,
int height, int height,
@ -132,8 +132,8 @@ class RendererImpl : public Renderer {
int paletteEntryCount, int paletteEntryCount,
const PaletteEntry* pEntries const PaletteEntry* pEntries
); );
inline Tgl::Result CreateDevice(const DeviceDirect3DCreateData& rCreateData, DeviceImpl& rDevice); inline Result CreateDevice(const DeviceDirect3DCreateData& rCreateData, DeviceImpl& rDevice);
inline Tgl::Result CreateDevice(const DeviceDirectDrawCreateData& rCreateData, DeviceImpl& rDevice); inline Result CreateDevice(const DeviceDirectDrawCreateData& rCreateData, DeviceImpl& rDevice);
private: private:
RendererDataType m_data; RendererDataType m_data;
@ -177,13 +177,13 @@ class DeviceImpl : public Device {
unsigned int GetHeight() override; unsigned int GetHeight() override;
// vtable+0x10 // vtable+0x10
Tgl::Result SetColorModel(ColorModel) override; Result SetColorModel(ColorModel) override;
Tgl::Result SetShadingModel(ShadingModel) override; Result SetShadingModel(ShadingModel) override;
Tgl::Result SetShadeCount(unsigned int) override; Result SetShadeCount(unsigned int) override;
Tgl::Result SetDither(int) override; Result SetDither(int) override;
// vtable+0x20 // vtable+0x20
Tgl::Result Update() override; Result Update() override;
void HandleActivate(WORD) override; void HandleActivate(WORD) override;
void HandlePaint(void*) override; void HandlePaint(void*) override;
@ -233,25 +233,25 @@ class ViewImpl : public View {
void* ImplementationDataPtr() override; void* ImplementationDataPtr() override;
// vtable+0x08 // vtable+0x08
Tgl::Result Add(const Light*) override; Result Add(const Light*) override;
Tgl::Result Remove(const Light*) override; Result Remove(const Light*) override;
// vtable+0x10 // vtable+0x10
Tgl::Result SetCamera(const Camera*) override; Result SetCamera(const Camera*) override;
Tgl::Result SetProjection(ProjectionType) override; Result SetProjection(ProjectionType) override;
Tgl::Result SetFrustrum(float frontClippingDistance, float backClippingDistance, float degrees) override; Result SetFrustrum(float frontClippingDistance, float backClippingDistance, float degrees) override;
Tgl::Result SetBackgroundColor(float r, float g, float b) override; Result SetBackgroundColor(float r, float g, float b) override;
// vtable+0x20 // vtable+0x20
Tgl::Result GetBackgroundColor(float* r, float* g, float* b) override; Result GetBackgroundColor(float* r, float* g, float* b) override;
Tgl::Result Clear() override; Result Clear() override;
Tgl::Result Render(const Group*) override; Result Render(const Group*) override;
Tgl::Result ForceUpdate(unsigned int x, unsigned int y, unsigned int width, unsigned int height) override; Result ForceUpdate(unsigned int x, unsigned int y, unsigned int width, unsigned int height) override;
// vtable+0x30 // vtable+0x30
Tgl::Result TransformWorldToScreen(const float world[3], float screen[4]) override; Result TransformWorldToScreen(const float world[3], float screen[4]) override;
Tgl::Result TransformScreenToWorld(const float screen[4], float world[3]) override; Result TransformScreenToWorld(const float screen[4], float world[3]) override;
Tgl::Result Pick( Result Pick(
unsigned int x, unsigned int x,
unsigned int y, unsigned int y,
const Group** ppGroupsToPickFrom, const Group** ppGroupsToPickFrom,
@ -269,14 +269,14 @@ class ViewImpl : public View {
void SetImplementationData(IDirect3DRMViewport* viewport) { m_data = viewport; } void SetImplementationData(IDirect3DRMViewport* viewport) { m_data = viewport; }
static Tgl::Result ViewportCreateAppData(IDirect3DRM2*, IDirect3DRMViewport*, IDirect3DRMFrame2*); static Result ViewportCreateAppData(IDirect3DRM2*, IDirect3DRMViewport*, IDirect3DRMFrame2*);
inline void Destroy(); inline void Destroy();
Tgl::Result Add(const LightImpl& rLight); Result Add(const LightImpl& rLight);
Tgl::Result Remove(const LightImpl& rLight); Result Remove(const LightImpl& rLight);
Tgl::Result SetCamera(const CameraImpl& rCamera); Result SetCamera(const CameraImpl& rCamera);
Tgl::Result Render(const GroupImpl& rScene); Result Render(const GroupImpl& rScene);
Tgl::Result Pick( Result Pick(
unsigned int x, unsigned int x,
unsigned int y, unsigned int y,
const GroupImpl** ppGroupsToPickFrom, const GroupImpl** ppGroupsToPickFrom,
@ -319,7 +319,7 @@ class CameraImpl : public Camera {
void* ImplementationDataPtr() override; void* ImplementationDataPtr() override;
// vtable+0x08 // vtable+0x08
Tgl::Result SetTransformation(FloatMatrix4&) override; Result SetTransformation(FloatMatrix4&) override;
typedef IDirect3DRMFrame2* CameraDataType; typedef IDirect3DRMFrame2* CameraDataType;
@ -365,8 +365,8 @@ class LightImpl : public Light {
void* ImplementationDataPtr() override; void* ImplementationDataPtr() override;
// vtable+0x08 // vtable+0x08
Tgl::Result SetTransformation(FloatMatrix4&) override; Result SetTransformation(FloatMatrix4&) override;
Tgl::Result SetColor(float r, float g, float b) override; Result SetColor(float r, float g, float b) override;
typedef IDirect3DRMFrame2* LightDataType; typedef IDirect3DRMFrame2* LightDataType;
@ -412,13 +412,13 @@ class MeshImpl : public Mesh {
void* ImplementationDataPtr() override; void* ImplementationDataPtr() override;
// vtable+0x08 // vtable+0x08
Tgl::Result SetColor(float r, float g, float b, float a) override; Result SetColor(float r, float g, float b, float a) override;
Tgl::Result SetTexture(const Texture*) override; Result SetTexture(const Texture*) override;
// vtable+0x10 // vtable+0x10
Tgl::Result GetTexture(Texture*&) override; Result GetTexture(Texture*&) override;
Tgl::Result SetTextureMappingMode(TextureMappingMode) override; Result SetTextureMappingMode(TextureMappingMode) override;
Tgl::Result SetShadingModel(ShadingModel) override; Result SetShadingModel(ShadingModel) override;
Mesh* DeepClone(MeshBuilder*) override; Mesh* DeepClone(MeshBuilder*) override;
// vtable+0x20 // vtable+0x20
@ -438,8 +438,8 @@ class MeshImpl : public Mesh {
inline void Destroy(); inline void Destroy();
inline Mesh* DeepClone(const MeshBuilderImpl& rMesh); inline Mesh* DeepClone(const MeshBuilderImpl& rMesh);
inline Tgl::Result GetTexture(TextureImpl** ppTexture); inline Result GetTexture(TextureImpl** ppTexture);
inline Tgl::Result SetTexture(const TextureImpl* pTexture); inline Result SetTexture(const TextureImpl* pTexture);
inline Mesh* ShallowClone(const MeshBuilderImpl& rMesh); inline Mesh* ShallowClone(const MeshBuilderImpl& rMesh);
friend class RendererImpl; friend class RendererImpl;
@ -476,23 +476,23 @@ class GroupImpl : public Group {
void* ImplementationDataPtr() override; void* ImplementationDataPtr() override;
// vtable+0x08 // vtable+0x08
Tgl::Result SetTransformation(FloatMatrix4&) override; Result SetTransformation(FloatMatrix4&) override;
Tgl::Result SetColor(float r, float g, float b, float a) override; Result SetColor(float r, float g, float b, float a) override;
// vtable+0x10 // vtable+0x10
Tgl::Result SetTexture(const Texture*) override; Result SetTexture(const Texture*) override;
Tgl::Result GetTexture(Texture*&) override; Result GetTexture(Texture*&) override;
Tgl::Result SetMaterialMode(MaterialMode) override; Result SetMaterialMode(MaterialMode) override;
Tgl::Result Add(const Group*) override; Result Add(const Group*) override;
// vtable+0x20 // vtable+0x20
Tgl::Result Add(const MeshBuilder*) override; Result Add(const MeshBuilder*) override;
Tgl::Result Remove(const Group*) override; Result Remove(const Group*) override;
Tgl::Result Remove(const MeshBuilder*) override; Result Remove(const MeshBuilder*) override;
Tgl::Result RemoveAll() override; Result RemoveAll() override;
// vtable+0x30 // vtable+0x30
Tgl::Result Bounds(D3DVECTOR* p_min, D3DVECTOR* p_max) override; Result Bounds(D3DVECTOR* p_min, D3DVECTOR* p_max) override;
typedef IDirect3DRMFrame2* GroupDataType; typedef IDirect3DRMFrame2* GroupDataType;
@ -503,12 +503,12 @@ class GroupImpl : public Group {
GroupDataType& ImplementationData() { return m_data; } GroupDataType& ImplementationData() { return m_data; }
inline void Destroy(); inline void Destroy();
inline Tgl::Result SetTexture(const TextureImpl* pTexture); inline Result SetTexture(const TextureImpl* pTexture);
inline Tgl::Result GetTexture(TextureImpl** ppTexture); inline Result GetTexture(TextureImpl** ppTexture);
inline Tgl::Result Add(const GroupImpl& rGroup); inline Result Add(const GroupImpl& rGroup);
inline Tgl::Result Add(const MeshBuilderImpl& rMesh); inline Result Add(const MeshBuilderImpl& rMesh);
inline Tgl::Result Remove(const GroupImpl& rGroup); inline Result Remove(const GroupImpl& rGroup);
inline Tgl::Result Remove(const MeshBuilderImpl& rMesh); inline Result Remove(const MeshBuilderImpl& rMesh);
friend class RendererImpl; friend class RendererImpl;
@ -554,7 +554,7 @@ class MeshBuilderImpl : public MeshBuilder {
unsigned int (*pTextureIndices)[3], unsigned int (*pTextureIndices)[3],
ShadingModel shadingModel ShadingModel shadingModel
) override; ) override;
Tgl::Result GetBoundingBox(float min[3], float max[3]) const override; Result GetBoundingBox(float min[3], float max[3]) const override;
// vtable+0x10 // vtable+0x10
MeshBuilder* Clone() override; MeshBuilder* Clone() override;
@ -572,7 +572,7 @@ class MeshBuilderImpl : public MeshBuilder {
friend class RendererImpl; friend class RendererImpl;
private: private:
inline Tgl::Result CreateMeshImpl( inline Result CreateMeshImpl(
MeshImpl* pMeshImpl, MeshImpl* pMeshImpl,
unsigned int faceCount, unsigned int faceCount,
unsigned int vertexCount, unsigned int vertexCount,
@ -616,10 +616,10 @@ class TglD3DRMIMAGE {
); );
~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(); void Destroy();
Tgl::Result FillRowsOfTexture(int y, int height, char* content); Result FillRowsOfTexture(int y, int height, char* content);
Tgl::Result InitializePalette(int paletteSize, PaletteEntry* pEntries); Result InitializePalette(int paletteSize, PaletteEntry* pEntries);
D3DRMIMAGE m_image; D3DRMIMAGE m_image;
int m_texelsAllocatedByClient; int m_texelsAllocatedByClient;
@ -641,12 +641,12 @@ class TextureImpl : public Texture {
void* ImplementationDataPtr() override; void* ImplementationDataPtr() override;
// vtable+0x08 // 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; void FillRowsOfTexture(int y, int height, void* pBuffer) override;
// vtable+0x10 // vtable+0x10
Tgl::Result Changed(int texelsChanged, int paletteChanged) override; Result Changed(int texelsChanged, int paletteChanged) override;
Tgl::Result GetBufferAndPalette( Result GetBufferAndPalette(
int* pWidth, int* pWidth,
int* pHeight, int* pHeight,
int* pDepth, int* pDepth,
@ -654,7 +654,7 @@ class TextureImpl : public Texture {
int* ppPaletteSize, int* ppPaletteSize,
unsigned char (*pEntries)[3] unsigned char (*pEntries)[3]
) override; ) override;
Tgl::Result SetPalette(int entryCount, PaletteEntry* entries) override; Result SetPalette(int entryCount, PaletteEntry* entries) override;
typedef IDirect3DRMTexture* TextureDataType; typedef IDirect3DRMTexture* TextureDataType;
@ -670,7 +670,7 @@ class TextureImpl : public Texture {
friend class RendererImpl; friend class RendererImpl;
static Tgl::Result SetImage(IDirect3DRMTexture* pSelf, TglD3DRMIMAGE* pImage); static Result SetImage(IDirect3DRMTexture* pSelf, TglD3DRMIMAGE* pImage);
private: private:
TextureDataType m_data; TextureDataType m_data;
@ -693,7 +693,7 @@ void TextureImpl::Destroy()
// Used by both Mesh and MeshBuilder // Used by both Mesh and MeshBuilder
// FUNCTION: BETA10 0x10170270 // FUNCTION: BETA10 0x10170270
inline Tgl::Result MeshSetTextureMappingMode(MeshImpl::MeshData* pMesh, TextureMappingMode mode) inline Result MeshSetTextureMappingMode(MeshImpl::MeshData* pMesh, TextureMappingMode mode)
{ {
if (mode == PerspectiveCorrect) { if (mode == PerspectiveCorrect) {
return ResultVal(pMesh->groupMesh->SetGroupMapping(pMesh->groupIndex, D3DRMMAP_PERSPCORRECT)); return ResultVal(pMesh->groupMesh->SetGroupMapping(pMesh->groupIndex, D3DRMMAP_PERSPCORRECT));

10
LEGO1/tgl/d3drm/light.cpp
View File

@ -15,7 +15,7 @@ void* LightImpl::ImplementationDataPtr()
} }
// FUNCTION: BETA10 0x1016f6e0 // FUNCTION: BETA10 0x1016f6e0
inline Tgl::Result LightSetTransformation(IDirect3DRMFrame2* pLight, FloatMatrix4& matrix) inline Result LightSetTransformation(IDirect3DRMFrame2* pLight, FloatMatrix4& matrix)
{ {
D3DRMMATRIX4D helper; D3DRMMATRIX4D helper;
D3DRMMATRIX4D* d3dMatrix = Translate(matrix, helper); D3DRMMATRIX4D* d3dMatrix = Translate(matrix, helper);
@ -24,7 +24,7 @@ inline Tgl::Result LightSetTransformation(IDirect3DRMFrame2* pLight, FloatMatrix
// FUNCTION: LEGO1 0x100a3780 // FUNCTION: LEGO1 0x100a3780
// FUNCTION: BETA10 0x1016f680 // FUNCTION: BETA10 0x1016f680
Tgl::Result LightImpl::SetTransformation(FloatMatrix4& matrix) Result LightImpl::SetTransformation(FloatMatrix4& matrix)
{ {
assert(m_data); assert(m_data);
@ -32,11 +32,11 @@ Tgl::Result LightImpl::SetTransformation(FloatMatrix4& matrix)
} }
// FUNCTION: BETA10 0x1016f860 // 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; IDirect3DRMLightArray* lights;
IDirect3DRMLight* light; IDirect3DRMLight* light;
Tgl::Result result = ResultVal(pLight->GetLights(&lights)); Result result = ResultVal(pLight->GetLights(&lights));
assert(Succeeded(result)); assert(Succeeded(result));
assert(lights->GetSize() == 1); assert(lights->GetSize() == 1);
@ -48,7 +48,7 @@ inline Tgl::Result LightSetColor(IDirect3DRMFrame2* pLight, float r, float g, fl
// FUNCTION: LEGO1 0x100a37e0 // FUNCTION: LEGO1 0x100a37e0
// FUNCTION: BETA10 0x1016f7f0 // 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); assert(m_data);

40
LEGO1/tgl/d3drm/mesh.cpp
View File

@ -17,7 +17,7 @@ void* MeshImpl::ImplementationDataPtr()
} }
// FUNCTION: BETA10 0x10170590 // 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) { if (a > 0) {
D3DCOLOR color = D3DRMCreateColorRGBA(r, g, b, a); 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: LEGO1 0x100a3ee0
// FUNCTION: BETA10 0x10170520 // 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); assert(m_data);
@ -38,14 +38,14 @@ Tgl::Result MeshImpl::SetColor(float r, float g, float b, float a)
} }
// FUNCTION: BETA10 0x10171320 // 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; return result;
} }
// FUNCTION: BETA10 0x10171260 // FUNCTION: BETA10 0x10171260
inline Tgl::Result MeshImpl::SetTexture(const TextureImpl* pTexture) inline Result MeshImpl::SetTexture(const TextureImpl* pTexture)
{ {
assert(m_data); assert(m_data);
assert(!pTexture || pTexture->ImplementationData()); assert(!pTexture || pTexture->ImplementationData());
@ -56,7 +56,7 @@ inline Tgl::Result MeshImpl::SetTexture(const TextureImpl* pTexture)
// FUNCTION: LEGO1 0x100a3f50 // FUNCTION: LEGO1 0x100a3f50
// FUNCTION: BETA10 0x10170630 // FUNCTION: BETA10 0x10170630
Tgl::Result MeshImpl::SetTexture(const Texture* pTexture) Result MeshImpl::SetTexture(const Texture* pTexture)
{ {
assert(m_data); assert(m_data);
@ -65,7 +65,7 @@ Tgl::Result MeshImpl::SetTexture(const Texture* pTexture)
// FUNCTION: LEGO1 0x100a3f80 // FUNCTION: LEGO1 0x100a3f80
// FUNCTION: BETA10 0x10170690 // FUNCTION: BETA10 0x10170690
Tgl::Result MeshImpl::SetTextureMappingMode(TextureMappingMode mode) Result MeshImpl::SetTextureMappingMode(TextureMappingMode mode)
{ {
assert(m_data); assert(m_data);
@ -73,7 +73,7 @@ Tgl::Result MeshImpl::SetTextureMappingMode(TextureMappingMode mode)
} }
// FUNCTION: BETA10 0x10170750 // FUNCTION: BETA10 0x10170750
inline Tgl::Result MeshSetShadingModel(MeshImpl::MeshData* pMesh, ShadingModel model) inline Result MeshSetShadingModel(MeshImpl::MeshData* pMesh, ShadingModel model)
{ {
D3DRMRENDERQUALITY mode = Translate(model); D3DRMRENDERQUALITY mode = Translate(model);
return ResultVal(pMesh->groupMesh->SetGroupQuality(pMesh->groupIndex, mode)); 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: LEGO1 0x100a3fc0
// FUNCTION: BETA10 0x101706f0 // FUNCTION: BETA10 0x101706f0
Tgl::Result MeshImpl::SetShadingModel(ShadingModel model) Result MeshImpl::SetShadingModel(ShadingModel model)
{ {
assert(m_data); assert(m_data);
return MeshSetShadingModel(m_data, model); return MeshSetShadingModel(m_data, model);
} }
// FUNCTION: BETA10 0x101714e0 // 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 = new MeshImpl::MeshData();
rpTarget->groupMesh = pMesh; rpTarget->groupMesh = pMesh;
// Query information from old group // Query information from old group
DWORD dataSize; DWORD dataSize;
#if defined(__3DS__) DWORD vcount, fcount, vperface;
unsigned long vcount, fcount, vperface;
#else
unsigned int vcount, fcount, vperface;
#endif
Tgl::Result result = Result result =
ResultVal(pSource->groupMesh->GetGroup(pSource->groupIndex, &vcount, &fcount, &vperface, &dataSize, NULL)); ResultVal(pSource->groupMesh->GetGroup(pSource->groupIndex, &vcount, &fcount, &vperface, &dataSize, NULL));
assert(Succeeded(result)); assert(Succeeded(result));
@ -189,9 +185,9 @@ Mesh* MeshImpl::DeepClone(MeshBuilder* pMesh)
return DeepClone(*static_cast<MeshBuilderImpl*>(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(); rpTarget = new MeshImpl::MeshData();
if (rpTarget) { if (rpTarget) {
@ -229,13 +225,13 @@ Mesh* MeshImpl::ShallowClone(MeshBuilder* pMeshBuilder)
} }
// FUNCTION: BETA10 0x10171ac0 // 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)); return ResultVal(pMesh->groupMesh->GetGroupTexture(pMesh->groupIndex, pD3DTexture));
} }
// FUNCTION: BETA10 0x10171980 // FUNCTION: BETA10 0x10171980
inline Tgl::Result MeshImpl::GetTexture(TextureImpl** ppTexture) inline Result MeshImpl::GetTexture(TextureImpl** ppTexture)
{ {
assert(m_data); assert(m_data);
assert(ppTexture); assert(ppTexture);
@ -245,7 +241,7 @@ inline Tgl::Result MeshImpl::GetTexture(TextureImpl** ppTexture)
// TODO: This helps retail match, but it adds to the stack // TODO: This helps retail match, but it adds to the stack
IDirect3DRMTexture* tex; IDirect3DRMTexture* tex;
Tgl::Result result = MeshGetTexture(m_data, &tex); Result result = MeshGetTexture(m_data, &tex);
#ifndef BETA10 #ifndef BETA10
if (Succeeded(result)) { if (Succeeded(result)) {
@ -260,7 +256,7 @@ inline Tgl::Result MeshImpl::GetTexture(TextureImpl** ppTexture)
// FUNCTION: LEGO1 0x100a4330 // FUNCTION: LEGO1 0x100a4330
// FUNCTION: BETA10 0x10170820 // FUNCTION: BETA10 0x10170820
Tgl::Result MeshImpl::GetTexture(Texture*& rpTexture) Result MeshImpl::GetTexture(Texture*& rpTexture)
{ {
assert(m_data); assert(m_data);

12
LEGO1/tgl/d3drm/meshbuilder.cpp
View File

@ -45,7 +45,7 @@ Mesh* MeshBuilderImpl::CreateMesh(
return pMeshImpl; return pMeshImpl;
} }
inline Tgl::Result CreateMesh( inline Result CreateMesh(
IDirect3DRMMesh* pD3DRM, IDirect3DRMMesh* pD3DRM,
unsigned int faceCount, unsigned int faceCount,
unsigned int vertexCount, 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)); result = ResultVal(pD3DRM->AddGroup(vertexCount, faceCount, 3, fData, &groupIndex));
if (Succeeded(result)) { if (Succeeded(result)) {
@ -129,7 +129,7 @@ inline Tgl::Result CreateMesh(
return result; return result;
} }
inline Tgl::Result MeshBuilderImpl::CreateMeshImpl( inline Result MeshBuilderImpl::CreateMeshImpl(
MeshImpl* pMeshImpl, MeshImpl* pMeshImpl,
unsigned int faceCount, unsigned int faceCount,
unsigned int vertexCount, unsigned int vertexCount,
@ -156,10 +156,10 @@ inline Tgl::Result MeshBuilderImpl::CreateMeshImpl(
} }
// FUNCTION: BETA10 0x1016e060 // 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; D3DRMBOX box;
Tgl::Result result = ResultVal(pMesh->GetBox(&box)); Result result = ResultVal(pMesh->GetBox(&box));
if (Succeeded(result)) { if (Succeeded(result)) {
min[0] = box.min.x; min[0] = box.min.x;
min[1] = box.min.y; min[1] = box.min.y;
@ -173,7 +173,7 @@ inline Tgl::Result MeshBuilderGetBoundingBox(IDirect3DRMMesh* pMesh, float min[3
// FUNCTION: LEGO1 0x100a3ae0 // FUNCTION: LEGO1 0x100a3ae0
// FUNCTION: BETA10 0x1016ce00 // 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); assert(m_data);

60
LEGO1/tgl/d3drm/renderer.cpp
View File

@ -22,7 +22,7 @@ IDirect3DRM2* g_pD3DRM = NULL;
} // namespace TglImpl } // namespace TglImpl
// Inlined only // Inlined only
Tgl::Result RendererImpl::Create() Result RendererImpl::Create()
{ {
if (g_pD3DRM) { if (g_pD3DRM) {
g_pD3DRM->AddRef(); g_pD3DRM->AddRef();
@ -37,19 +37,19 @@ Tgl::Result RendererImpl::Create()
} }
// FUNCTION: BETA10 0x1016cf00 // FUNCTION: BETA10 0x1016cf00
inline Tgl::Result RendererCreateDevice( inline Result RendererCreateDevice(
IDirect3DRM2* pD3DRM, IDirect3DRM2* pD3DRM,
const DeviceDirect3DCreateData& rCreateData, const DeviceDirect3DCreateData& rCreateData,
IDirect3DRMDevice2*& rpDevice IDirect3DRMDevice2*& rpDevice
) )
{ {
Tgl::Result result = Result result =
ResultVal(pD3DRM->CreateDeviceFromD3D(rCreateData.m_pDirect3D, rCreateData.m_pDirect3DDevice, &rpDevice)); ResultVal(pD3DRM->CreateDeviceFromD3D(rCreateData.m_pDirect3D, rCreateData.m_pDirect3DDevice, &rpDevice));
return result; return result;
} }
// FUNCTION: BETA10 0x1016ce60 // 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(m_data);
assert(!rDevice.ImplementationData()); assert(!rDevice.ImplementationData());
@ -73,13 +73,13 @@ Device* RendererImpl::CreateDevice(const DeviceDirect3DCreateData& data)
} }
// FUNCTION: BETA10 0x1016cfe0 // FUNCTION: BETA10 0x1016cfe0
inline Tgl::Result RendererCreateDevice( inline Result RendererCreateDevice(
IDirect3DRM2* pD3DRM, IDirect3DRM2* pD3DRM,
const DeviceDirectDrawCreateData& rCreateData, const DeviceDirectDrawCreateData& rCreateData,
IDirect3DRMDevice2*& rpDevice IDirect3DRMDevice2*& rpDevice
) )
{ {
Tgl::Result result = ResultVal(pD3DRM->CreateDeviceFromSurface( Result result = ResultVal(pD3DRM->CreateDeviceFromSurface(
const_cast<GUID*>(rCreateData.m_driverGUID), const_cast<GUID*>(rCreateData.m_driverGUID),
rCreateData.m_pDirectDraw, rCreateData.m_pDirectDraw,
rCreateData.m_pBackBuffer, rCreateData.m_pBackBuffer,
@ -92,7 +92,7 @@ inline Tgl::Result RendererCreateDevice(
// GLOBAL: BETA10 0x102055f4 // GLOBAL: BETA10 0x102055f4
static int g_setBufferCount = 1; static int g_setBufferCount = 1;
if (g_setBufferCount) { if (g_setBufferCount) {
Tgl::Result result2 = ResultVal(rpDevice->SetBufferCount(2)); Result result2 = ResultVal(rpDevice->SetBufferCount(2));
assert(Succeeded(result)); assert(Succeeded(result));
} }
} }
@ -102,7 +102,7 @@ inline Tgl::Result RendererCreateDevice(
} }
// FUNCTION: BETA10 0x1016cf40 // 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(m_data);
assert(!rDevice.ImplementationData()); assert(!rDevice.ImplementationData());
@ -126,7 +126,7 @@ Device* RendererImpl::CreateDevice(const DeviceDirectDrawCreateData& data)
} }
// FUNCTION: BETA10 0x1016d1d0 // FUNCTION: BETA10 0x1016d1d0
inline Tgl::Result RendererCreateView( inline Result RendererCreateView(
IDirect3DRM2* pRenderer, IDirect3DRM2* pRenderer,
const IDirect3DRMDevice2* pDevice, const IDirect3DRMDevice2* pDevice,
const IDirect3DRMFrame2* pCamera, const IDirect3DRMFrame2* pCamera,
@ -137,7 +137,7 @@ inline Tgl::Result RendererCreateView(
IDirect3DRMViewport*& rpView IDirect3DRMViewport*& rpView
) )
{ {
Tgl::Result result = ResultVal(pRenderer->CreateViewport( Result result = ResultVal(pRenderer->CreateViewport(
const_cast<IDirect3DRMDevice2*>(pDevice), const_cast<IDirect3DRMDevice2*>(pDevice),
const_cast<IDirect3DRMFrame2*>(pCamera), const_cast<IDirect3DRMFrame2*>(pCamera),
x, x,
@ -159,7 +159,7 @@ inline Tgl::Result RendererCreateView(
} }
// FUNCTION: BETA10 0x1016d0b0 // FUNCTION: BETA10 0x1016d0b0
inline Tgl::Result RendererImpl::CreateView( inline Result RendererImpl::CreateView(
const DeviceImpl& rDevice, const DeviceImpl& rDevice,
const CameraImpl& rCamera, const CameraImpl& rCamera,
unsigned int x, unsigned int x,
@ -219,13 +219,13 @@ View* RendererImpl::CreateView(
} }
// FUNCTION: BETA10 0x1016d380 // FUNCTION: BETA10 0x1016d380
inline Tgl::Result RendererCreateGroup( inline Result RendererCreateGroup(
IDirect3DRM2* pRenderer, IDirect3DRM2* pRenderer,
const IDirect3DRMFrame2* pParent, const IDirect3DRMFrame2* pParent,
IDirect3DRMFrame2*& rpGroup IDirect3DRMFrame2*& rpGroup
) )
{ {
Tgl::Result result = ResultVal(pRenderer->CreateFrame(NULL, &rpGroup)); Result result = ResultVal(pRenderer->CreateFrame(NULL, &rpGroup));
if (Succeeded(result) && pParent) { if (Succeeded(result) && pParent) {
result = ResultVal(const_cast<IDirect3DRMFrame2*>(pParent)->AddVisual(rpGroup)); result = ResultVal(const_cast<IDirect3DRMFrame2*>(pParent)->AddVisual(rpGroup));
if (!Succeeded(result)) { if (!Succeeded(result)) {
@ -237,7 +237,7 @@ inline Tgl::Result RendererCreateGroup(
} }
// FUNCTION: BETA10 0x1016d280 // 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(m_data);
assert(!pParentGroup || pParentGroup->ImplementationData()); assert(!pParentGroup || pParentGroup->ImplementationData());
@ -265,13 +265,13 @@ Group* RendererImpl::CreateGroup(const Group* pParent)
} }
// FUNCTION: BETA10 0x1016d4b0 // FUNCTION: BETA10 0x1016d4b0
inline Tgl::Result RendererCreateCamera(IDirect3DRM2* pD3DRM, IDirect3DRMFrame2*& rpCamera) inline Result RendererCreateCamera(IDirect3DRM2* pD3DRM, IDirect3DRMFrame2*& rpCamera)
{ {
return ResultVal(pD3DRM->CreateFrame(NULL, &rpCamera)); return ResultVal(pD3DRM->CreateFrame(NULL, &rpCamera));
} }
// FUNCTION: BETA10 0x1016d420 // FUNCTION: BETA10 0x1016d420
inline Tgl::Result RendererImpl::CreateCamera(CameraImpl& rCamera) inline Result RendererImpl::CreateCamera(CameraImpl& rCamera)
{ {
assert(m_data); assert(m_data);
assert(!rCamera.ImplementationData()); assert(!rCamera.ImplementationData());
@ -295,7 +295,7 @@ Camera* RendererImpl::CreateCamera()
} }
// FUNCTION: BETA10 0x1016d580 // FUNCTION: BETA10 0x1016d580
inline Tgl::Result RendererCreateLight( inline Result RendererCreateLight(
IDirect3DRM2* pD3DRM, IDirect3DRM2* pD3DRM,
LightType type, LightType type,
float r, float r,
@ -307,7 +307,7 @@ inline Tgl::Result RendererCreateLight(
D3DRMLIGHTTYPE lightType = Translate(type); D3DRMLIGHTTYPE lightType = Translate(type);
IDirect3DRMFrame2* pLightFrame; IDirect3DRMFrame2* pLightFrame;
IDirect3DRMLight* pLight; IDirect3DRMLight* pLight;
Tgl::Result result; Result result;
result = ResultVal(pD3DRM->CreateFrame(NULL, &pLightFrame)); result = ResultVal(pD3DRM->CreateFrame(NULL, &pLightFrame));
assert(Succeeded(result)); assert(Succeeded(result));
@ -348,7 +348,7 @@ inline Tgl::Result RendererCreateLight(
} }
// FUNCTION: BETA10 0x1016d4e0 // 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(m_data);
assert(!rLight.ImplementationData()); assert(!rLight.ImplementationData());
@ -373,13 +373,13 @@ Light* RendererImpl::CreateLight(LightType type, float r, float g, float b)
} }
// FUNCTION: BETA10 0x1016d8e0 // FUNCTION: BETA10 0x1016d8e0
inline Tgl::Result RendererCreateMeshBuilder(IDirect3DRM2* pD3DRM, IDirect3DRMMesh*& rpMesh) inline Result RendererCreateMeshBuilder(IDirect3DRM2* pD3DRM, IDirect3DRMMesh*& rpMesh)
{ {
return ResultVal(pD3DRM->CreateMesh(&rpMesh)); return ResultVal(pD3DRM->CreateMesh(&rpMesh));
} }
// FUNCTION: BETA10 0x1016d850 // FUNCTION: BETA10 0x1016d850
inline Tgl::Result RendererImpl::CreateMeshBuilder(MeshBuilderImpl& rMesh) inline Result RendererImpl::CreateMeshBuilder(MeshBuilderImpl& rMesh)
{ {
assert(m_data); assert(m_data);
assert(!rMesh.ImplementationData()); assert(!rMesh.ImplementationData());
@ -403,7 +403,7 @@ MeshBuilder* RendererImpl::CreateMeshBuilder()
} }
// FUNCTION: BETA10 0x1016d9c0 // FUNCTION: BETA10 0x1016d9c0
inline Tgl::Result RendererCreateTexture( inline Result RendererCreateTexture(
IDirect3DRM2* pRenderer, IDirect3DRM2* pRenderer,
int width, int width,
int height, int height,
@ -415,7 +415,7 @@ inline Tgl::Result RendererCreateTexture(
IDirect3DRMTexture*& rpTexture IDirect3DRMTexture*& rpTexture
) )
{ {
Tgl::Result result; Result result;
TglD3DRMIMAGE* pImage = new TglD3DRMIMAGE(width, height, bytesPerPixel, pBuffer, useBuffer, paletteSize, pEntries); TglD3DRMIMAGE* pImage = new TglD3DRMIMAGE(width, height, bytesPerPixel, pBuffer, useBuffer, paletteSize, pEntries);
assert(pImage); assert(pImage);
@ -443,7 +443,7 @@ inline Tgl::Result RendererCreateTexture(
} }
// FUNCTION: BETA10 0x1016d910 // FUNCTION: BETA10 0x1016d910
inline Tgl::Result RendererImpl::CreateTexture( inline Result RendererImpl::CreateTexture(
TextureImpl& rTexture, TextureImpl& rTexture,
int width, int width,
int height, int height,
@ -502,13 +502,13 @@ Texture* RendererImpl::CreateTexture(
} }
// FUNCTION: BETA10 0x1016dcb0 // 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); return RendererCreateTexture(pRenderer, 0, 0, 0, NULL, FALSE, 0, NULL, rpTexture);
} }
// FUNCTION: BETA10 0x1016dc20 // FUNCTION: BETA10 0x1016dc20
inline Tgl::Result RendererImpl::CreateTexture(TextureImpl& rTexture) inline Result RendererImpl::CreateTexture(TextureImpl& rTexture)
{ {
assert(m_data); assert(m_data);
assert(!rTexture.ImplementationData()); assert(!rTexture.ImplementationData());
@ -532,14 +532,14 @@ Texture* RendererImpl::CreateTexture()
} }
// FUNCTION: BETA10 0x1016af90 // 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)); return ResultVal(pRenderer->SetDefaultTextureShades(shadeCount));
} }
// FUNCTION: LEGO1 0x100a2270 // FUNCTION: LEGO1 0x100a2270
// FUNCTION: BETA10 0x1016af30 // FUNCTION: BETA10 0x1016af30
Tgl::Result RendererImpl::SetTextureDefaultShadeCount(unsigned int shadeCount) Result RendererImpl::SetTextureDefaultShadeCount(unsigned int shadeCount)
{ {
assert(m_data); assert(m_data);
@ -547,14 +547,14 @@ Tgl::Result RendererImpl::SetTextureDefaultShadeCount(unsigned int shadeCount)
} }
// FUNCTION: BETA10 0x1016b020 // 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)); return ResultVal(pRenderer->SetDefaultTextureColors(colorCount));
} }
// FUNCTION: LEGO1 0x100a2290 // FUNCTION: LEGO1 0x100a2290
// FUNCTION: BETA10 0x1016afc0 // FUNCTION: BETA10 0x1016afc0
Tgl::Result RendererImpl::SetTextureDefaultColorCount(unsigned int colorCount) Result RendererImpl::SetTextureDefaultColorCount(unsigned int colorCount)
{ {
assert(m_data); assert(m_data);

38
LEGO1/tgl/d3drm/texture.cpp
View File

@ -17,10 +17,10 @@ void TextureDestroyCallback(IDirect3DRMObject* pObject, void* pArg);
// FUNCTION: LEGO1 0x100a12a0 // FUNCTION: LEGO1 0x100a12a0
// FUNCTION: BETA10 0x10169113 // FUNCTION: BETA10 0x10169113
Tgl::Result TextureImpl::SetImage(IDirect3DRMTexture* pSelf, TglD3DRMIMAGE* pImage) Result TextureImpl::SetImage(IDirect3DRMTexture* pSelf, TglD3DRMIMAGE* pImage)
{ {
void* appData; void* appData;
Tgl::Result result; Result result;
appData = pImage; appData = pImage;
assert(reinterpret_cast<TglD3DRMIMAGE*>(appData) == pImage); assert(reinterpret_cast<TglD3DRMIMAGE*>(appData) == pImage);
@ -84,7 +84,7 @@ TglD3DRMIMAGE::TglD3DRMIMAGE(
m_image.palette = NULL; m_image.palette = NULL;
m_texelsAllocatedByClient = 0; m_texelsAllocatedByClient = 0;
Tgl::Result result; Result result;
if (pBuffer != NULL) { if (pBuffer != NULL) {
result = CreateBuffer(width, height, depth, pBuffer, useBuffer); result = CreateBuffer(width, height, depth, pBuffer, useBuffer);
assert(Succeeded(result)); assert(Succeeded(result));
@ -122,7 +122,7 @@ inline static int IsPowerOfTwo(int v)
// FUNCTION: LEGO1 0x100a13e0 // FUNCTION: LEGO1 0x100a13e0
// FUNCTION: BETA10 0x101694a4 // 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; int bytesPerScanline = width;
@ -162,7 +162,7 @@ Tgl::Result TglD3DRMIMAGE::CreateBuffer(int width, int height, int depth, void*
// FUNCTION: LEGO1 0x100a1510 // FUNCTION: LEGO1 0x100a1510
// FUNCTION: BETA10 0x1016969c // 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(m_image.buffer1 && pTexels);
assert((destVOffset + srcHeight) <= m_image.height); assert((destVOffset + srcHeight) <= m_image.height);
@ -175,7 +175,7 @@ Tgl::Result TglD3DRMIMAGE::FillRowsOfTexture(int destVOffset, int srcHeight, cha
// FUNCTION: LEGO1 0x100a1550 // FUNCTION: LEGO1 0x100a1550
// FUNCTION: BETA10 0x10169758 // 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 // This function is a 100% match if the PaletteEntry class is copied
// into into the TglD3DRMIMAGE class instead of being a global struct. // 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 // FUNCTION: BETA10 0x1016ee80
inline Tgl::Result TextureSetTexels( inline Result TextureSetTexels(
IDirect3DRMTexture* pTexture, IDirect3DRMTexture* pTexture,
int width, int width,
int height, int height,
@ -216,7 +216,7 @@ inline Tgl::Result TextureSetTexels(
TglD3DRMIMAGE* pImage = TextureGetImage(pTexture); TglD3DRMIMAGE* pImage = TextureGetImage(pTexture);
assert(pImage); assert(pImage);
Tgl::Result result = pImage->CreateBuffer(width, height, bitsPerTexel, pTexels, pTexelsArePersistent); Result result = pImage->CreateBuffer(width, height, bitsPerTexel, pTexels, pTexelsArePersistent);
assert(Succeeded(result)); assert(Succeeded(result));
if (Succeeded(result)) { if (Succeeded(result)) {
@ -229,7 +229,7 @@ inline Tgl::Result TextureSetTexels(
// FUNCTION: LEGO1 0x100a3c10 // FUNCTION: LEGO1 0x100a3c10
// FUNCTION: BETA10 0x1016c390 // 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); assert(m_data);
@ -237,12 +237,12 @@ Tgl::Result TextureImpl::SetTexels(int width, int height, int bitsPerTexel, void
} }
// FUNCTION: BETA10 0x1016f160 // 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); TglD3DRMIMAGE* pImage = TextureGetImage(pTexture);
assert(pImage); assert(pImage);
Tgl::Result result = pImage->FillRowsOfTexture(y, height, (char*) pBuffer); Result result = pImage->FillRowsOfTexture(y, height, (char*) pBuffer);
assert(Succeeded(result)); assert(Succeeded(result));
return result; return result;
@ -258,16 +258,16 @@ void TextureImpl::FillRowsOfTexture(int y, int height, void* pBuffer)
} }
// FUNCTION: BETA10 0x1016f270 // 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)); assert(Succeeded(result));
return result; return result;
} }
// FUNCTION: LEGO1 0x100a3c90 // FUNCTION: LEGO1 0x100a3c90
// FUNCTION: BETA10 0x1016c540 // FUNCTION: BETA10 0x1016c540
Tgl::Result TextureImpl::Changed(int texelsChanged, int paletteChanged) Result TextureImpl::Changed(int texelsChanged, int paletteChanged)
{ {
assert(m_data); assert(m_data);
@ -275,7 +275,7 @@ Tgl::Result TextureImpl::Changed(int texelsChanged, int paletteChanged)
} }
// FUNCTION: BETA10 0x1016f4c0 // FUNCTION: BETA10 0x1016f4c0
inline Tgl::Result TextureGetBufferAndPalette( inline Result TextureGetBufferAndPalette(
IDirect3DRMTexture* pTexture, IDirect3DRMTexture* pTexture,
int* width, int* width,
int* height, int* height,
@ -305,7 +305,7 @@ inline Tgl::Result TextureGetBufferAndPalette(
// FUNCTION: LEGO1 0x100a3cc0 // FUNCTION: LEGO1 0x100a3cc0
// FUNCTION: BETA10 0x1016c5d0 // FUNCTION: BETA10 0x1016c5d0
Tgl::Result TextureImpl::GetBufferAndPalette( Result TextureImpl::GetBufferAndPalette(
int* width, int* width,
int* height, int* height,
int* depth, int* depth,
@ -320,13 +320,13 @@ Tgl::Result TextureImpl::GetBufferAndPalette(
} }
// FUNCTION: BETA10 0x1016f730 // 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); TglD3DRMIMAGE* pImage = TextureGetImage(pTexture);
assert(pImage); assert(pImage);
pImage->InitializePalette(entryCount, pEntries); pImage->InitializePalette(entryCount, pEntries);
Tgl::Result result = ResultVal(pTexture->Changed(FALSE, TRUE)); Result result = ResultVal(pTexture->Changed(FALSE, TRUE));
assert(Succeeded(result)); assert(Succeeded(result));
return Success; return Success;
@ -334,7 +334,7 @@ inline Tgl::Result TextureSetPalette(IDirect3DRMTexture* pTexture, int entryCoun
// FUNCTION: LEGO1 0x100a3d40 // FUNCTION: LEGO1 0x100a3d40
// FUNCTION: BETA10 0x1016c6a0 // FUNCTION: BETA10 0x1016c6a0
Tgl::Result TextureImpl::SetPalette(int entryCount, PaletteEntry* pEntries) Result TextureImpl::SetPalette(int entryCount, PaletteEntry* pEntries)
{ {
assert(m_data); assert(m_data);

92
LEGO1/tgl/d3drm/view.cpp
View File

@ -22,7 +22,7 @@ DECOMP_SIZE_ASSERT(ViewportAppData, 0x18);
// FUNCTION: BETA10 0x10168920 // FUNCTION: BETA10 0x10168920
ViewportAppData::ViewportAppData(IDirect3DRM2* pRenderer) ViewportAppData::ViewportAppData(IDirect3DRM2* pRenderer)
{ {
Tgl::Result result = ResultVal(pRenderer->CreateFrame(NULL, &m_pLightFrame)); Result result = ResultVal(pRenderer->CreateFrame(NULL, &m_pLightFrame));
assert(Succeeded(result)); assert(Succeeded(result));
m_pCamera = NULL; m_pCamera = NULL;
@ -39,7 +39,7 @@ ViewportAppData::~ViewportAppData()
int refCount; int refCount;
IDirect3DRMFrameArray* pChildFrames; IDirect3DRMFrameArray* pChildFrames;
IDirect3DRMFrame* pChildFrame = NULL; IDirect3DRMFrame* pChildFrame = NULL;
Tgl::Result result = ResultVal(m_pLightFrame->GetChildren(&pChildFrames)); Result result = ResultVal(m_pLightFrame->GetChildren(&pChildFrames));
assert(Succeeded(result)); assert(Succeeded(result));
for (int i = 0; i < (int) pChildFrames->GetSize(); i++) { for (int i = 0; i < (int) pChildFrames->GetSize(); i++) {
@ -65,7 +65,7 @@ void ViewportDestroyCallback(IDirect3DRMObject* pObject, void* pArg);
// FUNCTION: LEGO1 0x100a1160 // FUNCTION: LEGO1 0x100a1160
// FUNCTION: BETA10 0x10168ba5 // FUNCTION: BETA10 0x10168ba5
Tgl::Result ViewImpl::ViewportCreateAppData( Result ViewImpl::ViewportCreateAppData(
IDirect3DRM2* pDevice, IDirect3DRM2* pDevice,
IDirect3DRMViewport* pViewport, IDirect3DRMViewport* pViewport,
IDirect3DRMFrame2* pCamera IDirect3DRMFrame2* pCamera
@ -77,7 +77,7 @@ Tgl::Result ViewImpl::ViewportCreateAppData(
pViewportAppData->m_pCamera = pCamera; pViewportAppData->m_pCamera = pCamera;
assert(!pViewport->GetAppData()); 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(Succeeded(result));
assert(reinterpret_cast<ViewportAppData*>(pViewport->GetAppData()) == pViewportAppData); assert(reinterpret_cast<ViewportAppData*>(pViewport->GetAppData()) == pViewportAppData);
@ -95,13 +95,13 @@ Tgl::Result ViewImpl::ViewportCreateAppData(
} }
// FUNCTION: BETA10 0x1016bd80 // FUNCTION: BETA10 0x1016bd80
inline Tgl::Result ViewRestoreFrameAfterRender( inline Result ViewRestoreFrameAfterRender(
IDirect3DRMFrame* pFrame, IDirect3DRMFrame* pFrame,
IDirect3DRMFrame* pCamera, IDirect3DRMFrame* pCamera,
IDirect3DRMFrame* pLightFrame IDirect3DRMFrame* pLightFrame
) )
{ {
Tgl::Result result = Success; Result result = Success;
if (pFrame) { if (pFrame) {
// remove camera and light frame from frame that was rendered // 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... // 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(static_cast<ViewImpl::ViewDataType>(pObject));
assert(pViewportAppData); assert(pViewportAppData);
Tgl::Result result = ViewRestoreFrameAfterRender( Result result = ViewRestoreFrameAfterRender(
pViewportAppData->m_pLastRenderedFrame, pViewportAppData->m_pLastRenderedFrame,
pViewportAppData->m_pCamera, pViewportAppData->m_pCamera,
pViewportAppData->m_pLightFrame pViewportAppData->m_pLightFrame
@ -141,7 +141,7 @@ void ViewportDestroyCallback(IDirect3DRMObject* pObject, void* pArg)
// FUNCTION: LEGO1 0x100a1290 // FUNCTION: LEGO1 0x100a1290
// FUNCTION: BETA10 0x10168eab // FUNCTION: BETA10 0x10168eab
Tgl::Result ViewportPickImpl( Result ViewportPickImpl(
IDirect3DRMViewport* pViewport, IDirect3DRMViewport* pViewport,
int x, int x,
int y, int y,
@ -175,7 +175,7 @@ void* ViewImpl::ImplementationDataPtr()
} }
// FUNCTION: BETA10 0x10170a40 // FUNCTION: BETA10 0x10170a40
inline Tgl::Result ViewAddLight(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame* pLight) inline Result ViewAddLight(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame* pLight)
{ {
IDirect3DRMFrame* pLightFrame = ViewportGetLightFrame(pViewport); IDirect3DRMFrame* pLightFrame = ViewportGetLightFrame(pViewport);
@ -184,7 +184,7 @@ inline Tgl::Result ViewAddLight(IDirect3DRMViewport* pViewport, const IDirect3DR
} }
// FUNCTION: BETA10 0x101709a0 // FUNCTION: BETA10 0x101709a0
inline Tgl::Result ViewImpl::Add(const LightImpl& rLight) inline Result ViewImpl::Add(const LightImpl& rLight)
{ {
assert(m_data); assert(m_data);
assert(rLight.ImplementationData()); assert(rLight.ImplementationData());
@ -194,7 +194,7 @@ inline Tgl::Result ViewImpl::Add(const LightImpl& rLight)
// FUNCTION: LEGO1 0x100a2d90 // FUNCTION: LEGO1 0x100a2d90
// FUNCTION: BETA10 0x1016e690 // FUNCTION: BETA10 0x1016e690
Tgl::Result ViewImpl::Add(const Light* pLight) Result ViewImpl::Add(const Light* pLight)
{ {
assert(m_data); assert(m_data);
assert(pLight); assert(pLight);
@ -203,7 +203,7 @@ Tgl::Result ViewImpl::Add(const Light* pLight)
} }
// FUNCTION: BETA10 0x10170bb0 // FUNCTION: BETA10 0x10170bb0
inline Tgl::Result ViewRemoveLight(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame* pLight) inline Result ViewRemoveLight(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame* pLight)
{ {
IDirect3DRMFrame* pLightFrame = ViewportGetLightFrame(pViewport); IDirect3DRMFrame* pLightFrame = ViewportGetLightFrame(pViewport);
@ -212,7 +212,7 @@ inline Tgl::Result ViewRemoveLight(IDirect3DRMViewport* pViewport, const IDirect
} }
// FUNCTION: BETA10 0x10170b10 // FUNCTION: BETA10 0x10170b10
inline Tgl::Result ViewImpl::Remove(const LightImpl& rLight) inline Result ViewImpl::Remove(const LightImpl& rLight)
{ {
assert(m_data); assert(m_data);
assert(rLight.ImplementationData()); assert(rLight.ImplementationData());
@ -222,7 +222,7 @@ inline Tgl::Result ViewImpl::Remove(const LightImpl& rLight)
// FUNCTION: LEGO1 0x100a2dc0 // FUNCTION: LEGO1 0x100a2dc0
// FUNCTION: BETA10 0x1016e710 // FUNCTION: BETA10 0x1016e710
Tgl::Result ViewImpl::Remove(const Light* pLight) Result ViewImpl::Remove(const Light* pLight)
{ {
assert(m_data); assert(m_data);
assert(pLight); assert(pLight);
@ -231,10 +231,10 @@ Tgl::Result ViewImpl::Remove(const Light* pLight)
} }
// FUNCTION: BETA10 0x10170cc0 // FUNCTION: BETA10 0x10170cc0
inline Tgl::Result ViewSetCamera(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame2* pCamera) inline Result ViewSetCamera(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame2* pCamera)
{ {
ViewportAppData* pViewportAppData; ViewportAppData* pViewportAppData;
Tgl::Result result; Result result;
pViewportAppData = reinterpret_cast<ViewportAppData*>(pViewport->GetAppData()); pViewportAppData = reinterpret_cast<ViewportAppData*>(pViewport->GetAppData());
assert(pViewportAppData); assert(pViewportAppData);
@ -252,7 +252,7 @@ inline Tgl::Result ViewSetCamera(IDirect3DRMViewport* pViewport, const IDirect3D
} }
// FUNCTION: BETA10 0x10170c20 // FUNCTION: BETA10 0x10170c20
inline Tgl::Result ViewImpl::SetCamera(const CameraImpl& rCamera) inline Result ViewImpl::SetCamera(const CameraImpl& rCamera)
{ {
assert(m_data); assert(m_data);
assert(rCamera.ImplementationData()); assert(rCamera.ImplementationData());
@ -262,7 +262,7 @@ inline Tgl::Result ViewImpl::SetCamera(const CameraImpl& rCamera)
// FUNCTION: LEGO1 0x100a2df0 // FUNCTION: LEGO1 0x100a2df0
// FUNCTION: BETA10 0x1016e790 // FUNCTION: BETA10 0x1016e790
Tgl::Result ViewImpl::SetCamera(const Camera* pCamera) Result ViewImpl::SetCamera(const Camera* pCamera)
{ {
assert(m_data); assert(m_data);
assert(pCamera); assert(pCamera);
@ -271,7 +271,7 @@ Tgl::Result ViewImpl::SetCamera(const Camera* pCamera)
} }
// FUNCTION: BETA10 0x1016e870 // FUNCTION: BETA10 0x1016e870
inline Tgl::Result ViewSetProjection(IDirect3DRMViewport* pViewport, ProjectionType type) inline Result ViewSetProjection(IDirect3DRMViewport* pViewport, ProjectionType type)
{ {
D3DRMPROJECTIONTYPE projectionType = Translate(type); D3DRMPROJECTIONTYPE projectionType = Translate(type);
@ -280,7 +280,7 @@ inline Tgl::Result ViewSetProjection(IDirect3DRMViewport* pViewport, ProjectionT
// FUNCTION: LEGO1 0x100a2e70 // FUNCTION: LEGO1 0x100a2e70
// FUNCTION: BETA10 0x1016e810 // FUNCTION: BETA10 0x1016e810
Tgl::Result ViewImpl::SetProjection(ProjectionType type) Result ViewImpl::SetProjection(ProjectionType type)
{ {
assert(m_data); assert(m_data);
@ -288,7 +288,7 @@ Tgl::Result ViewImpl::SetProjection(ProjectionType type)
} }
// FUNCTION: BETA10 0x1016e920 // FUNCTION: BETA10 0x1016e920
inline Tgl::Result ViewSetFrustrum( inline Result ViewSetFrustrum(
IDirect3DRMViewport* pViewport, IDirect3DRMViewport* pViewport,
float frontClippingDistance, float frontClippingDistance,
float backClippingDistance, float backClippingDistance,
@ -296,7 +296,7 @@ inline Tgl::Result ViewSetFrustrum(
) )
{ {
float field = frontClippingDistance * tan(DegreesToRadians(degrees / 2)); float field = frontClippingDistance * tan(DegreesToRadians(degrees / 2));
Tgl::Result result; Result result;
result = ResultVal(pViewport->SetFront(frontClippingDistance)); result = ResultVal(pViewport->SetFront(frontClippingDistance));
if (Succeeded(result)) { if (Succeeded(result)) {
result = ResultVal(pViewport->SetBack(backClippingDistance)); result = ResultVal(pViewport->SetBack(backClippingDistance));
@ -310,7 +310,7 @@ inline Tgl::Result ViewSetFrustrum(
// FUNCTION: LEGO1 0x100a2eb0 // FUNCTION: LEGO1 0x100a2eb0
// FUNCTION: BETA10 0x1016e8b0 // 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); assert(m_data);
@ -318,9 +318,9 @@ Tgl::Result ViewImpl::SetFrustrum(float frontClippingDistance, float backClippin
} }
// FUNCTION: BETA10 0x1016ea70 // 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()); ViewportAppData* pViewportAppData = reinterpret_cast<ViewportAppData*>(pViewport->GetAppData());
assert(pViewportAppData); assert(pViewportAppData);
@ -339,7 +339,7 @@ inline Tgl::Result ViewSetBackgroundColor(IDirect3DRMViewport* pViewport, float
// FUNCTION: LEGO1 0x100a2f30 // FUNCTION: LEGO1 0x100a2f30
// FUNCTION: BETA10 0x1016ea00 // 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); assert(m_data);
@ -347,7 +347,7 @@ Tgl::Result ViewImpl::SetBackgroundColor(float r, float g, float b)
} }
// FUNCTION: BETA10 0x1016ebd0 // 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()); ViewportAppData* pViewportAppData = reinterpret_cast<ViewportAppData*>(pViewport->GetAppData());
assert(pViewportAppData); assert(pViewportAppData);
@ -361,7 +361,7 @@ inline Tgl::Result ViewGetBackgroundColor(IDirect3DRMViewport* pViewport, float*
// FUNCTION: LEGO1 0x100a2f80 // FUNCTION: LEGO1 0x100a2f80
// FUNCTION: BETA10 0x1016eb60 // 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); assert(m_data);
@ -369,14 +369,14 @@ Tgl::Result ViewImpl::GetBackgroundColor(float* r, float* g, float* b)
} }
// FUNCTION: BETA10 0x1016ecb0 // FUNCTION: BETA10 0x1016ecb0
inline Tgl::Result ViewClear(IDirect3DRMViewport* pViewport) inline Result ViewClear(IDirect3DRMViewport* pViewport)
{ {
return ResultVal(pViewport->Clear()); return ResultVal(pViewport->Clear());
} }
// FUNCTION: LEGO1 0x100a2fb0 // FUNCTION: LEGO1 0x100a2fb0
// FUNCTION: BETA10 0x1016ec50 // FUNCTION: BETA10 0x1016ec50
Tgl::Result ViewImpl::Clear() Result ViewImpl::Clear()
{ {
assert(m_data); assert(m_data);
@ -384,7 +384,7 @@ Tgl::Result ViewImpl::Clear()
} }
// FUNCTION: BETA10 0x10170fb0 // FUNCTION: BETA10 0x10170fb0
inline Tgl::Result ViewPrepareFrameForRender( inline Result ViewPrepareFrameForRender(
IDirect3DRMFrame* pFrame, IDirect3DRMFrame* pFrame,
IDirect3DRMFrame* pCamera, IDirect3DRMFrame* pCamera,
IDirect3DRMFrame* pLightFrame, IDirect3DRMFrame* pLightFrame,
@ -393,7 +393,7 @@ inline Tgl::Result ViewPrepareFrameForRender(
float backgroundBlue float backgroundBlue
) )
{ {
Tgl::Result result = Success; Result result = Success;
if (pFrame) { if (pFrame) {
// set background color // set background color
@ -416,10 +416,10 @@ inline Tgl::Result ViewPrepareFrameForRender(
} }
// FUNCTION: BETA10 0x10170e30 // FUNCTION: BETA10 0x10170e30
inline Tgl::Result ViewRender(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame2* pGroup) inline Result ViewRender(IDirect3DRMViewport* pViewport, const IDirect3DRMFrame2* pGroup)
{ {
ViewportAppData* pViewportAppData; ViewportAppData* pViewportAppData;
Tgl::Result result; Result result;
pViewportAppData = reinterpret_cast<ViewportAppData*>(pViewport->GetAppData()); pViewportAppData = reinterpret_cast<ViewportAppData*>(pViewport->GetAppData());
assert(pViewportAppData); assert(pViewportAppData);
@ -454,7 +454,7 @@ inline Tgl::Result ViewRender(IDirect3DRMViewport* pViewport, const IDirect3DRMF
} }
// FUNCTION: BETA10 0x10170d90 // FUNCTION: BETA10 0x10170d90
inline Tgl::Result ViewImpl::Render(const GroupImpl& rScene) inline Result ViewImpl::Render(const GroupImpl& rScene)
{ {
assert(m_data); assert(m_data);
assert(rScene.ImplementationData()); assert(rScene.ImplementationData());
@ -464,7 +464,7 @@ inline Tgl::Result ViewImpl::Render(const GroupImpl& rScene)
// FUNCTION: LEGO1 0x100a2fd0 // FUNCTION: LEGO1 0x100a2fd0
// FUNCTION: BETA10 0x1016ece0 // FUNCTION: BETA10 0x1016ece0
Tgl::Result ViewImpl::Render(const Group* pGroup) Result ViewImpl::Render(const Group* pGroup)
{ {
assert(m_data); assert(m_data);
assert(pGroup); assert(pGroup);
@ -473,7 +473,7 @@ Tgl::Result ViewImpl::Render(const Group* pGroup)
} }
// FUNCTION: BETA10 0x1016edd0 // FUNCTION: BETA10 0x1016edd0
inline Tgl::Result ViewForceUpdate( inline Result ViewForceUpdate(
IDirect3DRMViewport* pViewport, IDirect3DRMViewport* pViewport,
unsigned int x, unsigned int x,
unsigned int y, unsigned int y,
@ -486,7 +486,7 @@ inline Tgl::Result ViewForceUpdate(
// FUNCTION: LEGO1 0x100a3080 // FUNCTION: LEGO1 0x100a3080
// FUNCTION: BETA10 0x1016ed60 // 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); assert(m_data);
@ -494,7 +494,7 @@ Tgl::Result ViewImpl::ForceUpdate(unsigned int x, unsigned int y, unsigned int w
} }
// FUNCTION: BETA10 0x101710f0 // FUNCTION: BETA10 0x101710f0
inline Tgl::Result ViewImpl::Pick( inline Result ViewImpl::Pick(
unsigned int x, unsigned int x,
unsigned int y, unsigned int y,
const GroupImpl** ppGroupsToPickFrom, const GroupImpl** ppGroupsToPickFrom,
@ -518,7 +518,7 @@ inline Tgl::Result ViewImpl::Pick(
// FUNCTION: LEGO1 0x100a30c0 // FUNCTION: LEGO1 0x100a30c0
// FUNCTION: BETA10 0x1016ee10 // FUNCTION: BETA10 0x1016ee10
Tgl::Result ViewImpl::Pick( Result ViewImpl::Pick(
unsigned int x, unsigned int x,
unsigned int y, unsigned int y,
const Group** ppGroupsToPickFrom, const Group** ppGroupsToPickFrom,
@ -540,12 +540,12 @@ Tgl::Result ViewImpl::Pick(
} }
// FUNCTION: BETA10 0x1016eff0 // 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; D3DRMVECTOR4D d3dRMScreen;
D3DVECTOR d3dRMWorld; D3DVECTOR d3dRMWorld;
D3DVECTOR* pD3DRMWorld = Translate(world, d3dRMWorld); D3DVECTOR* pD3DRMWorld = Translate(world, d3dRMWorld);
Tgl::Result result; Result result;
result = ResultVal(pViewport->Transform(&d3dRMScreen, pD3DRMWorld)); result = ResultVal(pViewport->Transform(&d3dRMScreen, pD3DRMWorld));
@ -561,7 +561,7 @@ inline Tgl::Result ViewTransformWorldToScreen(IDirect3DRMViewport* pViewport, co
// FUNCTION: LEGO1 0x100a30f0 // FUNCTION: LEGO1 0x100a30f0
// FUNCTION: BETA10 0x1016ef90 // 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); assert(m_data);
@ -569,7 +569,7 @@ Tgl::Result ViewImpl::TransformWorldToScreen(const float world[3], float screen[
} }
// FUNCTION: BETA10 0x1016f0d0 // 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; D3DVECTOR d3dRMWorld;
D3DRMVECTOR4D d3dScreen; D3DRMVECTOR4D d3dScreen;
@ -577,7 +577,7 @@ inline Tgl::Result ViewTransformScreenToWorld(IDirect3DRMViewport* pViewport, co
d3dScreen.y = screen[1]; d3dScreen.y = screen[1];
d3dScreen.z = screen[2]; d3dScreen.z = screen[2];
d3dScreen.w = screen[3]; d3dScreen.w = screen[3];
Tgl::Result result; Result result;
result = ResultVal(pViewport->InverseTransform(&d3dRMWorld, &d3dScreen)); result = ResultVal(pViewport->InverseTransform(&d3dRMWorld, &d3dScreen));
@ -592,7 +592,7 @@ inline Tgl::Result ViewTransformScreenToWorld(IDirect3DRMViewport* pViewport, co
// FUNCTION: LEGO1 0x100a3160 // FUNCTION: LEGO1 0x100a3160
// FUNCTION: BETA10 0x1016f070 // 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); assert(m_data);

3
miniwin/include/miniwin/windows.h
View File

@ -1,8 +1,5 @@
#pragma once #pragma once
#if defined(__3DS__)
#include <3ds/types.h>
#endif
#include <SDL3/SDL_video.h> #include <SDL3/SDL_video.h>
#include <limits.h> #include <limits.h>
#include <stdint.h> #include <stdint.h>