depth

Author: malytomas

sources/include/cage-engine/graphicsEncoder.h

@@ -2,6 +2,7 @@
 #define guard_graphicsPipelines_sdrzhlkdz
 
 #include <array>
+#include <optional>
 #include <vector>
 
 #include <cage-engine/core.h>
@@ -21,13 +22,22 @@ namespace cage
 
 	struct CAGE_ENGINE_API PassConfig
 	{
-		struct TargetConfig
+		struct ColorTargetConfig
 		{
 			Texture *texture = nullptr;
 			Vec4 clearValue = Vec4(0, 0, 0, 1);
 			bool clear = true;
 		};
-		std::vector<TargetConfig> targets;
+		std::vector<ColorTargetConfig> colorTargets;
+
+		struct DepthTargetConfig
+		{
+			Texture *texture = nullptr;
+			bool clear = true;
+			bool write = true;
+		};
+		std::optional<DepthTargetConfig> depthTarget;
+
 		const char *label = nullptr;
 	};
 

sources/include/cage-engine/texture.h

@@ -34,15 +34,25 @@ namespace cage
 		wgpu::Sampler nativeSampler();
 	};
 
-	struct CAGE_ENGINE_API TextureCreateConfig
+	struct CAGE_ENGINE_API ColorTextureCreateConfig
 	{
 		Vec3i resolution = Vec3i(0, 0, 1);
 		uint32 channels = 3;
 		uint32 mipLevels = 1;
 		bool srgb = false;
+		bool sampling = true;
+		bool renderable = false;
 	};
 
-	CAGE_ENGINE_API Holder<Texture> newTexture(GraphicsDevice *device, const TextureCreateConfig &config);
+	struct CAGE_ENGINE_API DepthTextureCreateConfig
+	{
+		Vec2i resolution = Vec2i(0, 0);
+		bool sampling = false;
+		bool renderable = true;
+	};
+
+	CAGE_ENGINE_API Holder<Texture> newTexture(GraphicsDevice *device, const ColorTextureCreateConfig &config);
+	CAGE_ENGINE_API Holder<Texture> newTexture(GraphicsDevice *device, const DepthTextureCreateConfig &config);
 	CAGE_ENGINE_API Holder<Texture> newTexture(GraphicsDevice *device, const Image *image);
 	CAGE_ENGINE_API Holder<Texture> newTexture(wgpu::Texture texture, wgpu::Sampler sampler);
 }

sources/libengine/graphics/encoder.cpp

@@ -41,11 +41,11 @@ namespace cage
 				}
 				{
 					passData = PassData{ config };
-					passData.colors.reserve(config.targets.size());
+					passData.colors.reserve(config.colorTargets.size());
 
 					std::vector<wgpu::RenderPassColorAttachment> atts;
-					atts.reserve(config.targets.size());
-					for (const auto &it : config.targets)
+					atts.reserve(config.colorTargets.size());
+					for (const auto &it : config.colorTargets)
 					{
 						wgpu::RenderPassColorAttachment rpca = {};
 						rpca.clearValue = { it.clearValue[0].value, it.clearValue[1].value, it.clearValue[2].value, it.clearValue[3].value };
@@ -59,9 +59,20 @@ namespace cage
 						passData.colors.push_back(std::move(cts));
 					}
 
+					wgpu::RenderPassDepthStencilAttachment rpdsa = {};
+					if (config.depthTarget)
+					{
+						rpdsa.view = config.depthTarget->texture->nativeView();
+						rpdsa.depthLoadOp = config.depthTarget->clear ? wgpu::LoadOp::Clear : wgpu::LoadOp::Load;
+						rpdsa.depthStoreOp = wgpu::StoreOp::Store;
+						rpdsa.depthClearValue = 1;
+					}
+
 					wgpu::RenderPassDescriptor rpd = {};
 					rpd.colorAttachmentCount = atts.size();
 					rpd.colorAttachments = atts.data();
+					if (config.depthTarget)
+						rpd.depthStencilAttachment = &rpdsa;
 					passEnc = cmdEnc.BeginRenderPass(&rpd);
 					if (config.label)
 						passEnc.SetLabel(config.label);
@@ -74,6 +85,14 @@ namespace cage
 
 				wgpu::RenderPipeline pip;
 				{
+					wgpu::DepthStencilState dss = {};
+					if (passData.depthTarget)
+					{
+						dss.format = passData.depthTarget->texture->nativeTexture().GetFormat();
+						dss.depthCompare = wgpu::CompareFunction::Less;
+						dss.depthWriteEnabled = passData.depthTarget->write;
+					}
+
 					wgpu::FragmentState fs = {};
 					fs.module = config.shader->nativeFragment();
 					fs.targetCount = passData.colors.size();
@@ -83,13 +102,16 @@ namespace cage
 					rpd.vertex.module = config.shader->nativeVertex();
 					rpd.vertex.bufferCount = 1;
 					rpd.vertex.buffers = &config.model->getLayout();
+					if (passData.depthTarget)
+						rpd.depthStencil = &dss;
 					rpd.fragment = &fs;
 					pip = device->nativeDevice().CreateRenderPipeline(&rpd);
 				}
 
 				passEnc.SetPipeline(pip);
 				passEnc.SetVertexBuffer(0, config.model->geometryBuffer->nativeBuffer());
-				passEnc.SetIndexBuffer(config.model->geometryBuffer->nativeBuffer(), wgpu::IndexFormat::Uint32, config.model->indicesOffset);
+				if (config.model->indicesCount)
+					passEnc.SetIndexBuffer(config.model->geometryBuffer->nativeBuffer(), wgpu::IndexFormat::Uint32, config.model->indicesOffset);
 				/*
 				{
 					std::array<wgpu::BindGroupEntry, 2> entries = {}; // todo adapt to the mesh
@@ -105,7 +127,10 @@ namespace cage
 					passEnc.SetBindGroup(0, group);
 				}
 				*/
-				passEnc.DrawIndexed(config.model->indicesCount);
+				if (config.model->indicesCount)
+					passEnc.DrawIndexed(config.model->indicesCount);
+				else
+					passEnc.Draw(config.model->verticesCount);
 			}
 
 			void submit()

sources/libengine/graphics/texture.cpp

@@ -83,10 +83,14 @@ namespace cage
 			wgpu::TextureView view;
 			wgpu::Sampler sampler;
 
-			TextureImpl(GraphicsDevice *device, const TextureCreateConfig &config)
+			TextureImpl(GraphicsDevice *device, const ColorTextureCreateConfig &config)
 			{
 				wgpu::TextureDescriptor desc = {};
-				desc.usage = wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::CopyDst;
+				desc.usage = wgpu::TextureUsage::CopyDst;
+				if (config.sampling)
+					desc.usage |= wgpu::TextureUsage::TextureBinding;
+				if (config.renderable)
+					desc.usage |= wgpu::TextureUsage::RenderAttachment;
 				desc.dimension = wgpu::TextureDimension::e2D;
 				desc.size.width = config.resolution[0];
 				desc.size.height = config.resolution[1];
@@ -98,6 +102,24 @@ namespace cage
 				sampler = device->nativeDevice().CreateSampler();
 			}
 
+			TextureImpl(GraphicsDevice *device, const DepthTextureCreateConfig &config)
+			{
+				wgpu::TextureDescriptor desc = {};
+				desc.usage = wgpu::TextureUsage::None;
+				if (config.sampling)
+					desc.usage |= wgpu::TextureUsage::TextureBinding;
+				if (config.renderable)
+					desc.usage |= wgpu::TextureUsage::RenderAttachment;
+				desc.dimension = wgpu::TextureDimension::e2D;
+				desc.size.width = config.resolution[0];
+				desc.size.height = config.resolution[1];
+				desc.size.depthOrArrayLayers = 1;
+				desc.format = wgpu::TextureFormat::Depth32Float;
+				texture = device->nativeDevice().CreateTexture(&desc);
+				view = texture.CreateView();
+				sampler = device->nativeDevice().CreateSampler();
+			}
+
 			TextureImpl(wgpu::Texture texture, wgpu::Sampler sampler) : texture(texture), sampler(sampler) { view = texture.CreateView(); }
 
 			Vec3i mipRes(uint32 mip) const
@@ -164,7 +186,12 @@ namespace cage
 		return impl->sampler;
 	}
 
-	Holder<Texture> newTexture(GraphicsDevice *device, const TextureCreateConfig &config)
+	Holder<Texture> newTexture(GraphicsDevice *device, const ColorTextureCreateConfig &config)
+	{
+		return systemMemory().createImpl<Texture, TextureImpl>(device, config);
+	}
+
+	Holder<Texture> newTexture(GraphicsDevice *device, const DepthTextureCreateConfig &config)
 	{
 		return systemMemory().createImpl<Texture, TextureImpl>(device, config);
 	}
@@ -173,7 +200,7 @@ namespace cage
 	{
 		if (image->format() != ImageFormatEnum::U8)
 			CAGE_THROW_ERROR(Exception, "unsupported image format for texture (not U8)");
-		TextureCreateConfig conf;
+		ColorTextureCreateConfig conf;
 		conf.resolution = Vec3i(image->resolution(), 1);
 		conf.channels = image->channels();
 		conf.srgb = image->colorConfig.gammaSpace == GammaSpaceEnum::Gamma;