src/Device/Context.cpp

// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "Context.hpp"

#include "Primitive.hpp"
#include "Pipeline/SpirvShader.hpp"
#include "System/Debug.hpp"
#include "System/Memory.hpp"
#include "Vulkan/VkImageView.hpp"

#include <string.h>

namespace sw {

Context::Context()
{
	init();
}

bool Context::isDrawPoint(bool polygonModeAware) const
{
	switch(topology)
	{
		case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
			return true;
		case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
		case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
			return false;
		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
			return polygonModeAware ? (polygonMode == VK_POLYGON_MODE_POINT) : false;
		default:
			UNSUPPORTED("topology %d", int(topology));
	}
	return false;
}

bool Context::isDrawLine(bool polygonModeAware) const
{
	switch(topology)
	{
		case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
			return false;
		case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
		case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
			return true;
		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
			return polygonModeAware ? (polygonMode == VK_POLYGON_MODE_LINE) : false;
		default:
			UNSUPPORTED("topology %d", int(topology));
	}
	return false;
}

bool Context::isDrawTriangle(bool polygonModeAware) const
{
	switch(topology)
	{
		case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
		case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
		case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
			return false;
		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
			return polygonModeAware ? (polygonMode == VK_POLYGON_MODE_FILL) : true;
		default:
			UNSUPPORTED("topology %d", int(topology));
	}
	return false;
}

void Context::init()
{
	for(int i = 0; i < RENDERTARGETS; ++i)
	{
		renderTarget[i] = nullptr;
	}

	depthBuffer = nullptr;
	stencilBuffer = nullptr;

	stencilEnable = false;
	frontStencil = {};
	backStencil = {};

	robustBufferAccess = false;

	rasterizerDiscard = false;

	depthCompareMode = VK_COMPARE_OP_LESS;
	depthBoundsTestEnable = false;
	depthBufferEnable = false;
	depthWriteEnable = false;

	cullMode = VK_CULL_MODE_FRONT_BIT;
	frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
	provokingVertexMode = VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT;
	lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT;

	depthBias = 0.0f;
	slopeDepthBias = 0.0f;

	for(int i = 0; i < RENDERTARGETS; i++)
	{
		colorWriteMask[i] = 0x0000000F;
	}

	pipelineLayout = nullptr;

	pixelShader = nullptr;
	vertexShader = nullptr;

	occlusionEnabled = false;

	lineWidth = 1.0f;

	sampleMask = 0xFFFFFFFF;
	alphaToCoverage = false;
}

bool Context::depthWriteActive() const
{
	if(!depthBufferActive()) return false;

	return depthWriteEnable;
}

bool Context::depthBufferActive() const
{
	return depthBuffer && depthBufferEnable;
}

bool Context::stencilActive() const
{
	return stencilBuffer && stencilEnable;
}

void Context::setBlendState(int index, BlendState state)
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	blendState[index] = state;
}

BlendState Context::getBlendState(int index) const
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	BlendState activeBlendState;
	activeBlendState.alphaBlendEnable = alphaBlendActive(index);
	activeBlendState.sourceBlendFactor = sourceBlendFactor(index);
	activeBlendState.destBlendFactor = destBlendFactor(index);
	activeBlendState.blendOperation = blendOperation(index);
	activeBlendState.sourceBlendFactorAlpha = sourceBlendFactorAlpha(index);
	activeBlendState.destBlendFactorAlpha = destBlendFactorAlpha(index);
	activeBlendState.blendOperationAlpha = blendOperationAlpha(index);
	return activeBlendState;
}

bool Context::alphaBlendActive(int index) const
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	if(!blendState[index].alphaBlendEnable)
	{
		return false;
	}

	if(!colorUsed())
	{
		return false;
	}

	bool colorBlend = !(blendOperation(index) == VK_BLEND_OP_SRC_EXT && sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE);
	bool alphaBlend = !(blendOperationAlpha(index) == VK_BLEND_OP_SRC_EXT && sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE);

	return colorBlend || alphaBlend;
}

VkBlendFactor Context::sourceBlendFactor(int index) const
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	if(!blendState[index].alphaBlendEnable) return VK_BLEND_FACTOR_ONE;

	switch(blendState[index].blendOperation)
	{
		case VK_BLEND_OP_ADD:
		case VK_BLEND_OP_SUBTRACT:
		case VK_BLEND_OP_REVERSE_SUBTRACT:
			return blendState[index].sourceBlendFactor;
		case VK_BLEND_OP_MIN:
			return VK_BLEND_FACTOR_ONE;
		case VK_BLEND_OP_MAX:
			return VK_BLEND_FACTOR_ONE;
		default:
			ASSERT(false);
	}

	return blendState[index].sourceBlendFactor;
}

VkBlendFactor Context::destBlendFactor(int index) const
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	if(!blendState[index].alphaBlendEnable) return VK_BLEND_FACTOR_ONE;

	switch(blendState[index].blendOperation)
	{
		case VK_BLEND_OP_ADD:
		case VK_BLEND_OP_SUBTRACT:
		case VK_BLEND_OP_REVERSE_SUBTRACT:
			return blendState[index].destBlendFactor;
		case VK_BLEND_OP_MIN:
			return VK_BLEND_FACTOR_ONE;
		case VK_BLEND_OP_MAX:
			return VK_BLEND_FACTOR_ONE;
		default:
			ASSERT(false);
	}

	return blendState[index].destBlendFactor;
}

bool Context::allTargetsColorClamp() const
{
	// TODO: remove all of this and support VkPhysicalDeviceFeatures::independentBlend instead
	for(int i = 0; i < RENDERTARGETS; i++)
	{
		if(renderTarget[i] && renderTarget[i]->getFormat().isFloatFormat())
		{
			return false;
		}
	}

	return true;
}

VkBlendOp Context::blendOperation(int index) const
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	if(!blendState[index].alphaBlendEnable) return VK_BLEND_OP_SRC_EXT;

	switch(blendState[index].blendOperation)
	{
		case VK_BLEND_OP_ADD:
			if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
			{
				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_ZERO_EXT;
				}
				else
				{
					return VK_BLEND_OP_DST_EXT;
				}
			}
			else if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE)
			{
				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_SRC_EXT;
				}
				else
				{
					return VK_BLEND_OP_ADD;
				}
			}
			else
			{
				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_SRC_EXT;
				}
				else
				{
					return VK_BLEND_OP_ADD;
				}
			}
		case VK_BLEND_OP_SUBTRACT:
			if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
			{
				return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
			}
			else if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE)
			{
				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_SRC_EXT;
				}
				else
				{
					return VK_BLEND_OP_SUBTRACT;
				}
			}
			else
			{
				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_SRC_EXT;
				}
				else
				{
					return VK_BLEND_OP_SUBTRACT;
				}
			}
		case VK_BLEND_OP_REVERSE_SUBTRACT:
			if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
			{
				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_ZERO_EXT;
				}
				else
				{
					return VK_BLEND_OP_DST_EXT;
				}
			}
			else if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE)
			{
				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
				{
					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
				}
				else
				{
					return VK_BLEND_OP_REVERSE_SUBTRACT;
				}
			}
			else
			{
				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
				{
					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
				}
				else
				{
					return VK_BLEND_OP_REVERSE_SUBTRACT;
				}
			}
		case VK_BLEND_OP_MIN:
			return VK_BLEND_OP_MIN;
		case VK_BLEND_OP_MAX:
			return VK_BLEND_OP_MAX;
		default:
			ASSERT(false);
	}

	return blendState[index].blendOperation;
}

VkBlendFactor Context::sourceBlendFactorAlpha(int index) const
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	switch(blendState[index].blendOperationAlpha)
	{
		case VK_BLEND_OP_ADD:
		case VK_BLEND_OP_SUBTRACT:
		case VK_BLEND_OP_REVERSE_SUBTRACT:
			return blendState[index].sourceBlendFactorAlpha;
		case VK_BLEND_OP_MIN:
			return VK_BLEND_FACTOR_ONE;
		case VK_BLEND_OP_MAX:
			return VK_BLEND_FACTOR_ONE;
		default:
			ASSERT(false);
	}

	return blendState[index].sourceBlendFactorAlpha;
}

VkBlendFactor Context::destBlendFactorAlpha(int index) const
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	switch(blendState[index].blendOperationAlpha)
	{
		case VK_BLEND_OP_ADD:
		case VK_BLEND_OP_SUBTRACT:
		case VK_BLEND_OP_REVERSE_SUBTRACT:
			return blendState[index].destBlendFactorAlpha;
		case VK_BLEND_OP_MIN:
			return VK_BLEND_FACTOR_ONE;
		case VK_BLEND_OP_MAX:
			return VK_BLEND_FACTOR_ONE;
		default:
			ASSERT(false);
	}

	return blendState[index].destBlendFactorAlpha;
}

VkBlendOp Context::blendOperationAlpha(int index) const
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	switch(blendState[index].blendOperationAlpha)
	{
		case VK_BLEND_OP_ADD:
			if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
			{
				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_ZERO_EXT;
				}
				else
				{
					return VK_BLEND_OP_DST_EXT;
				}
			}
			else if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE)
			{
				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_SRC_EXT;
				}
				else
				{
					return VK_BLEND_OP_ADD;
				}
			}
			else
			{
				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_SRC_EXT;
				}
				else
				{
					return VK_BLEND_OP_ADD;
				}
			}
		case VK_BLEND_OP_SUBTRACT:
			if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
			{
				return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
			}
			else if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE)
			{
				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_SRC_EXT;
				}
				else
				{
					return VK_BLEND_OP_SUBTRACT;
				}
			}
			else
			{
				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_SRC_EXT;
				}
				else
				{
					return VK_BLEND_OP_SUBTRACT;
				}
			}
		case VK_BLEND_OP_REVERSE_SUBTRACT:
			if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
			{
				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
				{
					return VK_BLEND_OP_ZERO_EXT;
				}
				else
				{
					return VK_BLEND_OP_DST_EXT;
				}
			}
			else if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE)
			{
				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
				{
					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
				}
				else
				{
					return VK_BLEND_OP_REVERSE_SUBTRACT;
				}
			}
			else
			{
				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
				{
					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
				}
				else
				{
					return VK_BLEND_OP_REVERSE_SUBTRACT;
				}
			}
		case VK_BLEND_OP_MIN:
			return VK_BLEND_OP_MIN;
		case VK_BLEND_OP_MAX:
			return VK_BLEND_OP_MAX;
		default:
			ASSERT(false);
	}

	return blendState[index].blendOperationAlpha;
}

VkFormat Context::renderTargetInternalFormat(int index) const
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	if(renderTarget[index])
	{
		return renderTarget[index]->getFormat();
	}
	else
	{
		return VK_FORMAT_UNDEFINED;
	}
}

bool Context::colorWriteActive() const
{
	for(int i = 0; i < RENDERTARGETS; i++)
	{
		if(colorWriteActive(i))
		{
			return true;
		}
	}

	return false;
}

int Context::colorWriteActive(int index) const
{
	ASSERT((index >= 0) && (index < RENDERTARGETS));

	if(!renderTarget[index] || renderTarget[index]->getFormat() == VK_FORMAT_UNDEFINED)
	{
		return 0;
	}

	if(blendOperation(index) == VK_BLEND_OP_DST_EXT && destBlendFactor(index) == VK_BLEND_FACTOR_ONE &&
	   (blendOperationAlpha(index) == VK_BLEND_OP_DST_EXT && destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE))
	{
		return 0;
	}

	return colorWriteMask[index];
}

bool Context::colorUsed() const
{
	return colorWriteActive() || (pixelShader && pixelShader->getModes().ContainsKill);
}

}  // namespace sw