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

Merge branch 'master' into CreateFrame

Browse Source
This commit is contained in:
Anders Jenbo 2025-05-25 02:30:19 +02:00 committed by GitHub
commit 090405f871
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 156 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
miniwin/miniwin/include/miniwin.h
View File

@ -36,7 +36,6 @@
#define WS_CAPTION 0x00C00000L
#define WS_OVERLAPPED 0x00000000L
#define WS_POPUP 0x80000000L
#define WS_SYSMENU 0x00080000L
#define WS_THICKFRAME 0x00040000L
#define GWL_STYLE (-16)

2
miniwin/miniwin/include/miniwin_d3drm.h
View File

@ -101,6 +101,7 @@ typedef D3DRMPROJECTIONTYPE* LPD3DRMPROJECTIONTYPE;
// --- GUIDs ---
DEFINE_GUID(IID_IDirect3DRM2, 0x4516ecc8, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
DEFINE_GUID(IID_IDirect3DRMWinDevice, 0xc5016cc0, 0xd273, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1);
DEFINE_GUID(IID_IDirect3DRMFrame, 0xeb16cb03, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
DEFINE_GUID(IID_IDirect3DRMMesh, 0xa3a80d01, 0x6e12, 0x11cf, 0xac, 0x4a, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1);
DEFINE_GUID(IID_IDirect3DRMMeshBuilder, 0xa3a80d02, 0x6e12, 0x11cf, 0xac, 0x4a, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1);
DEFINE_GUID(IID_IDirect3DRMTexture2, 0x120f30c0, 0x1629, 0x11d0, 0x94, 0x1c, 0x00, 0x80, 0xc8, 0x0c, 0xfa, 0x7b);
@ -185,6 +186,7 @@ struct IDirect3DRMMesh : public IDirect3DRMVisual {
DWORD* dataSize,
DWORD* data
) = 0;
virtual DWORD GetGroupCount() = 0;
virtual HRESULT SetGroupColor(DWORD groupIndex, D3DCOLOR color) = 0;
virtual HRESULT SetGroupColorRGB(DWORD groupIndex, float r, float g, float b) = 0;
virtual HRESULT SetGroupTexture(DWORD groupIndex, IDirect3DRMTexture* texture) = 0;

1
miniwin/miniwin/src/include/miniwin_d3drmframe_p.h
View File

@ -6,6 +6,7 @@
struct Direct3DRMFrameImpl : public Direct3DRMObjectBase<IDirect3DRMFrame2> {
Direct3DRMFrameImpl();
~Direct3DRMFrameImpl() override;
HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;
HRESULT AddChild(IDirect3DRMFrame* child) override;
HRESULT DeleteChild(IDirect3DRMFrame* child) override;
HRESULT SetSceneBackgroundRGB(float r, float g, float b) override;

2
miniwin/miniwin/src/include/miniwin_d3drmmesh_p.h
View File

@ -64,6 +64,7 @@ struct MeshGroup {
};
struct Direct3DRMMeshImpl : public Direct3DRMObjectBase<IDirect3DRMMesh> {
HRESULT QueryInterface(const GUID& riid, void** ppvObject) override;
HRESULT Clone(int flags, GUID iid, void** object) override;
HRESULT AddGroup(int vertexCount, int faceCount, int vertexPerFace, DWORD* faceBuffer, D3DRMGROUPINDEX* groupIndex)
override;
@ -75,6 +76,7 @@ struct Direct3DRMMeshImpl : public Direct3DRMObjectBase<IDirect3DRMMesh> {
DWORD* dataSize,
DWORD* data
) override;
DWORD GetGroupCount() override;
HRESULT SetGroupColor(DWORD groupIndex, D3DCOLOR color) override;
HRESULT SetGroupColorRGB(DWORD groupIndex, float r, float g, float b) override;
D3DCOLOR GetGroupColor(D3DRMGROUPINDEX index) override;

5
miniwin/miniwin/src/include/miniwin_d3drmviewport_p.h
View File

@ -38,7 +38,7 @@ struct Direct3DRMViewportImpl : public Direct3DRMObjectBase<IDirect3DRMViewport>
HRESULT InverseTransform(D3DVECTOR* world, D3DRMVECTOR4D* screen) override;
HRESULT Pick(float x, float y, LPDIRECT3DRMPICKEDARRAY* pickedArray) override;
void CloseDevice();
void CollectSceneData(IDirect3DRMFrame* group);
HRESULT CollectSceneData(IDirect3DRMFrame* group);
void PushVertices(const PositionColorVertex* vertices, size_t count);
private:
@ -48,6 +48,9 @@ struct Direct3DRMViewportImpl : public Direct3DRMObjectBase<IDirect3DRMViewport>
D3DCOLOR m_backgroundColor = 0xFF000000;
DWORD m_width;
DWORD m_height;
D3DVALUE m_zMin;
D3DVALUE m_zMax;
D3DVALUE m_fov;
IDirect3DRMFrame* m_camera = nullptr;
SDL_GPUDevice* m_device;
SDL_GPUGraphicsPipeline* m_pipeline;

25
miniwin/miniwin/src/miniwin.cpp
View File

@ -146,7 +146,6 @@ int GetTextExtentPoint32(HDC hdc, LPCSTR str, int len, SIZE* out)
HMENU GetMenu(HWND hWnd)
{
MINIWIN_NOT_IMPLEMENTED();
return NULL;
}
@ -178,13 +177,34 @@ int StretchDIBits(
LONG GetWindowLong(HWND hWnd, int nIndex)
{
if (nIndex == GWL_STYLE) {
Uint32 flags = SDL_GetWindowFlags(hWnd);
LONG style = WS_POPUP;
if ((flags & SDL_WINDOW_BORDERLESS) == 0) {
style = WS_OVERLAPPED | WS_CAPTION;
if (flags & SDL_WINDOW_RESIZABLE) {
style |= WS_THICKFRAME;
}
}
return style;
}
else if (nIndex == GWL_EXSTYLE) {
return 0;
}
MINIWIN_NOT_IMPLEMENTED();
return 0;
}
LONG SetWindowLong(HWND hWnd, int nIndex, LONG dwNewLong)
{
MINIWIN_NOT_IMPLEMENTED();
if (nIndex == GWL_STYLE) {
SDL_SetWindowBordered(hWnd, (dwNewLong & WS_CAPTION) != 0);
SDL_SetWindowResizable(hWnd, (dwNewLong & WS_THICKFRAME) != 0);
return dwNewLong;
}
return 0;
}
@ -196,7 +216,6 @@ int DeleteObject(void*)
BOOL AdjustWindowRectEx(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle)
{
MINIWIN_NOT_IMPLEMENTED();
return TRUE;
}

5
miniwin/miniwin/src/miniwin_d3drm.cpp
View File

@ -205,6 +205,7 @@ struct Direct3DRMImpl : virtual public IDirect3DRM2 {
IDirect3DRMDevice2** outDevice
) override
{
MINIWIN_NOT_IMPLEMENTED(); // Respect the chosen GUID
DDSURFACEDESC DDSDesc;
DDSDesc.dwSize = sizeof(DDSURFACEDESC);
surface->GetSurfaceDesc(&DDSDesc);
@ -212,11 +213,13 @@ struct Direct3DRMImpl : virtual public IDirect3DRM2 {
}
HRESULT CreateTexture(D3DRMIMAGE* image, IDirect3DRMTexture2** outTexture) override
{
MINIWIN_NOT_IMPLEMENTED();
*outTexture = static_cast<IDirect3DRMTexture2*>(new Direct3DRMTextureImpl);
return DD_OK;
}
HRESULT CreateTextureFromSurface(LPDIRECTDRAWSURFACE surface, IDirect3DRMTexture2** outTexture) override
{
MINIWIN_NOT_IMPLEMENTED();
*outTexture = static_cast<IDirect3DRMTexture2*>(new Direct3DRMTextureImpl);
return DD_OK;
}
@ -227,11 +230,13 @@ struct Direct3DRMImpl : virtual public IDirect3DRM2 {
}
HRESULT CreateMaterial(D3DVAL power, IDirect3DRMMaterial** outMaterial) override
{
MINIWIN_NOT_IMPLEMENTED();
*outMaterial = static_cast<IDirect3DRMMaterial*>(new Direct3DRMMaterialImpl);
return DD_OK;
}
HRESULT CreateLightRGB(D3DRMLIGHTTYPE type, D3DVAL r, D3DVAL g, D3DVAL b, IDirect3DRMLight** outLight) override
{
MINIWIN_NOT_IMPLEMENTED();
*outLight = static_cast<IDirect3DRMLight*>(new Direct3DRMLightImpl);
return DD_OK;
}

14
miniwin/miniwin/src/miniwin_d3drmframe.cpp
View File

@ -21,6 +21,20 @@ Direct3DRMFrameImpl::~Direct3DRMFrameImpl()
}
}
HRESULT Direct3DRMFrameImpl::QueryInterface(const GUID& riid, void** ppvObject)
{
if (SDL_memcmp(&riid, &IID_IDirect3DRMFrame, sizeof(GUID)) == 0) {
this->IUnknown::AddRef();
*ppvObject = static_cast<IDirect3DRMFrame*>(this);
return S_OK;
}
if (SDL_memcmp(&riid, &IID_IDirect3DRMMesh, sizeof(GUID)) == 0) {
return E_NOINTERFACE;
}
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Direct3DRMFrameImpl does not implement guid");
return E_NOINTERFACE;
}
HRESULT Direct3DRMFrameImpl::AddChild(IDirect3DRMFrame* child)
{
return m_children->AddElement(child);

19
miniwin/miniwin/src/miniwin_d3drmmesh.cpp
View File

@ -3,6 +3,20 @@
#include <limits>
HRESULT Direct3DRMMeshImpl::QueryInterface(const GUID& riid, void** ppvObject)
{
if (SDL_memcmp(&riid, &IID_IDirect3DRMMesh, sizeof(GUID)) == 0) {
this->IUnknown::AddRef();
*ppvObject = static_cast<IDirect3DRMMesh*>(this);
return S_OK;
}
if (SDL_memcmp(&riid, &IID_IDirect3DRMFrame, sizeof(GUID)) == 0) {
return E_NOINTERFACE;
}
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Direct3DRMMeshImpl does not implement guid");
return E_NOINTERFACE;
}
HRESULT Direct3DRMMeshImpl::Clone(int flags, GUID iid, void** object)
{
if (!object || SDL_memcmp(&iid, &IID_IDirect3DRMMesh, sizeof(GUID)) != 0) {
@ -86,6 +100,11 @@ HRESULT Direct3DRMMeshImpl::GetGroup(
return DD_OK;
}
DWORD Direct3DRMMeshImpl::GetGroupCount()
{
return m_groups.size();
}
HRESULT Direct3DRMMeshImpl::SetGroupColor(DWORD groupIndex, D3DCOLOR color)
{
if (groupIndex >= m_groups.size()) {

108
miniwin/miniwin/src/miniwin_d3drmviewport.cpp
View File

@ -4,6 +4,7 @@
#include "miniwin_p.h"
#include <SDL3/SDL.h>
#include <functional>
Direct3DRMViewportImpl::Direct3DRMViewportImpl(
DWORD width,
@ -29,14 +30,73 @@ Direct3DRMViewportImpl::~Direct3DRMViewportImpl()
FreeDeviceResources();
}
void Direct3DRMViewportImpl::CollectSceneData(IDirect3DRMFrame* group)
HRESULT Direct3DRMViewportImpl::CollectSceneData(IDirect3DRMFrame* group)
{
m_backgroundColor = static_cast<Direct3DRMFrameImpl*>(group)->m_backgroundColor;
MINIWIN_NOT_IMPLEMENTED(); // Lights, textures, materials
std::vector<PositionColorVertex> vertices =
{{-1, -1, 0, 0, 255, 0, 255}, {1, -1, 0, 0, 0, 255, 255}, {0, 1, 0, 255, 0, 0, 128}};
std::vector<PositionColorVertex> verts;
std::function<void(IDirect3DRMFrame*)> recurseFrame;
PushVertices(vertices.data(), vertices.size());
recurseFrame = [&](IDirect3DRMFrame* frame) {
IDirect3DRMVisualArray* va = nullptr;
if (SUCCEEDED(frame->GetVisuals(&va)) && va) {
DWORD n = va->GetSize();
for (DWORD i = 0; i < n; ++i) {
IDirect3DRMVisual* vis = nullptr;
va->GetElement(i, &vis);
if (!vis) {
continue;
}
// Pull geometry from meshes
IDirect3DRMMesh* mesh = nullptr;
if (SUCCEEDED(vis->QueryInterface(IID_IDirect3DRMMesh, (void**) &mesh)) && mesh) {
DWORD groupCount = mesh->GetGroupCount();
for (DWORD gi = 0; gi < groupCount; ++gi) {
DWORD vtxCount, faceCount, vpf, dataSize;
mesh->GetGroup(gi, &vtxCount, &faceCount, &vpf, &dataSize, nullptr);
std::vector<D3DRMVERTEX> d3dVerts(vtxCount);
std::vector<DWORD> faces(faceCount * vpf);
mesh->GetVertices(gi, 0, vtxCount, d3dVerts.data());
mesh->GetGroup(gi, &vtxCount, &faceCount, &vpf, nullptr, faces.data());
D3DCOLOR color = mesh->GetGroupColor(gi);
for (DWORD fi = 0; fi < faceCount; ++fi) {
for (int idx = 0; idx < vpf; ++idx) {
auto& dv = d3dVerts[faces[fi * vpf + idx]];
PositionColorVertex vtx;
vtx.x = dv.position.x;
vtx.y = dv.position.y;
vtx.z = dv.position.z;
vtx.a = (color >> 24) & 0xFF;
vtx.r = (color >> 16) & 0xFF;
vtx.g = (color >> 8) & 0xFF;
vtx.b = (color >> 0) & 0xFF;
verts.push_back(vtx);
}
}
}
mesh->Release();
}
// Recurse over sub-frames
IDirect3DRMFrame* childFrame = nullptr;
if (SUCCEEDED(vis->QueryInterface(IID_IDirect3DRMFrame, (void**) &childFrame)) && childFrame) {
recurseFrame(childFrame);
childFrame->Release();
}
vis->Release();
}
va->Release();
}
};
recurseFrame(group);
PushVertices(verts.data(), verts.size());
return D3DRM_OK;
}
void Direct3DRMViewportImpl::PushVertices(const PositionColorVertex* vertices, size_t count)
@ -53,8 +113,10 @@ void Direct3DRMViewportImpl::PushVertices(const PositionColorVertex* vertices, s
}
m_vertexCount = count;
if (!count) {
return;
}
MINIWIN_NOT_IMPLEMENTED();
SDL_GPUTransferBufferCreateInfo transferCreateInfo = {};
transferCreateInfo.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
transferCreateInfo.size = static_cast<Uint32>(sizeof(PositionColorVertex) * m_vertexCount);
@ -92,7 +154,10 @@ HRESULT Direct3DRMViewportImpl::Render(IDirect3DRMFrame* group)
return DDERR_GENERIC;
}
CollectSceneData(group);
HRESULT success = CollectSceneData(group);
if (success != DD_OK) {
return success;
}
SDL_GPUCommandBuffer* cmdbuf = SDL_AcquireGPUCommandBuffer(m_device);
if (cmdbuf == NULL) {
@ -107,11 +172,15 @@ HRESULT Direct3DRMViewportImpl::Render(IDirect3DRMFrame* group)
colorTargetInfo.load_op = SDL_GPU_LOADOP_CLEAR;
SDL_GPURenderPass* renderPass = SDL_BeginGPURenderPass(cmdbuf, &colorTargetInfo, 1, NULL);
SDL_BindGPUGraphicsPipeline(renderPass, m_pipeline);
SDL_GPUBufferBinding vertexBufferBinding = {};
vertexBufferBinding.buffer = m_vertexBuffer;
vertexBufferBinding.offset = 0;
SDL_BindGPUVertexBuffers(renderPass, 0, &vertexBufferBinding, 1);
SDL_DrawGPUPrimitives(renderPass, m_vertexCount, 1, 0, 0);
if (m_vertexCount) {
SDL_GPUBufferBinding vertexBufferBinding = {};
vertexBufferBinding.buffer = m_vertexBuffer;
vertexBufferBinding.offset = 0;
SDL_BindGPUVertexBuffers(renderPass, 0, &vertexBufferBinding, 1);
SDL_DrawGPUPrimitives(renderPass, m_vertexCount, 1, 0, 0);
}
SDL_EndGPURenderPass(renderPass);
// Download rendered image
@ -235,38 +304,35 @@ D3DRMPROJECTIONTYPE Direct3DRMViewportImpl::GetProjection()
HRESULT Direct3DRMViewportImpl::SetFront(D3DVALUE z)
{
MINIWIN_NOT_IMPLEMENTED();
m_zMin = z;
return DD_OK;
}
D3DVALUE Direct3DRMViewportImpl::GetFront()
{
MINIWIN_NOT_IMPLEMENTED();
return 0;
return m_zMin;
}
HRESULT Direct3DRMViewportImpl::SetBack(D3DVALUE z)
{
MINIWIN_NOT_IMPLEMENTED();
m_zMax = z;
return DD_OK;
}
D3DVALUE Direct3DRMViewportImpl::GetBack()
{
MINIWIN_NOT_IMPLEMENTED();
return 0;
return m_zMax;
}
HRESULT Direct3DRMViewportImpl::SetField(D3DVALUE field)
{
MINIWIN_NOT_IMPLEMENTED();
m_fov = field;
return DD_OK;
}
D3DVALUE Direct3DRMViewportImpl::GetField()
{
MINIWIN_NOT_IMPLEMENTED();
return 0;
return m_fov;
}
DWORD Direct3DRMViewportImpl::GetWidth()