src/Shader/PixelShader.cpp

// SwiftShader Software Renderer
//
// Copyright(c) 2005-2013 TransGaming Inc.
//
// All rights reserved. No part of this software may be copied, distributed, transmitted,
// transcribed, stored in a retrieval system, translated into any human or computer
// language by any means, or disclosed to third parties without the explicit written
// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
// or implied, including but not limited to any patent rights, are granted to you.
//

#include "PixelShader.hpp"

#include "Debug.hpp"

#include <string.h>

namespace sw
{
	PixelShader::PixelShader(const PixelShader *ps) : Shader()
	{
		version = 0x0300;
		vPosDeclared = false;
		vFaceDeclared = false;
		centroid = false;

		if(ps)   // Make a copy
		{
			for(size_t i = 0; i < ps->getLength(); i++)
			{
				append(new sw::Shader::Instruction(*ps->getInstruction(i)));
			}

			memcpy(semantic, ps->semantic, sizeof(semantic));
			vPosDeclared = ps->vPosDeclared;
			vFaceDeclared = ps->vFaceDeclared;
			usedSamplers = ps->usedSamplers;

			optimize();
			analyze();
		}
	}

	PixelShader::PixelShader(const unsigned long *token) : Shader()
	{
		parse(token);

		vPosDeclared = false;
		vFaceDeclared = false;
		centroid = false;

		optimize();
		analyze();
	}

	PixelShader::~PixelShader()
	{
	}

	int PixelShader::validate(const unsigned long *const token)
	{
		if(!token)
		{
			return 0;
		}

		unsigned short version = (unsigned short)(token[0] & 0x0000FFFF);
		unsigned char minorVersion = (unsigned char)(token[0] & 0x000000FF);
		unsigned char majorVersion = (unsigned char)((token[0] & 0x0000FF00) >> 8);
		ShaderType shaderType = (ShaderType)((token[0] & 0xFFFF0000) >> 16);

		if(shaderType != SHADER_PIXEL || majorVersion > 3)
		{
			return 0;
		}

		int instructionCount = 1;

		for(int i = 0; token[i] != 0x0000FFFF; i++)
		{
			if((token[i] & 0x0000FFFF) == 0x0000FFFE)   // Comment token
			{
				int length = (token[i] & 0x7FFF0000) >> 16;

				i += length;
			}
			else
			{
				Shader::Opcode opcode = (Shader::Opcode)(token[i] & 0x0000FFFF);

				switch(opcode)
				{
				case Shader::OPCODE_RESERVED0:
				case Shader::OPCODE_MOVA:
					return 0;   // Unsupported operation
				default:
					instructionCount++;
					break;
				}

				i += size(token[i], version);
			}
		}

		return instructionCount;
	}

	bool PixelShader::depthOverride() const
	{
		return zOverride;
	}

	bool PixelShader::containsKill() const
	{
		return kill;
	}

	bool PixelShader::containsCentroid() const
	{
		return centroid;
	}

	bool PixelShader::usesDiffuse(int component) const
	{
		return semantic[0][component].active();
	}

	bool PixelShader::usesSpecular(int component) const
	{
		return semantic[1][component].active();
	}

	bool PixelShader::usesTexture(int coordinate, int component) const
	{
		return semantic[2 + coordinate][component].active();
	}

	void PixelShader::analyze()
	{
		analyzeZOverride();
		analyzeKill();
		analyzeInterpolants();
		analyzeDirtyConstants();
		analyzeDynamicBranching();
		analyzeSamplers();
		analyzeCallSites();
		analyzeDynamicIndexing();
	}

	void PixelShader::analyzeZOverride()
	{
		zOverride = false;

		for(unsigned int i = 0; i < instruction.size(); i++)
		{
			if(instruction[i]->opcode == Shader::OPCODE_TEXM3X2DEPTH ||
			   instruction[i]->opcode == Shader::OPCODE_TEXDEPTH ||
			   instruction[i]->dst.type == Shader::PARAMETER_DEPTHOUT)
			{
				zOverride = true;

				break;
			}
		}
	}

	void PixelShader::analyzeKill()
	{
		kill = false;

		for(unsigned int i = 0; i < instruction.size(); i++)
		{
			if(instruction[i]->opcode == Shader::OPCODE_TEXKILL ||
			   instruction[i]->opcode == Shader::OPCODE_DISCARD)
			{
				kill = true;

				break;
			}
		}
	}

	void PixelShader::analyzeInterpolants()
	{
		if(version < 0x0300)
		{
			// Set default mapping; disable unused interpolants below
			semantic[0][0] = Semantic(Shader::USAGE_COLOR, 0);
			semantic[0][1] = Semantic(Shader::USAGE_COLOR, 0);
			semantic[0][2] = Semantic(Shader::USAGE_COLOR, 0);
			semantic[0][3] = Semantic(Shader::USAGE_COLOR, 0);

			semantic[1][0] = Semantic(Shader::USAGE_COLOR, 1);
			semantic[1][1] = Semantic(Shader::USAGE_COLOR, 1);
			semantic[1][2] = Semantic(Shader::USAGE_COLOR, 1);
			semantic[1][3] = Semantic(Shader::USAGE_COLOR, 1);

			for(int i = 0; i < 8; i++)
			{
				semantic[2 + i][0] = Semantic(Shader::USAGE_TEXCOORD, i);
				semantic[2 + i][1] = Semantic(Shader::USAGE_TEXCOORD, i);
				semantic[2 + i][2] = Semantic(Shader::USAGE_TEXCOORD, i);
				semantic[2 + i][3] = Semantic(Shader::USAGE_TEXCOORD, i);
			}

			Shader::SamplerType samplerType[16];

			for(int i = 0; i < 16; i++)
			{
				samplerType[i] = Shader::SAMPLER_UNKNOWN;
			}

			for(unsigned int i = 0; i < instruction.size(); i++)
			{
				if(instruction[i]->dst.type == Shader::PARAMETER_SAMPLER)
				{
					int sampler = instruction[i]->dst.index;

					samplerType[sampler] = instruction[i]->samplerType;
				}
			}

			bool interpolant[MAX_INPUT_VARYINGS][4] = {{false}};   // Interpolants in use

			for(unsigned int i = 0; i < instruction.size(); i++)
			{
				if(instruction[i]->dst.type == Shader::PARAMETER_TEXTURE)
				{	
					int index = instruction[i]->dst.index + 2;
					int mask = instruction[i]->dst.mask;

					switch(instruction[i]->opcode)
					{
					case Shader::OPCODE_TEX:
					case Shader::OPCODE_TEXBEM:
					case Shader::OPCODE_TEXBEML:
					case Shader::OPCODE_TEXCOORD:
					case Shader::OPCODE_TEXDP3:
					case Shader::OPCODE_TEXDP3TEX:
					case Shader::OPCODE_TEXM3X2DEPTH:
					case Shader::OPCODE_TEXM3X2PAD:
					case Shader::OPCODE_TEXM3X2TEX:
					case Shader::OPCODE_TEXM3X3:
					case Shader::OPCODE_TEXM3X3PAD:
					case Shader::OPCODE_TEXM3X3TEX:
						interpolant[index][0] = true;
						interpolant[index][1] = true;
						interpolant[index][2] = true;
						break;
					case Shader::OPCODE_TEXKILL:
						if(majorVersion < 2)
						{
							interpolant[index][0] = true;
							interpolant[index][1] = true;
							interpolant[index][2] = true;
						}
						else
						{
							interpolant[index][0] = true;
							interpolant[index][1] = true;
							interpolant[index][2] = true;
							interpolant[index][3] = true;
						}
						break;
					case Shader::OPCODE_TEXM3X3VSPEC:
						interpolant[index][0] = true;
						interpolant[index][1] = true;
						interpolant[index][2] = true;
						interpolant[index - 2][3] = true;
						interpolant[index - 1][3] = true;
						interpolant[index - 0][3] = true;
						break;
					case Shader::OPCODE_DCL:
						break;   // Ignore
					default:   // Arithmetic instruction
						if(version >= 0x0104)
						{
							ASSERT(false);
						}
					}
				}

				for(int argument = 0; argument < 4; argument++)
				{
					if(instruction[i]->src[argument].type == Shader::PARAMETER_INPUT ||
					   instruction[i]->src[argument].type == Shader::PARAMETER_TEXTURE)
					{
						int index = instruction[i]->src[argument].index;
						int swizzle = instruction[i]->src[argument].swizzle;
						int mask = instruction[i]->dst.mask;
						
						if(instruction[i]->src[argument].type == Shader::PARAMETER_TEXTURE)
						{
							index += 2;
						}

						switch(instruction[i]->opcode)
						{
						case Shader::OPCODE_TEX:
						case Shader::OPCODE_TEXLDD:
						case Shader::OPCODE_TEXLDL:
						case Shader::OPCODE_TEXOFFSET:
						case Shader::OPCODE_TEXLDLOFFSET:
						case Shader::OPCODE_TEXELFETCH:
						case Shader::OPCODE_TEXELFETCHOFFSET:
						case Shader::OPCODE_TEXGRAD:
						case Shader::OPCODE_TEXGRADOFFSET:
							{
								int sampler = instruction[i]->src[1].index;

								switch(samplerType[sampler])
								{
								case Shader::SAMPLER_UNKNOWN:
									if(version == 0x0104)
									{
										if((instruction[i]->src[0].swizzle & 0x30) == 0x20)   // .xyz
										{
											interpolant[index][0] = true;
											interpolant[index][1] = true;
											interpolant[index][2] = true;
										}
										else   // .xyw
										{
											interpolant[index][0] = true;
											interpolant[index][1] = true;
											interpolant[index][3] = true;
										}
									}
									else
									{
										ASSERT(false);
									}
									break;
								case Shader::SAMPLER_1D:
									interpolant[index][0] = true;
									break;
								case Shader::SAMPLER_2D:
									interpolant[index][0] = true;
									interpolant[index][1] = true;
									break;
								case Shader::SAMPLER_CUBE:
									interpolant[index][0] = true;
									interpolant[index][1] = true;
									interpolant[index][2] = true;
									break;
								case Shader::SAMPLER_VOLUME:
									interpolant[index][0] = true;
									interpolant[index][1] = true;
									interpolant[index][2] = true;
									break;
								default:
									ASSERT(false);
								}

								if(instruction[i]->bias)
								{
									interpolant[index][3] = true;
								}

								if(instruction[i]->project)
								{
									interpolant[index][3] = true;
								}

								if(version == 0x0104 && instruction[i]->opcode == Shader::OPCODE_TEX)
								{
									if(instruction[i]->src[0].modifier == Shader::MODIFIER_DZ)
									{
										interpolant[index][2] = true;
									}

									if(instruction[i]->src[0].modifier == Shader::MODIFIER_DW)
									{
										interpolant[index][3] = true;
									}
								}
							}
							break;
						case Shader::OPCODE_M3X2:
							if(mask & 0x1)
							{
								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
							}

							if(argument == 1)
							{
								if(mask & 0x2)
								{
									interpolant[index + 1][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
									interpolant[index + 1][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
									interpolant[index + 1][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
									interpolant[index + 1][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
								}
							}
							break;
						case Shader::OPCODE_M3X3:
							if(mask & 0x1)
							{
								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
							}

							if(argument == 1)
							{
								if(mask & 0x2)
								{
									interpolant[index + 1][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
									interpolant[index + 1][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
									interpolant[index + 1][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
									interpolant[index + 1][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
								}

								if(mask & 0x4)
								{
									interpolant[index + 2][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
									interpolant[index + 2][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
									interpolant[index + 2][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
									interpolant[index + 2][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
								}
							}
							break;
						case Shader::OPCODE_M3X4:
							if(mask & 0x1)
							{
								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
							}

							if(argument == 1)
							{
								if(mask & 0x2)
								{
									interpolant[index + 1][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
									interpolant[index + 1][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
									interpolant[index + 1][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
									interpolant[index + 1][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
								}

								if(mask & 0x4)
								{
									interpolant[index + 2][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
									interpolant[index + 2][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
									interpolant[index + 2][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
									interpolant[index + 2][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
								}

								if(mask & 0x8)
								{
									interpolant[index + 3][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
									interpolant[index + 3][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
									interpolant[index + 3][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
									interpolant[index + 3][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
								}
							}
							break;
						case Shader::OPCODE_M4X3:
							if(mask & 0x1)
							{
								interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
								interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
								interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
								interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
							}

							if(argument == 1)
							{
								if(mask & 0x2)
								{
									interpolant[index + 1][0] |= swizzleContainsComponent(swizzle, 0);
									interpolant[index + 1][1] |= swizzleContainsComponent(swizzle, 1);
									interpolant[index + 1][2] |= swizzleContainsComponent(swizzle, 2);
									interpolant[index + 1][3] |= swizzleContainsComponent(swizzle, 3);
								}

								if(mask & 0x4)
								{
									interpolant[index + 2][0] |= swizzleContainsComponent(swizzle, 0);
									interpolant[index + 2][1] |= swizzleContainsComponent(swizzle, 1);
									interpolant[index + 2][2] |= swizzleContainsComponent(swizzle, 2);
									interpolant[index + 2][3] |= swizzleContainsComponent(swizzle, 3);
								}
							}
							break;
						case Shader::OPCODE_M4X4:
							if(mask & 0x1)
							{
								interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
								interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
								interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
								interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
							}

							if(argument == 1)
							{
								if(mask & 0x2)
								{
									interpolant[index + 1][0] |= swizzleContainsComponent(swizzle, 0);
									interpolant[index + 1][1] |= swizzleContainsComponent(swizzle, 1);
									interpolant[index + 1][2] |= swizzleContainsComponent(swizzle, 2);
									interpolant[index + 1][3] |= swizzleContainsComponent(swizzle, 3);
								}

								if(mask & 0x4)
								{
									interpolant[index + 2][0] |= swizzleContainsComponent(swizzle, 0);
									interpolant[index + 2][1] |= swizzleContainsComponent(swizzle, 1);
									interpolant[index + 2][2] |= swizzleContainsComponent(swizzle, 2);
									interpolant[index + 2][3] |= swizzleContainsComponent(swizzle, 3);
								}

								if(mask & 0x8)
								{
									interpolant[index + 3][0] |= swizzleContainsComponent(swizzle, 0);
									interpolant[index + 3][1] |= swizzleContainsComponent(swizzle, 1);
									interpolant[index + 3][2] |= swizzleContainsComponent(swizzle, 2);
									interpolant[index + 3][3] |= swizzleContainsComponent(swizzle, 3);
								}
							}
							break;
						case Shader::OPCODE_CRS:
							if(mask & 0x1)
							{
								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x6);
								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x6);
								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x6);
								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x6);
							}

							if(mask & 0x2)
							{
								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x5);
								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x5);
								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x5);
								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x5);
							}

							if(mask & 0x4)
							{
								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x3);
								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x3);
								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x3);
								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x3);
							}
							break;
						case Shader::OPCODE_DP2ADD:
							if(argument == 0 || argument == 1)
							{
								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x3);
								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x3);
								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x3);
								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x3);
							}
							else   // argument == 2
							{
								interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
								interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
								interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
								interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
							}
							break;
						case Shader::OPCODE_DP3:
							interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
							interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
							interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
							interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
							break;
						case Shader::OPCODE_DP4:
							interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
							interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
							interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
							interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
							break;
						case Shader::OPCODE_SINCOS:
						case Shader::OPCODE_EXP2X:
						case Shader::OPCODE_LOG2X:
						case Shader::OPCODE_POWX:
						case Shader::OPCODE_RCPX:
						case Shader::OPCODE_RSQX:
							interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
							interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
							interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
							interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
							break;
						case Shader::OPCODE_NRM3:
							interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7 | mask);
							interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7 | mask);
							interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7 | mask);
							interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7 | mask);
							break;
						case Shader::OPCODE_MOV:
						case Shader::OPCODE_ADD:
						case Shader::OPCODE_SUB:
						case Shader::OPCODE_MUL:
						case Shader::OPCODE_MAD:
						case Shader::OPCODE_ABS:
						case Shader::OPCODE_CMP0:
						case Shader::OPCODE_CND:
						case Shader::OPCODE_FRC:
						case Shader::OPCODE_LRP:
						case Shader::OPCODE_MAX:
						case Shader::OPCODE_MIN:
						case Shader::OPCODE_CMP:
						case Shader::OPCODE_BREAKC:
						case Shader::OPCODE_DFDX:
						case Shader::OPCODE_DFDY:
							interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, mask);
							interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, mask);
							interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, mask);
							interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, mask);
							break;
						case Shader::OPCODE_TEXCOORD:
							interpolant[index][0] = true;
							interpolant[index][1] = true;
							interpolant[index][2] = true;
							interpolant[index][3] = true;
							break;
						case Shader::OPCODE_TEXDP3:
						case Shader::OPCODE_TEXDP3TEX:
						case Shader::OPCODE_TEXM3X2PAD:
						case Shader::OPCODE_TEXM3X3PAD:
						case Shader::OPCODE_TEXM3X2TEX:
						case Shader::OPCODE_TEXM3X3SPEC:
						case Shader::OPCODE_TEXM3X3VSPEC:
						case Shader::OPCODE_TEXBEM:
						case Shader::OPCODE_TEXBEML:
						case Shader::OPCODE_TEXM3X2DEPTH:
						case Shader::OPCODE_TEXM3X3:
						case Shader::OPCODE_TEXM3X3TEX:
							interpolant[index][0] = true;
							interpolant[index][1] = true;
							interpolant[index][2] = true;
							break;
						case Shader::OPCODE_TEXREG2AR:
						case Shader::OPCODE_TEXREG2GB:
						case Shader::OPCODE_TEXREG2RGB:
							break;
						default:
						//	ASSERT(false);   // Refine component usage
							interpolant[index][0] = true;
							interpolant[index][1] = true;
							interpolant[index][2] = true;
							interpolant[index][3] = true;
						}
					}
				}
			}

			for(int index = 0; index < MAX_INPUT_VARYINGS; index++)
			{
				for(int component = 0; component < 4; component++)
				{
					if(!interpolant[index][component])
					{
						semantic[index][component] = Semantic();
					}
				}
			}
		}
		else   // Shader Model 3.0 input declaration; v# indexable
		{
			for(unsigned int i = 0; i < instruction.size(); i++)
			{
				if(instruction[i]->opcode == Shader::OPCODE_DCL)
				{
					if(instruction[i]->dst.type == Shader::PARAMETER_INPUT)
					{
						unsigned char usage = instruction[i]->usage;
						unsigned char index = instruction[i]->usageIndex;
						unsigned char mask = instruction[i]->dst.mask;
						unsigned char reg = instruction[i]->dst.index;

						if(mask & 0x01)	semantic[reg][0] = Semantic(usage, index);
						if(mask & 0x02) semantic[reg][1] = Semantic(usage, index);
						if(mask & 0x04) semantic[reg][2] = Semantic(usage, index);
						if(mask & 0x08)	semantic[reg][3] = Semantic(usage, index);
					}
					else if(instruction[i]->dst.type == Shader::PARAMETER_MISCTYPE)
					{
						unsigned char index = instruction[i]->dst.index;

						if(index == 0)
						{
							vPosDeclared = true;
						}
						else if(index == 1)
						{
							vFaceDeclared = true;
						}
						else ASSERT(false);
					}
				}
			}
		}

		if(version >= 0x0200)
		{
			for(unsigned int i = 0; i < instruction.size(); i++)
			{
				if(instruction[i]->opcode == Shader::OPCODE_DCL)
				{
					bool centroid = instruction[i]->dst.centroid;
					unsigned char reg = instruction[i]->dst.index;

					switch(instruction[i]->dst.type)
					{
					case Shader::PARAMETER_INPUT:
						semantic[reg][0].centroid = centroid;
						break;
					case Shader::PARAMETER_TEXTURE:
						semantic[2 + reg][0].centroid = centroid;
						break;
					default:
						break;
					}

					this->centroid = this->centroid || centroid;
				}
			}
		}
	}
}