diff --git a/src/drm.cpp b/src/drm.cpp
index 86308a0..0e0cf95 100644
--- a/src/drm.cpp
+++ b/src/drm.cpp
@@ -818,7 +818,7 @@ void finish_drm(struct drm_t *drm)
 	// page-flip handler thread.
 }
 
-int drm_commit(struct drm_t *drm, struct Composite_t *pComposite, struct VulkanPipeline_t *pPipeline )
+int drm_commit(struct drm_t *drm, const struct FrameInfo_t *frameInfo )
 {
 	int ret;
 
@@ -1080,25 +1080,25 @@ void drm_unlock_fbid( struct drm_t *drm, uint32_t fbid )
 
 /* Prepares an atomic commit without using libliftoff */
 static int
-drm_prepare_basic( struct drm_t *drm, const struct Composite_t *pComposite, const struct VulkanPipeline_t *pPipeline )
+drm_prepare_basic( struct drm_t *drm, const struct FrameInfo_t *frameInfo )
 {
 	// Discard cases where our non-liftoff path is known to fail
 
 	// It only supports one layer
-	if ( pComposite->nLayerCount > 1 )
+	if ( frameInfo->layerCount > 1 )
 	{
-		drm_verbose_log.errorf("drm_prepare_basic: cannot handle %d layers", pComposite->nLayerCount);
+		drm_verbose_log.errorf("drm_prepare_basic: cannot handle %d layers", frameInfo->layerCount);
 		return -EINVAL;
 	}
 
-	if ( pPipeline->layerBindings[ 0 ].fbid == 0 )
+	if ( frameInfo->layers[ 0 ].fbid == 0 )
 	{
 		drm_verbose_log.errorf("drm_prepare_basic: layer has no FB");
 		return -EINVAL;
 	}
 
 	drmModeAtomicReq *req = drm->req;
-	uint32_t fb_id = pPipeline->layerBindings[ 0 ].fbid;
+	uint32_t fb_id = frameInfo->layers[ 0 ].fbid;
 
 	drm->fbids_in_req.push_back( fb_id );
 
@@ -1109,8 +1109,8 @@ drm_prepare_basic( struct drm_t *drm, const struct Composite_t *pComposite, cons
 	add_plane_property(req, drm->primary, "SRC_X", 0);
 	add_plane_property(req, drm->primary, "SRC_Y", 0);
 
-	const uint16_t srcWidth = pPipeline->layerBindings[ 0 ].surfaceWidth;
-	const uint16_t srcHeight = pPipeline->layerBindings[ 0 ].surfaceHeight;
+	const uint16_t srcWidth = frameInfo->layers[ 0 ].tex->m_width;
+	const uint16_t srcHeight = frameInfo->layers[ 0 ].tex->m_height;
 
 	add_plane_property(req, drm->primary, "SRC_W", srcWidth << 16);
 	add_plane_property(req, drm->primary, "SRC_H", srcHeight << 16);
@@ -1118,14 +1118,14 @@ drm_prepare_basic( struct drm_t *drm, const struct Composite_t *pComposite, cons
 	gpuvis_trace_printf ( "legacy flip fb_id %u src %ix%i", fb_id,
 						 srcWidth, srcHeight );
 
-	int64_t crtcX = pComposite->data.vOffset[ 0 ].x * -1;
-	int64_t crtcY = pComposite->data.vOffset[ 0 ].y * -1;
-	int64_t crtcW = pPipeline->layerBindings[ 0 ].surfaceWidth / pComposite->data.vScale[ 0 ].x;
-	int64_t crtcH = pPipeline->layerBindings[ 0 ].surfaceHeight / pComposite->data.vScale[ 0 ].y;
+	int64_t crtcX = frameInfo->layers[ 0 ].offset.x * -1;
+	int64_t crtcY = frameInfo->layers[ 0 ].offset.y * -1;
+	int64_t crtcW = srcWidth / frameInfo->layers[ 0 ].scale.x;
+	int64_t crtcH = srcHeight / frameInfo->layers[ 0 ].scale.y;
 
 	if ( g_bRotated )
 	{
-		int64_t imageH = pPipeline->layerBindings[ 0 ].imageHeight / pComposite->data.vScale[ 0 ].y;
+		int64_t imageH = frameInfo->layers[ 0 ].imageHeight / frameInfo->layers[ 0 ].scale.y;
 
 		int64_t tmp = crtcX;
 		crtcX = g_nOutputHeight - imageH - crtcY;
@@ -1156,39 +1156,39 @@ drm_prepare_basic( struct drm_t *drm, const struct Composite_t *pComposite, cons
 }
 
 static int
-drm_prepare_liftoff( struct drm_t *drm, const struct Composite_t *pComposite, const struct VulkanPipeline_t *pPipeline )
+drm_prepare_liftoff( struct drm_t *drm, const struct FrameInfo_t *frameInfo )
 {
 	for ( int i = 0; i < k_nMaxLayers; i++ )
 	{
-		if ( i < pComposite->nLayerCount )
+		if ( i < frameInfo->layerCount )
 		{
-			if ( pPipeline->layerBindings[ i ].fbid == 0 )
+			if ( frameInfo->layers[ i ].fbid == 0 )
 			{
 				drm_verbose_log.errorf("drm_prepare_liftoff: layer %d has no FB", i );
 				return -EINVAL;
 			}
 
-			liftoff_layer_set_property( drm->lo_layers[ i ], "FB_ID", pPipeline->layerBindings[ i ].fbid);
-			drm->fbids_in_req.push_back( pPipeline->layerBindings[ i ].fbid );
+			liftoff_layer_set_property( drm->lo_layers[ i ], "FB_ID", frameInfo->layers[ i ].fbid);
+			drm->fbids_in_req.push_back( frameInfo->layers[ i ].fbid );
 
-			liftoff_layer_set_property( drm->lo_layers[ i ], "zpos", pPipeline->layerBindings[ i ].zpos );
-			liftoff_layer_set_property( drm->lo_layers[ i ], "alpha", pComposite->data.flOpacity[ i ] * 0xffff);
+			liftoff_layer_set_property( drm->lo_layers[ i ], "zpos", frameInfo->layers[ i ].zpos );
+			liftoff_layer_set_property( drm->lo_layers[ i ], "alpha", frameInfo->layers[ i ].opacity * 0xffff);
 
-			const uint16_t srcWidth = pPipeline->layerBindings[ i ].surfaceWidth;
-			const uint16_t srcHeight = pPipeline->layerBindings[ i ].surfaceHeight;
+			const uint16_t srcWidth = frameInfo->layers[ i ].tex->m_width;
+			const uint16_t srcHeight = frameInfo->layers[ i ].tex->m_height;
 
 			liftoff_layer_set_property( drm->lo_layers[ i ], "SRC_X", 0);
 			liftoff_layer_set_property( drm->lo_layers[ i ], "SRC_Y", 0);
 			liftoff_layer_set_property( drm->lo_layers[ i ], "SRC_W", srcWidth << 16);
 			liftoff_layer_set_property( drm->lo_layers[ i ], "SRC_H", srcHeight << 16);
 
-			int32_t crtcX = -pComposite->data.vOffset[ i ].x;
-			int32_t crtcY = -pComposite->data.vOffset[ i ].y;
-			uint64_t crtcW = srcWidth / pComposite->data.vScale[ i ].x;
-			uint64_t crtcH = srcHeight / pComposite->data.vScale[ i ].y;
+			int32_t crtcX = -frameInfo->layers[ i ].offset.x;
+			int32_t crtcY = -frameInfo->layers[ i ].offset.y;
+			uint64_t crtcW = srcWidth / frameInfo->layers[ i ].scale.x;
+			uint64_t crtcH = srcHeight / frameInfo->layers[ i ].scale.y;
 
 			if (g_bRotated) {
-				int64_t imageH = pPipeline->layerBindings[ i ].imageHeight / pComposite->data.vScale[ i ].y;
+				int64_t imageH = frameInfo->layers[ i ].imageHeight / frameInfo->layers[ i ].scale.y;
 
 				const int32_t x = crtcX;
 				const uint64_t w = crtcW;
@@ -1222,16 +1222,16 @@ drm_prepare_liftoff( struct drm_t *drm, const struct Composite_t *pComposite, co
 	}
 
 	if ( ret == 0 )
-		drm_verbose_log.debugf( "can drm present %i layers", pComposite->nLayerCount );
+		drm_verbose_log.debugf( "can drm present %i layers", frameInfo->layerCount );
 	else
-		drm_verbose_log.debugf( "can NOT drm present %i layers", pComposite->nLayerCount );
+		drm_verbose_log.debugf( "can NOT drm present %i layers", frameInfo->layerCount );
 
 	return ret;
 }
 
 /* Prepares an atomic commit for the provided scene-graph. Returns false on
  * error or if the scene-graph can't be presented directly. */
-int drm_prepare( struct drm_t *drm, const struct Composite_t *pComposite, const struct VulkanPipeline_t *pPipeline )
+int drm_prepare( struct drm_t *drm, const struct FrameInfo_t *frameInfo )
 {
 	drm_update_gamma_lut(drm);
 
@@ -1297,9 +1297,9 @@ int drm_prepare( struct drm_t *drm, const struct Composite_t *pComposite, const
 
 	int ret;
 	if ( g_bUseLayers == true ) {
-		ret = drm_prepare_liftoff( drm, pComposite, pPipeline );
+		ret = drm_prepare_liftoff( drm, frameInfo );
 	} else {
-		ret = drm_prepare_basic( drm, pComposite, pPipeline );
+		ret = drm_prepare_basic( drm, frameInfo );
 	}
 
 	if ( ret != 0 ) {
diff --git a/src/drm.hpp b/src/drm.hpp
index f782052..82a97bf 100644
--- a/src/drm.hpp
+++ b/src/drm.hpp
@@ -145,8 +145,8 @@ extern enum drm_mode_generation g_drmModeGeneration;
 
 bool init_drm(struct drm_t *drm, int width, int height, int refresh);
 void finish_drm(struct drm_t *drm);
-int drm_commit(struct drm_t *drm, struct Composite_t *pComposite, struct VulkanPipeline_t *pPipeline );
-int drm_prepare( struct drm_t *drm, const struct Composite_t *pComposite, const struct VulkanPipeline_t *pPipeline );
+int drm_commit(struct drm_t *drm, const struct FrameInfo_t *frameInfo );
+int drm_prepare( struct drm_t *drm, const struct FrameInfo_t *frameInfo );
 void drm_rollback( struct drm_t *drm );
 bool drm_poll_state(struct drm_t *drm);
 uint32_t drm_fbid_from_dmabuf( struct drm_t *drm, struct wlr_buffer *buf, struct wlr_dmabuf_attributes *dma_buf );
diff --git a/src/rendervulkan.cpp b/src/rendervulkan.cpp
index 327acd9..1949dee 100644
--- a/src/rendervulkan.cpp
+++ b/src/rendervulkan.cpp
@@ -1562,7 +1562,7 @@ retry:
 	VkPushConstantRange pushConstantRange = {
 		.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
 		.offset = 0,
-		.size = uint32_t(sizeof(Composite_t::CompositeData_t) + sizeof(uint32_t)),
+		.size = 128,
 	};
 	
 	VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
@@ -2305,7 +2305,7 @@ bool float_is_integer(float x)
 
 static uint32_t s_frameId = 0;
 
-VkDescriptorSet vulkan_update_descriptor( struct VulkanPipeline_t *pPipeline, int nYCBCRMask, bool firstNrm, bool firstSrgb, VkImageView targetImageView, VkImageView extraImageView = VK_NULL_HANDLE)
+VkDescriptorSet vulkan_update_descriptor( const struct FrameInfo_t *frameInfo, bool firstNrm, bool firstSrgb, VkImageView targetImageView, VkImageView extraImageView = VK_NULL_HANDLE)
 {
     VkDescriptorSet descriptorSet = descriptorSets[nCurrentDescriptorSet];
     nCurrentDescriptorSet = (nCurrentDescriptorSet + 1) % descriptorSets.size();
@@ -2337,12 +2337,12 @@ VkDescriptorSet vulkan_update_descriptor( struct VulkanPipeline_t *pPipeline, in
 	{
 		bool compositeLayer = i > 0;
 
-		VkImageView imageView = pPipeline->layerBindings[ i ].tex
-			? pPipeline->layerBindings[ i ].tex->getView(compositeLayer || !firstSrgb)
+		VkImageView imageView = frameInfo->layers[i].tex
+			? frameInfo->layers[i].tex->getView(compositeLayer || !firstSrgb)
 			: VK_NULL_HANDLE;
 
 		VulkanSamplerCacheKey_t samplerKey;
-		samplerKey.bNearest = !pPipeline->layerBindings[i].bFilter;
+		samplerKey.bNearest = !frameInfo->layers[i].linearFilter;
 		samplerKey.bUnnormalized = compositeLayer || !firstNrm;
 
 		VkSampler sampler = vulkan_make_sampler(samplerKey);
@@ -2364,7 +2364,7 @@ VkDescriptorSet vulkan_update_descriptor( struct VulkanPipeline_t *pPipeline, in
 
 	for (uint32_t i = 0; i < k_nMaxLayers; i++)
 	{
-		if ( nYCBCRMask & ( 1u << i ) )
+		if ( frameInfo->ycbcrMask() & ( 1u << i ) )
 		{
 			ycbcrImageDescriptors[i] = imageDescriptors[i];
 			// We use immutable samplers.
@@ -2457,7 +2457,30 @@ std::shared_ptr<CVulkanTexture> vulkan_acquire_screenshot_texture(bool exportabl
 	return nullptr;
 }
 
-bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *pPipeline, std::shared_ptr<CVulkanTexture> pScreenshotTexture )
+struct CompositeData_t
+{
+	vec2_t scale[k_nMaxLayers];
+	vec2_t offset[k_nMaxLayers];
+	float opacity[k_nMaxLayers];
+	uint32_t borderMask;
+	uint32_t frameId;
+};
+
+static CompositeData_t pack_composite_data( const struct FrameInfo_t *frameInfo )
+{
+	CompositeData_t result = {};
+	for (int i = 0; i < frameInfo->layerCount; i++) {
+		const FrameInfo_t::Layer_t *layer = &frameInfo->layers[i];
+		result.scale[i] = layer->scale;
+		result.offset[i] = layer->offset;
+		result.opacity[i] = layer->opacity;
+	}
+	result.borderMask = frameInfo->borderMask();
+	result.frameId = s_frameId++;
+	return result;
+}
+
+bool vulkan_composite( struct FrameInfo_t *frameInfo, std::shared_ptr<CVulkanTexture> pScreenshotTexture )
 {
 	VkImage compositeImage;
 	VkImageView targetImageView;
@@ -2473,17 +2496,6 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 		targetImageView = g_output.outputImage[ g_output.nOutImage ]->m_srgbView;
 	}
 	
-	pComposite->nYCBCRMask = 0;
-	for (uint32_t i = 0; i < k_nMaxLayers; i++)
-	{
-		if ( pPipeline->layerBindings[ i ].tex != 0 )
-		{
-			const auto& pTex = pPipeline->layerBindings[ i ].tex;
-			if (pTex->m_format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM)
-				pComposite->nYCBCRMask |= 1 << i;
-		}
-	}
-	
 	VkCommandBuffer curCommandBuffer = g_output.commandBuffers[ g_output.nCurCmdBuffer ];
 	
 	VkCommandBufferBeginInfo commandBufferBeginInfo = {
@@ -2537,8 +2549,8 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 	vkCmdPipelineBarrier( curCommandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
 			      		0, 0, nullptr, 0, nullptr, 1, &memoryBarrier );
 
-	std::vector<VkImageMemoryBarrier> textureBarriers(pComposite->nLayerCount);
-	for (int32_t i = 0; i < pComposite->nLayerCount; i++)
+	std::vector<VkImageMemoryBarrier> textureBarriers(frameInfo->layerCount);
+	for (int32_t i = 0; i < frameInfo->layerCount; i++)
 	{
 		textureBarriers[i].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 		textureBarriers[i].pNext = nullptr;
@@ -2550,28 +2562,30 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 													? VK_QUEUE_FAMILY_FOREIGN_EXT
 													: VK_QUEUE_FAMILY_EXTERNAL_KHR;
 		textureBarriers[i].dstQueueFamilyIndex = queueFamilyIndex;
-		textureBarriers[i].image = pPipeline->layerBindings[i].tex->m_vkImage;
+		textureBarriers[i].image = frameInfo->layers[i].tex->m_vkImage;
 		textureBarriers[i].subresourceRange = subResRange;
 	}
 
 	vkCmdPipelineBarrier( curCommandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
 			      		0, 0, nullptr, 0, nullptr, textureBarriers.size(), textureBarriers.data() );
 
-	for ( int i = pComposite->useFSRLayer0 ? 1 : 0; i < pComposite->nLayerCount; i++ )
+	for ( int i = frameInfo->useFSRLayer0 ? 1 : 0; i < frameInfo->layerCount; i++ )
 	{
-		bool bForceNearest = pComposite->data.vScale[i].x == 1.0f &&
-							 pComposite->data.vScale[i].y == 1.0f &&
-							 float_is_integer(pComposite->data.vOffset[i].x) &&
-							 float_is_integer(pComposite->data.vOffset[i].y);
+		FrameInfo_t::Layer_t *layer = &frameInfo->layers[i];
 
-		pPipeline->layerBindings[i].bFilter &= !bForceNearest;
+		bool bForceNearest = layer->scale.x == 1.0f &&
+							 layer->scale.y == 1.0f &&
+							 float_is_integer(layer->offset.x) &&
+							 float_is_integer(layer->offset.y);
 
-		pComposite->data.vOffset[ i ].x += 0.5f / pComposite->data.vScale[ i ].x;
-		pComposite->data.vOffset[ i ].y += 0.5f / pComposite->data.vScale[ i ].y;
+		layer->linearFilter &= !bForceNearest;
+
+		layer->offset.x += 0.5f / layer->scale.x;
+		layer->offset.y += 0.5f / layer->scale.y;
 	}
 
 
-	if ( pComposite->useFSRLayer0 )
+	if ( frameInfo->useFSRLayer0 )
 	{
 		struct uvec4_t
 		{
@@ -2605,15 +2619,14 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 			uint32_t u_c1;
 		} rcasConstants;
 
-		struct Composite_t fsrpComposite = *pComposite;
-		struct VulkanPipeline_t fsrLayers = *pPipeline;
-		fsrLayers.layerBindings[0].bFilter = true;
+		struct FrameInfo_t fsrFrameInfo = *frameInfo;
+		fsrFrameInfo.layers[0].linearFilter = true;
 
-		uint32_t inputX = fsrLayers.layerBindings[0].tex->m_width;
-		uint32_t inputY = fsrLayers.layerBindings[0].tex->m_height;
+		uint32_t inputX = fsrFrameInfo.layers[0].tex->m_width;
+		uint32_t inputY = fsrFrameInfo.layers[0].tex->m_height;
 
-		uint32_t tempX = float(inputX) / fsrpComposite.data.vScale[0].x;
-		uint32_t tempY = float(inputY) / fsrpComposite.data.vScale[0].y;
+		uint32_t tempX = fsrFrameInfo.layers[0].integerWidth();
+		uint32_t tempY = fsrFrameInfo.layers[0].integerHeight();
 
 		update_tmp_images(tempX, tempY);
 
@@ -2623,7 +2636,7 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 
 		vkCmdBindPipeline(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, easuPipeline);
 
-		VkDescriptorSet descriptorSet = vulkan_update_descriptor( &fsrLayers, 0, true, true, g_output.tmpOutput->m_srgbView );
+		VkDescriptorSet descriptorSet = vulkan_update_descriptor( &fsrFrameInfo, true, true, g_output.tmpOutput->m_srgbView );
 
 		vkCmdBindDescriptorSets(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, &descriptorSet, 0, 0);
 
@@ -2655,25 +2668,25 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 			      		0, 0, nullptr, 0, nullptr, 1, &memoryBarrier );
 
 
-		vkCmdBindPipeline(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, get_vk_pipeline(pComposite->nLayerCount - 1, pComposite->nYCBCRMask, 0, SHADER_TYPE_RCAS));
-		fsrLayers.layerBindings[0].tex = g_output.tmpOutput;
-		descriptorSet = vulkan_update_descriptor( &fsrLayers, 0, true, true, targetImageView );
+		vkCmdBindPipeline(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, get_vk_pipeline(frameInfo->layerCount - 1, frameInfo->ycbcrMask(), 0, SHADER_TYPE_RCAS));
+		fsrFrameInfo.layers[0].tex = g_output.tmpOutput;
+		descriptorSet = vulkan_update_descriptor( &fsrFrameInfo, true, true, targetImageView );
 
 		vkCmdBindDescriptorSets(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, &descriptorSet, 0, 0);
 
 		uvec4_t tmp;
 		FsrRcasCon(&tmp.x, g_fsrSharpness / 10.0f);
-		rcasConstants.u_layer0Offset.x = uint32_t(int32_t(fsrpComposite.data.vOffset[0].x));
-		rcasConstants.u_layer0Offset.y = uint32_t(int32_t(fsrpComposite.data.vOffset[0].y));
-		rcasConstants.u_opacity[0] = fsrpComposite.data.flOpacity[0];
-		rcasConstants.u_borderMask = fsrpComposite.data.nBorderMask >> 1u;
+		rcasConstants.u_layer0Offset.x = uint32_t(int32_t(fsrFrameInfo.layers[0].offset.x));
+		rcasConstants.u_layer0Offset.y = uint32_t(int32_t(fsrFrameInfo.layers[0].offset.y));
+		rcasConstants.u_opacity[0] = fsrFrameInfo.layers[0].opacity;
+		rcasConstants.u_borderMask = fsrFrameInfo.borderMask() >> 1u;
 		rcasConstants.u_frameId = s_frameId++;
 		rcasConstants.u_c1 = tmp.x;
 		for (uint32_t i = 1; i < k_nMaxLayers; i++)
 		{
-			rcasConstants.u_scale[i - 1] = fsrpComposite.data.vScale[i];
-			rcasConstants.u_offset[i - 1] = fsrpComposite.data.vOffset[i];
-			rcasConstants.u_opacity[i] = fsrpComposite.data.flOpacity[i];
+			rcasConstants.u_scale[i - 1] = fsrFrameInfo.layers[i].scale;
+			rcasConstants.u_offset[i - 1] = fsrFrameInfo.layers[i].offset;
+			rcasConstants.u_opacity[i] = fsrFrameInfo.layers[i].opacity;
 		}
 
 
@@ -2684,11 +2697,10 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 
 		vkCmdDispatch( curCommandBuffer, dispatchX, dispatchY, 1 );
 	}
-	else if ( pComposite->blurLayer0 )
+	else if ( frameInfo->blurLayer0 )
 	{
-		struct Composite_t blurComposite = *pComposite;
-		struct VulkanPipeline_t blurLayers = *pPipeline;
-		blurLayers.layerBindings[0].bFilter = true;
+		struct FrameInfo_t blurFrameInfo = *frameInfo;
+		blurFrameInfo.layers[0].linearFilter = true;
 
 		update_tmp_images(currentOutputWidth, currentOutputHeight);
 
@@ -2700,17 +2712,19 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 
 		uint32_t blur_layer_count = 0;
 		// Also blur the override on top if we have one.
-		if (blurComposite.nLayerCount >= 2 && blurLayers.layerBindings[1].zpos == g_zposOverride)
+		if (blurFrameInfo.layerCount >= 2 && blurFrameInfo.layers[1].zpos == g_zposOverride)
 			blur_layer_count++;
 
-		vkCmdBindPipeline(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, get_vk_pipeline(blur_layer_count, blurComposite.nYCBCRMask & 0x1u, blurComposite.blurRadius, type));
+		vkCmdBindPipeline(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, get_vk_pipeline(blur_layer_count, blurFrameInfo.ycbcrMask() & 0x1u, blurFrameInfo.blurRadius, type));
 
-		VkDescriptorSet descriptorSet = vulkan_update_descriptor( &blurLayers, pComposite->nYCBCRMask, false, false, g_output.tmpOutput->m_srgbView );
+		VkDescriptorSet descriptorSet = vulkan_update_descriptor( &blurFrameInfo, false, false, g_output.tmpOutput->m_srgbView );
 
 		vkCmdBindDescriptorSets(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE,
 								pipelineLayout, 0, 1, &descriptorSet, 0, 0);
 
-		vkCmdPushConstants(curCommandBuffer, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(blurComposite.data), &blurComposite.data);
+		CompositeData_t data = pack_composite_data(frameInfo);
+
+		vkCmdPushConstants(curCommandBuffer, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(data), &data);
 
 		uint32_t nGroupCountX = currentOutputWidth % 8 ? currentOutputWidth / 8 + 1: currentOutputWidth / 8;
 		uint32_t nGroupCountY = currentOutputHeight % 8 ? currentOutputHeight / 8 + 1: currentOutputHeight / 8;
@@ -2733,19 +2747,15 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 		vkCmdPipelineBarrier( curCommandBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
 			      		0, 0, nullptr, 0, nullptr, 1, &memoryBarrier );
 
-		descriptorSet = vulkan_update_descriptor( &blurLayers, blurComposite.nYCBCRMask, false, false, targetImageView, g_output.tmpOutput->m_linearView );
+		descriptorSet = vulkan_update_descriptor( &blurFrameInfo, false, false, targetImageView, g_output.tmpOutput->m_linearView );
 
 		vkCmdBindDescriptorSets(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, &descriptorSet, 0, 0);
 
-		type = pComposite->blurLayer0 == BLUR_MODE_COND ? SHADER_TYPE_BLUR_COND : SHADER_TYPE_BLUR;
+		type = blurFrameInfo.blurLayer0 == BLUR_MODE_COND ? SHADER_TYPE_BLUR_COND : SHADER_TYPE_BLUR;
 
-		vkCmdBindPipeline(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, get_vk_pipeline(blurComposite.nLayerCount - 1, blurComposite.nYCBCRMask, blurComposite.blurRadius, type, blur_layer_count));
+		vkCmdBindPipeline(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, get_vk_pipeline(blurFrameInfo.layerCount - 1, blurFrameInfo.ycbcrMask(), blurFrameInfo.blurRadius, type, blur_layer_count));
 
-		vkCmdPushConstants(curCommandBuffer, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(blurComposite.data), &blurComposite.data);
-		if (g_bIsCompositeDebug) {
-			vkCmdPushConstants(curCommandBuffer, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, sizeof(blurComposite.data), sizeof(uint32_t), &s_frameId);
-			s_frameId++;
-		}
+		vkCmdPushConstants(curCommandBuffer, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(data), &data);
 
 		nGroupCountX = currentOutputWidth % 8 ? currentOutputWidth / 8 + 1: currentOutputWidth / 8;
 		nGroupCountY = currentOutputHeight % 8 ? currentOutputHeight / 8 + 1: currentOutputHeight / 8;
@@ -2755,18 +2765,16 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 	else
 	{
 
-		vkCmdBindPipeline(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, get_vk_pipeline(pComposite->nLayerCount - 1, pComposite->nYCBCRMask, 0, SHADER_TYPE_BLIT));
+		vkCmdBindPipeline(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, get_vk_pipeline(frameInfo->layerCount - 1, frameInfo->ycbcrMask(), 0, SHADER_TYPE_BLIT));
 
-		VkDescriptorSet descriptorSet = vulkan_update_descriptor( pPipeline, pComposite->nYCBCRMask, false, false, targetImageView );
+		VkDescriptorSet descriptorSet = vulkan_update_descriptor( frameInfo, false, false, targetImageView );
 
 		vkCmdBindDescriptorSets(curCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE,
 								pipelineLayout, 0, 1, &descriptorSet, 0, 0);
 
-		vkCmdPushConstants(curCommandBuffer, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pComposite->data), &pComposite->data);
-		if (g_bIsCompositeDebug) {
-			vkCmdPushConstants(curCommandBuffer, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, sizeof(pComposite->data), sizeof(uint32_t), &s_frameId);
-			s_frameId++;
-		}
+		CompositeData_t data = pack_composite_data(frameInfo);
+
+		vkCmdPushConstants(curCommandBuffer, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(data), &data);
 
 		uint32_t nGroupCountX = currentOutputWidth % 8 ? currentOutputWidth / 8 + 1: currentOutputWidth / 8;
 		uint32_t nGroupCountY = currentOutputHeight % 8 ? currentOutputHeight / 8 + 1: currentOutputHeight / 8;
@@ -2862,7 +2870,7 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 			      useForeignQueue ? 0 : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
 			      0, 0, nullptr, 0, nullptr, 1, &memoryBarrier );
 
-	for (int32_t i = 0; i < pComposite->nLayerCount; i++)
+	for (int32_t i = 0; i < frameInfo->layerCount; i++)
 	{
 		textureBarriers[i].dstAccessMask = 0;
 		textureBarriers[i].oldLayout = VK_IMAGE_LAYOUT_GENERAL;
@@ -2913,9 +2921,9 @@ bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *
 	return true;
 }
 
-uint32_t vulkan_get_last_composite_fbid( void )
+std::shared_ptr<CVulkanTexture> vulkan_get_last_output_image( void )
 {
-	return g_output.outputImage[ !g_output.nOutImage ]->m_FBID;
+	return g_output.outputImage[ !g_output.nOutImage ];
 }
 
 uint32_t vulkan_texture_get_fbid( const std::shared_ptr<CVulkanTexture>& vulkanTex )
diff --git a/src/rendervulkan.hpp b/src/rendervulkan.hpp
index 21058d4..acc8b89 100644
--- a/src/rendervulkan.hpp
+++ b/src/rendervulkan.hpp
@@ -34,50 +34,6 @@ enum BlurMode {
     BLUR_MODE_ALWAYS = 2,
 };
 
-class CVulkanTexture;
-
-// These two structs are horrible
-struct VulkanPipeline_t
-{
-	struct LayerBinding_t
-	{
-		int surfaceWidth;
-		int surfaceHeight;
-
-		int imageWidth;
-		int imageHeight;
-		
-		std::shared_ptr<CVulkanTexture> tex;
-		uint32_t fbid;
-		
-		int zpos;
-
-		bool bFilter;
-	} layerBindings[ k_nMaxLayers ];
-};
-
-struct vec2_t
-{
-	float x, y;
-};
-
-struct Composite_t
-{
-	int nLayerCount;
-	int nYCBCRMask;
-	bool useFSRLayer0;
-	BlurMode blurLayer0;
-	int blurRadius;
-
-	struct CompositeData_t
-	{
-		vec2_t vScale[k_nMaxLayers];
-		vec2_t vOffset[k_nMaxLayers];
-		float flOpacity[k_nMaxLayers];
-		uint32_t nBorderMask;
-	} data;
-
-};
 
 #include "drm.hpp"
 
@@ -169,6 +125,66 @@ public:
 	bool m_bTransitioned = false;
 };
 
+struct vec2_t
+{
+	float x, y;
+};
+
+struct FrameInfo_t
+{
+	bool useFSRLayer0;
+	BlurMode blurLayer0;
+	int blurRadius;
+
+
+	int layerCount;
+	struct Layer_t
+	{
+		std::shared_ptr<CVulkanTexture> tex;
+		uint32_t fbid; // TODO pretty sure we can just move this into tex
+
+		// Cursor has a bigger surface than the actual image
+		// TODO maybe move into tex?
+		int imageWidth;
+		int imageHeight;
+
+		int zpos;
+
+		vec2_t offset;
+		vec2_t scale;
+
+		float opacity;
+
+		bool blackBorder;
+		bool linearFilter;
+
+		uint32_t integerWidth() const { return tex->m_width / scale.x; }
+		uint32_t integerHeight() const { return tex->m_height / scale.y; }
+	} layers[ k_nMaxLayers ];
+
+	uint32_t borderMask() const {
+		uint32_t result = 0;
+		for (int i = 0; i < layerCount; i++)
+		{
+			if (layers[ i ].blackBorder)
+				result |= 1 << i;
+		}
+		return result;
+	}
+	uint32_t ycbcrMask() const {
+		uint32_t result = 0;
+		for (int i = 0; i < layerCount; i++)
+		{
+			if ( layers[ i ].tex )
+			{
+				if (layers[ i ].tex->m_format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM)
+					result |= 1 << i;
+			}
+		}
+		return result;
+	}
+};
+
 extern bool g_vulkanSupportsModifiers;
 
 extern bool g_vulkanHasDrmPrimaryDevId;
@@ -187,8 +203,8 @@ std::shared_ptr<CVulkanTexture> vulkan_create_texture_from_wlr_buffer( struct wl
 uint32_t vulkan_texture_get_fbid( const std::shared_ptr<CVulkanTexture>& vulkanTex );
 int vulkan_texture_get_fence( const std::shared_ptr<CVulkanTexture>& vulkanTex );
 
-bool vulkan_composite( struct Composite_t *pComposite, struct VulkanPipeline_t *pPipeline, std::shared_ptr<CVulkanTexture> pScreenshotTexture );
-uint32_t vulkan_get_last_composite_fbid( void );
+bool vulkan_composite( struct FrameInfo_t *frameInfo, std::shared_ptr<CVulkanTexture> pScreenshotTexture );
+std::shared_ptr<CVulkanTexture> vulkan_get_last_output_image( void );
 std::shared_ptr<CVulkanTexture> vulkan_acquire_screenshot_texture(bool exportable);
 
 void vulkan_present_to_window( void );
diff --git a/src/steamcompmgr.cpp b/src/steamcompmgr.cpp
index a7988c4..9605072 100644
--- a/src/steamcompmgr.cpp
+++ b/src/steamcompmgr.cpp
@@ -1188,8 +1188,7 @@ bool MouseCursor::getTexture()
 	return true;
 }
 
-void MouseCursor::paint(win *window, win *fit, struct Composite_t *pComposite,
-						struct VulkanPipeline_t *pPipeline)
+void MouseCursor::paint(win *window, win *fit, struct FrameInfo_t *frameInfo)
 {
 	if (m_hideForMovement || m_imageEmpty) {
 		return;
@@ -1247,31 +1246,28 @@ void MouseCursor::paint(win *window, win *fit, struct Composite_t *pComposite,
 	scaledX = scaledX - m_hotspotX;
 	scaledY = scaledY - m_hotspotY;
 
-	int curLayer = pComposite->nLayerCount;
+	int curLayer = frameInfo->layerCount++;
 
-	pComposite->data.flOpacity[ curLayer ] = 1.0;
+	FrameInfo_t::Layer_t *layer = &frameInfo->layers[ curLayer ];
 
-	pComposite->data.vScale[ curLayer ].x = 1.0;
-	pComposite->data.vScale[ curLayer ].y = 1.0;
+	layer->opacity = 1.0;
 
-	pComposite->data.vOffset[ curLayer ].x = -scaledX;
-	pComposite->data.vOffset[ curLayer ].y = -scaledY;
+	layer->scale.x = 1.0;
+	layer->scale.y = 1.0;
 
-	pPipeline->layerBindings[ curLayer ].surfaceWidth = m_surfaceWidth;
-	pPipeline->layerBindings[ curLayer ].surfaceHeight = m_surfaceHeight;
+	layer->offset.x = -scaledX;
+	layer->offset.y = -scaledY;
 
-	pPipeline->layerBindings[ curLayer ].imageWidth = m_imageWidth;
-	pPipeline->layerBindings[ curLayer ].imageHeight = m_imageHeight;
+	layer->imageWidth = m_imageWidth;
+	layer->imageHeight = m_imageHeight;
 
-	pPipeline->layerBindings[ curLayer ].zpos = g_zposCursor; // cursor, on top of both bottom layers
+	layer->zpos = g_zposCursor; // cursor, on top of both bottom layers
 
-	pPipeline->layerBindings[ curLayer ].tex = m_texture;
-	pPipeline->layerBindings[ curLayer ].fbid = BIsNested() ? 0 :
-															  vulkan_texture_get_fbid(m_texture);
+	layer->tex = m_texture;
+	layer->fbid = BIsNested() ? 0 : vulkan_texture_get_fbid(m_texture);
 
-	pPipeline->layerBindings[ curLayer ].bFilter = false;
-
-	pComposite->nLayerCount += 1;
+	layer->linearFilter = false;
+	layer->blackBorder = false;
 }
 
 struct BaseLayerInfo_t
@@ -1284,23 +1280,23 @@ struct BaseLayerInfo_t
 std::array< BaseLayerInfo_t, HELD_COMMIT_COUNT > g_CachedPlanes = {};
 
 static void
-paint_cached_base_layer(const std::shared_ptr<commit_t>& commit, const BaseLayerInfo_t& base, struct Composite_t *pComposite, struct VulkanPipeline_t *pPipeline, float flOpacityScale)
+paint_cached_base_layer(const std::shared_ptr<commit_t>& commit, const BaseLayerInfo_t& base, struct FrameInfo_t *frameInfo, float flOpacityScale)
 {
-	int curLayer = pComposite->nLayerCount;
+	int curLayer = frameInfo->layerCount++;
 
-	pComposite->data.vScale[ curLayer ].x = base.scale[0];
-	pComposite->data.vScale[ curLayer ].y = base.scale[1];
-	pComposite->data.vOffset[ curLayer ].x = base.offset[0];
-	pComposite->data.vOffset[ curLayer ].y = base.offset[1];
-	pComposite->data.flOpacity[ curLayer ] = base.opacity * flOpacityScale;
+	FrameInfo_t::Layer_t *layer = &frameInfo->layers[ curLayer ];
 
-	pPipeline->layerBindings[ curLayer ].tex = commit->vulkanTex;
-	pPipeline->layerBindings[ curLayer ].fbid = commit->fb_id;
-	pPipeline->layerBindings[ curLayer ].bFilter = true;
+	layer->scale.x = base.scale[0];
+	layer->scale.y = base.scale[1];
+	layer->offset.x = base.offset[0];
+	layer->offset.y = base.offset[1];
+	layer->opacity = base.opacity * flOpacityScale;
 
-	pComposite->data.nBorderMask |= (1u << curLayer);
+	layer->tex = commit->vulkanTex;
+	layer->fbid = commit->fb_id;
 
-	pComposite->nLayerCount++;
+	layer->linearFilter = true;
+	layer->blackBorder = true;
 }
 
 namespace PaintWindowFlag
@@ -1314,8 +1310,8 @@ namespace PaintWindowFlag
 using PaintWindowFlags = uint32_t;
 
 static void
-paint_window(win *w, win *scaleW, struct Composite_t *pComposite,
-			  struct VulkanPipeline_t *pPipeline, MouseCursor *cursor, PaintWindowFlags flags = 0, float flOpacityScale = 1.0f, win *fit = nullptr )
+paint_window(win *w, win *scaleW, struct FrameInfo_t *frameInfo,
+			  MouseCursor *cursor, PaintWindowFlags flags = 0, float flOpacityScale = 1.0f, win *fit = nullptr )
 {
 	uint32_t sourceWidth, sourceHeight;
 	int drawXOffset = 0, drawYOffset = 0;
@@ -1332,7 +1328,7 @@ paint_window(win *w, win *scaleW, struct Composite_t *pComposite,
 			// pick up that buffer we've been holding onto if we have one.
 			if ( g_HeldCommits[ HELD_COMMIT_BASE ] )
 			{
-				paint_cached_base_layer( g_HeldCommits[ HELD_COMMIT_BASE ], g_CachedPlanes[ HELD_COMMIT_BASE ], pComposite, pPipeline, flOpacityScale );
+				paint_cached_base_layer( g_HeldCommits[ HELD_COMMIT_BASE ], g_CachedPlanes[ HELD_COMMIT_BASE ], frameInfo, flOpacityScale );
 				return;
 			}
 		}
@@ -1422,17 +1418,19 @@ paint_window(win *w, win *scaleW, struct Composite_t *pComposite,
 		}
 	}
 
-	int curLayer = pComposite->nLayerCount;
+	int curLayer = frameInfo->layerCount++;
 
-	pComposite->data.flOpacity[ curLayer ] = ( (w->isOverlay || w->isExternalOverlay) ? w->opacity / (float)OPAQUE : 1.0f ) * flOpacityScale;
+	FrameInfo_t::Layer_t *layer = &frameInfo->layers[ curLayer ];
 
-	pComposite->data.vScale[ curLayer ].x = 1.0 / currentScaleRatio;
-	pComposite->data.vScale[ curLayer ].y = 1.0 / currentScaleRatio;
+	layer->opacity = ( (w->isOverlay || w->isExternalOverlay) ? w->opacity / (float)OPAQUE : 1.0f ) * flOpacityScale;
+
+	layer->scale.x = 1.0 / currentScaleRatio;
+	layer->scale.y = 1.0 / currentScaleRatio;
 
 	if ( w != scaleW )
 	{
-		pComposite->data.vOffset[ curLayer ].x = -drawXOffset;
-		pComposite->data.vOffset[ curLayer ].y = -drawYOffset;
+		layer->offset.x = -drawXOffset;
+		layer->offset.y = -drawYOffset;
 	}
 	else if (notificationMode)
 	{
@@ -1447,60 +1445,54 @@ paint_window(win *w, win *scaleW, struct Composite_t *pComposite,
 			yOffset = (currentOutputHeight - currentOutputHeight * globalScaleRatio) / 2.0;
 		}
 
-		pComposite->data.vOffset[ curLayer ].x = (currentOutputWidth - xOffset - width) * -1.0f;
-		pComposite->data.vOffset[ curLayer ].y = (currentOutputHeight - yOffset - height) * -1.0f;
+		layer->offset.x = (currentOutputWidth - xOffset - width) * -1.0f;
+		layer->offset.y = (currentOutputHeight - yOffset - height) * -1.0f;
 	}
 	else
 	{
-		pComposite->data.vOffset[ curLayer ].x = -drawXOffset;
-		pComposite->data.vOffset[ curLayer ].y = -drawYOffset;
+		layer->offset.x = -drawXOffset;
+		layer->offset.y = -drawYOffset;
 	}
 
-	if ( flags & PaintWindowFlag::DrawBorders )
-		pComposite->data.nBorderMask |= (1u << curLayer);
+	layer->blackBorder = flags & PaintWindowFlag::DrawBorders;
 
-	pPipeline->layerBindings[ curLayer ].surfaceWidth = w->a.width;
-	pPipeline->layerBindings[ curLayer ].surfaceHeight = w->a.height;
+	layer->imageWidth = w->a.width;
+	layer->imageHeight = w->a.height;
 
-	pPipeline->layerBindings[ curLayer ].imageWidth = w->a.width;
-	pPipeline->layerBindings[ curLayer ].imageHeight = w->a.height;
-
-	pPipeline->layerBindings[ curLayer ].zpos = g_zposBase;
+	layer->zpos = g_zposBase;
 
 	if ( w != scaleW )
 	{
-		pPipeline->layerBindings[ curLayer ].zpos = g_zposOverride;
+		layer->zpos = g_zposOverride;
 	}
 
 	if ( w->isOverlay || w->isSteamStreamingClient )
 	{
-		pPipeline->layerBindings[ curLayer ].zpos = g_zposOverlay;
+		layer->zpos = g_zposOverlay;
 	}
 	if ( w->isExternalOverlay )
 	{
-		pPipeline->layerBindings[ curLayer ].zpos = g_zposExternalOverlay;
+		layer->zpos = g_zposExternalOverlay;
 	}
 
-	pPipeline->layerBindings[ curLayer ].tex = lastCommit->vulkanTex;
-	pPipeline->layerBindings[ curLayer ].fbid = lastCommit->fb_id;
+	layer->tex = lastCommit->vulkanTex;
+	layer->fbid = lastCommit->fb_id;
 
-	pPipeline->layerBindings[ curLayer ].bFilter = (w->isOverlay || w->isExternalOverlay) ? true : g_bFilterGameWindow;
+	layer->linearFilter = (w->isOverlay || w->isExternalOverlay) ? true : g_bFilterGameWindow;
 
 	if ( flags & PaintWindowFlag::BasePlane )
 	{
 		BaseLayerInfo_t basePlane = {};
-		basePlane.scale[0] = pComposite->data.vScale[ curLayer ].x;
-		basePlane.scale[1] = pComposite->data.vScale[ curLayer ].y;
-		basePlane.offset[0] = pComposite->data.vOffset[ curLayer ].x;
-		basePlane.offset[1] = pComposite->data.vOffset[ curLayer ].y;
-		basePlane.opacity = pComposite->data.flOpacity[ curLayer ];
+		basePlane.scale[0] = layer->scale.x;
+		basePlane.scale[1] = layer->scale.y;
+		basePlane.offset[0] = layer->offset.x;
+		basePlane.offset[1] = layer->offset.y;
+		basePlane.opacity = layer->opacity;
 
 		g_CachedPlanes[ HELD_COMMIT_BASE ] = basePlane;
 		if ( !(flags & PaintWindowFlag::FadeTarget) )
 			g_CachedPlanes[ HELD_COMMIT_FADE ] = basePlane;
 	}
-
-	pComposite->nLayerCount += 1;
 }
 
 bool g_bFirstFrame = true;
@@ -1510,15 +1502,15 @@ static bool is_fading_out()
 	return fadeOutStartTime || g_bPendingFade;
 }
 
-static void update_touch_scaling( struct Composite_t *pComposite )
+static void update_touch_scaling( const struct FrameInfo_t *frameInfo )
 {
-	if ( !pComposite->nLayerCount )
+	if ( !frameInfo->layerCount )
 		return;
 
-	focusedWindowScaleX = pComposite->data.vScale[ pComposite->nLayerCount - 1 ].x;
-	focusedWindowScaleY = pComposite->data.vScale[ pComposite->nLayerCount - 1 ].y;
-	focusedWindowOffsetX = pComposite->data.vOffset[ pComposite->nLayerCount - 1 ].x;
-	focusedWindowOffsetY = pComposite->data.vOffset[ pComposite->nLayerCount - 1 ].y;
+	focusedWindowScaleX = frameInfo->layers[ frameInfo->layerCount - 1 ].scale.x;
+	focusedWindowScaleY = frameInfo->layers[ frameInfo->layerCount - 1 ].scale.y;
+	focusedWindowOffsetX = frameInfo->layers[ frameInfo->layerCount - 1 ].offset.x;
+	focusedWindowOffsetY = frameInfo->layers[ frameInfo->layerCount - 1 ].offset.y;
 }
 
 static void
@@ -1566,8 +1558,7 @@ paint_all()
 		}
 	}
 
-	struct Composite_t composite = {};
-	struct VulkanPipeline_t pipeline = {};
+	struct FrameInfo_t frameInfo = {};
 
 	// If the window we'd paint as the base layer is the streaming client,
 	// find the video underlay and put it up first in the scenegraph
@@ -1586,25 +1577,25 @@ paint_all()
 					if ( videow->isSteamStreamingClientVideo == true )
 					{
 						// TODO: also check matching AppID so we can have several pairs
-						paint_window(videow, videow, &composite, &pipeline, global_focus.cursor, PaintWindowFlag::BasePlane | PaintWindowFlag::DrawBorders);
+						paint_window(videow, videow, &frameInfo, global_focus.cursor, PaintWindowFlag::BasePlane | PaintWindowFlag::DrawBorders);
 						bHasVideoUnderlay = true;
 						break;
 					}
 				}
 			}
 			
-			int nOldLayerCount = composite.nLayerCount;
+			int nOldLayerCount = frameInfo.layerCount;
 
 			uint32_t flags = 0;
 			if ( !bHasVideoUnderlay )
 				flags |= PaintWindowFlag::BasePlane;
-			paint_window(w, w, &composite, &pipeline, global_focus.cursor, flags);
-			update_touch_scaling( &composite );
+			paint_window(w, w, &frameInfo, global_focus.cursor, flags);
+			update_touch_scaling( &frameInfo );
 			
 			// paint UI unless it's fully hidden, which it communicates to us through opacity=0
 			// we paint it to extract scaling coefficients above, then remove the layer if one was added
-			if ( w->opacity == TRANSLUCENT && bHasVideoUnderlay && nOldLayerCount < composite.nLayerCount )
-				composite.nLayerCount--;
+			if ( w->opacity == TRANSLUCENT && bHasVideoUnderlay && nOldLayerCount < frameInfo.layerCount )
+				frameInfo.layerCount--;
 		}
 		else
 		{
@@ -1614,8 +1605,8 @@ paint_all()
 					? 0.0f
 					: ((currentTime - fadeOutStartTime) / (float)g_FadeOutDuration);
 		
-				paint_cached_base_layer(g_HeldCommits[HELD_COMMIT_FADE], g_CachedPlanes[HELD_COMMIT_FADE], &composite, &pipeline, 1.0f - opacityScale);
-				paint_window(w, w, &composite, &pipeline, global_focus.cursor, PaintWindowFlag::BasePlane | PaintWindowFlag::FadeTarget | PaintWindowFlag::DrawBorders, opacityScale, override);
+				paint_cached_base_layer(g_HeldCommits[HELD_COMMIT_FADE], g_CachedPlanes[HELD_COMMIT_FADE], &frameInfo, 1.0f - opacityScale);
+				paint_window(w, w, &frameInfo, global_focus.cursor, PaintWindowFlag::BasePlane | PaintWindowFlag::FadeTarget | PaintWindowFlag::DrawBorders, opacityScale, override);
 			}
 			else
 			{
@@ -1629,17 +1620,17 @@ paint_all()
 					}
 				}
 				// Just draw focused window as normal, be it Steam or the game
-				paint_window(w, w, &composite, &pipeline, global_focus.cursor, PaintWindowFlag::BasePlane | PaintWindowFlag::DrawBorders, 1.0f, override);
+				paint_window(w, w, &frameInfo, global_focus.cursor, PaintWindowFlag::BasePlane | PaintWindowFlag::DrawBorders, 1.0f, override);
 
-				composite.useFSRLayer0 = g_fsrUpscale && composite.data.vScale[0].x < 1.0f && composite.data.vScale[0].y < 1.0f;
+				frameInfo.useFSRLayer0 = g_fsrUpscale && frameInfo.layers[0].scale.x < 1.0f && frameInfo.layers[0].scale.y < 1.0f;
 			}
-			update_touch_scaling( &composite );
+			update_touch_scaling( &frameInfo );
 		}
 	}
 	else
 	{
 		if ( g_HeldCommits[HELD_COMMIT_BASE] )
-			paint_cached_base_layer(g_HeldCommits[HELD_COMMIT_BASE], g_CachedPlanes[HELD_COMMIT_BASE], &composite, &pipeline, 1.0f);
+			paint_cached_base_layer(g_HeldCommits[HELD_COMMIT_BASE], g_CachedPlanes[HELD_COMMIT_BASE], &frameInfo, 1.0f);
 	}
 
 	// TODO: We want to paint this at the same scale as the normal window and probably
@@ -1648,23 +1639,23 @@ paint_all()
 	// as we will have too many layers. Better to be safe than sorry.
 	if ( override && w && !w->isSteamStreamingClient )
 	{
-		paint_window(override, w, &composite, &pipeline, global_focus.cursor, 0, 1.0f, override);
-		// Don't update touch scaling for composite. We don't ever make it our
+		paint_window(override, w, &frameInfo, global_focus.cursor, 0, 1.0f, override);
+		// Don't update touch scaling for frameInfo. We don't ever make it our
 		// wlserver_mousefocus window.
-		//update_touch_scaling( &composite );
+		//update_touch_scaling( &frameInfo );
 	}
 
 	// If we have any layers that aren't a cursor or overlay, then we have valid contents for presentation.
-	const bool bValidContents = composite.nLayerCount > 0;
+	const bool bValidContents = frameInfo.layerCount > 0;
 
   	if (externalOverlay)
 	{
 		if (externalOverlay->opacity)
 		{
-			paint_window(externalOverlay, externalOverlay, &composite, &pipeline, global_focus.cursor, PaintWindowFlag::NoScale);
+			paint_window(externalOverlay, externalOverlay, &frameInfo, global_focus.cursor, PaintWindowFlag::NoScale);
 
 			if ( externalOverlay == global_focus.inputFocusWindow )
-				update_touch_scaling( &composite );
+				update_touch_scaling( &frameInfo );
 		}
 	}
 
@@ -1672,10 +1663,10 @@ paint_all()
 	{
 		if (overlay->opacity)
 		{
-			paint_window(overlay, overlay, &composite, &pipeline, global_focus.cursor, PaintWindowFlag::DrawBorders);
+			paint_window(overlay, overlay, &frameInfo, global_focus.cursor, PaintWindowFlag::DrawBorders);
 
 			if ( overlay == global_focus.inputFocusWindow )
-				update_touch_scaling( &composite );
+				update_touch_scaling( &frameInfo );
 		}
 	}
 
@@ -1683,7 +1674,7 @@ paint_all()
 	{
 		if (notification->opacity)
 		{
-			paint_window(notification, notification, &composite, &pipeline, global_focus.cursor, PaintWindowFlag::NotificationMode);
+			paint_window(notification, notification, &frameInfo, global_focus.cursor, PaintWindowFlag::NotificationMode);
 		}
 	}
 
@@ -1691,11 +1682,11 @@ paint_all()
 
 	// Draw cursor if we need to
 	if (input) {
-		int nLayerCountBefore = composite.nLayerCount;
+		int nLayerCountBefore = frameInfo.layerCount;
 		global_focus.cursor->paint(
 			input, w == input ? override : nullptr,
-			&composite, &pipeline);
-		int nLayerCountAfter = composite.nLayerCount;
+			&frameInfo);
+		int nLayerCountAfter = frameInfo.layerCount;
 		bDrewCursor = nLayerCountAfter > nLayerCountBefore;
 	}
 
@@ -1708,10 +1699,10 @@ paint_all()
 	bool blurFading = blurFadeTime < g_BlurFadeDuration;
 	BlurMode currentBlurMode = blurFading ? std::max(g_BlurMode, g_BlurModeOld) : g_BlurMode;
 
-	if (currentBlurMode && !(composite.nLayerCount <= 1 && currentBlurMode == BLUR_MODE_COND))
+	if (currentBlurMode && !(frameInfo.layerCount <= 1 && currentBlurMode == BLUR_MODE_COND))
 	{
-		composite.blurLayer0 = currentBlurMode;
-		composite.blurRadius = g_BlurRadius;
+		frameInfo.blurLayer0 = currentBlurMode;
+		frameInfo.blurRadius = g_BlurRadius;
 
 		if (blurFading)
 		{
@@ -1721,13 +1712,13 @@ paint_all()
 			if (!fadingIn)
 				ratio = 1.0 - ratio;
 
-			composite.blurRadius = ratio * g_BlurRadius;
+			frameInfo.blurRadius = ratio * g_BlurRadius;
 		}
 
-		composite.useFSRLayer0 = false;
+		frameInfo.useFSRLayer0 = false;
 	}
 
-	g_bFSRActive = composite.useFSRLayer0;
+	g_bFSRActive = frameInfo.useFSRLayer0;
 
 	bool bWasFirstFrame = g_bFirstFrame;
 	g_bFirstFrame = false;
@@ -1758,20 +1749,20 @@ paint_all()
 	if ( !BIsNested() && g_nOutputRefresh != nTargetRefresh && g_uDynamicRefreshEqualityTime + g_uDynamicRefreshDelay < now )
 		drm_set_refresh( &g_DRM, nTargetRefresh );
 
-	bool bNeedsNearest = !g_bFilterGameWindow && composite.data.vScale[0].x != 1.0f && composite.data.vScale[0].y != 1.0f;
+	bool bNeedsNearest = !g_bFilterGameWindow && frameInfo.layers[0].scale.x != 1.0f && frameInfo.layers[0].scale.y != 1.0f;
 
 	bool bNeedsComposite = BIsNested();
 	bNeedsComposite |= alwaysComposite;
 	bNeedsComposite |= bCapture;
 	bNeedsComposite |= bWasFirstFrame;
-	bNeedsComposite |= composite.useFSRLayer0;
-	bNeedsComposite |= composite.blurLayer0;
+	bNeedsComposite |= frameInfo.useFSRLayer0;
+	bNeedsComposite |= frameInfo.blurLayer0;
 	bNeedsComposite |= bNeedsNearest;
 	bNeedsComposite |= bDrewCursor;
 
 	if ( !bNeedsComposite )
 	{
-		int ret = drm_prepare( &g_DRM, &composite, &pipeline );
+		int ret = drm_prepare( &g_DRM, &frameInfo );
 		if ( ret == 0 )
 			bDoComposite = false;
 		else if ( ret == -EACCES )
@@ -1792,7 +1783,7 @@ paint_all()
 			pCaptureTexture = vulkan_acquire_screenshot_texture(false);
 		}
 
-		bool bResult = vulkan_composite( &composite, &pipeline, pCaptureTexture );
+		bool bResult = vulkan_composite( &frameInfo, pCaptureTexture );
 
 		if ( bResult != true )
 		{
@@ -1809,23 +1800,23 @@ paint_all()
 		}
 		else
 		{
-			composite = {};
-			composite.nLayerCount = 1;
-			composite.data.vScale[ 0 ].x = 1.0;
-			composite.data.vScale[ 0 ].y = 1.0;
-			composite.data.flOpacity[ 0 ] = 1.0;
+			frameInfo = {};
 
-			pipeline = {};
-			pipeline.layerBindings[ 0 ].surfaceWidth = g_nOutputWidth;
-			pipeline.layerBindings[ 0 ].surfaceHeight = g_nOutputHeight;
+			frameInfo.layerCount = 1;
+			FrameInfo_t::Layer_t *layer = &frameInfo.layers[ 0 ];
+			layer->scale.x = 1.0;
+			layer->scale.y = 1.0;
+			layer->opacity = 1.0;
 
-			pipeline.layerBindings[ 0 ].imageWidth = g_nOutputWidth;
-			pipeline.layerBindings[ 0 ].imageHeight = g_nOutputHeight;
+			layer->imageWidth = g_nOutputWidth;
+			layer->imageHeight = g_nOutputHeight;
 
-			pipeline.layerBindings[ 0 ].fbid = vulkan_get_last_composite_fbid();
-			pipeline.layerBindings[ 0 ].bFilter = false;
+			layer->tex = vulkan_get_last_output_image();
+			layer->fbid = layer->tex->m_FBID;
 
-			int ret = drm_prepare( &g_DRM, &composite, &pipeline );
+			layer->linearFilter = false;
+
+			int ret = drm_prepare( &g_DRM, &frameInfo );
 
 			// Happens when we're VT-switched away
 			if ( ret == -EACCES )
@@ -1844,7 +1835,7 @@ paint_all()
 				drm_rollback( &g_DRM );
 
 				// Try once again to in case we need to fall back to another mode.
-				ret = drm_prepare( &g_DRM, &composite, &pipeline );
+				ret = drm_prepare( &g_DRM, &frameInfo );
 
 				// Happens when we're VT-switched away
 				if ( ret == -EACCES )
@@ -1858,7 +1849,7 @@ paint_all()
 				}
 			}
 
-			drm_commit( &g_DRM, &composite, &pipeline );
+			drm_commit( &g_DRM, &frameInfo );
 		}
 
 		if ( takeScreenshot )
@@ -1926,11 +1917,11 @@ paint_all()
 	{
 		assert( BIsNested() == false );
 
-		drm_commit( &g_DRM, &composite, &pipeline );
+		drm_commit( &g_DRM, &frameInfo );
 	}
 
 	gpuvis_trace_end_ctx_printf( paintID, "paint_all" );
-	gpuvis_trace_printf( "paint_all %i layers, composite %i", (int)composite.nLayerCount, bDoComposite );
+	gpuvis_trace_printf( "paint_all %i layers, composite %i", (int)frameInfo.layerCount, bDoComposite );
 }
 
 /* Get prop from window
diff --git a/src/steamcompmgr.hpp b/src/steamcompmgr.hpp
index 91e3644..f931433 100644
--- a/src/steamcompmgr.hpp
+++ b/src/steamcompmgr.hpp
@@ -48,8 +48,7 @@ public:
 	void constrainPosition();
 	void resetPosition();
 
-	void paint(struct win *window, struct win *fit, struct Composite_t *pComposite,
-			   struct VulkanPipeline_t *pPipeline);
+	void paint(struct win *window, struct win *fit, struct FrameInfo_t *frameInfo);
 	void setDirty();
 
 	// Will take ownership of data.