Exemplo n.º 1
0
		public static InterfaceSlot Parse(BytecodeReader reader, BytecodeReader interfaceSlotReader)
		{
			var slotSpan = interfaceSlotReader.ReadUInt32();

			var count = interfaceSlotReader.ReadUInt32();

			var typeIDsOffset = interfaceSlotReader.ReadUInt32();
			var typeIDsReader = reader.CopyAtOffset((int) typeIDsOffset);

			var tableIDsOffset = interfaceSlotReader.ReadUInt32();
			var tableIDsReader = reader.CopyAtOffset((int) tableIDsOffset);

			var result = new InterfaceSlot
			{
				SlotSpan = slotSpan
			};

			for (int i = 0; i < count; i++)
			{
				result.TypeIDs.Add(typeIDsReader.ReadUInt16());
				result.TableIDs.Add(tableIDsReader.ReadUInt32());
			}

			return result;
		}
		public static ShaderMessageDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			var length = reader.ReadUInt32() - 2;

			var result = new ShaderMessageDeclarationToken
			{
				DeclarationLength = length,
				InfoQueueMessageID = reader.ReadUInt32(),
				MessageFormat = (ShaderMessageFormat) reader.ReadUInt32(),
				NumCharacters = reader.ReadUInt32(),
				NumOperands = reader.ReadUInt32(),
				OperandsLength = reader.ReadUInt32()
			};

			for (int i = 0; i < result.NumOperands; i++)
				result.Operands.Add(Operand.Parse(reader, OpcodeType.CustomData));

			result.Format = reader.ReadString();

			// String is padded to a multiple of DWORDs.
			uint remainingBytes = (4 - ((result.NumCharacters + 1) % 4)) % 4;
			reader.ReadBytes((int) remainingBytes);

			return result;
		}
		public static ResourceDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();

			var resourceDimension = token0.DecodeValue<ResourceDimension>(11, 15);

			byte sampleCount;
			switch (resourceDimension)
			{
				case ResourceDimension.Texture2DMultiSampled:
				case ResourceDimension.Texture2DMultiSampledArray:
					sampleCount = token0.DecodeValue<byte>(16, 22);
					break;
				default:
					sampleCount = 0;
					break;
			}

			var operand = Operand.Parse(reader, token0.DecodeValue<OpcodeType>(0, 10));
			var returnType = ResourceReturnTypeToken.Parse(reader);

			return new ResourceDeclarationToken
			{
				ResourceDimension = resourceDimension,
				SampleCount = sampleCount,
				Operand = operand,
				ReturnType = returnType
			};
		}
Exemplo n.º 4
0
		public static ConstantBuffer Parse(
			BytecodeReader reader, BytecodeReader constantBufferReader,
			ShaderVersion target)
		{
			uint nameOffset = constantBufferReader.ReadUInt32();
			var nameReader = reader.CopyAtOffset((int) nameOffset);

			uint variableCount = constantBufferReader.ReadUInt32();
			uint variableOffset = constantBufferReader.ReadUInt32();

			var result = new ConstantBuffer
			{
				Name = nameReader.ReadString()
			};

			var variableReader = reader.CopyAtOffset((int) variableOffset);
			for (int i = 0; i < variableCount; i++)
				result.Variables.Add(ShaderVariable.Parse(reader, variableReader, target, i == 0));

			result.Size = constantBufferReader.ReadUInt32();
			result.Flags = (ConstantBufferFlags) constantBufferReader.ReadUInt32();
			result.BufferType = (ConstantBufferType) constantBufferReader.ReadUInt32();

			return result;
		}
Exemplo n.º 5
0
		public static ShaderProgramChunk Parse(BytecodeReader reader)
		{
			var program = new ShaderProgramChunk
			{
				Version = ShaderVersion.ParseShex(reader),

				// Length Token (LenTok)
				// Always follows VerTok
				// [31:00] Unsigned integer count of number of DWORDs in program code, including version and length tokens.
				// So the minimum value is 0x00000002 (if an empty program is ever valid).
				Length = reader.ReadUInt32()
			};

			while (!reader.EndOfBuffer)
			{
				// Opcode Format (OpcodeToken0)
				//
				// [10:00] D3D10_SB_OPCODE_TYPE
				// if( [10:00] == D3D10_SB_OPCODE_CUSTOMDATA )
				// {
				//    Token starts a custom-data block.  See "Custom-Data Block Format".
				// }
				// else // standard opcode token
				// {
				//    [23:11] Opcode-Specific Controls
				//    [30:24] Instruction length in DWORDs including the opcode token.
				//    [31]    0 normally. 1 if extended operand definition, meaning next DWORD
				//            contains extended opcode token.
				// }
				var opcodeHeaderReader = reader.CopyAtCurrentPosition();
				var opcodeToken0 = opcodeHeaderReader.ReadUInt32();
				var opcodeHeader = new OpcodeHeader
				{
					OpcodeType = opcodeToken0.DecodeValue<OpcodeType>(0, 10),
					Length = opcodeToken0.DecodeValue(24, 30),
					IsExtended = (opcodeToken0.DecodeValue(31, 31) == 1)
				};

				OpcodeToken opcodeToken;
				if (opcodeHeader.OpcodeType == OpcodeType.CustomData)
				{
					opcodeToken = CustomDataToken.Parse(reader, opcodeToken0);
				}
				else if (opcodeHeader.OpcodeType.IsDeclaration())
				{
					opcodeToken = DeclarationToken.Parse(reader, opcodeHeader.OpcodeType);
				}
				else // Not custom data or declaration, so must be instruction.
				{
					opcodeToken = InstructionToken.Parse(reader, opcodeHeader);
				}

				opcodeToken.Header = opcodeHeader;
				program.Tokens.Add(opcodeToken);
			}

			program.LinkControlFlowInstructions();

			return program;
		}
		public static ResourceDefinitionChunk Parse(BytecodeReader reader)
		{
			var headerReader = reader.CopyAtCurrentPosition();

			uint constantBufferCount = headerReader.ReadUInt32();
			uint constantBufferOffset = headerReader.ReadUInt32();
			uint resourceBindingCount = headerReader.ReadUInt32();
			uint resourceBindingOffset = headerReader.ReadUInt32();
			var target = ShaderVersion.ParseRdef(headerReader);
			uint flags = headerReader.ReadUInt32();

			var creatorOffset = headerReader.ReadUInt32();
			var creatorReader = reader.CopyAtOffset((int) creatorOffset);
			var creator = creatorReader.ReadString();

			var result = new ResourceDefinitionChunk
			{
				Target = target,
				Flags = (ShaderFlags) flags,
				Creator = creator
			};

			if (target.MajorVersion >= 5)
			{
				string rd11 = headerReader.ReadUInt32().ToFourCcString();
				if (rd11 != "RD11")
					throw new ParseException("Expected RD11.");

				var unknown1 = headerReader.ReadUInt32(); // TODO
				Debug.Assert(unknown1 == 60);

				var unknown2 = headerReader.ReadUInt32();
				Debug.Assert(unknown2 == 24);

				var unknown3 = headerReader.ReadUInt32();
				Debug.Assert(unknown3 == 32);

				var unknown4 = headerReader.ReadUInt32();
				Debug.Assert(unknown4 == 40);

				var unknown5 = headerReader.ReadUInt32();
				Debug.Assert(unknown5 == 36);

				var unknown6 = headerReader.ReadUInt32();
				Debug.Assert(unknown6 == 12);

				result.InterfaceSlotCount = headerReader.ReadUInt32();
			}

			var constantBufferReader = reader.CopyAtOffset((int) constantBufferOffset);
			for (int i = 0; i < constantBufferCount; i++)
				result.ConstantBuffers.Add(ConstantBuffer.Parse(reader, constantBufferReader, result.Target));

			var resourceBindingReader = reader.CopyAtOffset((int) resourceBindingOffset);
			for (int i = 0; i < resourceBindingCount; i++)
				result.ResourceBindings.Add(ResourceBinding.Parse(reader, resourceBindingReader));

			return result;
		}
		public static GeometryShaderMaxOutputVertexCountDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new GeometryShaderMaxOutputVertexCountDeclarationToken
			{
				MaxPrimitives = reader.ReadUInt32()
			};
		}
		public static RawShaderResourceViewDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new RawShaderResourceViewDeclarationToken
			{
				Operand = Operand.Parse(reader, token0.DecodeValue<OpcodeType>(0, 10))
			};
		}
		public static GeometryShaderOutputPrimitiveTopologyDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new GeometryShaderOutputPrimitiveTopologyDeclarationToken
			{
				PrimitiveTopology = token0.DecodeValue<PrimitiveTopology>(11, 17)
			};
		}
		public static GeometryShaderInputPrimitiveDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new GeometryShaderInputPrimitiveDeclarationToken
			{
				Primitive = token0.DecodeValue<Primitive>(11, 16)
			};
		}
		public static ControlPointCountDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new ControlPointCountDeclarationToken
			{
				ControlPointCount = token0.DecodeValue(11, 16)
			};
		}
		public static TempRegisterDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new TempRegisterDeclarationToken
			{
				TempCount = reader.ReadUInt32()
			};
		}
Exemplo n.º 13
0
		public static Number Parse(BytecodeReader reader)
		{
			const int byteCount = 4;
			var bytes = new byte[byteCount];
			for (int i = 0; i < byteCount; i++)
				bytes[i] = reader.ReadByte();
			return new Number(bytes);
		}
		public static GeometryShaderInstanceCountDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new GeometryShaderInstanceCountDeclarationToken
			{
				InstanceCount = reader.ReadUInt32()
			};
		}
		public static TessellatorPartitioningDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new TessellatorPartitioningDeclarationToken
			{
				Partitioning = token0.DecodeValue<TessellatorPartitioning>(11, 13)
			};
		}
		public static FunctionBodyDeclarationToken Parse(BytecodeReader reader)
		{
			uint token0 = reader.ReadUInt32();
			return new FunctionBodyDeclarationToken
			{
				Identifier = reader.ReadUInt32()
			};
		}
		public static HullShaderMaxTessFactorDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new HullShaderMaxTessFactorDeclarationToken
			{
				MaxTessFactor = reader.ReadSingle()
			};
		}
		public static HullShaderForkPhaseInstanceCountDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new HullShaderForkPhaseInstanceCountDeclarationToken
			{
				InstanceCount = reader.ReadUInt32()
			};
		}
		public static GlobalFlagsDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new GlobalFlagsDeclarationToken
			{
				Flags = token0.DecodeValue<GlobalFlags>(11, 18)
			};
		}
		public static TessellatorDomainDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new TessellatorDomainDeclarationToken
			{
				Domain = token0.DecodeValue<TessellatorDomain>(11, 12)
			};
		}
		public static TessellatorOutputPrimitiveDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new TessellatorOutputPrimitiveDeclarationToken
			{
				OutputPrimitive = token0.DecodeValue<TessellatorOutputPrimitive>(11, 13)
			};
		}
		public static StreamDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new StreamDeclarationToken
			{
				Operand = Operand.Parse(reader, token0.DecodeValue<OpcodeType>(0, 10))
			};
		}
		public static RawUnorderedAccessViewDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new RawUnorderedAccessViewDeclarationToken
			{
				Coherency = token0.DecodeValue<UnorderedAccessViewCoherency>(16, 16),
				Operand = Operand.Parse(reader, token0.DecodeValue<OpcodeType>(0, 10))
			};
		}
		public static RawThreadGroupSharedMemoryDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new RawThreadGroupSharedMemoryDeclarationToken
			{
				Operand = Operand.Parse(reader, token0.DecodeValue<OpcodeType>(0, 10)),
				ElementCount = reader.ReadUInt32()
			};
		}
		public static ConstantBufferDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new ConstantBufferDeclarationToken
			{
				AccessPattern = token0.DecodeValue<ConstantBufferAccessPattern>(11, 11),
				Operand = Operand.Parse(reader, token0.DecodeValue<OpcodeType>(0, 10))
			};
		}
		public static IndexableTempRegisterDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new IndexableTempRegisterDeclarationToken
			{
				RegisterIndex = reader.ReadUInt32(),
				RegisterCount = reader.ReadUInt32(),
				NumComponents = reader.ReadUInt32()
			};
		}
		public static StructuredThreadGroupSharedMemoryDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			return new StructuredThreadGroupSharedMemoryDeclarationToken
			{
				Operand = Operand.Parse(reader, token0.DecodeValue<OpcodeType>(0, 10)),
				StructByteStride = reader.ReadUInt32(),
				StructCount = reader.ReadUInt32()
			};
		}
Exemplo n.º 28
0
 public static ShaderVersion ParseShex(BytecodeReader reader)
 {
     uint versionToken = reader.ReadUInt32();
     return new ShaderVersion
     {
         MinorVersion = versionToken.DecodeValue<byte>(0, 3),
         MajorVersion = versionToken.DecodeValue<byte>(4, 7),
         ProgramType = versionToken.DecodeValue<ProgramType>(16, 31)
     };
 }
		public static SamplerDeclarationToken Parse(BytecodeReader reader)
		{
			var token0 = reader.ReadUInt32();
			var operand = Operand.Parse(reader, token0.DecodeValue<OpcodeType>(0, 10));
			return new SamplerDeclarationToken
			{
				SamplerMode = token0.DecodeValue<SamplerMode>(11, 14),
				Operand = operand
			};
		}
Exemplo n.º 30
0
		public static DebuggingChunk Parse(BytecodeReader reader, ChunkType chunkType, int chunkSize)
		{
			var result = new DebuggingChunk();

			if (chunkType == ChunkType.Sdbg) // SDGB is not supported.
				return result;

			result.PdbBytes = reader.ReadBytes(chunkSize);
			return result;
		}