TextureStage.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 "TextureStage.hpp"

#include "Sampler.hpp"
#include "Common/Debug.hpp"

#include <string.h>

namespace sw
{
	TextureStage::State::State()
	{
		memset(this, 0, sizeof(State));
	}

	TextureStage::TextureStage() : sampler(0), previousStage(0)
	{
	}

	TextureStage::~TextureStage()
	{
	}

	void TextureStage::init(int stage, const Sampler *sampler, const TextureStage *previousStage)
	{
		this->stage = stage;

		stageOperation = (stage == 0 ? STAGE_MODULATE : STAGE_DISABLE);
		firstArgument = SOURCE_TEXTURE;
		secondArgument = SOURCE_CURRENT;
		thirdArgument = SOURCE_CURRENT;
		stageOperationAlpha = (stage == 0 ? STAGE_SELECTARG1 : STAGE_DISABLE);
		firstArgumentAlpha = SOURCE_DIFFUSE;
		secondArgumentAlpha = SOURCE_CURRENT;
		thirdArgumentAlpha = SOURCE_CURRENT;
		firstModifier = MODIFIER_COLOR;
		secondModifier = MODIFIER_COLOR;
		thirdModifier = MODIFIER_COLOR;
	    firstModifierAlpha = MODIFIER_COLOR;
		secondModifierAlpha = MODIFIER_COLOR;
		thirdModifierAlpha = MODIFIER_COLOR;
		destinationArgument = DESTINATION_CURRENT;

		texCoordIndex = stage;
		this->sampler = sampler;
		this->previousStage = previousStage;
	}

	TextureStage::State TextureStage::textureStageState() const
	{
		State state;

		if(!isStageDisabled())
		{
			state.stageOperation = stageOperation;
			state.firstArgument = firstArgument;
			state.secondArgument = secondArgument;
			state.thirdArgument = thirdArgument;
			state.stageOperationAlpha = stageOperationAlpha;
			state.firstArgumentAlpha = firstArgumentAlpha;
			state.secondArgumentAlpha = secondArgumentAlpha;
			state.thirdArgumentAlpha = thirdArgumentAlpha;
			state.firstModifier = firstModifier;
			state.secondModifier = secondModifier;
			state.thirdModifier = thirdModifier;
			state.firstModifierAlpha = firstModifierAlpha;
			state.secondModifierAlpha = secondModifierAlpha;
			state.thirdModifierAlpha = thirdModifierAlpha;
			state.destinationArgument = destinationArgument;
			state.texCoordIndex = texCoordIndex;

			state.cantUnderflow = sampler->hasUnsignedTexture() || !usesTexture();
			state.usesTexture = usesTexture();
		}

		return state;
	}

	void TextureStage::setConstantColor(const Color<float> &constantColor)
	{
		// FIXME: Compact into generic function   // FIXME: Clamp
		short r = iround(4095 * constantColor.r);
		short g = iround(4095 * constantColor.g);
		short b = iround(4095 * constantColor.b);
		short a = iround(4095 * constantColor.a);

		uniforms.constantColor4[0][0] = uniforms.constantColor4[0][1] = uniforms.constantColor4[0][2] = uniforms.constantColor4[0][3] = r;
		uniforms.constantColor4[1][0] = uniforms.constantColor4[1][1] = uniforms.constantColor4[1][2] = uniforms.constantColor4[1][3] = g;
		uniforms.constantColor4[2][0] = uniforms.constantColor4[2][1] = uniforms.constantColor4[2][2] = uniforms.constantColor4[2][3] = b;
		uniforms.constantColor4[3][0] = uniforms.constantColor4[3][1] = uniforms.constantColor4[3][2] = uniforms.constantColor4[3][3] = a;
	}

	void TextureStage::setBumpmapMatrix(int element, float value)
	{
		uniforms.bumpmapMatrix4F[element / 2][element % 2][0] = value;
		uniforms.bumpmapMatrix4F[element / 2][element % 2][1] = value;
		uniforms.bumpmapMatrix4F[element / 2][element % 2][2] = value;
		uniforms.bumpmapMatrix4F[element / 2][element % 2][3] = value;

		uniforms.bumpmapMatrix4W[element / 2][element % 2][0] = iround(4095 * value);
		uniforms.bumpmapMatrix4W[element / 2][element % 2][1] = iround(4095 * value);
		uniforms.bumpmapMatrix4W[element / 2][element % 2][2] = iround(4095 * value);
		uniforms.bumpmapMatrix4W[element / 2][element % 2][3] = iround(4095 * value);
	}

	void TextureStage::setLuminanceScale(float value)
	{
		short scale = iround(4095 * value);

		uniforms.luminanceScale4[0] = uniforms.luminanceScale4[1] = uniforms.luminanceScale4[2] = uniforms.luminanceScale4[3] = scale;
	}

	void TextureStage::setLuminanceOffset(float value)
	{
		short offset = iround(4095 * value);

		uniforms.luminanceOffset4[0] = uniforms.luminanceOffset4[1] = uniforms.luminanceOffset4[2] = uniforms.luminanceOffset4[3] = offset;
	}

	void TextureStage::setTexCoordIndex(unsigned int texCoordIndex)
	{
		ASSERT(texCoordIndex < 8);

		this->texCoordIndex = texCoordIndex;
	}

	void TextureStage::setStageOperation(StageOperation stageOperation)
	{
		this->stageOperation = stageOperation;
	}

	void TextureStage::setFirstArgument(SourceArgument firstArgument)
	{
		this->firstArgument = firstArgument;
	}

	void TextureStage::setSecondArgument(SourceArgument secondArgument)
	{
		this->secondArgument = secondArgument;
	}

	void TextureStage::setThirdArgument(SourceArgument thirdArgument)
	{
		this->thirdArgument = thirdArgument;
	}

	void TextureStage::setStageOperationAlpha(StageOperation stageOperationAlpha)
	{
		this->stageOperationAlpha = stageOperationAlpha;
	}

	void TextureStage::setFirstArgumentAlpha(SourceArgument firstArgumentAlpha)
	{
		this->firstArgumentAlpha = firstArgumentAlpha;
	}

	void TextureStage::setSecondArgumentAlpha(SourceArgument secondArgumentAlpha)
	{
		this->secondArgumentAlpha = secondArgumentAlpha;
	}

	void TextureStage::setThirdArgumentAlpha(SourceArgument thirdArgumentAlpha)
	{
		this->thirdArgumentAlpha= thirdArgumentAlpha;
	}

	void TextureStage::setFirstModifier(ArgumentModifier firstModifier)
	{
		this->firstModifier = firstModifier;
	}

	void TextureStage::setSecondModifier(ArgumentModifier secondModifier)
	{
		this->secondModifier = secondModifier;
	}

	void TextureStage::setThirdModifier(ArgumentModifier thirdModifier)
	{
		this->thirdModifier = thirdModifier;
	}

	void TextureStage::setFirstModifierAlpha(ArgumentModifier firstModifierAlpha)
	{
		this->firstModifierAlpha = firstModifierAlpha;
	}

	void TextureStage::setSecondModifierAlpha(ArgumentModifier secondModifierAlpha)
	{
		this->secondModifierAlpha = secondModifierAlpha;
	}

	void TextureStage::setThirdModifierAlpha(ArgumentModifier thirdModifierAlpha)
	{
		this->thirdModifierAlpha = thirdModifierAlpha;
	}

	void TextureStage::setDestinationArgument(DestinationArgument destinationArgument)
	{
		this->destinationArgument = destinationArgument;
	}

	bool TextureStage::usesColor(SourceArgument source) const
	{
		// One argument
		if(stageOperation == STAGE_SELECTARG1 || stageOperation == STAGE_PREMODULATE)
		{
			return firstArgument == source;
		}
		else if(stageOperation == STAGE_SELECTARG2)
		{
			return secondArgument == source;
		}
		else if(stageOperation == STAGE_SELECTARG3)
		{
			return thirdArgument == source;
		}
		else
		{
			// Two arguments or more
			if(firstArgument == source || secondArgument == source)
			{
				return true;
			}

			// Three arguments
			if(stageOperation == STAGE_MULTIPLYADD || stageOperation == STAGE_LERP)
			{
				return thirdArgument == source;
			}
		}
	
		return false;
	}

	bool TextureStage::usesAlpha(SourceArgument source) const
	{
		if(stageOperationAlpha == STAGE_DISABLE)
		{
			return false;
		}

		if(source == SOURCE_TEXTURE)
		{
			if(stageOperation == STAGE_BLENDTEXTUREALPHA ||	stageOperation == STAGE_BLENDTEXTUREALPHAPM)
			{
				return true;
			}
		}
		else if(source == SOURCE_CURRENT)
		{
			if(stageOperation == STAGE_BLENDCURRENTALPHA)
			{
				return true;
			}
		}
		else if(source == SOURCE_DIFFUSE)
		{
			if(stageOperation == STAGE_BLENDDIFFUSEALPHA)
			{
				return true;
			}
		}
		else if(source == SOURCE_TFACTOR)
		{
			if(stageOperation == STAGE_BLENDFACTORALPHA)
			{
				return true;
			}
		}

		// One argument
		if(stageOperation == STAGE_SELECTARG1 || stageOperation == STAGE_PREMODULATE)
		{
			if(firstArgument == source && (firstModifier == MODIFIER_ALPHA || firstModifier == MODIFIER_INVALPHA))
			{
				return true;
			}
		}
		else if(stageOperation == STAGE_SELECTARG2)
		{
			if(secondArgument == source && (secondModifier == MODIFIER_ALPHA || secondModifier == MODIFIER_INVALPHA))
			{
				return true;
			}
		}
		else if(stageOperation == STAGE_SELECTARG3)
		{
			if(thirdArgument == source && (thirdModifier == MODIFIER_ALPHA || thirdModifier == MODIFIER_INVALPHA))
			{
				return true;
			}
		}
		else
		{
			// Two arguments or more
			if(firstArgument == source || secondArgument == source)
			{
				if(firstArgument == source && (firstModifier == MODIFIER_ALPHA || firstModifier == MODIFIER_INVALPHA))
				{
					return true;
				}

				if(secondArgument == source && (secondModifier == MODIFIER_ALPHA || secondModifier == MODIFIER_INVALPHA))
				{
					return true;
				}
			}

			// Three arguments
			if(stageOperation == STAGE_MULTIPLYADD || stageOperation == STAGE_LERP)
			{
				if(thirdArgument == source && (thirdModifier == MODIFIER_ALPHA || thirdModifier == MODIFIER_INVALPHA))
				{
					return true;
				}
			}
		}

		// One argument
		if(stageOperationAlpha == STAGE_SELECTARG1 || stageOperationAlpha == STAGE_PREMODULATE)
		{
			return firstArgumentAlpha == source;
		}
		else if(stageOperationAlpha == STAGE_SELECTARG2)
		{
			return secondArgumentAlpha == source;
		}
		else if(stageOperationAlpha == STAGE_SELECTARG3)
		{
			return thirdArgumentAlpha == source;
		}
		else
		{
			// Two arguments or more
			if(firstArgumentAlpha == source || secondArgumentAlpha == source)
			{
				return true;
			}

			// Three arguments
			if(stageOperationAlpha == STAGE_MULTIPLYADD || stageOperationAlpha == STAGE_LERP)
			{
				return thirdArgumentAlpha == source;
			}
		}
		
		return false;
	}

	bool TextureStage::uses(SourceArgument source) const
	{
		return usesColor(source) || usesAlpha(source);
	}

	bool TextureStage::usesCurrent() const
	{
		return uses(SOURCE_CURRENT) || (stageOperation == STAGE_BLENDCURRENTALPHA || stageOperationAlpha == STAGE_BLENDCURRENTALPHA);
	}

	bool TextureStage::usesDiffuse() const
	{
		return uses(SOURCE_DIFFUSE) || (stageOperation == STAGE_BLENDDIFFUSEALPHA || stageOperationAlpha == STAGE_BLENDDIFFUSEALPHA);
	}

	bool TextureStage::usesSpecular() const
	{
		return uses(SOURCE_SPECULAR);
	}

	bool TextureStage::usesTexture() const
	{
		return uses(SOURCE_TEXTURE) ||
		       stageOperation == STAGE_BLENDTEXTUREALPHA ||
		       stageOperationAlpha == STAGE_BLENDTEXTUREALPHA ||
		       stageOperation == STAGE_BLENDTEXTUREALPHAPM ||
		       stageOperationAlpha == STAGE_BLENDTEXTUREALPHAPM ||
		       (previousStage && previousStage->stageOperation == STAGE_PREMODULATE) ||
		       (previousStage && previousStage->stageOperationAlpha == STAGE_PREMODULATE);
	}

	bool TextureStage::isStageDisabled() const
	{
		bool disabled = (stageOperation == STAGE_DISABLE) || (!sampler->hasTexture() && usesTexture());

		if(!previousStage || disabled)
		{
			return disabled;
		}
		else
		{
			return previousStage->isStageDisabled();
		}
	}

	bool TextureStage::writesCurrent() const
	{
		return !isStageDisabled() && destinationArgument == DESTINATION_CURRENT && stageOperation != STAGE_BUMPENVMAP && stageOperation != STAGE_BUMPENVMAPLUMINANCE;
	}
}