basic model and texture

Author: malytomas

sources/include/cage-engine/gpuBuffer.h

@@ -0,0 +1,35 @@
+#ifndef guard_gpuBuffer_s54dtu4kfesas
+#define guard_gpuBuffer_s54dtu4kfesas
+
+#include <cage-engine/core.h>
+
+namespace wgpu
+{
+	class Buffer;
+}
+
+namespace cage
+{
+	class GraphicsDevice;
+
+	class CAGE_ENGINE_API GpuBuffer : private Immovable
+	{
+	protected:
+		detail::StringBase<128> label;
+
+	public:
+		void setLabel(const String &name);
+
+		void write(PointerRange<const char> buffer);
+		void write(uint32 offset, PointerRange<const char> buffer);
+
+		uint32 size() const;
+
+		wgpu::Buffer nativeBuffer();
+	};
+
+	CAGE_ENGINE_API Holder<GpuBuffer> newGpuBufferUniform(GraphicsDevice *device);
+	CAGE_ENGINE_API Holder<GpuBuffer> newGpuBufferGeometry(GraphicsDevice *device);
+}
+
+#endif // guard_gpuBuffer_s54dtu4kfesas

sources/include/cage-engine/graphicsDevice.h

@@ -22,7 +22,7 @@ namespace cage
 		Holder<Texture> nextFrame(Window *window);
 
 		wgpu::Device nativeDevice();
-		wgpu::Queue nativeQueue();
+		Holder<wgpu::Queue> nativeQueue(); // locks the queue for thread-safe access
 	};
 
 	struct CAGE_CORE_API GraphicsDeviceCreateConfig

sources/include/cage-engine/model.h

@@ -0,0 +1,54 @@
+#ifndef guard_model_dthu41r5df
+#define guard_model_dthu41r5df
+
+#include <array>
+
+#include <cage-core/geometry.h>
+#include <cage-engine/core.h>
+
+namespace cage
+{
+	class Mesh;
+	class Collider;
+	class GraphicsDevice;
+	class GpuBuffer;
+	enum class MeshRenderFlags : uint32;
+
+	class CAGE_ENGINE_API Model : private Immovable
+	{
+	protected:
+		detail::StringBase<128> label;
+
+	public:
+		void setLabel(const String &name);
+
+		// general
+		Mat4 importTransform;
+		Aabb boundingBox = Aabb::Universe();
+		Holder<const Collider> collider;
+
+		// geometry
+		Holder<GpuBuffer> geometryBuffer;
+		uint32 verticesCount = 0;
+		uint32 bonesCount = 0;
+		uint32 indicesCount = 0;
+		uint32 indicesOffset = 0;
+		uint32 primitivesCount = 0;
+		uint32 primitiveType = 0;
+
+		// material
+		Holder<GpuBuffer> materialBuffer;
+		std::array<uint32, MaxTexturesCountPerMaterial> textureNames = {};
+		uint32 shaderName = 0;
+		sint32 layer = 0;
+		MeshRenderFlags flags = {};
+	};
+
+	CAGE_ENGINE_API Holder<Model> newModel();
+	CAGE_ENGINE_API Holder<Model> newModel(GraphicsDevice *device, const Mesh *mesh, PointerRange<const char> material);
+
+	CAGE_ENGINE_API AssetsScheme genAssetSchemeModel(uint32 threadIndex);
+	constexpr uint32 AssetSchemeIndexModel = 12;
+}
+
+#endif // guard_model_dthu41r5df

sources/include/cage-engine/shader.h

@@ -21,6 +21,9 @@ namespace cage
 	};
 
 	CAGE_ENGINE_API Holder<Shader> newShader(GraphicsDevice *device, const Spirv *spirv);
+
+	CAGE_ENGINE_API AssetsScheme genAssetSchemeShaderProgram(uint32 threadIndex);
+	constexpr uint32 AssetSchemeIndexShaderProgram = 10;
 }
 
 #endif

sources/include/cage-engine/texture.h

@@ -11,6 +11,7 @@ namespace wgpu
 
 namespace cage
 {
+	class Image;
 	class GraphicsDevice;
 
 	class CAGE_ENGINE_API Texture : private Immovable
@@ -34,11 +35,17 @@ namespace cage
 	struct CAGE_ENGINE_API TextureCreateConfig
 	{
 		Vec3i resolution = Vec3i(0, 0, 1);
+		uint32 channels = 3;
 		uint32 mipLevels = 1;
-		bool volume3D = false; // true = 3D texture; false = layers, cube
+		bool srgb = false;
 	};
 
-	CAGE_ENGINE_API Holder<Texture> newGraphicsTexture(GraphicsDevice *device, const TextureCreateConfig &config);
+	CAGE_ENGINE_API Holder<Texture> newTexture(GraphicsDevice *device, const TextureCreateConfig &config);
+	CAGE_ENGINE_API Holder<Texture> newTexture(GraphicsDevice *device, const Image *image);
+	CAGE_ENGINE_API Holder<Texture> newTexture(wgpu::Texture texture);
+
+	CAGE_ENGINE_API AssetsScheme genAssetSchemeTexture(uint32 threadIndex);
+	constexpr uint32 AssetSchemeIndexTexture = 11;
 }
 
 #endif

sources/libengine/graphics/buffer.cpp

@@ -0,0 +1,71 @@
+#include <webgpu/webgpu_cpp.h>
+
+#include <cage-engine/gpuBuffer.h>
+#include <cage-engine/graphicsDevice.h>
+
+namespace cage
+{
+	namespace
+	{
+		class GpuBufferImpl : public GpuBuffer
+		{
+		public:
+			wgpu::Buffer buffer;
+			GraphicsDevice *device = nullptr;
+
+			explicit GpuBufferImpl(GraphicsDevice *device, wgpu::BufferUsage usage) : device(device)
+			{
+				wgpu::BufferDescriptor desc = {};
+				desc.usage = usage | wgpu::BufferUsage::CopyDst;
+				buffer = device->nativeDevice().CreateBuffer(&desc);
+			}
+		};
+	}
+
+	void GpuBuffer::setLabel(const String &name)
+	{
+		label = name;
+		GpuBufferImpl *impl = (GpuBufferImpl *)this;
+		impl->buffer.SetLabel(name.c_str());
+	}
+
+	void GpuBuffer::write(PointerRange<const char> buffer)
+	{
+		GpuBufferImpl *impl = (GpuBufferImpl *)this;
+		wgpu::BufferDescriptor desc = {};
+		desc.size = buffer.size();
+		desc.usage = impl->buffer.GetUsage();
+		impl->buffer = impl->device->nativeDevice().CreateBuffer(&desc);
+		if (buffer.size() > 0)
+			write(0, buffer);
+	}
+
+	void GpuBuffer::write(uint32 offset, PointerRange<const char> buffer)
+	{
+		CAGE_ASSERT(offset + buffer.size() <= size());
+		GpuBufferImpl *impl = (GpuBufferImpl *)this;
+		impl->device->nativeQueue()->WriteBuffer(impl->buffer, offset, buffer.data(), buffer.size());
+	}
+
+	uint32 GpuBuffer::size() const
+	{
+		const GpuBufferImpl *impl = (const GpuBufferImpl *)this;
+		return numeric_cast<uint32>(impl->buffer.GetSize());
+	}
+
+	wgpu::Buffer GpuBuffer::nativeBuffer()
+	{
+		GpuBufferImpl *impl = (GpuBufferImpl *)this;
+		return impl->buffer;
+	}
+
+	Holder<GpuBuffer> newGpuBufferUniform(GraphicsDevice *device)
+	{
+		return systemMemory().createImpl<GpuBuffer, GpuBufferImpl>(device, wgpu::BufferUsage::Uniform);
+	}
+
+	Holder<GpuBuffer> newGpuBufferGeometry(GraphicsDevice *device)
+	{
+		return systemMemory().createImpl<GpuBuffer, GpuBufferImpl>(device, wgpu::BufferUsage::Vertex | wgpu::BufferUsage::Index);
+	}
+}

sources/libengine/graphics/device.cpp

@@ -7,14 +7,14 @@
 
 #include "../window/private.h"
 
+#include <cage-core/concurrent.h>
 #include <cage-core/debug.h>
 #include <cage-engine/graphicsDevice.h>
+#include <cage-engine/texture.h>
 #include <cage-engine/window.h>
 
 namespace cage
 {
-	Holder<Texture> adaptWgpuTexture(wgpu::Texture texture);
-
 	struct GraphicsContext
 	{
 		wgpu::Surface surface;
@@ -73,16 +73,17 @@ namespace cage
 		class GraphicsDeviceImpl : public GraphicsDevice
 		{
 		public:
+			Holder<Mutex> mutex = newMutex();
 			wgpu::Instance instance;
 			wgpu::Device device;
 			wgpu::Queue queue;
 
 			GraphicsDeviceImpl(const GraphicsDeviceCreateConfig &config)
 			{
 				{
-					dawn::native::DawnInstanceDescriptor ex;
+					dawn::native::DawnInstanceDescriptor ex = {};
 					ex.SetLoggingCallback(logFromInstance);
-					wgpu::InstanceDescriptor desc;
+					wgpu::InstanceDescriptor desc = {};
 					desc.nextInChain = &ex;
 					std::array<wgpu::InstanceFeatureName, 2> features = { wgpu::InstanceFeatureName::TimedWaitAny, wgpu::InstanceFeatureName::ShaderSourceSPIRV };
 					desc.requiredFeatureCount = features.size();
@@ -95,7 +96,7 @@ namespace cage
 
 				wgpu::Adapter adapter;
 				{
-					wgpu::RequestAdapterOptions opts;
+					wgpu::RequestAdapterOptions opts = {};
 					opts.backendType = wgpu::BackendType::Vulkan;
 					opts.powerPreference = wgpu::PowerPreference::HighPerformance;
 					if (config.compatibility)
@@ -111,15 +112,15 @@ namespace cage
 					if (!adapter)
 						CAGE_THROW_ERROR(Exception, "failed to create wgpu adapter");
 
-					wgpu::AdapterInfo info;
+					wgpu::AdapterInfo info = {};
 					adapter.GetInfo(&info);
 					CAGE_LOG(SeverityEnum::Info, "graphics", Stringizer() + "adapter vendor: " + conv(info.vendor));
 					CAGE_LOG(SeverityEnum::Info, "graphics", Stringizer() + "adapter device: " + conv(info.device));
 					CAGE_LOG(SeverityEnum::Info, "graphics", Stringizer() + "adapter description: " + conv(info.description));
 				}
 
 				{
-					wgpu::DeviceDescriptor desc;
+					wgpu::DeviceDescriptor desc = {};
 					desc.SetDeviceLostCallback(wgpu::CallbackMode::AllowProcessEvents, lostFromDevice);
 					desc.SetUncapturedErrorCallback(errorFromDevice);
 
@@ -163,7 +164,7 @@ namespace cage
 				if (res != context->resolution)
 				{
 					context->presentable = false;
-					wgpu::SurfaceConfiguration cfg;
+					wgpu::SurfaceConfiguration cfg = {};
 					cfg.device = device;
 					cfg.width = res[0];
 					cfg.height = res[1];
@@ -177,7 +178,7 @@ namespace cage
 				if (context->presentable)
 					context->surface.Present();
 
-				wgpu::SurfaceTexture tex;
+				wgpu::SurfaceTexture tex = {};
 				context->surface.GetCurrentTexture(&tex);
 				switch (tex.status)
 				{
@@ -192,7 +193,7 @@ namespace cage
 
 				CAGE_ASSERT(tex.texture);
 				context->presentable = true;
-				return adaptWgpuTexture(tex.texture);
+				return newTexture(tex.texture);
 			}
 		};
 	}
@@ -220,9 +221,17 @@ namespace cage
 		return impl->device;
 	}
 
-	wgpu::Queue GraphicsDevice::nativeQueue()
+	Holder<wgpu::Queue> GraphicsDevice::nativeQueue()
 	{
 		GraphicsDeviceImpl *impl = (GraphicsDeviceImpl *)this;
-		return impl->queue;
+		struct LockedQueue : private Noncopyable
+		{
+			ScopeLock<Mutex> lock;
+			wgpu::Queue queue;
+
+			LockedQueue(ScopeLock<Mutex> &&l, wgpu::Queue &&q) : lock(std::move(l)), queue(std::move(q)) {}
+		};
+		Holder<LockedQueue> l = systemMemory().createHolder<LockedQueue>(ScopeLock(impl->mutex), impl->queue);
+		return Holder<wgpu::Queue>(&l->queue, std::move(l));
 	}
 }