funnygame/materialsystem/vulkan/commands/draw.cpp

#include "../vulkan_state.h"
#include "../commands.h"
#include "materialsystem/imaterialsystem.h"
#include "tier0/platform.h"
#include "tier1/utlvector.h"


DECLARE_VULKAN_COMMAND(ClearColor)
{

	CVkImage *pImg;

	if (pImage)
		pImg = (CVkImage*)pImage;
	if (ppSwapchainImages)
		pImg = (CVkImage*)ppSwapchainImages[iCurrentFrame];

	if (pImg == NULL)
		Plat_FatalErrorFunc("pImage and *ppSwapchainImages are NULL\n");


	VkClearColorValue color = {.float32 = {r,g,b,a}};
	VkImageSubresourceRange range = {
		.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
		.levelCount = 1,
		.layerCount = 1,
	};
	vkCmdClearColorImage(hCommandBuffer, pImg->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &range);
}

DECLARE_VULKAN_COMMAND(Begin)
{
	VkRenderingInfo stRenderingInfo = {};
	CUtlVector<VkRenderingAttachmentInfo> attachments = {};
	VkRenderingAttachmentInfo depthAttachment = {};
	for (auto i: images)
	{
		VkRenderingAttachmentInfo a = {};
		a.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
		a.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
		a.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
		a.clearValue.color.float32[0] = i.m_fClearColor[0];
		a.clearValue.color.float32[1] = i.m_fClearColor[1];
		a.clearValue.color.float32[2] = i.m_fClearColor[2];
		a.clearValue.color.float32[3] = i.m_fClearColor[3];
		a.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
		a.imageView = ((CVkImage*)VulkanGetObject(i.m_stImage, iCurrentFrame))->m_imageView;
		attachments.AppendTail(a);
	}
	if (bDepthEnabled)
	{
		depthAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
		depthAttachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
		depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
		depthAttachment.clearValue.depthStencil.depth = stDepthImage.m_fClearDepth;
		depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
		depthAttachment.imageView = ((CVkImage*)VulkanGetObject(stDepthImage.m_stImage, iCurrentFrame))->m_imageView;
		stRenderingInfo.pDepthAttachment = &depthAttachment;
	}

	stRenderingInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
	stRenderingInfo.layerCount = 1;
	stRenderingInfo.colorAttachmentCount = attachments.GetSize();
	stRenderingInfo.pColorAttachments = attachments.GetData();
	stRenderingInfo.renderArea = (VkRect2D){0,0,nResolutionX,nResolutionY};
	
	vkCmdBeginRendering(hCommandBuffer, &stRenderingInfo);
}

DECLARE_VULKAN_COMMAND(End)
{
	vkCmdEndRendering(hCommandBuffer);
}

DECLARE_VULKAN_COMMAND(SetShader)
{
	CVkShader *pVkShader = (CVkShader*)pShader;
	vkCmdBindPipeline(hCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pVkShader->m_hPipeline);
}
DECLARE_VULKAN_COMMAND(SetShaderData)
{
	CVkMaterial *pMat = (CVkMaterial*)pShaderData;
	vkCmdBindDescriptorSets(hCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pMat->m_pVkShader->m_hPipelineLayout, 0, pMat->m_hSets.GetSize(), pMat->m_hSets.GetData(), 0, 0 );
}

DECLARE_VULKAN_COMMAND(SetVertexBuffer)
{
	CVkBuffer *pVkBuffer = (CVkBuffer*)pBuffer;
	VkDeviceSize uOffset = 0;
	vkCmdBindVertexBuffers(hCommandBuffer, uBinding, 1, &pVkBuffer->m_buffer, &uOffset);
}

DECLARE_VULKAN_COMMAND(DrawPrimitives)
{
	vkCmdDraw(hCommandBuffer, nVertexCount, nInstanceCount, nFirstVertex, nFirstInstance);
}

DECLARE_VULKAN_COMMAND(SetScissors)
{
	VkRect2D r = {
		.offset = {
			iX,
			iY,
		},
		.extent = {
			uWidth,
			uHeight,
		},
	};
	vkCmdSetScissorWithCount(hCommandBuffer, 1, &r);
}

DECLARE_VULKAN_COMMAND(SetViewport)
{
	VkViewport v = {
		fX,
		fY+fHeight,
		fWidth,
		-fHeight,
		fDepthMin,
		fDepthMax
	};
	vkCmdSetViewportWithCount(hCommandBuffer, 1, &v);
}
DECLARE_VULKAN_COMMAND(ResolveImage)
{
	CVkImage *pInput = (CVkImage*)VulkanGetObject(stInputImage, iCurrentFrame);
	CVkImage *pOutput = (CVkImage*)VulkanGetObject(stOutputImage, iCurrentFrame);
	VkImageResolve2 r = {
		.sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2,
		.srcSubresource = {
			.aspectMask = pInput->m_range.aspectMask,
			.layerCount = 1,
		},
		.srcOffset = {0,0,0},
		.dstSubresource = {
			.aspectMask = pOutput->m_range.aspectMask,
			.layerCount = 1,
		},
		.dstOffset = {0,0,0},
		.extent = {pInput->m_nWidth, pInput->m_nHeight, 1}
	};
	VkResolveImageInfo2 i = {
		.sType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2,
		.srcImage = pInput->m_image,
		.srcImageLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
		.dstImage = pOutput->m_image,
		.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
		.regionCount = 1,
		.pRegions = &r,
	};
	vkCmdResolveImage2(hCommandBuffer, &i);
}
DECLARE_VULKAN_COMMAND(CopyBufferToImage)
{
	VkBufferImageCopy2 r = {
		.sType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2,
		.imageSubresource = {
			.aspectMask = ((CVkImage*)VulkanGetObject(stOutputImage, iCurrentFrame))->m_range.aspectMask,
			.layerCount = 1,
		},
		.imageOffset = {iOffsetX, iOffsetY, iOffsetZ},
		.imageExtent = {iImageX, iImageY, iImageZ},
	};
	VkCopyBufferToImageInfo2 c = {
		.sType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2,
		.srcBuffer = ((CVkBuffer*)pBuffer)->m_buffer,
		.dstImage = ((CVkImage*)VulkanGetObject(stOutputImage, iCurrentFrame))->m_image,
		.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
		.regionCount = 1,
		.pRegions = &r,
	};
	vkCmdCopyBufferToImage2(hCommandBuffer, &c);
}