diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml index 16ad85ae..2eab4970 100644 --- a/.github/workflows/format.yml +++ b/.github/workflows/format.yml @@ -19,6 +19,7 @@ jobs: LEGO1/*.cpp LEGO1/*.h \ LEGO1/realtime/*.cpp LEGO1/realtime/*.h \ LEGO1/tgl/*.h \ + LEGO1/tgl/d3drm/*.cpp LEGO1/tgl/d3drm/*.h \ LEGO1/viewmanager/*.cpp LEGO1/viewmanager/*.h python-format: diff --git a/CMakeLists.txt b/CMakeLists.txt index f6ff00b0..e1fa4db2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -210,6 +210,15 @@ add_library(lego1 SHARED LEGO1/score.cpp LEGO1/scorestate.cpp LEGO1/skateboard.cpp + LEGO1/tgl/d3drm/camera.cpp + LEGO1/tgl/d3drm/device.cpp + LEGO1/tgl/d3drm/group.cpp + LEGO1/tgl/d3drm/light.cpp + LEGO1/tgl/d3drm/mesh.cpp + LEGO1/tgl/d3drm/renderer.cpp + LEGO1/tgl/d3drm/texture.cpp + LEGO1/tgl/d3drm/unk.cpp + LEGO1/tgl/d3drm/view.cpp LEGO1/towtrack.cpp LEGO1/towtrackmissionstate.cpp LEGO1/viewmanager/viewmanager.cpp @@ -241,7 +250,7 @@ if (ISLE_USE_DX5) endif() # Link libraries -target_link_libraries(lego1 PRIVATE ddraw dsound dxguid dinput winmm) +target_link_libraries(lego1 PRIVATE ddraw dsound dxguid dinput winmm d3drm) # Make sure filenames are ALL CAPS set_property(TARGET lego1 PROPERTY OUTPUT_NAME LEGO1) diff --git a/LEGO1/tgl/d3drm/camera.cpp b/LEGO1/tgl/d3drm/camera.cpp new file mode 100644 index 00000000..08aea939 --- /dev/null +++ b/LEGO1/tgl/d3drm/camera.cpp @@ -0,0 +1,33 @@ +#include "impl.h" + +using namespace TglImpl; + +DECOMP_SIZE_ASSERT(Camera, 0x4); +DECOMP_SIZE_ASSERT(CameraImpl, 0x8); + +// SYNTHETIC: LEGO1 0x100a2560 +// TglImpl::CameraImpl::`scalar deleting destructor' + +// FUNCTION: LEGO1 0x100a36f0 +void* CameraImpl::ImplementationDataPtr() +{ + return reinterpret_cast(&m_data); +} + +// FUNCTION: LEGO1 0x100a3700 +Result CameraImpl::SetTransformation(const FloatMatrix4& matrix) +{ + D3DRMMATRIX4D helper; + D3DRMMATRIX4D* pTransformation = Translate(matrix, helper); + + D3DVECTOR position; + Result result; + Result result2; + + result2 = ResultVal(m_data->GetPosition(0, &position)); + result = ResultVal(m_data->AddTransform(D3DRMCOMBINE_REPLACE, *pTransformation)); + // The did this second call just to assert on the return value + result2 = ResultVal(m_data->GetPosition(0, &position)); + + return result; +} diff --git a/LEGO1/tgl/d3drm/device.cpp b/LEGO1/tgl/d3drm/device.cpp new file mode 100644 index 00000000..44307268 --- /dev/null +++ b/LEGO1/tgl/d3drm/device.cpp @@ -0,0 +1,85 @@ +#include "impl.h" + +#include + +using namespace TglImpl; + +// SYNTHETIC: LEGO1 0x100a22c0 +// TglImpl::DeviceImpl::`scalar deleting destructor' + +// FUNCTION: LEGO1 0x100a2bf0 +void* DeviceImpl::ImplementationDataPtr() +{ + return reinterpret_cast(&m_data); +} + +// FUNCTION: LEGO1 0x100a2c00 +unsigned long DeviceImpl::GetWidth() +{ + return m_data->GetWidth(); +} + +// FUNCTION: LEGO1 0x100a2c10 +unsigned long DeviceImpl::GetHeight() +{ + return m_data->GetHeight(); +} + +// FUNCTION: LEGO1 0x100a2c20 +Result DeviceImpl::SetColorModel(ColorModel) +{ + return Success; +} + +// FUNCTION: LEGO1 0x100a2c30 +Result DeviceImpl::SetShadingModel(ShadingModel model) +{ + // Doesn't match well even though we know this is exactly + // the original code thanks to the jump table. + D3DRMRENDERQUALITY renderQuality = Translate(model); + return ResultVal(m_data->SetQuality(renderQuality)); +} + +// FUNCTION: LEGO1 0x100a2ca0 +Result DeviceImpl::SetShadeCount(unsigned long shadeCount) +{ + return ResultVal(m_data->SetShades(shadeCount)); +} + +// FUNCTION: LEGO1 0x100a2cc0 +Result DeviceImpl::SetDither(int dither) +{ + return ResultVal(m_data->SetDither(dither)); +} + +// Probably wrong, not sure what's going on in this method. +// FUNCTION: LEGO1 0x100a2ce0 +void DeviceImpl::InitFromD3DDevice(Device*) +{ + // Device argument is intentionally unused. + IDirect3DRMWinDevice* winDevice; + if (ResultVal(m_data->QueryInterface(IID_IDirect3DRMWinDevice, (LPVOID*) &winDevice))) { + m_data->InitFromD3D((LPDIRECT3D) &winDevice, (LPDIRECT3DDEVICE) m_data); + winDevice->Release(); + } +} + +// Really don't know what's going on here. Seems it will call down to Init +// but the decomp suggests it otherwise looks the same as InitFromD3D but Init +// takes widly different parameters. +// FUNCTION: LEGO1 0x100a2d20 +void DeviceImpl::InitFromWindowsDevice(Device*) +{ + // Device argument is intentionally unused. + IDirect3DRMWinDevice* winDevice; + if (SUCCEEDED(m_data->QueryInterface(IID_IDirect3DRMWinDevice, (LPVOID*) &winDevice))) { + // m_data->Init(??); + winDevice->Release(); + } +} + +// FUNCTION: LEGO1 0x100a2d60 +Result DeviceImpl::Update() +{ + return ResultVal(m_data->Update()); +} diff --git a/LEGO1/tgl/d3drm/group.cpp b/LEGO1/tgl/d3drm/group.cpp new file mode 100644 index 00000000..4e6bed96 --- /dev/null +++ b/LEGO1/tgl/d3drm/group.cpp @@ -0,0 +1,122 @@ +#include "impl.h" + +using namespace TglImpl; + +// SYNTHETIC: LEGO1 0x100a2480 +// TglImpl::GroupImpl::`scalar deleting destructor' + +// FUNCTION: LEGO1 0x100a31d0 +void* GroupImpl::ImplementationDataPtr() +{ + return reinterpret_cast(&m_data); +} + +// FUNCTION: LEGO1 0x100a31e0 +Result GroupImpl::SetTransformation(const FloatMatrix4& matrix) +{ + D3DRMMATRIX4D helper; + D3DRMMATRIX4D* d3dMatrix = Translate(matrix, helper); + return ResultVal(m_data->AddTransform(D3DRMCOMBINE_REPLACE, *d3dMatrix)); +} + +// FUNCTION: LEGO1 0x100a3240 +Result GroupImpl::SetColor(float r, float g, float b, float a) +{ + // The first instruction makes no sense here: + // cmp dword ptr [esp + 0x10], 0 + // This compares a, which we know is a float because it immediately + // gets passed into D3DRMCreateColorRGBA, but does the comparison + // as though it's an int?? + if (*reinterpret_cast(&a) > 0) { + D3DCOLOR color = D3DRMCreateColorRGBA(r, g, b, a); + return ResultVal(m_data->SetColor(color)); + } + else { + return ResultVal(m_data->SetColorRGB(r, a, b)); + } +} + +// FUNCTION: LEGO1 0x100a32b0 +Result GroupImpl::SetTexture(const Texture* pTexture) +{ + IDirect3DRMTexture* pD3DTexture = pTexture ? static_cast(pTexture)->ImplementationData() : NULL; + return ResultVal(m_data->SetTexture(pD3DTexture)); +} + +// FUNCTION: LEGO1 0x100a32e0 +Result GroupImpl::GetTexture(Texture*& pTexture) +{ + IDirect3DRMTexture* pD3DTexture; + TextureImpl* holder = new TextureImpl(); + Result result = ResultVal(m_data->GetTexture(&pD3DTexture)); + if (result) { + // Seems to actually call the first virtual method of holder here + // but that doesn't make any sense since it passes three arguments + // to the method (self + string constant? + an offset?). + + // This line makes the start of the function match and is what I + // would expect to see there but it clearly isn't what's actually + // there. + holder->SetImplementation(pD3DTexture); + } + pTexture = holder; + return Success; +} + +// FUNCTION: LEGO1 0x100a33c0 +Result GroupImpl::SetMaterialMode(MaterialMode mode) +{ + D3DRMMATERIALMODE d3dMode; + switch (mode) { + case FromParent: + d3dMode = D3DRMMATERIAL_FROMPARENT; + break; + case FromFrame: + d3dMode = D3DRMMATERIAL_FROMFRAME; + break; + case FromMesh: + d3dMode = D3DRMMATERIAL_FROMMESH; + break; + } + return ResultVal(m_data->SetMaterialMode(d3dMode)); +} + +// FUNCTION: LEGO1 0x100a3410 +Result GroupImpl::Add(const Mesh* pMesh) +{ + const MeshImpl* pMeshImpl = static_cast(pMesh); + return ResultVal(m_data->AddVisual(pMeshImpl->ImplementationData()->groupMesh)); +} + +// FUNCTION: LEGO1 0x100a3430 +Result GroupImpl::Add(const Group* pGroup) +{ + const GroupImpl* pGroupImpl = static_cast(pGroup); + return ResultVal(m_data->AddVisual(pGroupImpl->m_data)); +} + +// FUNCTION: LEGO1 0x100a3450 +Result GroupImpl::Remove(const Group* pGroup) +{ + const GroupImpl* pGroupImpl = static_cast(pGroup); + return ResultVal(m_data->DeleteVisual(pGroupImpl->m_data)); +} + +// FUNCTION: LEGO1 0x100a3480 +Result GroupImpl::Remove(const Mesh* pMesh) +{ + const MeshImpl* pMeshImpl = static_cast(pMesh); + return ResultVal(m_data->DeleteVisual(pMeshImpl->ImplementationData()->groupMesh)); +} + +// FUNCTION: LEGO1 0x100a34b0 STUB +Result GroupImpl::RemoveAll() +{ + return Error; +} + +// FUNCTION: LEGO1 0x100a34c0 STUB +Result GroupImpl::Unknown() +{ + return Error; +} diff --git a/LEGO1/tgl/d3drm/impl.h b/LEGO1/tgl/d3drm/impl.h new file mode 100644 index 00000000..bbc7baa0 --- /dev/null +++ b/LEGO1/tgl/d3drm/impl.h @@ -0,0 +1,467 @@ + +#include "../../decomp.h" +#include "../tgl.h" + +#include + +// Forward declare D3D types +struct IDirect3DRM; +struct IDirect3DRMDevice; +struct IDirect3DRMViewport; +struct IDirect3DRMFrame; +struct IDirect3DRMMesh; +struct IDirect3DRMMeshBuilder; +struct IDirect3DRMTexture; + +namespace TglImpl +{ + +using namespace Tgl; + +// Utility function used by implementations +inline Result ResultVal(HRESULT result) +{ + return SUCCEEDED(result) ? Success : Error; +} + +// Forward declare implementations +class RendererImpl; +class DeviceImpl; +class ViewImpl; +class LightImpl; +class CameraImpl; +class GroupImpl; +class MeshImpl; +class TextureImpl; +class UnkImpl; + +// VTABLE 0x100db910 +class RendererImpl : public Renderer { +public: + RendererImpl() : m_data(0) {} + ~RendererImpl() { Destroy(); }; + + virtual void* ImplementationDataPtr(); + + // vtable+0x08 + virtual Device* CreateDevice(const DeviceDirect3DCreateData&); + virtual Device* CreateDevice(const DeviceDirectDrawCreateData&); + + // vtable+0x10 + virtual View* CreateView( + const Device*, + const Camera*, + unsigned long x, + unsigned long y, + unsigned long width, + unsigned long height + ); + virtual Camera* CreateCamera(); + virtual Light* CreateLight(LightType, float r, float g, float b); + virtual Group* CreateGroup(const Group* pParent); + + // vtable+0x20 + virtual Unk* CreateUnk(); + virtual Texture* CreateTexture(); + virtual Texture* CreateTexture( + int width, + int height, + int bitsPerTexel, + const void* pTexels, + int pTexelsArePersistent, + int paletteEntryCount, + const PaletteEntry* pEntries + ); + virtual Result SetTextureDefaultShadeCount(unsigned long); + + // vtable+0x30 + virtual Result SetTextureDefaultColorCount(unsigned long); + +public: + inline Result Create(); + inline void Destroy(); + +private: + IDirect3DRM* m_data; +}; + +// VTABLE 0x100db988 +class DeviceImpl : public Device { +public: + DeviceImpl() : m_data(0) {} + ~DeviceImpl() + { + if (m_data) { + m_data->Release(); + m_data = NULL; + } + } + + virtual void* ImplementationDataPtr(); + + // vtable+0x08 + virtual unsigned long GetWidth(); + virtual unsigned long GetHeight(); + + // vtable+0x10 + virtual Result SetColorModel(ColorModel); + virtual Result SetShadingModel(ShadingModel); + virtual Result SetShadeCount(unsigned long); + virtual Result SetDither(int); + + // vtable+0x20 + virtual Result Update(); + virtual void InitFromD3DDevice(Device*); + virtual void InitFromWindowsDevice(Device*); + + inline IDirect3DRMDevice* ImplementationData() const { return m_data; } + + friend class RendererImpl; + +private: + IDirect3DRMDevice* m_data; +}; + +// VTABLE 0x100db9e8 +class ViewImpl : public View { +public: + ViewImpl() : m_data(0) {} + ~ViewImpl() + { + if (m_data) { + m_data->Release(); + m_data = NULL; + } + } + + virtual void* ImplementationDataPtr(); + + // vtable+0x08 + virtual Result Add(const Light*); + virtual Result Remove(const Light*); + + // vtable+0x10 + virtual Result SetCamera(const Camera*); + virtual Result SetProjection(ProjectionType); + virtual Result SetFrustrum(float frontClippingDistance, float backClippingDistance, float degrees); + virtual Result SetBackgroundColor(float r, float g, float b); + + // vtable+0x20 + virtual Result GetBackgroundColor(float* r, float* g, float* b); + virtual Result Clear(); + virtual Result Render(const Light*); + virtual Result ForceUpdate(unsigned long x, unsigned long y, unsigned long width, unsigned long height); + + // vtable+0x30 + virtual Result TransformWorldToScreen(const float world[3], float screen[4]); + virtual Result TransformScreenToWorld(const float screen[4], float world[3]); + virtual Result Pick( + unsigned long x, + unsigned long y, + const Group** ppGroupsToPickFrom, + int groupsToPickFromCount, + const Group**& rppPickedGroups, + int& rPickedGroupCount + ); + + inline IDirect3DRMViewport* ImplementationData() const { return m_data; } + + static Result ViewportCreateAppData(IDirect3DRM*, IDirect3DRMViewport*, IDirect3DRMFrame*); + + friend class RendererImpl; + +private: + IDirect3DRMViewport* m_data; +}; + +// VTABLE 0x100dbad8 +class CameraImpl : public Camera { +public: + CameraImpl() : m_data(0) {} + ~CameraImpl() + { + if (m_data) { + m_data->Release(); + m_data = NULL; + } + } + + virtual void* ImplementationDataPtr(); + + // vtable+0x08 + virtual Result SetTransformation(const FloatMatrix4&); + + inline IDirect3DRMFrame* ImplementationData() const { return m_data; } + + friend class RendererImpl; + +private: + IDirect3DRMFrame* m_data; +}; + +// VTABLE 0x100dbaf8 +class LightImpl : public Light { +public: + LightImpl() : m_data(0) {} + ~LightImpl() + { + if (m_data) { + m_data->Release(); + m_data = NULL; + } + } + + virtual void* ImplementationDataPtr(); + + // vtable+0x08 + virtual Result SetTransformation(const FloatMatrix4&); + virtual Result SetColor(float r, float g, float b); + + inline IDirect3DRMFrame* ImplementationData() const { return m_data; } + + friend class RendererImpl; + +private: + IDirect3DRMFrame* m_data; +}; + +// VTABLE 0x100dbb88 +class MeshImpl : public Mesh { +public: + MeshImpl() : m_data(0) {} + ~MeshImpl() + { + if (m_data) { + delete m_data; + m_data = NULL; + } + } + + virtual void* ImplementationDataPtr(); + + // vtable+0x08 + virtual Result SetColor(float r, float g, float b, float a); + virtual Result SetTexture(const Texture*); + + // vtable+0x10 + virtual Result GetTexture(Texture*&); + virtual Result SetTextureMappingMode(ProjectionType); + virtual Result SetShadingModel(ShadingModel); + virtual Mesh* DeepClone(Unk*); + + // vtable+0x20 + virtual Mesh* ShallowClone(Unk*); + + struct MeshData { + IDirect3DRMMesh* groupMesh; + int groupIndex; + }; + + inline MeshData* ImplementationData() const { return m_data; } + + friend class RendererImpl; + +private: + MeshData* m_data; +}; + +// VTABLE 0x100dba68 +class GroupImpl : public Group { +public: + GroupImpl() : m_data(0) {} + ~GroupImpl() + { + if (m_data) { + m_data->Release(); + m_data = NULL; + } + } + + virtual void* ImplementationDataPtr(); + + // vtable+0x08 + virtual Result SetTransformation(const FloatMatrix4&); + virtual Result SetColor(float r, float g, float b, float a); + + // vtable+0x10 + virtual Result SetTexture(const Texture*); + virtual Result GetTexture(Texture*&); + virtual Result SetMaterialMode(MaterialMode); + virtual Result Add(const Group*); + + // vtable+0x20 + virtual Result Add(const Mesh*); + virtual Result Remove(const Group*); + virtual Result Remove(const Mesh*); + virtual Result RemoveAll(); + + // vtable+0x30 + virtual Result Unknown(); + + friend class RendererImpl; + +private: + IDirect3DRMFrame* m_data; +}; + +// VTABLE 0x100dbb18 +class UnkImpl : public Unk { +public: + UnkImpl() : m_data(0) {} + ~UnkImpl() + { + if (m_data) { + m_data->Release(); + m_data = NULL; + } + } + + virtual void* ImplementationDataPtr(); + + // vtable+0x08 + virtual Result SetMeshData( + unsigned long faceCount, + unsigned long vertexCount, + const float (*pPositions)[3], + const float (*pNormals)[3], + const float (*pTextureCoordinates)[2], + unsigned long vertexPerFaceCount, + unsigned long* pFaceData + ); + virtual Result GetBoundingBox(float min[3], float max[3]); + + // vtable+0x10 + virtual Unk* Clone(); + + inline IDirect3DRMMesh* ImplementationData() const { return m_data; } + + friend class RendererImpl; + +private: + IDirect3DRMMesh* m_data; +}; + +// No vtable, this is just a simple wrapper around D3DRMIMAGE +class TglD3DRMIMAGE { +public: + TglD3DRMIMAGE( + int width, + int height, + int depth, + void* pBuffer, + int useBuffer, + int paletteSize, + PaletteEntry* pEntries + ); + ~TglD3DRMIMAGE() { Destroy(); } + + Result CreateBuffer(int width, int height, int depth, void* pBuffer, int useBuffer); + void Destroy(); + void FillRowsOfTexture(int y, int height, char* content); + Result InitializePalette(int paletteSize, PaletteEntry* pEntries); + + D3DRMIMAGE m_image; + int m_texelsAllocatedByClient; +}; + +// VTABLE 0x100dbb48 +class TextureImpl : public Texture { +public: + TextureImpl() : m_data(0) {} + ~TextureImpl() + { + if (m_data) { + m_data->Release(); + m_data = NULL; + } + } + + virtual void* ImplementationDataPtr(); + + // vtable+0x08 + virtual Result SetTexels(int width, int height, int bitsPerTexel, void* pTexels); + virtual void FillRowsOfTexture(int y, int height, void* pBuffer); + + // vtable+0x10 + virtual Result Changed(int texelsChanged, int paletteChanged); + virtual Result GetBufferAndPalette( + int* pWidth, + int* pHeight, + int* pDepth, + void** ppBuffer, + int* ppPaletteSize, + PaletteEntry** ppPalette + ); + virtual Result SetPalette(int entryCount, PaletteEntry* entries); + + inline IDirect3DRMTexture* ImplementationData() const { return m_data; } + inline void SetImplementation(IDirect3DRMTexture* pData) { m_data = pData; } + + friend class RendererImpl; + + static Result SetImage(IDirect3DRMTexture* pSelf, TglD3DRMIMAGE* pImage); + +private: + IDirect3DRMTexture* m_data; +}; + +// Translation helpers +inline D3DRMRENDERQUALITY Translate(ShadingModel tglShadingModel) +{ + D3DRMRENDERQUALITY renderQuality; + + switch (tglShadingModel) { + case Wireframe: + renderQuality = D3DRMRENDER_WIREFRAME; + break; + case UnlitFlat: + renderQuality = D3DRMRENDER_UNLITFLAT; + break; + case Flat: + renderQuality = D3DRMRENDER_FLAT; + break; + case Gouraud: + renderQuality = D3DRMRENDER_GOURAUD; + break; + case Phong: + renderQuality = D3DRMRENDER_PHONG; + break; + default: + renderQuality = D3DRMRENDER_FLAT; + break; + } + + return renderQuality; +} + +inline D3DRMPROJECTIONTYPE Translate(ProjectionType tglProjectionType) +{ + D3DRMPROJECTIONTYPE projectionType; + switch (tglProjectionType) { + case Perspective: + projectionType = D3DRMPROJECT_PERSPECTIVE; + break; + case Orthographic: + projectionType = D3DRMPROJECT_ORTHOGRAPHIC; + break; + default: + projectionType = D3DRMPROJECT_PERSPECTIVE; + break; + } + return projectionType; +} + +// Yes this function serves no purpose, originally they intended it to +// convert from doubles to floats but ended up using floats throughout +// the software stack. +inline D3DRMMATRIX4D* Translate(const FloatMatrix4& tglMatrix4x4, D3DRMMATRIX4D& rD3DRMMatrix4x4) +{ + for (int i = 0; i < (sizeof(rD3DRMMatrix4x4) / sizeof(rD3DRMMatrix4x4[0])); i++) { + for (int j = 0; j < (sizeof(rD3DRMMatrix4x4[0]) / sizeof(rD3DRMMatrix4x4[0][0])); j++) { + rD3DRMMatrix4x4[i][j] = D3DVAL(tglMatrix4x4[i][j]); + } + } + return &rD3DRMMatrix4x4; +} + +} /* namespace TglImpl */ diff --git a/LEGO1/tgl/d3drm/light.cpp b/LEGO1/tgl/d3drm/light.cpp new file mode 100644 index 00000000..2f62c4e6 --- /dev/null +++ b/LEGO1/tgl/d3drm/light.cpp @@ -0,0 +1,33 @@ +#include "impl.h" + +using namespace TglImpl; + +DECOMP_SIZE_ASSERT(Light, 0x4); +DECOMP_SIZE_ASSERT(LightImpl, 0x8); + +// SYNTHETIC: LEGO1 0x100a2640 +// TglImpl::LightImpl::`scalar deleting destructor' + +// FUNCTION: LEGO1 0x100a3770 +void* LightImpl::ImplementationDataPtr() +{ + return reinterpret_cast(&m_data); +} + +// FUNCTION: LEGO1 0x100a3780 +Result LightImpl::SetTransformation(const FloatMatrix4& matrix) +{ + D3DRMMATRIX4D helper; + D3DRMMATRIX4D* d3dMatrix = Translate(matrix, helper); + return ResultVal(m_data->AddTransform(D3DRMCOMBINE_REPLACE, *d3dMatrix)); +} + +// FUNCTION: LEGO1 0x100a37e0 +Result LightImpl::SetColor(float r, float g, float b) +{ + IDirect3DRMLightArray* lightArray; + IDirect3DRMLight* light; + m_data->GetLights(&lightArray); + lightArray->GetElement(0, &light); + return ResultVal(light->SetColorRGB(r, g, b)); +} diff --git a/LEGO1/tgl/d3drm/mesh.cpp b/LEGO1/tgl/d3drm/mesh.cpp new file mode 100644 index 00000000..d29ff2b3 --- /dev/null +++ b/LEGO1/tgl/d3drm/mesh.cpp @@ -0,0 +1,158 @@ +#include "impl.h" + +using namespace TglImpl; + +DECOMP_SIZE_ASSERT(D3DRMVERTEX, 0x24); + +DECOMP_SIZE_ASSERT(Mesh, 0x4); +DECOMP_SIZE_ASSERT(MeshImpl, 0x8); + +// SYNTHETIC: LEGO1 0x100a3d80 +// TglImpl::MeshImpl::`scalar deleting destructor' + +// FUNCTION: LEGO1 0x100a3ed0 +void* MeshImpl::ImplementationDataPtr() +{ + return reinterpret_cast(&m_data); +} + +// FUNCTION: LEGO1 0x100a3ee0 +Result MeshImpl::SetColor(float r, float g, float b, float a) +{ + // The first instruction makes no sense here: + // cmp dword ptr [esp + 0x10], 0 + // This compares a, which we know is a float because it immediately + // gets passed into D3DRMCreateColorRGBA, but does the comparison + // as though it's an int?? + if (*reinterpret_cast(&a) > 0) { + D3DCOLOR color = D3DRMCreateColorRGBA(r, g, b, a); + return ResultVal(m_data->groupMesh->SetGroupColor(m_data->groupIndex, color)); + } + else { + return ResultVal(m_data->groupMesh->SetGroupColorRGB(m_data->groupIndex, r, g, b)); + } +} + +// FUNCTION: LEGO1 0x100a3f50 +Result MeshImpl::SetTexture(const Texture* pTexture) +{ + IDirect3DRMTexture* texture = pTexture ? static_cast(pTexture)->ImplementationData() : NULL; + return ResultVal(m_data->groupMesh->SetGroupTexture(m_data->groupIndex, texture)); +} + +// FUNCTION: LEGO1 0x100a3f80 +Result MeshImpl::SetTextureMappingMode(ProjectionType projType) +{ + if (projType == Perspective) { + return ResultVal(m_data->groupMesh->SetGroupMapping(m_data->groupIndex, D3DRMMAP_PERSPCORRECT)); + } + else { + return ResultVal(m_data->groupMesh->SetGroupMapping(m_data->groupIndex, 0)); + } +} + +// FUNCTION: LEGO1 0x100a3fc0 +Result MeshImpl::SetShadingModel(ShadingModel model) +{ + D3DRMRENDERQUALITY mode; + switch (model) { + case Wireframe: + mode = D3DRMRENDER_WIREFRAME; + break; + case UnlitFlat: + mode = D3DRMRENDER_UNLITFLAT; + break; + case Flat: + mode = D3DRMRENDER_FLAT; + break; + case Gouraud: + mode = D3DRMRENDER_GOURAUD; + break; + case Phong: + mode = D3DRMRENDER_PHONG; + break; + } + return ResultVal(m_data->groupMesh->SetGroupQuality(m_data->groupIndex, mode)); +} + +// FUNCTION: LEGO1 0x100a4030 +Mesh* MeshImpl::DeepClone(Unk* pUnk) +{ + // Create group + MeshImpl* newMesh = new MeshImpl(); + MeshData* data = new MeshData(); + newMesh->m_data = data; + + // Query information from old group + DWORD dataSize; + unsigned int vcount, fcount, vperface; + m_data->groupMesh->GetGroup(m_data->groupIndex, &vcount, &fcount, &vperface, &dataSize, NULL); + unsigned int* faceBuffer = new unsigned int[dataSize]; + m_data->groupMesh->GetGroup(m_data->groupIndex, &vcount, &fcount, &vperface, &dataSize, faceBuffer); + // We expect vertex to be sized 0x24, checked at start of file. + D3DRMVERTEX* vertexBuffer = new D3DRMVERTEX[vcount]; + m_data->groupMesh->GetVertices(m_data->groupIndex, 0, vcount, vertexBuffer); + LPDIRECT3DRMTEXTURE textureRef; + m_data->groupMesh->GetGroupTexture(m_data->groupIndex, &textureRef); + D3DRMMAPPING mapping = m_data->groupMesh->GetGroupMapping(m_data->groupIndex); + D3DRMRENDERQUALITY quality = m_data->groupMesh->GetGroupQuality(m_data->groupIndex); + D3DCOLOR color = m_data->groupMesh->GetGroupColor(m_data->groupIndex); + + // Push information to new group + UnkImpl* target = static_cast(pUnk); + D3DRMGROUPINDEX index; + target->ImplementationData()->AddGroup(vcount, fcount, vperface, faceBuffer, &index); + newMesh->m_data->groupIndex = index; + target->ImplementationData()->SetVertices(index, 0, vcount, vertexBuffer); + target->ImplementationData()->SetGroupTexture(index, textureRef); + target->ImplementationData()->SetGroupMapping(index, mapping); + target->ImplementationData()->SetGroupQuality(index, quality); + Result result = ResultVal(target->ImplementationData()->SetGroupColor(index, color)); + + // Cleanup + delete[] faceBuffer; + delete[] vertexBuffer; + if (result == Error) { + delete newMesh; + newMesh = NULL; + } + + return newMesh; +} + +// FUNCTION: LEGO1 0x100a4240 +Mesh* MeshImpl::ShallowClone(Unk* pUnk) +{ + MeshImpl* newGroup = new MeshImpl(); + MeshData* newData = new MeshData(); + newGroup->m_data = newData; + if (newData) { + newData->groupIndex = m_data->groupIndex; + newData->groupMesh = static_cast(pUnk)->ImplementationData(); + } + else { + delete newGroup; + newGroup = NULL; + } + return newGroup; +} + +// FUNCTION: LEGO1 0x100a4330 +Result MeshImpl::GetTexture(Texture*& rpTexture) +{ + IDirect3DRMTexture* texture; + TextureImpl* holder = new TextureImpl(); + Result result = ResultVal(m_data->groupMesh->GetGroupTexture(m_data->groupIndex, &texture)); + if (result) { + // Seems to actually call the first virtual method of holder here + // but that doesn't make any sense since it passes three arguments + // to the method (self + string constant? + an offset?). + + // This line makes the start of the function match and is what I + // would expect to see there but it clearly isn't what's actually + // there. + holder->SetImplementation(texture); + } + rpTexture = holder; + return Success; +} diff --git a/LEGO1/tgl/d3drm/renderer.cpp b/LEGO1/tgl/d3drm/renderer.cpp new file mode 100644 index 00000000..92d80d83 --- /dev/null +++ b/LEGO1/tgl/d3drm/renderer.cpp @@ -0,0 +1,332 @@ +#include "impl.h" + +using namespace TglImpl; + +// FUNCTION: LEGO1 0x100a15e0 +Renderer* Tgl::CreateRenderer() +{ + RendererImpl* renderer = new RendererImpl(); + if (!renderer->Create()) { + delete renderer; + renderer = NULL; + } + return renderer; +} + +// SYNTHETIC: LEGO1 0x100a16d0 +// TglImpl::RendererImpl::`scalar deleting destructor' + +// GLOBAL: LEGO1 0x1010103c +IDirect3DRM* g_pD3DRM = NULL; + +// Inlined only +Result RendererImpl::Create() +{ + if (g_pD3DRM) { + g_pD3DRM->AddRef(); + } + else { + LPDIRECT3DRM handle; + Direct3DRMCreate(&handle); + handle->QueryInterface(IID_IDirect3DRM2, (LPVOID*) &g_pD3DRM); + } + m_data = g_pD3DRM; + return (m_data != NULL) ? Success : Error; +} + +inline void RendererDestroy(IDirect3DRM* pRenderer) +{ + int refCount = pRenderer->Release(); + if (refCount <= 0) { + g_pD3DRM = NULL; + } +} + +// Inlined only +void RendererImpl::Destroy() +{ + if (m_data) { + RendererDestroy(m_data); + m_data = NULL; + } +} + +// FUNCTION: LEGO1 0x100a1894 +Device* RendererImpl::CreateDevice(const DeviceDirect3DCreateData& data) +{ + DeviceImpl* device = new DeviceImpl(); + HRESULT result = m_data->CreateDeviceFromD3D(data.m_pDirect3D, data.m_pDirect3DDevice, &device->m_data); + if (!SUCCEEDED(result)) { + delete device; + device = NULL; + } + return device; +} + +// GLOBAL: LEGO1 0x10101040 +static int gSetBufferCount = 1; + +// FUNCTION: LEGO1 0x100a1900 +Device* RendererImpl::CreateDevice(const DeviceDirectDrawCreateData& data) +{ + DeviceImpl* device = new DeviceImpl(); + HRESULT result = m_data->CreateDeviceFromSurface( + const_cast(data.m_driverGUID), + data.m_pDirectDraw, + data.m_pBackBuffer, + &device->m_data + ); + if (SUCCEEDED(result) && data.m_pBackBuffer && gSetBufferCount) { + device->m_data->SetBufferCount(2); + } + if (!SUCCEEDED(result)) { + delete device; + device = NULL; + } + return device; +} + +inline Result RendererCreateView( + IDirect3DRM* pRenderer, + IDirect3DRMDevice* pDevice, + IDirect3DRMFrame* pCamera, + IDirect3DRMViewport*& rpView, + unsigned long x, + unsigned long y, + unsigned long width, + unsigned long height +) +{ + Result result = ResultVal(pRenderer->CreateViewport(pDevice, pCamera, x, y, width, height, &rpView)); + if (Succeeded(result)) { + result = ViewImpl::ViewportCreateAppData(pRenderer, rpView, pCamera); + if (!Succeeded(result)) { + rpView->Release(); + rpView = NULL; + } + } + return result; +} + +// FUNCTION: LEGO1 0x100a1a00 +View* RendererImpl::CreateView( + const Device* pDevice, + const Camera* pCamera, + unsigned long x, + unsigned long y, + unsigned long width, + unsigned long height +) +{ + ViewImpl* view = new ViewImpl(); + Result result = RendererCreateView( + m_data, + static_cast(pDevice)->m_data, + static_cast(pCamera)->m_data, + view->m_data, + x, + y, + width, + height + ); + if (!result) { + delete view; + view = NULL; + } + return view; +} + +inline Result RendererCreateGroup(IDirect3DRM* pRenderer, IDirect3DRMFrame* pParent, IDirect3DRMFrame*& rpGroup) +{ + Result result = ResultVal(pRenderer->CreateFrame(NULL, &rpGroup)); + if (Succeeded(result) && pParent) { + result = ResultVal(pParent->AddVisual(rpGroup)); + if (!Succeeded(result)) { + rpGroup->Release(); + rpGroup = NULL; + } + } + return result; +} + +// FUNCTION: LEGO1 0x100a1b20 +Group* RendererImpl::CreateGroup(const Group* pParent) +{ + GroupImpl* group = new GroupImpl(); + Result result = + RendererCreateGroup(m_data, pParent ? static_cast(pParent)->m_data : NULL, group->m_data); + if (!result) { + delete group; + group = NULL; + } + return group; +} + +// FUNCTION: LEGO1 0x100a1c30 +Camera* RendererImpl::CreateCamera() +{ + CameraImpl* camera = new CameraImpl(); + if (FAILED(m_data->CreateFrame(NULL, &camera->m_data))) { + delete camera; + camera = NULL; + } + return camera; +} + +// FUNCTION: LEGO1 0x100a1cf0 +Light* RendererImpl::CreateLight(LightType type, float r, float g, float b) +{ + LightImpl* newLight = new LightImpl(); + D3DRMLIGHTTYPE translatedType; + switch (type) { + case Ambient: + translatedType = D3DRMLIGHT_AMBIENT; + break; + case Point: + translatedType = D3DRMLIGHT_POINT; + break; + case Spot: + translatedType = D3DRMLIGHT_SPOT; + break; + case Directional: + translatedType = D3DRMLIGHT_DIRECTIONAL; + break; + case ParallelPoint: + translatedType = D3DRMLIGHT_PARALLELPOINT; + break; + default: + translatedType = D3DRMLIGHT_AMBIENT; + } + + LPDIRECT3DRMFRAME frame; + Result result = ResultVal(m_data->CreateFrame(NULL, &frame)); + if (Succeeded(result)) { + LPDIRECT3DRMLIGHT d3dLight; + result = ResultVal(m_data->CreateLightRGB(translatedType, r, g, b, &d3dLight)); + if (!Succeeded(result)) { + frame->Release(); + } + else { + result = ResultVal(frame->AddLight(d3dLight)); + if (!Succeeded(result)) { + d3dLight->Release(); + frame->Release(); + } + else { + d3dLight->Release(); + newLight->m_data = frame; + } + } + } + if (!Succeeded(result)) { + delete newLight; + newLight = NULL; + } + return newLight; +} + +// FUNCTION: LEGO1 0x100a1e90 +Unk* RendererImpl::CreateUnk() +{ + // Note: I'm fairly certain that Unknown is not what Tgl calls a + // "Mesh", because the methods on Mesh in the Tgl leak line up much + // more closely with a different vtable than the one assigned in + // this method (meaning this method is not creating a Mesh). + // Maybe this method is something like CreateMeshBuilder where the + // Mesh data type in the Tgl leak was split into builder/result? + UnkImpl* unknown = new UnkImpl(); + if (FAILED(m_data->CreateMesh(&unknown->m_data))) { + delete unknown; + unknown = NULL; + } + return unknown; +} + +inline Result RendererCreateTexture( + IDirect3DRM* renderer, + IDirect3DRMTexture*& texture, + int width, + int height, + int bytesPerPixel, + void* pBuffer, + int useBuffer, + int paletteSize, + PaletteEntry* pEntries +) +{ + TglD3DRMIMAGE* image; + Result result; + + image = new TglD3DRMIMAGE(width, height, bytesPerPixel, pBuffer, useBuffer, paletteSize, pEntries); + result = ResultVal(renderer->CreateTexture(&image->m_image, &texture)); + if (Succeeded(result)) { + result = TextureImpl::SetImage(texture, image); + if (!Succeeded(result)) { + texture->Release(); + texture = NULL; + delete image; + } + } + else { + delete image; + } + return result; +} + +// FUNCTION: LEGO1 0x100a1f50 +Texture* RendererImpl::CreateTexture( + int width, + int height, + int bitsPerTexel, + const void* pTexels, + int texelsArePersistent, + int paletteEntryCount, + const PaletteEntry* pEntries +) +{ + TextureImpl* texture = new TextureImpl(); + if (!Succeeded(RendererCreateTexture( + m_data, + texture->m_data, + width, + height, + bitsPerTexel, + const_cast(pTexels), + texelsArePersistent, + paletteEntryCount, + const_cast(pEntries) + ))) { + delete texture; + texture = NULL; + } + return texture; +} + +// FUNCTION: LEGO1 0x100a20d0 +Texture* RendererImpl::CreateTexture() +{ + TextureImpl* texture = new TextureImpl(); + if (!Succeeded(RendererCreateTexture(m_data, texture->m_data, 0, 0, 0, NULL, FALSE, 0, NULL))) { + delete texture; + texture = NULL; + } + return texture; +} + +// FUNCTION: LEGO1 0x100a2270 +Result RendererImpl::SetTextureDefaultShadeCount(unsigned long shadeCount) +{ + return ResultVal(m_data->SetDefaultTextureShades(shadeCount)); +} + +// FUNCTION: LEGO1 0x100a2290 +Result RendererImpl::SetTextureDefaultColorCount(unsigned long colorCount) +{ + return ResultVal(m_data->SetDefaultTextureColors(colorCount)); +} + +// FUNCTION: LEGO1 0x100a22b0 +void* RendererImpl::ImplementationDataPtr() +{ + return reinterpret_cast(&m_data); +} diff --git a/LEGO1/tgl/d3drm/texture.cpp b/LEGO1/tgl/d3drm/texture.cpp new file mode 100644 index 00000000..5b733eae --- /dev/null +++ b/LEGO1/tgl/d3drm/texture.cpp @@ -0,0 +1,196 @@ +#include "impl.h" + +using namespace TglImpl; + +DECOMP_SIZE_ASSERT(TglD3DRMIMAGE, 0x40); + +inline TglD3DRMIMAGE* TextureGetImage(IDirect3DRMTexture* pTexture) +{ + return reinterpret_cast(pTexture->GetAppData()); +} + +// Forward declare to satisfy order check +void TextureDestroyCallback(IDirect3DRMObject* pObject, void* pArg); + +// FUNCTION: LEGO1 0x100a12a0 +Result TextureImpl::SetImage(IDirect3DRMTexture* pSelf, TglD3DRMIMAGE* pImage) +{ + unsigned long appData; + Result result; + + appData = reinterpret_cast(pImage); + + // This is here because in the original code they asserted + // on the return value being NULL. + TextureGetImage(pSelf); + + result = ResultVal(pSelf->SetAppData(appData)); + if (Succeeded(result) && pImage) { + result = ResultVal(pSelf->AddDestroyCallback(TextureDestroyCallback, NULL)); + if (!Succeeded(result)) { + pSelf->SetAppData(0); + } + } + return result; +} + +// FUNCTION: LEGO1 0x100a1300 +void TextureDestroyCallback(IDirect3DRMObject* pObject, void* pArg) +{ + TglD3DRMIMAGE* pImage = reinterpret_cast(pObject->GetAppData()); + delete pImage; + pObject->SetAppData(0); +} + +// FUNCTION: LEGO1 0x100a1330 +TglD3DRMIMAGE::TglD3DRMIMAGE( + int width, + int height, + int depth, + void* pBuffer, + int useBuffer, + int paletteSize, + PaletteEntry* pEntries +) +{ + m_image.aspectx = 1; + m_image.aspecty = 1; + m_image.width = 0; + m_image.height = 0; + m_image.depth = 0; + m_image.rgb = 0; + m_image.bytes_per_line = 0; + m_image.buffer1 = NULL; + m_image.buffer2 = NULL; + m_image.red_mask = 0xFF; + m_image.green_mask = 0xFF; + m_image.blue_mask = 0xFF; + m_image.alpha_mask = 0xFF; + m_image.palette_size = 0; + m_image.palette = NULL; + m_texelsAllocatedByClient = 0; + if (pBuffer != NULL) { + CreateBuffer(width, height, depth, pBuffer, useBuffer); + } + if (pEntries != NULL) { + InitializePalette(paletteSize, pEntries); + } +} + +// FUNCTION: LEGO1 0x100a13b0 +void TglD3DRMIMAGE::Destroy() +{ + if (m_texelsAllocatedByClient == 0) { + delete m_image.buffer1; + } + delete m_image.palette; +} + +// FUNCTION: LEGO1 0x100a13e0 STUB +Result TglD3DRMIMAGE::CreateBuffer(int width, int height, int depth, void* pBuffer, int useBuffer) +{ + return Error; +} + +// FUNCTION: LEGO1 0x100a1510 +void TglD3DRMIMAGE::FillRowsOfTexture(int y, int height, char* pContent) +{ + // The purpose is clearly this but I can't get the assembly to line up. + memcpy((char*) m_image.buffer1 + (y * m_image.bytes_per_line), pContent, height * m_image.bytes_per_line); +} + +// FUNCTION: LEGO1 0x100a1550 +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. + if (m_image.palette_size != paletteSize) { + if (m_image.palette != NULL) { + delete m_image.palette; + m_image.palette = NULL; + m_image.palette_size = 0; + } + if (paletteSize > 0) { + m_image.palette = new D3DRMPALETTEENTRY[paletteSize]; + m_image.palette_size = paletteSize; + } + } + if (paletteSize > 0) { + for (int i = 0; i < paletteSize; i++) { + m_image.palette[i].red = pEntries[i].m_red; + m_image.palette[i].green = pEntries[i].m_green; + m_image.palette[i].blue = pEntries[i].m_blue; + m_image.palette[i].flags = D3DRMPALETTE_READONLY; + } + } + return Success; +} + +// SYNTHETIC: LEGO1 0x100a2800 +// TglImpl::TextureImpl::`scalar deleting destructor' + +// FUNCTION: LEGO1 0x100a3c10 +Result TextureImpl::SetTexels(int width, int height, int bitsPerTexel, void* pTexels) +{ + TglD3DRMIMAGE* image = TextureGetImage(m_data); + Result result = image->CreateBuffer(width, height, bitsPerTexel, pTexels, TRUE); + if (Succeeded(result)) { + result = ResultVal(m_data->Changed(TRUE, FALSE)); + } + return result; +} + +// FUNCTION: LEGO1 0x100a3c60 +void TextureImpl::FillRowsOfTexture(int y, int height, void* pBuffer) +{ + TglD3DRMIMAGE* image = TextureGetImage(m_data); + image->FillRowsOfTexture(y, height, (char*) pBuffer); +} + +// FUNCTION: LEGO1 0x100a3c90 +Result TextureImpl::Changed(int texelsChanged, int paletteChanged) +{ + return ResultVal(m_data->Changed(texelsChanged, paletteChanged)); +} + +// FUNCTION: LEGO1 0x100a3d00 +Result TextureImpl::GetBufferAndPalette( + int* width, + int* height, + int* depth, + void** pBuffer, + int* paletteSize, + PaletteEntry** pEntries +) +{ + // Something really doesn't match here, not sure what's up. + TglD3DRMIMAGE* image = TextureGetImage(m_data); + *width = image->m_image.width; + *height = image->m_image.height; + *depth = image->m_image.depth; + *pBuffer = image->m_image.buffer1; + *paletteSize = image->m_image.palette_size; + for (int i = 0; i < image->m_image.palette_size; i++) { + pEntries[i]->m_red = image->m_image.palette[i].red; + pEntries[i]->m_green = image->m_image.palette[i].green; + pEntries[i]->m_blue = image->m_image.palette[i].blue; + } + return Success; +} + +// FUNCTION: LEGO1 0x100a3d40 +Result TextureImpl::SetPalette(int entryCount, PaletteEntry* pEntries) +{ + // Not 100% confident this is supposed to directly be forwarding arguments, + // but it probably is given FillRowsOfTexture matches doing that. + TglD3DRMIMAGE* image = TextureGetImage(m_data); + image->InitializePalette(entryCount, pEntries); + m_data->Changed(FALSE, TRUE); + return Success; +} + +// FUNCTION: LEGO1 0x100a3d70 +void* TextureImpl::ImplementationDataPtr() +{ + return reinterpret_cast(&m_data); +} diff --git a/LEGO1/tgl/d3drm/unk.cpp b/LEGO1/tgl/d3drm/unk.cpp new file mode 100644 index 00000000..05785b2e --- /dev/null +++ b/LEGO1/tgl/d3drm/unk.cpp @@ -0,0 +1,57 @@ +#include "impl.h" + +using namespace TglImpl; + +DECOMP_SIZE_ASSERT(Unk, 0x4); +DECOMP_SIZE_ASSERT(UnkImpl, 0x8); + +// SYNTHETIC: LEGO1 0x100a2720 +// TglImpl::UnkImpl::`scalar deleting destructor' + +// FUNCTION: LEGO1 0x100a3830 +void* UnkImpl::ImplementationDataPtr() +{ + return reinterpret_cast(&m_data); +} + +// FUNCTION: LEGO1 0x100a3840 STUB +Result UnkImpl::SetMeshData( + unsigned long faceCount, + unsigned long vertexCount, + const float (*pPositions)[3], + const float (*pNormals)[3], + const float (*pTextureCoordinates)[2], + unsigned long vertexPerFaceCount, + unsigned long* pFaceData +) +{ + return Error; +} + +// FUNCTION: LEGO1 0x100a3ae0 +Result UnkImpl::GetBoundingBox(float min[3], float max[3]) +{ + D3DRMBOX box; + Result result = ResultVal(m_data->GetBox(&box)); + if (result == Success) { + min[0] = box.min.x; + min[1] = box.min.y; + min[2] = box.min.z; + max[0] = box.max.x; + max[1] = box.max.y; + max[2] = box.max.z; + } + return result; +} + +// FUNCTION: LEGO1 0x100a3b40 +Unk* UnkImpl::Clone() +{ + UnkImpl* mesh = new UnkImpl(); + int ret = m_data->Clone(0, IID_IDirect3DRMMeshBuilder, (void**) &mesh->m_data); + if (ret < 0) { + delete mesh; + mesh = NULL; + } + return mesh; +} diff --git a/LEGO1/tgl/d3drm/view.cpp b/LEGO1/tgl/d3drm/view.cpp new file mode 100644 index 00000000..116c2b98 --- /dev/null +++ b/LEGO1/tgl/d3drm/view.cpp @@ -0,0 +1,349 @@ +#include "impl.h" + +using namespace TglImpl; + +struct ViewportAppData { + ViewportAppData(IDirect3DRM* pRenderer); + ~ViewportAppData(); + + IDirect3DRMFrame* m_pLightFrame; + IDirect3DRMFrame* m_pCamera; + IDirect3DRMFrame* m_pLastRenderedFrame; + float m_backgroundColorRed; + float m_backgroundColorGreen; + float m_backgroundColorBlue; +}; + +DECOMP_SIZE_ASSERT(ViewportAppData, 0x18); + +// FUNCTION: LEGO1 0x100a10b0 +ViewportAppData::ViewportAppData(IDirect3DRM* pRenderer) +{ + pRenderer->CreateFrame(NULL, &m_pLightFrame); + m_pCamera = NULL; + m_pLastRenderedFrame = NULL; + m_backgroundColorRed = 0.0f; + m_backgroundColorGreen = 0.0f; + m_backgroundColorBlue = 0.0f; +} + +// FUNCTION: LEGO1 0x100a10e0 +ViewportAppData::~ViewportAppData() +{ + IDirect3DRMFrameArray* pChildFrames; + IDirect3DRMFrame* pChildFrame = NULL; + m_pLightFrame->GetChildren(&pChildFrames); + for (int i = 0; i < (int) pChildFrames->GetSize(); i++) { + pChildFrames->GetElement(i, &pChildFrame); + m_pLightFrame->DeleteChild(pChildFrame); + pChildFrame->Release(); // GetElement() does AddRef() + } + pChildFrames->Release(); + m_pLightFrame->Release(); +} + +// Forward declare to satisfy order check +void ViewportDestroyCallback(IDirect3DRMObject* pObject, void* pArg); + +// FUNCTION: LEGO1 0x100a1160 +Result ViewImpl::ViewportCreateAppData(IDirect3DRM* pDevice, IDirect3DRMViewport* pView, IDirect3DRMFrame* pCamera) +{ + ViewportAppData* data = new ViewportAppData(pDevice); + data->m_pCamera = pCamera; + Result result = ResultVal(pView->SetAppData(reinterpret_cast(data))); + if (Succeeded(result)) { + result = ResultVal(pView->AddDestroyCallback(ViewportDestroyCallback, data)); + } + if (!Succeeded(result)) { + delete data; + pView->SetAppData(0); + } + return result; +} + +inline Result ViewRestoreFrameAfterRender( + IDirect3DRMFrame* pFrame, + IDirect3DRMFrame* pCamera, + IDirect3DRMFrame* pLightFrame +) +{ + 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... + result = ResultVal(pFrame->DeleteChild(pCamera)); + result = ResultVal(pFrame->DeleteChild(pLightFrame)); + + // decrease frame's ref count (it was increased in ViewPrepareFrameForRender()) + pFrame->Release(); + } + return result; +} + +// FUNCTION: LEGO1 0x100a1240 +void ViewportDestroyCallback(IDirect3DRMObject* pObject, void* pArg) +{ + ViewportAppData* pViewportAppData = reinterpret_cast(pArg); + + ViewRestoreFrameAfterRender( + pViewportAppData->m_pLastRenderedFrame, + pViewportAppData->m_pCamera, + pViewportAppData->m_pLightFrame + ); + + delete pViewportAppData; +} + +// FUNCTION: LEGO1 0x100a1290 +Result ViewportPickImpl( + IDirect3DRMViewport* pViewport, + int x, + int y, + const Group** ppGroupsToPickFrom, + int groupsToPickFromCount, + const Group**& rppPickedGroups, + int& rPickedGroupCount +) +{ + // Left unimplemented in shipped game. + return Error; +} + +inline ViewportAppData* ViewportGetData(IDirect3DRMViewport* pViewport) +{ + return reinterpret_cast(pViewport->GetAppData()); +} + +inline IDirect3DRMFrame* ViewportGetLightFrame(IDirect3DRMViewport* pViewport) +{ + return ViewportGetData(pViewport)->m_pLightFrame; +} + +// SYNTHETIC: LEGO1 0x100a23a0 +// TglImpl::ViewImpl::`scalar deleting destructor' + +// FUNCTION: LEGO1 0x100a2d80 +void* ViewImpl::ImplementationDataPtr() +{ + return reinterpret_cast(&m_data); +} + +// FUNCTION: LEGO1 0x100a2d90 +Result ViewImpl::Add(const Light* pLight) +{ + const LightImpl* light = static_cast(pLight); + IDirect3DRMFrame* frame = light->ImplementationData(); + return ResultVal(ViewportGetLightFrame(m_data)->AddChild(frame)); +} + +// FUNCTION: LEGO1 0x100a2dc0 +Result ViewImpl::Remove(const Light* pLight) +{ + const LightImpl* light = static_cast(pLight); + IDirect3DRMFrame* frame = light->ImplementationData(); + return ResultVal(ViewportGetLightFrame(m_data)->DeleteChild(frame)); +} + +// FUNCTION: LEGO1 0x100a2df0 +Result ViewImpl::SetCamera(const Camera* pCamera) +{ + const CameraImpl* camera = static_cast(pCamera); + IDirect3DRMFrame* frame = camera->ImplementationData(); + + ViewportAppData* pViewportAppData; + Result result; + + pViewportAppData = reinterpret_cast(m_data->GetAppData()); + result = ViewRestoreFrameAfterRender( + pViewportAppData->m_pLastRenderedFrame, + pViewportAppData->m_pCamera, + pViewportAppData->m_pLightFrame + ); + pViewportAppData->m_pCamera = frame; + pViewportAppData->m_pLastRenderedFrame = 0; + + return ResultVal(m_data->SetCamera(frame)); +} + +// FUNCTION: LEGO1 0x100a2e70 +Result ViewImpl::SetProjection(ProjectionType type) +{ + return ResultVal(m_data->SetProjection(Translate(type))); +} + +// FUNCTION: LEGO1 0x100a2eb0 +Result ViewImpl::SetFrustrum(float frontClippingDistance, float backClippingDistance, float degrees) +{ + float field = frontClippingDistance * tan(DegreesToRadians(degrees / 2)); + Result result; + result = ResultVal(m_data->SetFront(frontClippingDistance)); + if (Succeeded(result)) { + result = ResultVal(m_data->SetBack(backClippingDistance)); + } + if (Succeeded(result)) { + result = ResultVal(m_data->SetField(field)); + } + + return result; +} + +// FUNCTION: LEGO1 0x100a2f30 +Result ViewImpl::SetBackgroundColor(float r, float g, float b) +{ + Result ret = Success; + // Note, this method in the shipped game is very diverged from + // the Tgl leak code. + ViewportAppData* data = ViewportGetData(m_data); + data->m_backgroundColorRed = r; + data->m_backgroundColorGreen = g; + data->m_backgroundColorBlue = b; + if (data->m_pLastRenderedFrame) { + ret = ResultVal(data->m_pLastRenderedFrame->SetSceneBackgroundRGB(r, g, b)); + } + return ret; +} + +// FUNCTION: LEGO1 0x100a2f80 +Result ViewImpl::GetBackgroundColor(float* r, float* g, float* b) +{ + ViewportAppData* data = ViewportGetData(m_data); + *r = data->m_backgroundColorRed; + *g = data->m_backgroundColorGreen; + *b = data->m_backgroundColorBlue; + return Success; +} + +// FUNCTION: LEGO1 0x100a2fb0 +Result ViewImpl::Clear() +{ + return ResultVal(m_data->Clear()); +} + +inline Result ViewPrepareFrameForRender( + IDirect3DRMFrame* pFrame, + IDirect3DRMFrame* pCamera, + IDirect3DRMFrame* pLightFrame, + float backgroundRed, + float backgroundGreen, + float backgroundBlue +) +{ + Result result = Success; + + if (pFrame) { + // set background color + result = ResultVal(pFrame->SetSceneBackgroundRGB(backgroundRed, backgroundGreen, backgroundBlue)); + + // add camera to frame to be rendered + result = ResultVal(pFrame->AddChild(pCamera)); + + // add light frame to frame to be rendered + result = ResultVal(pFrame->AddChild(pLightFrame)); + + // increase ref count of frame to ensure it does not get deleted underneath us + pFrame->AddRef(); + } + + return result; +} + +// FUNCTION: LEGO1 0x100a2fd0 +Result ViewImpl::Render(const Light* pCamera) +{ + ViewportAppData* appdata = ViewportGetData(m_data); + + IDirect3DRMFrame* light = static_cast(pCamera)->ImplementationData(); + + IDirect3DRMFrame* lastRendered = appdata->m_pLastRenderedFrame; + if (light != lastRendered) { + if (lastRendered) { + lastRendered->DeleteChild(appdata->m_pCamera); + // Some other call goes here, not sure what. + lastRendered->Release(); + } + appdata->m_pLastRenderedFrame = light; + if (light) { + light->SetSceneBackgroundRGB( + appdata->m_backgroundColorRed, + appdata->m_backgroundColorGreen, + appdata->m_backgroundColorBlue + ); + light->AddChild(appdata->m_pCamera); + // Some other call goes here, not sure what. + light->AddRef(); + } + } + return ResultVal(m_data->Render(light)); +} + +// FUNCTION: LEGO1 0x100a3080 +Result ViewImpl::ForceUpdate(unsigned long x, unsigned long y, unsigned long width, unsigned long height) +{ + return ResultVal(m_data->ForceUpdate(x, y, x + width - 1, y + height - 1)); +} + +// FUNCTION: LEGO1 0x100a30c0 +Result ViewImpl::Pick( + unsigned long x, + unsigned long y, + const Group** ppGroupsToPickFrom, + int groupsToPickFromCount, + const Group**& rppPickedGroups, + int& rPickedGroupCount +) +{ + return ViewportPickImpl( + m_data, + x, + y, + ppGroupsToPickFrom, + groupsToPickFromCount, + rppPickedGroups, + rPickedGroupCount + ); +} + +// FUNCTION: LEGO1 0x100a30f0 +Result ViewImpl::TransformWorldToScreen(const float world[3], float screen[4]) +{ + D3DRMVECTOR4D d3dRMScreen; + D3DVECTOR d3dRMWorld; + d3dRMWorld.x = world[0]; + d3dRMWorld.y = world[1]; + d3dRMWorld.z = world[2]; + Result result; + + result = ResultVal(m_data->Transform(&d3dRMScreen, &d3dRMWorld)); + + if (Succeeded(result)) { + screen[0] = d3dRMScreen.x; + screen[1] = d3dRMScreen.y; + screen[2] = d3dRMScreen.z; + screen[3] = d3dRMScreen.w; + } + + return result; +} + +// FUNCTION: LEGO1 0x100a3160 +Result ViewImpl::TransformScreenToWorld(const float screen[4], float world[3]) +{ + // 100% match minus instruction reordering. + D3DVECTOR d3dRMWorld; + D3DRMVECTOR4D d3dScreen; + d3dScreen.x = screen[0]; + d3dScreen.y = screen[1]; + d3dScreen.z = screen[2]; + d3dScreen.w = screen[3]; + Result result; + + result = ResultVal(m_data->InverseTransform(&d3dRMWorld, &d3dScreen)); + + if (Succeeded(result)) { + world[0] = d3dRMWorld.x; + world[1] = d3dRMWorld.y; + world[2] = d3dRMWorld.z; + } + + return result; +} diff --git a/LEGO1/tgl/tgl.h b/LEGO1/tgl/tgl.h index 5dec4a56..9bf4ce3a 100644 --- a/LEGO1/tgl/tgl.h +++ b/LEGO1/tgl/tgl.h @@ -1,27 +1,22 @@ -#ifndef TGL_H -#define TGL_H -#ifdef _WIN32 +#ifndef _tgl_h +#define _tgl_h + +#include "tglvector.h" -#define NOMINMAX // to avoid conflict with STL #include #include -#include // HWND - -#endif /* _WIN32 */ - -#include "tglVector.h" +#include namespace Tgl { -// ??? enum ColorModel { + // Note: Not used in shipped game, no way to verify contents. Ramp, RGB }; -// ??? enum ShadingModel { Wireframe, UnlitFlat, @@ -30,7 +25,6 @@ enum ShadingModel { Phong }; -// ????? enum LightType { Ambient, Point, @@ -39,7 +33,6 @@ enum LightType { ParallelPoint }; -// ??? enum ProjectionType { Perspective, Orthographic @@ -50,39 +43,39 @@ enum TextureMappingMode { PerspectiveCorrect }; +// Not in the Tgl leak, inferred from the assembly +enum MaterialMode { + FromParent, + FromFrame, + FromMesh, +}; + struct PaletteEntry { unsigned char m_red; unsigned char m_green; unsigned char m_blue; }; -#ifdef _WIN32 - -struct DeviceDirectDrawCreateData { - const GUID* m_driverGUID; - HWND m_hWnd; // ??? derive from m_pDirectDraw - IDirectDraw* m_pDirectDraw; - IDirectDrawSurface* m_pFrontBuffer; // ??? derive from m_pDirectDraw - IDirectDrawSurface* m_pBackBuffer; - IDirectDrawPalette* m_pPalette; // ??? derive from m_pDirectDraw - int m_isFullScreen; // ??? derive from m_pDirectDraw -}; - struct DeviceDirect3DCreateData { IDirect3D* m_pDirect3D; IDirect3DDevice* m_pDirect3DDevice; }; -#else +struct DeviceDirectDrawCreateData { + const GUID* m_driverGUID; + HWND m_hWnd; + IDirectDraw* m_pDirectDraw; + IDirectDrawSurface* m_pFrontBuffer; + IDirectDrawSurface* m_pBackBuffer; -struct DeviceDirectDrawCreateData {}; - -#endif - -////////////////////////////////////////////////////////////////////////////// -// -// Result (return value type) + // These have possibly been removed in the shipped game + // (Put them back if we can verify when we find a callsite + // which constructs this type) + // IDirectDrawPalette* m_pPalette; + // int m_isFullScreen; +}; +// Result type used for all methods in the Tgl API enum Result { Error = 0, Success = 1 @@ -93,10 +86,7 @@ inline int Succeeded(Result result) return (result == Success); } -////////////////////////////////////////////////////////////////////////////// -// // Forward declarations - class Renderer; class Object; class Device; @@ -106,30 +96,24 @@ class Camera; class Group; class Mesh; class Texture; +class Unk; -////////////////////////////////////////////////////////////////////////////// -// -// Object - +// VTABLE 0x100db980 class Object { public: virtual ~Object() {} - // returns pointer to implementation data virtual void* ImplementationDataPtr() = 0; }; -////////////////////////////////////////////////////////////////////////////// -// -// Renderer - -// ??? for now until we figured out how an app should pass the Renderer around -Renderer* CreateRenderer(); - +// VTABLE 0x100db948 class Renderer : public Object { public: - virtual Device* CreateDevice(const DeviceDirectDrawCreateData&) = 0; + // vtable+0x08 virtual Device* CreateDevice(const DeviceDirect3DCreateData&) = 0; + virtual Device* CreateDevice(const DeviceDirectDrawCreateData&) = 0; + + // vtable+0x10 virtual View* CreateView( const Device*, const Camera*, @@ -139,34 +123,12 @@ public: unsigned long height ) = 0; virtual Camera* CreateCamera() = 0; - virtual Light* CreateLight(LightType, double r, double g, double b) = 0; + virtual Light* CreateLight(LightType, float r, float g, float b) = 0; virtual Group* CreateGroup(const Group* pParent = 0) = 0; - // pTextureCoordinates is pointer to array of vertexCount elements - // (each element being two floats), or NULL - // pFaceData is faceCount tuples, each of format - // [vertex1index, ... vertexNindex], where N = vertexPerFaceCount - virtual Mesh* CreateMesh( - unsigned long vertexCount, - const float (*pVertices)[3], - const float (*pTextureCoordinates)[2], - unsigned long faceCount, - unsigned long vertexPerFaceCount, - unsigned long* pFaceData - ) = 0; - // pTextureCoordinates is pointer to array of vertexCount elements - // (each element being two floats), or NULL - // pFaceData is: - // [face1VertexCount face1Vertex1index, ... face1VertexMindex - // face2VertexCount face2Vertex1index, ... face2VertexNindex - // ... - // 0] - virtual Mesh* CreateMesh( - unsigned long vertexCount, - const float (*pVertices)[3], - const float (*pTextureCoordinates)[2], - unsigned long* pFaceData - ) = 0; + // vtable+0x20 + virtual Unk* CreateUnk() = 0; + virtual Texture* CreateTexture() = 0; virtual Texture* CreateTexture( int width, int height, @@ -176,61 +138,54 @@ public: int paletteEntryCount, const PaletteEntry* pEntries ) = 0; - virtual Texture* CreateTexture() = 0; - virtual Result SetTextureDefaultShadeCount(unsigned long) = 0; + + // vtable+0x30 virtual Result SetTextureDefaultColorCount(unsigned long) = 0; }; -////////////////////////////////////////////////////////////////////////////// -// -// Device +Renderer* CreateRenderer(); +// VTABLE 0x100db9b8 class Device : public Object { public: + // vtable+0x08 virtual unsigned long GetWidth() = 0; virtual unsigned long GetHeight() = 0; + + // vtable+0x10 virtual Result SetColorModel(ColorModel) = 0; virtual Result SetShadingModel(ShadingModel) = 0; virtual Result SetShadeCount(unsigned long) = 0; virtual Result SetDither(int) = 0; + + // vtable+0x20 virtual Result Update() = 0; - - // ??? should this be handled by app ??? - // ??? this needs to be called when the window on which the device is ... - // is being activated - virtual void HandleActivate(int bActivate) = 0; - - // ??? this needs to be called when the window on which this device is based - // needs to be repainted - virtual void HandlePaint(void*) = 0; - -#ifdef _DEBUG - virtual unsigned long GetDrawnTriangleCount() = 0; -#endif + virtual void InitFromD3DDevice(Device*) = 0; + virtual void InitFromWindowsDevice(Device*) = 0; }; -////////////////////////////////////////////////////////////////////////////// -// -// View - +// VTABLE 0x100dba28 class View : public Object { public: virtual Result Add(const Light*) = 0; virtual Result Remove(const Light*) = 0; + // vtable+0x10 virtual Result SetCamera(const Camera*) = 0; virtual Result SetProjection(ProjectionType) = 0; - virtual Result SetFrustrum(double frontClippingDistance, double backClippingDistance, double degrees) = 0; - virtual Result SetBackgroundColor(double r, double g, double b) = 0; + virtual Result SetFrustrum(float frontClippingDistance, float backClippingDistance, float degrees) = 0; + virtual Result SetBackgroundColor(float r, float g, float b) = 0; + // vtable+0x20 + virtual Result GetBackgroundColor(float* r, float* g, float* b) = 0; virtual Result Clear() = 0; - virtual Result Render(const Group*) = 0; - // ??? needed for fine grain control when using DirectDraw/D3D ??? + virtual Result Render(const Light*) = 0; virtual Result ForceUpdate(unsigned long x, unsigned long y, unsigned long width, unsigned long height) = 0; - // ??? for now: used by Mesh Cost calculation - virtual Result TransformWorldToScreen(const double world[3], double screen[4]) = 0; + // vtable+0x30 + virtual Result TransformWorldToScreen(const float world[3], float screen[4]) = 0; + virtual Result TransformScreenToWorld(const float screen[4], float world[3]) = 0; // Pick(): // x, y: @@ -264,102 +219,94 @@ public: ) = 0; }; -////////////////////////////////////////////////////////////////////////////// -// -// Camera - +// VTABLE 0x100dbae8 class Camera : public Object { public: -#if 0 - virtual Result SetPosition(const double[3]) = 0; - virtual Result SetOrientation(const double direction[3], - const double up[3]) = 0; -#endif virtual Result SetTransformation(const FloatMatrix4&) = 0; }; -////////////////////////////////////////////////////////////////////////////// -// -// Light - +// VTABLE 0x100dbb08 class Light : public Object { public: -#if 0 - virtual Result SetPosition(const double[3]) = 0; - virtual Result SetOrientation(const double direction[3], - const double up[3]) = 0; -#endif virtual Result SetTransformation(const FloatMatrix4&) = 0; + virtual Result SetColor(float r, float g, float b) = 0; }; -////////////////////////////////////////////////////////////////////////////// -// -// Group - -class Group : public Object { -public: -#if 0 - virtual Result SetPosition(const double[3]) = 0; - virtual Result SetOrientation(const double direction[3], - const double up[3]) = 0; -#endif - // TODO: The type was changed from `FloatMatrix` to `Matrix` to make code in UpdateWorldData match. - // However, this is unlikely to be correct and will have to be figured out at some point. - virtual Result SetTransformation(const Matrix4&) = 0; - - // ??? not yet fully implemented - virtual Result SetColor(double r, double g, double b) = 0; - virtual Result SetTexture(const Texture*) = 0; - - virtual Result Add(const Group*) = 0; - virtual Result Add(const Mesh*) = 0; - - virtual Result Remove(const Group*) = 0; - virtual Result Remove(const Mesh*) = 0; - - virtual Result RemoveAll() = 0; - - // ??? for now: used by Mesh Cost calculation - virtual Result TransformLocalToWorld(const double local[3], double world[3]) = 0; -}; - -////////////////////////////////////////////////////////////////////////////// -// -// Mesh - +// VTABLE 0x100dbbb0 class Mesh : public Object { public: - // ??? also on Group - virtual Result SetColor(double r, double g, double b) = 0; + virtual Result SetColor(float r, float g, float b, float a) = 0; virtual Result SetTexture(const Texture*) = 0; - virtual Result SetTextureMappingMode(TextureMappingMode) = 0; + virtual Result GetTexture(Texture*&) = 0; + + virtual Result SetTextureMappingMode(ProjectionType) = 0; virtual Result SetShadingModel(ShadingModel) = 0; -#ifdef _DEBUG - virtual Result GetBoundingBox(float min[3], float max[3]) = 0; - virtual unsigned long GetFaceCount() = 0; - virtual unsigned long GetVertexCount() = 0; -#endif + // Clone data in underlying group + virtual Mesh* DeepClone(Unk*) = 0; + + // Just get another Group pointing to the same underlying data + virtual Mesh* ShallowClone(Unk*) = 0; }; -////////////////////////////////////////////////////////////////////////////// -// -// Texture +// VTABLE 0x100dbaa0 +class Group : public Object { +public: + virtual Result SetTransformation(const FloatMatrix4&) = 0; + virtual Result SetColor(float r, float g, float b, float a) = 0; + virtual Result SetTexture(const Texture*) = 0; + virtual Result GetTexture(Texture*&) = 0; + virtual Result SetMaterialMode(MaterialMode) = 0; + virtual Result Add(const Group*) = 0; + virtual Result Add(const Mesh*) = 0; + virtual Result Remove(const Group*) = 0; + virtual Result Remove(const Mesh*) = 0; + virtual Result RemoveAll() = 0; + // This is TransformLocalToWorld in the leak, however it seems + // to have been replaced by something else in the shipped code. + virtual Result Unknown() = 0; +}; + +// Don't know what this is. Seems like another Tgl object which +// was not in the leaked Tgl code. My suspicion is that it's +// some kind of builder class for creating meshes. +// VTABLE 0x100dbb30 +class Unk : public Object { +public: + virtual Result SetMeshData( + unsigned long faceCount, + unsigned long vertexCount, + const float (*pPositions)[3], + const float (*pNormals)[3], + const float (*pTextureCoordinates)[2], + unsigned long vertexPerFaceCount, + unsigned long* pFaceData + ) = 0; + virtual Result GetBoundingBox(float min[3], float max[3]) = 0; + virtual Unk* Clone() = 0; +}; + +// VTABLE 0x100dbb68 class Texture : public Object { public: - virtual Result SetTexels( - int width, - int height, - int bitsPerTexel, - const void* pTexels, - int pTexelsArePersistent - ) = 0; - virtual Result SetPalette(int entryCount, const PaletteEntry* pEntries) = 0; -}; + // vtable+0x08 + virtual Result SetTexels(int width, int height, int bitsPerTexel, void* pTexels) = 0; + virtual void FillRowsOfTexture(int y, int height, void* pBuffer) = 0; -////////////////////////////////////////////////////////////////////////////// + // vtable+0x10 + virtual Result Changed(int texelsChanged, int paletteChanged) = 0; + virtual Result GetBufferAndPalette( + int* pWidth, + int* pHeight, + int* pDepth, + void** ppBuffer, + int* pPaletteSize, + PaletteEntry** ppPalette + ) = 0; + virtual Result SetPalette(int entryCount, PaletteEntry* pEntries) = 0; +}; } // namespace Tgl -#endif // TGL_H +#endif /* _tgl_h */ diff --git a/LEGO1/tgl/tglvector.h b/LEGO1/tgl/tglvector.h index a617928d..78255937 100644 --- a/LEGO1/tgl/tglvector.h +++ b/LEGO1/tgl/tglvector.h @@ -1,7 +1,10 @@ -#ifndef TGLVECTOR_H -#define TGLVECTOR_H +#ifndef _tglVector_h +#define _tglVector_h +// Note: This file is almost an exact copy of the one from +// the leak but using floats instead of doubles, hence the +// strange formatting in some places. -#include "math.h" // ??? sin() in RotateAroundY() +#include "math.h" // sin() in RotateAroundY() #include // offsetof() @@ -142,7 +145,6 @@ class RotationY : public FloatMatrix4 { public: RotationY(float radians); }; - ////////////////////////////////////////////////////////////////////////////// // // Transformation matrices implementation @@ -274,4 +276,4 @@ inline RotationY::RotationY(float radians) } // namespace Tgl -#endif // TLGVECTOR_H +#endif /* _tglVector_h */ diff --git a/LEGO1/viewmanager/viewroi.cpp b/LEGO1/viewmanager/viewroi.cpp index 00af794b..47cb71e8 100644 --- a/LEGO1/viewmanager/viewroi.cpp +++ b/LEGO1/viewmanager/viewroi.cpp @@ -27,8 +27,7 @@ void ViewROI::UpdateWorldData(const Matrix4Data& parent2world) { OrientableROI::UpdateWorldData(parent2world); if (geometry) { - // Tgl::FloatMatrix4 tgl_mat; - Matrix4 mat; + Tgl::FloatMatrix4 mat; SETMAT4(mat, m_local2world.GetMatrix()); Tgl::Result result = geometry->SetTransformation(mat); // assert(Tgl::Succeeded(result));