reworked begin and end

engine/kottui.cpp

@@ -313,14 +313,26 @@ void CKotUIBuffer::Draw( IImage *pImage )
 	m_pMaterial->PSSetTexture(2, m_pFont->GetAtlas());
 	m_pMaterial->PSSetSampler(3, m_pRenderContext->GetDefaultSampler());
 
+	pList->StartRecording();
 
-	pList->SetRenderTarget(0, pImage);
+	RenderImage image = {};
-	pList->SetLoadStoreModes(0, LOAD_MODE_LOAD, STORE_MODE_STORE);
+	image.pImage = pImage;
-	pList->SetRenderResolution(pImage->GetImageWidth(), pImage->GetImageHeight());
+	image.eLoadMode = LOAD_MODE_LOAD;
+	image.eStoreMode = STORE_MODE_STORE;
+	BeginInfo begin = {};
+	begin.uWidth = pImage->GetImageWidth();
+	begin.uHeight = pImage->GetImageHeight();
+	begin.pRenderImages = ℑ
+	begin.uRenderImageCount = 1;
+
+	pList->Begin(&begin);
+	pList->SetScissors(0, 0, begin.uWidth, begin.uHeight);
+	pList->SetViewport(0, 0, begin.uWidth, begin.uHeight, 0, 1);
 
 	pList->SetMaterial(m_pMaterial);
 	pList->SetVertexBuffer(0, s_pGlyphBuffer);
 	pList->DrawPrimitives(6, 0, uRealGlyphCount, 0);
+	pList->End();
 
 	pList->EndRecording();
 	m_pRenderContext->SubmitCommandList(pList);

game/client/worldrender.cpp

@@ -345,20 +345,37 @@ void CFunnyWorldRenderer::Frame( float fDelta )
 				IMAGE_LAYOUT_UNDEFINED, IMAGE_LAYOUT_DEPTH_STENCIL, 
 				STAGE_HAZARD_NONE, STAGE_HAZARD_RASTER_EARLY_DEPTH_OUT, 
 				BARRIER_HAZARD_DEPTH_STENCIL);
-		m_pRasterCommandList->SetRenderResolution(uWidth, uHeight);
+		RenderImage images[] = {
-		m_pRasterCommandList->SetRenderTarget(0, v->m_pColor);
+			{
-		m_pRasterCommandList->SetRenderTarget(1, v->m_pNormal);
+				v->m_pColor,
-		m_pRasterCommandList->SetRenderTarget(2, v->m_pWorldCoords);
+				LOAD_MODE_CLEAR,
-		m_pRasterCommandList->SetDepthTarget(v->m_pDepth);
+				STORE_MODE_STORE,
-		m_pRasterCommandList->SetViewport(0, 0, uWidth, uHeight, 0, 1);
+			},
-		m_pRasterCommandList->SetScissors(0, 0, uWidth, uHeight);
+			{
-		m_pRasterCommandList->SetClearColor(0, 0, 0, 0, 0);
+				v->m_pNormal,
-		m_pRasterCommandList->SetClearColor(1, 0, 0, 0, 0);
+				LOAD_MODE_CLEAR,
-		m_pRasterCommandList->SetClearColor(2, 0, 0, 0, 0);
+				STORE_MODE_STORE,
-		m_pRasterCommandList->SetClearDepth(1);
+			},
-		m_pRasterCommandList->SetLoadStoreModes(0, LOAD_MODE_CLEAR, STORE_MODE_STORE);
+			{
-		m_pRasterCommandList->SetLoadStoreModes(1, LOAD_MODE_CLEAR, STORE_MODE_STORE);
+				v->m_pWorldCoords,
-		m_pRasterCommandList->SetLoadStoreModes(2, LOAD_MODE_CLEAR, STORE_MODE_STORE);
+				LOAD_MODE_CLEAR,
+				STORE_MODE_STORE,
+			}
+
+		};
+		RenderImage depth = {
+			v->m_pDepth,
+			LOAD_MODE_CLEAR,
+			STORE_MODE_STORE,
+			{.depth = 0},
+		};
+		BeginInfo begin = {};
+		begin.uWidth = uWidth;
+		begin.uHeight = uHeight;
+		begin.pDepth = &depth;
+		begin.pRenderImages = images;
+		begin.uRenderImageCount = sizeof(images)/sizeof(*images);
+		m_pRasterCommandList->Begin(&begin);
 		uint32_t uTotalMeshes = 0;
 		uint32_t u = 0;
 		for ( auto mesh: m_pMeshes)
@@ -390,6 +407,8 @@ void CFunnyWorldRenderer::Frame( float fDelta )
 		m_pRasterMaterial->PSSetTextureArray(1, m_pTextures);
 
 		m_pRasterCommandList->SetMaterial(m_pRasterMaterial);
+		m_pRasterCommandList->SetViewport(0, 0, uWidth, uHeight, 0, 1);
+		m_pRasterCommandList->SetScissors(0, 0, uWidth, uHeight);
 		u = 0;
 		for ( auto mesh: m_pMeshes)
 		{
@@ -399,6 +418,7 @@ void CFunnyWorldRenderer::Frame( float fDelta )
 			m_pRasterCommandList->DrawPrimitives(mesh->m_pVertexBuffer->GetSize()/32, 0, mesh->m_instances.GetSize(), u);
 			u += mesh->m_instances.GetSize();
 		}
+		m_pRasterCommandList->End();
 		m_pRasterCommandList->Barrier(STAGE_HAZARD_RASTER_COLOR_OUT, STAGE_HAZARD_NONE, 0);
 		m_pRasterCommandList->BarrierTransition(
 				v->m_pColor, 

launcher/build.cpp

@@ -74,19 +74,20 @@ DECLARE_BUILD_STAGE(launcher)
 
 		CUtlString szOutputDir = manifest.BuildManifest();
 
-		filesystem2->MakeDirectory(CUtlString("%s/lib/x86_64",szOutputDir.GetString()));
+		CUtlString szLibDir = CUtlString("%s/lib/%s",szOutputDir.GetString(), Target_t::StringFromCPU(compileProject.m_target.cpu));
-		filesystem2->CopyFile(CUtlString("%s/lib/x86_64/libnative-app.so",szOutputDir.GetString()), outputProject);
+		filesystem2->MakeDirectory(szLibDir);
+		filesystem2->CopyFile(CUtlString("%s/libnative-app.so",szLibDir.GetString()), outputProject);
 
-		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/maps");
+		filesystem2->MakeDirectory(CUtlString("%s/assets/core/",szOutputDir.GetString()));
-		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/models");
+		filesystem2->CopyDirectory(CUtlString("%s/assets/core/",szOutputDir.GetString()), "../funnyassets/maps");
-		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/meshes");
+		filesystem2->CopyDirectory(CUtlString("%s/assets/core/",szOutputDir.GetString()), "../funnyassets/models");
-		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/materials");
+		filesystem2->CopyDirectory(CUtlString("%s/assets/core/",szOutputDir.GetString()), "../funnyassets/meshes");
-		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/textures");
+		filesystem2->CopyDirectory(CUtlString("%s/assets/core/",szOutputDir.GetString()), "../funnyassets/materials");
-		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/physics");
+		filesystem2->CopyDirectory(CUtlString("%s/assets/core/",szOutputDir.GetString()), "../funnyassets/textures");
-		filesystem2->CopyFile(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/default.cfg");
+		filesystem2->CopyDirectory(CUtlString("%s/assets/core/",szOutputDir.GetString()), "../funnyassets/physics");
-		filesystem2->CopyDirectory(szOutputDir, "../external/ios/SDL3.framework");
+		filesystem2->CopyFile(CUtlString("%s/assets/core/",szOutputDir.GetString()), "../funnyassets/default.cfg");
 
-		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../build/funnygame/assets/shaders");
+		filesystem2->CopyDirectory(CUtlString("%s/assets/core/",szOutputDir.GetString()), "../build/funnygame/assets/shaders");
 		CUtlString szApkPackage = APKTool()->BuildPackage( manifest, szOutputDir );
 		APKTool()->SignPackage(szApkPackage, NULL, "kotofyt", "password1", "password1");
 	}

launcher/launcher.cpp

@@ -103,3 +103,11 @@ int main( int argc, char **argv ) {
 	FunnyMain(argc, argv);
 	return 0;
 };
+
+
+#ifdef __ANDROID__
+void android_main(struct android_app* app)
+{
+
+}
+#endif

materialsystem/vulkan/commandbuffer.cpp

@@ -17,7 +17,6 @@ private:
 	CUtlVector<CVkCommand*> m_commands;
 	VkCommandBuffer m_hBuffer = NULL;
 
-
 	VkDevice m_hDevice;
 	IVkCommandBufferManager *m_pMgr;
 	VkCommandPool m_hPool = NULL;

materialsystem/vulkan/commands/draw.cpp

@@ -321,6 +321,8 @@ static VkAccessFlags2 GetAccessSrc( uint32_t hazard, EStageHazard stage )
 	}
 	if (hazard == 0)
 		f |= VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT;
+	if (stage == STAGE_HAZARD_COMPUTE)
+		f |= VK_ACCESS_2_SHADER_STORAGE_READ_BIT | VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
 	return f;
 
 }
@@ -337,6 +339,8 @@ static VkAccessFlags2 GetAccessDst( uint32_t hazard, EStageHazard stage )
 		f |= VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
 	if (hazard == 0)
 		f |= VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT;
+	if (stage == STAGE_HAZARD_COMPUTE)
+		f |= VK_ACCESS_2_SHADER_STORAGE_READ_BIT | VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
 	return f;
 }
 static VkImageLayout GetLayout( EImageLayoutHazard hazard )

materialsystem/vulkan/rendercommandlist.cpp

@@ -3,84 +3,77 @@
 
 CVkRenderCommandList::~CVkRenderCommandList()
 {
-	ResetRendering();
+	m_pCommandBufferManager->FreeCommandBufferWithCommands(m_pCommandBuffer);
 }
 
 
 void CVkRenderCommandList::ResetRendering()
 {
-	for ( auto m: m_pCommandBuffers )
+	m_pCommandBuffer->Reset();
-	{
-		m_pCommandBufferManager->FreeCommandBufferWithCommands(m);
-	}
-	m_pPostRaster = NULL;
-	m_materials = {};
-	m_pCommandBuffers = {};
 }
 
-void CVkRenderCommandList::SetRenderTarget( uint32_t uIndex, IImage *pImage )
+void CVkRenderCommandList::Begin( BeginInfo *pBegin )
 {
-	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
+	CUtlVector<VulkanRenderOutput_t> images = {};
-	VulkanRenderOutput_t *pOutput = FindOrCreateRenderOutput(uIndex);
+	images.Reserve(pBegin->uRenderImageCount);
-	pOutput->m_stImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
-	pOutput->m_stImage.m_pSingle = pImage;
-}
 
-void CVkRenderCommandList::SetClearColor( uint32_t uIndex, float r, float g, float b, float a )
+	CVkBeginCommand *pBeginCommand = CREATE_COMMAND(m_pCommandBufferManager, Begin);
+	pBeginCommand->nResolutionX = pBegin->uWidth;
+	pBeginCommand->nResolutionY = pBegin->uHeight;
+	for (uint32_t i = 0; i < pBegin->uRenderImageCount; i++)
 	{
-	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
+		RenderImage *renderImage = &pBegin->pRenderImages[i];
-	VulkanRenderOutput_t *pOutput = FindOrCreateRenderOutput(uIndex);
+		VulkanRenderOutput_t output = {};
-	pOutput->m_fClearColor[0] = r;
+		output.m_stImage.m_pSingle = renderImage->pImage;
-	pOutput->m_fClearColor[1] = g;
+		output.m_fClearColor[0] = renderImage->clear_color.r;
-	pOutput->m_fClearColor[2] = b;
+		output.m_fClearColor[1] = renderImage->clear_color.g;
-	pOutput->m_fClearColor[3] = a;
+		output.m_fClearColor[2] = renderImage->clear_color.b;
+		output.m_fClearColor[3] = renderImage->clear_color.a;
+		output.m_eLoadMode = renderImage->eLoadMode;
+		output.m_eStoreMode = renderImage->eStoreMode;
+		images.AppendTail(output);
 	}
-
+	pBeginCommand->images = images;
-void CVkRenderCommandList::SetLoadStoreModes( uint32_t uIndex, ELoadMode eLoadMode, EStoreMode eStoreMode )
+	if ( pBegin->pDepth )
 	{
-	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
+		VulkanRenderOutput_t output = {};
-	VulkanRenderOutput_t *pOutput = FindOrCreateRenderOutput(uIndex);
+		output.m_stImage.m_pSingle = pBegin->pDepth->pImage;
-	pOutput->m_eLoadMode = eLoadMode;
+		output.m_fClearDepth = pBegin->pDepth->clear_color.depth;
-	pOutput->m_eStoreMode = eStoreMode;
+		output.m_eLoadMode = pBegin->pDepth->eLoadMode;
-
+		output.m_eStoreMode = pBegin->pDepth->eStoreMode;
+		pBeginCommand->stDepthImage = output;
 	}
-
+	m_pCurrentBegin = pBeginCommand;
-void CVkRenderCommandList::SetDepthTarget( IImage *pDepth )
+	m_pCommandBuffer->AddCommand(pBeginCommand);
+}
+void CVkRenderCommandList::End()
 {
-	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
+	CVkEndCommand *pEndCommand = CREATE_COMMAND(m_pCommandBufferManager, End);
-	if (pDepth)
+	pEndCommand->pBeginCommand = (CVkBeginCommand*)m_pCurrentBegin;
-	{
+	m_pCommandBuffer->AddCommand(pEndCommand);
-		m_bDepthEnabled = true;
-		m_depth.m_stImage.m_pSingle = pDepth;
 }
-	else
-	{
-		m_bDepthEnabled = false;
-	}
-
-}
-void CVkRenderCommandList::SetClearDepth( float fVal)
-{
-	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
-	m_depth.m_fClearDepth = fVal;
-}
-
-void CVkRenderCommandList::SetRenderResolution( uint32_t iWidth, uint32_t iHeight )
-{
-	SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
-	m_uWidth = iWidth;
-	m_uHeight = iHeight;
-}
-
 
 void CVkRenderCommandList::SetScissors( uint32_t uX, uint32_t uY, uint32_t uWidth, uint32_t uHeight )
 {
-	SwitchRenderingStage(RENDERING_STAGE_RASTER);
+	CVkSetScissorsCommand *pScissorsCommand = CREATE_COMMAND(m_pCommandBufferManager, SetScissors);
+	pScissorsCommand->uWidth = uWidth;
+	pScissorsCommand->uHeight = uHeight;
+	pScissorsCommand->iX = uX;
+	pScissorsCommand->iY = uY;
+	m_pCommandBuffer->AddCommand(pScissorsCommand);
 }
 
 void CVkRenderCommandList::SetViewport( uint32_t uX, uint32_t uY, uint32_t uWidth, uint32_t uHeight, float fMinDepth, float fMaxDepth )
 {
-	SwitchRenderingStage(RENDERING_STAGE_RASTER);
+
+	CVkSetViewportCommand *pViewportCommand = CREATE_COMMAND(m_pCommandBufferManager, SetViewport);
+	pViewportCommand->fX = uX;
+	pViewportCommand->fY = uY;
+	pViewportCommand->fWidth = uWidth;
+	pViewportCommand->fHeight = uHeight;
+	pViewportCommand->fDepthMin = fMinDepth;
+	pViewportCommand->fDepthMax = fMaxDepth;
+	m_pCommandBuffer->AddCommand(pViewportCommand);
 }
 
 
@@ -90,108 +83,51 @@ void CVkRenderCommandList::SetViewport( uint32_t uX, uint32_t uY, uint32_t uWidt
 void CVkRenderCommandList::SetMaterial( IMaterial *pMaterial )
 {
 	CVkMaterial *pVkMat = (CVkMaterial*)pMaterial;
-	CVkComputeShader *pCS = dynamic_cast<CVkComputeShader*>(pVkMat->m_pShader);
-
-	if (pCS)
-	{
-		SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
 
 	CVkSetShaderCommand *pSetShader = CREATE_COMMAND(m_pCommandBufferManager, SetShader);
-		pSetShader->pShader = pCS;
+	pSetShader->pShader = pVkMat->m_pShader;
-		m_pPostRaster->AddCommand(pSetShader);
+	m_pCommandBuffer->AddCommand(pSetShader);
 
 	CVkSetShaderDataCommand *pSetShaderData = CREATE_COMMAND(m_pCommandBufferManager, SetShaderData);
 	pSetShaderData->pShaderData = pMaterial;
-		m_pPostRaster->AddCommand(pSetShaderData);
+	m_pCommandBuffer->AddCommand(pSetShaderData);
-	}
-	else
-	{
-		SwitchRenderingStage(RENDERING_STAGE_SETUP_RASTER);
-		bool bWasCreated = false;
-		m_pCurrentMaterialBuffer = FindOrCreateMaterialCommandBuffer(pMaterial, &bWasCreated);
-		if (bWasCreated)
-		{
-			m_pCurrentMaterialBuffer->Reset();
-			CVkBeginCommand *pBeginCommand = CREATE_COMMAND(m_pCommandBufferManager, Begin);
-			pBeginCommand->images = m_pOutput;
-			pBeginCommand->nResolutionX = m_uWidth;
-			pBeginCommand->nResolutionY = m_uHeight;
-			if ( m_bDepthEnabled )
-			{
-				pBeginCommand->bDepthEnabled = m_bDepthEnabled;
-				pBeginCommand->stDepthImage = m_depth;
-			}
-			m_materials[m_materials.GetSize()-1].m_pBeginCommand = pBeginCommand;
-			m_pCurrentMaterialBuffer->AddCommand(pBeginCommand);
-
-			CVkSetShaderCommand *pSetShader = CREATE_COMMAND(m_pCommandBufferManager, SetShader);
-			pSetShader->pShader = ((CVkMaterial*)pMaterial)->m_pShader;
-			m_pCurrentMaterialBuffer->AddCommand(pSetShader);
-
-			CVkSetShaderDataCommand *pSetShaderData = CREATE_COMMAND(m_pCommandBufferManager, SetShaderData);
-			pSetShaderData->pShaderData = pMaterial;
-			m_pCurrentMaterialBuffer->AddCommand(pSetShaderData);
-
-			CVkSetScissorsCommand *pScissorsCommand = CREATE_COMMAND(m_pCommandBufferManager, SetScissors);
-			pScissorsCommand->uWidth = m_uWidth;
-			pScissorsCommand->uHeight = m_uHeight;
-			m_pCurrentMaterialBuffer->AddCommand(pScissorsCommand);
-
-			CVkSetViewportCommand *pViewportCommand = CREATE_COMMAND(m_pCommandBufferManager, SetViewport);
-			pViewportCommand->fX = 0;
-			pViewportCommand->fY = 0;
-			pViewportCommand->fWidth = m_uWidth;
-			pViewportCommand->fHeight = m_uHeight;
-			pViewportCommand->fDepthMin = 0;
-			pViewportCommand->fDepthMax = 1;
-			m_pCurrentMaterialBuffer->AddCommand(pViewportCommand);
-		}
-
-	}
 }
 
 void CVkRenderCommandList::SetVertexBuffer( uint32_t uBinding, IVertexBuffer *pBuffer )
 {
-	SwitchRenderingStage(RENDERING_STAGE_RASTER);
 	CVkSetVertexBufferCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, SetVertexBuffer);
 	pCmd->uBinding = uBinding;
 	pCmd->pBuffer = pBuffer;
-	m_pCurrentMaterialBuffer->AddCommand(pCmd);
+	m_pCommandBuffer->AddCommand(pCmd);
 }
 
 void CVkRenderCommandList::SetIndexBuffer( IVertexBuffer *pBuffer )
 {
-	SwitchRenderingStage(RENDERING_STAGE_RASTER);
 }
 
 void CVkRenderCommandList::DrawPrimitives( uint32_t nVertexCount, uint32_t nFirstVertex, uint32_t nInstanceCount, uint32_t nFirstInstance )
 {
-	SwitchRenderingStage(RENDERING_STAGE_RASTER);
-
 	CVkDrawPrimitivesCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, DrawPrimitives);
 	pCmd->nVertexCount = nVertexCount;
 	pCmd->nFirstVertex = nFirstVertex;
 	pCmd->nInstanceCount = nInstanceCount;
 	pCmd->nFirstInstance = nFirstInstance;
 
-	m_pCurrentMaterialBuffer->AddCommand(pCmd);
+	m_pCommandBuffer->AddCommand(pCmd);
 }
 
 void CVkRenderCommandList::DrawPrimitivesIndexed( uint32_t nIndexCount, uint32_t nFirstIndex, uint32_t nVertexOffset, uint32_t nInstanceCount, uint32_t nFirstInstance )
 {
-	SwitchRenderingStage(RENDERING_STAGE_RASTER);
 
 }
 
 
 void CVkRenderCommandList::CopyImageToImage( IImage *pSrc, IImage *pDst )
 {
-	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
 	
 }
 void CVkRenderCommandList::BlitImageToImage( IImage *pSrc, ImageSector_t src, IImage *pDst, ImageSector_t dst )
 {
-	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
 	CVkBlitCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, Blit);
 	pCmd->stInputImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
 	pCmd->stInputImage.m_pSingle = pSrc;
@@ -209,13 +145,12 @@ void CVkRenderCommandList::BlitImageToImage( IImage *pSrc, ImageSector_t src, II
 	pCmd->iDstMax[0] = dst.m_iWidth;
 	pCmd->iDstMax[1] = dst.m_iHeight;
 	pCmd->iDstMax[2] = 1;
-	m_pPostRaster->AddCommand(pCmd);
+	m_pCommandBuffer->AddCommand(pCmd);
 
 }
 
 void CVkRenderCommandList::ClearImage( IImage *pImage, float fR, float fG, float fB, float fA )
 {
-	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
 	CVkClearColorCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, ClearColor);
 	pCmd->r = fR;
 	pCmd->g = fG;
@@ -223,7 +158,7 @@ void CVkRenderCommandList::ClearImage( IImage *pImage, float fR, float fG, float
 	pCmd->a = fA;
 	pCmd->stImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
 	pCmd->stImage.m_pSingle = pImage;
-	m_pPostRaster->AddCommand(pCmd);
+	m_pCommandBuffer->AddCommand(pCmd);
 
 }
 
@@ -234,40 +169,37 @@ void CVkRenderCommandList::ClearDepth( IImage *pImage, float fVal )
 
 void CVkRenderCommandList::ResolveImage( IImage *pOriginal, IImage *pResolved )
 {
-	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
-
 	CVkResolveImageCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, ResolveImage);
 	pCmd->stInputImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
 	pCmd->stInputImage.m_pSingle = pOriginal;
 	pCmd->stOutputImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
 	pCmd->stOutputImage.m_pSingle = pResolved;
-	m_pPostRaster->AddCommand(pCmd);
+	m_pCommandBuffer->AddCommand(pCmd);
 }
 
 
 void CVkRenderCommandList::StartRecording()
 {
-	ResetRendering();
+	m_pCommandBuffer = m_pCommandBufferManager->CreateCommandBuffer();
+	m_pCommandBuffer->Reset();
 }
 
 void CVkRenderCommandList::EndRecording()
 {
-	SwitchRenderingStage(RENDERING_STAGE_FINISHED);
+	m_pCommandBuffer->Render();
 }
 void CVkRenderCommandList::Barrier( EStageHazard eBefore, EStageHazard eAfter, uint32_t hazard )
 {
-	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
 	CVkBarrierCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, Barrier);
 	pCmd->eStageIn = eBefore;
 	pCmd->eStageOut = eAfter;
 	pCmd->eHazard = hazard;
-	m_pPostRaster->AddCommand(pCmd);
+	m_pCommandBuffer->AddCommand(pCmd);
 
 }
 
 void CVkRenderCommandList::BarrierTransition( IImage *pObject, EImageLayoutHazard old_layout, EImageLayoutHazard layout, EStageHazard eBefore, EStageHazard eAfter, uint32_t hazard )
 {
-	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
 	CVkLayoutBarrierCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, LayoutBarrier);
 	pCmd->eStageIn = eBefore;
 	pCmd->eStageOut = eAfter;
@@ -275,95 +207,22 @@ void CVkRenderCommandList::BarrierTransition( IImage *pObject, EImageLayoutHazar
 	pCmd->pImage = pObject;
 	pCmd->eLayoutIn = old_layout;
 	pCmd->eLayoutOut = layout;
-	m_pPostRaster->AddCommand(pCmd);
+	m_pCommandBuffer->AddCommand(pCmd);
 
 }
 
 void CVkRenderCommandList::DispatchCompute( uint32_t uX, uint32_t uY, uint32_t uZ )
 {	
-	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
-
 	CVkDispatchCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, Dispatch);
 
 	pCmd->uX = uX;
 	pCmd->uY = uY;
 	pCmd->uZ = uZ;
-	m_pPostRaster->AddCommand(pCmd);
+	m_pCommandBuffer->AddCommand(pCmd);
 	
 }
 
 void CVkRenderCommandList::Submit()
 {
-	for ( auto m: m_pCommandBuffers)
+	m_pCommandBuffer->Submit();
-	{
-		m->Submit();
-	}
-}
-
-void CVkRenderCommandList::SwitchRenderingStage( EVulkanRenderingStage eStage )
-{
-	if (eStage != RENDERING_STAGE_RASTER)
-	{
-		for ( auto m: m_materials)
-		{
-			CVkEndCommand *pEndCommand = CREATE_COMMAND(m_pCommandBufferManager, End);
-			m.m_pCommandBuffer->AddCommand(pEndCommand);
-			m.m_pCommandBuffer->Render();
-			m_pCommandBuffers.AppendTail(m.m_pCommandBuffer);
-		}
-		m_materials = {};
-	};
-	if (eStage == RENDERING_STAGE_POST_RASTER )
-	{
-		if (m_eCurrentStage != RENDERING_STAGE_POST_RASTER)
-		{
-			m_pPostRaster = m_pCommandBufferManager->CreateCommandBuffer();
-			m_pPostRaster->Reset();
-		}
-	}
-	else 
-	{
-		if (m_pPostRaster)
-		{
-			m_pPostRaster->Render();
-			m_pCommandBuffers.AppendTail(m_pPostRaster);
-			m_pPostRaster = NULL;
-		}
-	}
-	m_eCurrentStage = eStage;
-}
-
-VulkanRenderOutput_t *CVkRenderCommandList::FindOrCreateRenderOutput( uint32_t uIndex )
-{
-	for ( auto &v: m_pOutput )
-	{
-		if (v.m_uIndex == uIndex)
-			return &v;
-	}
-
-	VulkanRenderOutput_t output = {};
-	output.m_uIndex = uIndex;
-	m_pOutput.AppendTail(output);
-	return &m_pOutput[m_pOutput.GetSize()-1];
-}
-
-IVkCommandBuffer *CVkRenderCommandList::FindOrCreateMaterialCommandBuffer( IMaterial *pMaterial, bool *pbWasCreated )
-{
-	for (auto &m: m_materials)
-	{
-		if (m.m_pMaterial == pMaterial)
-		{
-			if (pbWasCreated)
-				*pbWasCreated = false;
-			return m.m_pCommandBuffer;
-		}
-	}
-
-	VulkanMaterialCommandBuffer_t mat;
-	mat.m_pCommandBuffer = m_pCommandBufferManager->CreateCommandBuffer();
-	mat.m_pMaterial = pMaterial;
-	m_materials.AppendTail(mat);
-	if (pbWasCreated)
-		*pbWasCreated = true;
-	return m_materials[m_materials.GetSize()-1].m_pCommandBuffer;
 }

materialsystem/vulkan/shader.cpp

@@ -81,10 +81,8 @@ void CVkShader::Build()
 	VkPipelineRenderingCreateInfo render = {};
 	CUtlVector<VkPipelineColorBlendAttachmentState> attachments = {};
 	VkDynamicState dynamicStates[] = {
-		VK_DYNAMIC_STATE_VIEWPORT,
+		vkCmdSetViewportWithCount ? VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT : VK_DYNAMIC_STATE_VIEWPORT,
-		VK_DYNAMIC_STATE_SCISSOR,
+		vkCmdSetScissorWithCount ? VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT : VK_DYNAMIC_STATE_SCISSOR,
-		VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT,
-		VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT,
 	};
 	VkPipelineLayoutCreateInfo stPipelineLayout = {};
 	CUtlVector<CUtlVector<VkDescriptorSetLayoutBinding>> bindings = {};
@@ -170,7 +168,7 @@ void CVkShader::Build()
 	inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
 
 	dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
-	dynamicState.dynamicStateCount = 2;
+	dynamicState.dynamicStateCount = sizeof(dynamicStates)/(sizeof(*dynamicStates));
 	dynamicState.pDynamicStates = dynamicStates;
 
 	rasterState.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;

materialsystem/vulkan/vulkan_state.h

@@ -427,16 +427,9 @@ public:
 	~CVkRenderCommandList();
 	virtual void ResetRendering() override;
 
-	virtual void SetRenderTarget( uint32_t uIndex, IImage *pImage ) override;
+	virtual void Begin( BeginInfo *pBegin ) override;
-	virtual void SetClearColor( uint32_t uIndex, float r, float g, float b, float a ) override;
+	virtual void End() override;
-	virtual void SetLoadStoreModes( uint32_t uIndex, ELoadMode eLoadMode, EStoreMode eStoreMode ) override;
 
-	virtual void SetDepthTarget( IImage *pDepth ) override;
-	virtual void SetClearDepth( float fVal ) override;
-
-	virtual void SetRenderResolution( uint32_t iWidth, uint32_t iHeight ) override;
-
-	// Should they apply per material or for all?
 	virtual void SetScissors( uint32_t uX, uint32_t uY, uint32_t uWidth, uint32_t uHeight ) override;
 	virtual void SetViewport( uint32_t uX, uint32_t uY, uint32_t uWidth, uint32_t uHeight, float fMinDepth, float fMaxDepth ) override;
 
@@ -464,26 +457,8 @@ public:
 
 	IVkCommandBufferManager *m_pCommandBufferManager;
 private:
-	void SwitchRenderingStage( EVulkanRenderingStage eStage );
+	IVkCommandBuffer *m_pCommandBuffer = NULL;
-
+	CVkCommand *m_pCurrentBegin = NULL;
-	VulkanRenderOutput_t *FindOrCreateRenderOutput( uint32_t uIndex );
-	IVkCommandBuffer *FindOrCreateMaterialCommandBuffer( IMaterial *pMaterial, bool *pbWasCreated = NULL );
-
-	bool m_bDepthEnabled = false;
-	VulkanRenderOutput_t m_depth = {};
-
-	CUtlVector<VulkanRenderOutput_t> m_pOutput = {};
-	CUtlVector<VulkanMaterialCommandBuffer_t> m_materials = {};
-	IVkCommandBuffer *m_pPostRaster = NULL;
-
-	IVkCommandBuffer *m_pCurrentMaterialBuffer = NULL;
-
-	uint32_t m_uWidth;
-	uint32_t m_uHeight;
-	CUtlVector<IVkCommandBuffer*> m_pCommandBuffers = {};
-	CUtlVector<IVkCommandBuffer*> m_pScheduledDestroyPostRaster = {};
-
-	EVulkanRenderingStage m_eCurrentStage = RENDERING_STAGE_SETUP_RASTER;
 };
 
 

public/materialsystem/imaterialsystem.h

@@ -81,7 +81,7 @@ enum EImageType
 
 enum EMultisampleType
 {
-	MULTISAMPLE_TYPE_NONE = 0,
+	MULTISAMPLE_TYPE_NONE = 1,
 	MULTISAMPLE_TYPE_1_SAMPLES = 1,
 	MULTISAMPLE_TYPE_2_SAMPLES = 2,
 	MULTISAMPLE_TYPE_4_SAMPLES = 4,
@@ -343,19 +343,41 @@ enum EImageLayoutHazard
 	IMAGE_LAYOUT_TRANSFER_DST,
 };
 
+struct RenderImage
+{
+	IImage *pImage;
+	ELoadMode eLoadMode;
+	EStoreMode eStoreMode;
+	union
+	{
+		struct
+		{
+			float r;
+			float g;
+			float b;
+			float a;
+		};
+		struct {
+			float depth;
+		};
+	} clear_color;
+};
+struct BeginInfo
+{
+	uint32_t uWidth; 
+	uint32_t uHeight;
+	uint32_t uRenderImageCount;
+	RenderImage *pRenderImages;
+	RenderImage *pDepth;
+};
+
 abstract_class IRenderCommandList
 {
 public:
 	virtual void ResetRendering() = 0;
 
-	virtual void SetRenderTarget( uint32_t uIndex, IImage *pImage ) = 0;
+	virtual void Begin( BeginInfo *pBegin ) = 0;
-	virtual void SetClearColor( uint32_t uIndex, float r, float g, float b, float a ) = 0;
+	virtual void End() = 0;
-	virtual void SetLoadStoreModes( uint32_t uIndex, ELoadMode eLoadMode, EStoreMode eStoreMode ) = 0;
-
-	virtual void SetDepthTarget( IImage *pDepth ) = 0;
-	virtual void SetClearDepth( float fVal ) = 0;
-
-	virtual void SetRenderResolution( uint32_t iWidth, uint32_t iHeight ) = 0;
 
 	virtual void SetScissors( uint32_t uX, uint32_t uY, uint32_t uWidth, uint32_t uHeight ) = 0;
 	virtual void SetViewport( uint32_t uX, uint32_t uY, uint32_t uWidth, uint32_t uHeight, float fMinDepth, float fMaxDepth ) = 0;