Merge branch 'master' into CreateFrame

miniwin/miniwin/include/miniwin.h

@@ -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)

miniwin/miniwin/include/miniwin_d3drm.h

@@ -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;

miniwin/miniwin/src/include/miniwin_d3drmframe_p.h

@@ -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;

miniwin/miniwin/src/include/miniwin_d3drmmesh_p.h

@@ -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;

miniwin/miniwin/src/include/miniwin_d3drmviewport_p.h

@@ -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;

miniwin/miniwin/src/miniwin.cpp

@@ -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;
 }
 

miniwin/miniwin/src/miniwin_d3drm.cpp

@@ -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;
 	}

miniwin/miniwin/src/miniwin_d3drmframe.cpp

@@ -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);

miniwin/miniwin/src/miniwin_d3drmmesh.cpp

@@ -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()) {

miniwin/miniwin/src/miniwin_d3drmviewport.cpp

@@ -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 =
+	std::vector<PositionColorVertex> verts;
-		{{-1, -1, 0, 0, 255, 0, 255}, {1, -1, 0, 0, 0, 255, 255}, {0, 1, 0, 255, 0, 0, 128}};
+	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;
+	if (m_vertexCount) {
-	vertexBufferBinding.offset = 0;
+		SDL_GPUBufferBinding vertexBufferBinding = {};
-	SDL_BindGPUVertexBuffers(renderPass, 0, &vertexBufferBinding, 1);
+		vertexBufferBinding.buffer = m_vertexBuffer;
-	SDL_DrawGPUPrimitives(renderPass, m_vertexCount, 1, 0, 0);
+		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 m_zMin;
-	return 0;
 }
 
 HRESULT Direct3DRMViewportImpl::SetBack(D3DVALUE z)
 {
-	MINIWIN_NOT_IMPLEMENTED();
+	m_zMax = z;
 	return DD_OK;
 }
 
 D3DVALUE Direct3DRMViewportImpl::GetBack()
 {
-	MINIWIN_NOT_IMPLEMENTED();
+	return m_zMax;
-	return 0;
 }
 
 HRESULT Direct3DRMViewportImpl::SetField(D3DVALUE field)
 {
-	MINIWIN_NOT_IMPLEMENTED();
+	m_fov = field;
 	return DD_OK;
 }
 
 D3DVALUE Direct3DRMViewportImpl::GetField()
 {
-	MINIWIN_NOT_IMPLEMENTED();
+	return m_fov;
-	return 0;
 }
 
 DWORD Direct3DRMViewportImpl::GetWidth()