public static InterfacesChunk Parse(BytecodeReader reader, uint sizeInBytes) { var headerReader = reader.CopyAtCurrentPosition(); var result = new InterfacesChunk(); var classInstanceCount = headerReader.ReadUInt32(); var classTypeCount = headerReader.ReadUInt32(); var interfaceSlotRecordCount = headerReader.ReadUInt32(); // Will be same as interfaceSlotRecordCount unless there are interface arrays. result.InterfaceSlotCount = headerReader.ReadUInt32(); // Think this is offset to start of interface slot info, but we // don't need it because it is also contained in the InterfaceSlot class var typeIDsOffset = headerReader.ReadUInt32(); var classTypeOffset = headerReader.ReadUInt32(); var availableClassReader = reader.CopyAtOffset((int)classTypeOffset); var interfaceSlotOffset = headerReader.ReadUInt32(); var interfaceSlotReader = reader.CopyAtOffset((int)interfaceSlotOffset); var unknown1 = headerReader.ReadUInt32(); Debug.Assert(unknown1.ToFourCcString() == "OSGN"); var unknown2 = headerReader.ReadUInt16(); Debug.Assert(unknown2 == 32); var unknown3 = headerReader.ReadUInt16(); Debug.Assert(unknown3 == 16); for (uint i = 0; i < classTypeCount; i++) { var classType = ClassType.Parse(reader, availableClassReader); classType.ID = i; // Really?? result.AvailableClassTypes.Add(classType); } for (uint i = 0; i < classInstanceCount; i++) { var classInstance = ClassInstance.Parse(reader, availableClassReader); result.AvailableClassInstances.Add(classInstance); } uint startSlot = 0; for (uint i = 0; i < interfaceSlotRecordCount; i++) { var interfaceSlot = InterfaceSlot.Parse(reader, interfaceSlotReader); interfaceSlot.StartSlot = startSlot; // Really?? result.InterfaceSlots.Add(interfaceSlot); startSlot += interfaceSlot.SlotSpan; } return(result); }
///// <summary> ///// Gets the corresponding interface slot for a variable that represents an interface pointer. ///// </summary> //public List<uint> InterfaceSlots { get; private set; } public static ShaderVariable Parse(BytecodeReader reader, BytecodeReader variableReader, ShaderVersion target, bool isFirst) { uint nameOffset = variableReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); var startOffset = variableReader.ReadUInt32(); uint size = variableReader.ReadUInt32(); var flags = (ShaderVariableFlags)variableReader.ReadUInt32(); var typeOffset = variableReader.ReadUInt32(); var typeReader = reader.CopyAtOffset((int)typeOffset); var shaderType = ShaderType.Parse(reader, typeReader, target, 2, isFirst, startOffset); var defaultValueOffset = variableReader.ReadUInt32(); List <Number> defaultValue = null; if (defaultValueOffset != 0) { defaultValue = new List <Number>(); var defaultValueReader = reader.CopyAtOffset((int)defaultValueOffset); if (size % 4 != 0) { throw new ParseException("Can only deal with 4-byte default values at the moment."); } for (int i = 0; i < size; i += 4) { defaultValue.Add(new Number(defaultValueReader.ReadBytes(4))); } } var name = nameReader.ReadString(); var result = new ShaderVariable { DefaultValue = defaultValue, Member = new ShaderTypeMember(0) { Name = name, Offset = startOffset, Type = shaderType }, BaseType = name, Size = size, Flags = flags }; if (target.MajorVersion >= 5) { result.StartTexture = variableReader.ReadInt32(); result.TextureSize = variableReader.ReadInt32(); result.StartSampler = variableReader.ReadInt32(); result.SamplerSize = variableReader.ReadInt32(); } return(result); }
internal static EffectNumericVariable Parse(BytecodeReader reader, BytecodeReader variableReader, ShaderVersion version, bool isShared) { var result = new EffectNumericVariable(); var nameOffset = variableReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); result.Name = nameReader.ReadString(); var typeOffset = variableReader.ReadUInt32(); var typeReader = reader.CopyAtOffset((int)typeOffset); result.Type = EffectType.Parse(reader, typeReader, version); var semanticOffset = result.SemanticOffset = variableReader.ReadUInt32(); if (semanticOffset != 0) { var semanticReader = reader.CopyAtOffset((int)semanticOffset); result.Semantic = semanticReader.ReadString(); } else { result.Semantic = ""; } result.BufferOffset = variableReader.ReadUInt32(); var defaultValueOffset = variableReader.ReadUInt32(); List <Number> defaultValue = null; var size = result.Type.PackedSize; if (defaultValueOffset != 0) { defaultValue = new List <Number>(); var defaultValueReader = reader.CopyAtOffset((int)defaultValueOffset); if (size % 4 != 0) { throw new ParseException("Can only deal with 4-byte default values at the moment."); } for (int i = 0; i < size; i += 4) { defaultValue.Add(new Number(defaultValueReader.ReadBytes(4))); } } result.DefaultValue = defaultValue; if (!isShared) { result.ExplicitBindPoint = variableReader.ReadUInt32(); } var annotationCount = variableReader.ReadUInt32(); for (int i = 0; i < annotationCount; i++) { result.Annotations.Add(EffectAnnotation.Parse(reader, variableReader, version)); } return(result); }
public static StructMember Parse(BytecodeReader reader, BytecodeReader memberReader) { var result = new StructMember(); var nameOffset = memberReader.ReadUInt32(); var typeOffset = memberReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); result.Name = nameReader.ReadString(); var typeReader = reader.CopyAtOffset((int)typeOffset); result.Type = ConstantType.Parse(reader, typeReader); return(result); }
public new static EffectVariableIndexAssignment Parse(BytecodeReader reader, BytecodeReader assignmentReader) { var result = new EffectVariableIndexAssignment(); var arrayNameOffset = assignmentReader.ReadUInt32(); var arrayNameReader = reader.CopyAtOffset((int)arrayNameOffset); result.ArrayName = arrayNameReader.ReadString(); var variableNameOffset = assignmentReader.ReadUInt32(); var variableNameReader = reader.CopyAtOffset((int)variableNameOffset); result.VariableName = variableNameReader.ReadString(); return(result); }
public static Annotation Parse(BytecodeReader reader, BytecodeReader variableReader) { var result = new Annotation(); var parameterOffset = variableReader.ReadUInt32(); var valueOffset = variableReader.ReadUInt32(); var parameterReader = reader.CopyAtOffset((int)parameterOffset); result.Parameter = Parameter.Parse(reader, parameterReader); var valueReader = reader.CopyAtOffset((int)valueOffset); result.Value = result.Parameter.ReadParameterValue(valueReader); return(result); }
public static EffectChunk Parse(BytecodeReader reader, uint size) { var headerReader = reader.CopyAtCurrentPosition(); var result = new EffectChunk(); var header = result.Header = EffectHeader.Parse(headerReader); var bodyOffset = header.Version.MajorVersion < 5 ? 0x4C : 0x60; var footerOffset = (int)(result.Header.FooterOffset + bodyOffset); var bodyReader = reader.CopyAtOffset((int)bodyOffset); var footerReader = reader.CopyAtOffset(footerOffset); var version = header.Version; for (int i = 0; i < header.ConstantBuffers; i++) { result.LocalBuffers.Add(EffectBuffer.Parse(bodyReader, footerReader, version, false)); } for (int i = 0; i < header.ObjectCount; i++) { result.LocalVariables.Add(EffectObjectVariable.Parse(bodyReader, footerReader, version, false)); } for (int i = 0; i < header.SharedConstantBuffers; i++) { result.SharedBuffers.Add(EffectBuffer.Parse(bodyReader, footerReader, version, true)); } for (int i = 0; i < header.SharedObjectCount; i++) { result.SharedVariables.Add(EffectObjectVariable.Parse(bodyReader, footerReader, version, true)); } if (header.Version.MajorVersion >= 5) { for (int i = 0; i < header.InterfaceVariableCount; i++) { result.InterfaceVariables.Add(EffectInterfaceVariable.Parse(bodyReader, footerReader, version)); } for (int i = 0; i < header.GroupCount; i++) { result.Groups.Add(EffectGroup.Parse(bodyReader, footerReader, header.Version)); } } else { for (int i = 0; i < header.Techniques; i++) { result.Techniques.Add(EffectTechnique.Parse(bodyReader, footerReader, header.Version)); } } return(result); }
public static RootParameter Parse(BytecodeReader reader, BytecodeReader paramReader, RootSignatureVersion version) { var type = (RootParameterType)paramReader.ReadUInt32(); var visibility = (ShaderVisibility)paramReader.ReadUInt32(); var bodyOffset = paramReader.ReadUInt32(); var bodyReader = reader.CopyAtOffset((int)bodyOffset); RootParameter result; switch (type) { case RootParameterType.DescriptorTable: result = RootDescriptorTable.Parse(reader, bodyReader, version); break; case RootParameterType._32BitConstants: result = RootConstants.Parse(bodyReader); break; case RootParameterType.Srv: case RootParameterType.Uav: case RootParameterType.Cbv: result = RootDescriptor.Parse(bodyReader, version); break; default: throw new InvalidOperationException($"Can't parse Root Parameter of type {type}"); } result.ParameterType = type; result.ShaderVisibility = visibility; return(result); }
public BytecodeContainer(byte[] rawBytes) { _rawBytes = rawBytes; Chunks = new List <BytecodeChunk>(); var reader = new BytecodeReader(rawBytes, 0, rawBytes.Length); var magicNumber = BitConverter.ToUInt32(rawBytes, 0); if (magicNumber == 0xFEFF2001) { Chunks.Add(EffectChunk.Parse(reader, (uint)rawBytes.Length)); return; } Header = BytecodeContainerHeader.Parse(reader); for (uint i = 0; i < Header.ChunkCount; i++) { uint chunkOffset = reader.ReadUInt32(); var chunkReader = reader.CopyAtOffset((int)chunkOffset); var chunk = BytecodeChunk.ParseChunk(chunkReader, this); if (chunk != null) { Chunks.Add(chunk); } } }
public static EffectGroup Parse(BytecodeReader reader, BytecodeReader groupReader, ShaderVersion version) { var result = new EffectGroup(); var nameOffset = groupReader.ReadUInt32(); if (nameOffset != 0) { var nameReader = reader.CopyAtOffset((int)nameOffset); result.Name = nameReader.ReadString(); } else { result.Name = ""; } var techniqueCount = groupReader.ReadUInt32(); for (int i = 0; i < techniqueCount; i++) { result.Techniques.Add(EffectTechnique.Parse(reader, groupReader, version)); } var annotationCount = groupReader.ReadUInt32(); for (int i = 0; i < annotationCount; i++) { result.Annotations.Add(EffectAnnotation.Parse(reader, groupReader, version)); } return(result); }
public static ResourceBinding Parse(BytecodeReader reader, BytecodeReader resourceBindingReader, ShaderVersion target) { uint nameOffset = resourceBindingReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); var result = new ResourceBinding { Name = nameReader.ReadString(), Type = (ShaderInputType)resourceBindingReader.ReadUInt32(), ReturnType = (ResourceReturnType)resourceBindingReader.ReadUInt32(), Dimension = (ShaderResourceViewDimension)resourceBindingReader.ReadUInt32(), NumSamples = resourceBindingReader.ReadUInt32(), BindPoint = resourceBindingReader.ReadUInt32(), BindCount = resourceBindingReader.ReadUInt32(), Flags = (ShaderInputFlags)resourceBindingReader.ReadUInt32() }; if (target.MajorVersion == 5 && target.MinorVersion == 1) { result.m_IsSM51 = true; result.SpaceIndex = resourceBindingReader.ReadUInt32(); result.ID = resourceBindingReader.ReadUInt32(); } else { result.ID = result.BindPoint; } return(result); }
public static InterfacesChunk Parse(BytecodeReader reader, uint sizeInBytes) { var headerReader = reader.CopyAtCurrentPosition(); var result = new InterfacesChunk(); var classInstanceCount = headerReader.ReadUInt32(); var classTypeCount = headerReader.ReadUInt32(); var interfaceSlotRecordCount = headerReader.ReadUInt32(); // Will be same as interfaceSlotRecordCount unless there are interface arrays. result.InterfaceSlotCount = headerReader.ReadUInt32(); headerReader.ReadUInt32(); // Think this is offset to start of interface slot info, but we don't need it. var classTypeOffset = headerReader.ReadUInt32(); var availableClassReader = reader.CopyAtOffset((int)classTypeOffset); var interfaceSlotOffset = headerReader.ReadUInt32(); var interfaceSlotReader = reader.CopyAtOffset((int)interfaceSlotOffset); for (uint i = 0; i < classTypeCount; i++) { var classType = ClassType.Parse(reader, availableClassReader); classType.ID = i; // Really?? result.AvailableClassTypes.Add(classType); } for (uint i = 0; i < classInstanceCount; i++) { var classInstance = ClassInstance.Parse(reader, availableClassReader); result.AvailableClassInstances.Add(classInstance); } uint startSlot = 0; for (uint i = 0; i < interfaceSlotRecordCount; i++) { var interfaceSlot = InterfaceSlot.Parse(reader, interfaceSlotReader); interfaceSlot.StartSlot = startSlot; // Really?? result.InterfaceSlots.Add(interfaceSlot); startSlot += interfaceSlot.SlotSpan; } return(result); }
public new static EffectInlineShaderAssignment Parse(BytecodeReader reader, BytecodeReader assignmentReader) { var result = new EffectInlineShaderAssignment(); var shaderOffset = assignmentReader.ReadUInt32(); var SODeclOffset = assignmentReader.ReadUInt32(); var shaderReader = reader.CopyAtOffset((int)shaderOffset); var shaderSize = shaderReader.ReadUInt32(); if (shaderSize != 0) { result.Shader = BytecodeContainer.Parse(shaderReader.ReadBytes((int)shaderSize)); } var SODeclReader = reader.CopyAtOffset((int)SODeclOffset); result.SODecl = SODeclReader.ReadString(); return(result); }
public new static EffectExpressionIndexAssignment Parse(BytecodeReader reader, BytecodeReader assignmentReader) { var result = new EffectExpressionIndexAssignment(); var arrayNameOffset = assignmentReader.ReadUInt32(); var arrayNameReader = reader.CopyAtOffset((int)arrayNameOffset); result.ArrayName = arrayNameReader.ReadString(); var shaderOffset = assignmentReader.ReadUInt32(); var shaderReader = reader.CopyAtOffset((int)shaderOffset); var shaderSize = shaderReader.ReadUInt32(); if (shaderSize != 0) { result.Shader = BytecodeContainer.Parse(shaderReader.ReadBytes((int)shaderSize)); } return(result); }
public static Assignment Parse(BytecodeReader reader, BytecodeReader shaderReader) { var result = new Assignment(); result.Type = (StateType)shaderReader.ReadUInt32(); result.ArrayIndex = shaderReader.ReadUInt32(); var parameterOffset = shaderReader.ReadUInt32(); var valueOffset = shaderReader.ReadUInt32(); var parameterReader = reader.CopyAtOffset((int)parameterOffset); result.Parameter = Parameter.Parse(reader, parameterReader); var valueReader = reader.CopyAtOffset((int)valueOffset); result.Value = result.Parameter.ReadParameterValue(valueReader); return(result); }
public static EffectGSSOInitializer Parse(BytecodeReader reader, BytecodeReader variableReader) { var result = new EffectGSSOInitializer(); var shaderOffset = variableReader.ReadUInt32(); var SODeclOffset = variableReader.ReadUInt32(); var bytecodeReader = reader.CopyAtOffset((int)shaderOffset); var shaderSize = bytecodeReader.ReadUInt32(); if (shaderSize != 0) { result.Shader = BytecodeContainer.Parse(bytecodeReader.ReadBytes((int)shaderSize)); } var declReader = reader.CopyAtOffset((int)SODeclOffset); result.SODecl = declReader.ReadString(); return(result); }
public static EffectAssignment Parse(BytecodeReader reader, BytecodeReader annotationReader) { //MemberType type, such as AddressV or Filter var memberType = (EffectAssignmentType)annotationReader.ReadUInt32(); // $"EffectStateAnnotationType is {memberType}"); //MemberIndex is 1 for BlendEnable[1] = TRUE; var memberIndex = annotationReader.ReadUInt32(); var assignmentType = (EffectCompilerAssignmentType)annotationReader.ReadUInt32(); var valueOffset = annotationReader.ReadUInt32(); var typeSpecificReader = reader.CopyAtOffset((int)valueOffset); EffectAssignment result; switch (assignmentType) { case EffectCompilerAssignmentType.Constant: result = EffectConstantAssignment.Parse(reader, typeSpecificReader); break; case EffectCompilerAssignmentType.Variable: result = EffectVariableAssignment.Parse(reader, typeSpecificReader); break; case EffectCompilerAssignmentType.ConstantIndex: result = EffectConstantIndexAssignment.Parse(reader, typeSpecificReader); break; case EffectCompilerAssignmentType.VariableIndex: result = EffectVariableIndexAssignment.Parse(reader, typeSpecificReader); break; case EffectCompilerAssignmentType.ExpressionIndex: result = EffectExpressionIndexAssignment.Parse(reader, typeSpecificReader); break; case EffectCompilerAssignmentType.Expression: result = EffectExpressionAssignment.Parse(reader, typeSpecificReader); break; case EffectCompilerAssignmentType.InlineShader: result = EffectInlineShaderAssignment.Parse(reader, typeSpecificReader); break; case EffectCompilerAssignmentType.InlineShader5: result = EffectInlineShader5Assignment.Parse(reader, typeSpecificReader); break; default: throw new ParseException($"Unsupported EffectCompilerAssignmentType {assignmentType}"); } result.MemberType = memberType; result.MemberIndex = memberIndex; result.AssignmentType = assignmentType; result.ValueOffset = valueOffset; return(result); }
public static Parameter Parse(BytecodeReader reader, BytecodeReader variableReader) { var result = new Parameter(); result.ParameterType = (ParameterType)variableReader.ReadUInt32(); result.ParameterClass = (ParameterClass)variableReader.ReadUInt32(); var nameOffset = variableReader.ReadUInt32(); var semanticOffset = variableReader.ReadUInt32(); if (result.ParameterClass == ParameterClass.Scalar || result.ParameterClass == ParameterClass.Vector || result.ParameterClass == ParameterClass.MatrixRows || result.ParameterClass == ParameterClass.MatrixColumns) { result.ElementCount = variableReader.ReadUInt32(); result.Rows = variableReader.ReadUInt32(); result.Columns = variableReader.ReadUInt32(); } if (result.ParameterClass == ParameterClass.Struct) { result.ElementCount = variableReader.ReadUInt32(); result.StructMemberCount = variableReader.ReadUInt32(); for (int i = 0; i < result.StructMemberCount; i++) { result.StructMembers.Add(Parameter.Parse(reader, variableReader)); } } if (result.ParameterClass == ParameterClass.Object) { result.ElementCount = variableReader.ReadUInt32(); } var nameReader = reader.CopyAtOffset((int)nameOffset); result.Name = nameReader.TryReadString(); var semanticReader = reader.CopyAtOffset((int)semanticOffset); result.Semantic = semanticReader.TryReadString(); return(result); }
public static ShaderTypeMember Parse(BytecodeReader reader, BytecodeReader memberReader, ShaderVersion target, int indent, bool isFirst, uint parentOffset) { var nameOffset = memberReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); var name = nameReader.ReadString(); var memberTypeOffset = memberReader.ReadUInt32(); var offset = memberReader.ReadUInt32(); var memberTypeReader = reader.CopyAtOffset((int)memberTypeOffset); var memberType = ShaderType.Parse(reader, memberTypeReader, target, indent, isFirst, parentOffset + offset); return(new ShaderTypeMember(parentOffset) { Name = name, Type = memberType, Offset = offset }); }
public new static RootDescriptorTable Parse(BytecodeReader reader, BytecodeReader tableReader, RootSignatureVersion version) { var result = new RootDescriptorTable(); var numDescriptorRanges = tableReader.ReadUInt32(); var descriptorRangesOffset = tableReader.ReadUInt32(); var rangeReader = reader.CopyAtOffset((int)descriptorRangesOffset); for (int i = 0; i < numDescriptorRanges; i++) { result.DescriptorRanges.Add(DescriptorRange.Parse(rangeReader, version)); } return(result); }
public static EffectInterfaceInitializer Parse(BytecodeReader reader, BytecodeReader initializerReader) { var nameOffset = initializerReader.ReadUInt32(); var index = initializerReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); var name = nameReader.ReadString(); return(new EffectInterfaceInitializer() { Name = name, Index = index }); }
public static EffectShaderData Parse(BytecodeReader reader, BytecodeReader variableReader) { var result = new EffectShaderData(); var shaderOffset = variableReader.ReadUInt32(); var bytecodeReader = reader.CopyAtOffset((int)shaderOffset); var shaderSize = bytecodeReader.ReadUInt32(); if (shaderSize != 0) { result.Shader = BytecodeContainer.Parse(bytecodeReader.ReadBytes((int)shaderSize)); } return(result); }
public new static EffectInlineShader5Assignment Parse(BytecodeReader reader, BytecodeReader variableReader) { var result = new EffectInlineShader5Assignment(); var shaderOffset = variableReader.ReadUInt32(); result.SODeclsOffset[0] = variableReader.ReadUInt32(); result.SODeclsOffset[1] = variableReader.ReadUInt32(); result.SODeclsOffset[2] = variableReader.ReadUInt32(); result.SODeclsOffset[3] = variableReader.ReadUInt32(); var SoDeclsCount = result.SODeclsCount = variableReader.ReadUInt32(); result.RasterizedStream = variableReader.ReadUInt32(); var interfaceBindingCount = variableReader.ReadUInt32(); var interfaceBindingOffset = variableReader.ReadUInt32(); var shaderReader = reader.CopyAtOffset((int)shaderOffset); var shaderSize = shaderReader.ReadUInt32(); if (shaderSize != 0) { result.Shader = BytecodeContainer.Parse(shaderReader.ReadBytes((int)shaderSize)); } for (int i = 0; i < 4; i++) { var offset = result.SODeclsOffset[i]; if (offset != 0) { var soDeclReader = reader.CopyAtOffset((int)offset); result.SODecls.Add(soDeclReader.ReadString()); } } var interfaceReader = reader.CopyAtOffset((int)interfaceBindingOffset); for (int i = 0; i < interfaceBindingCount; i++) { result.InterfaceBindings.Add(EffectInterfaceInitializer.Parse(reader, interfaceReader)); } return(result); }
public static ClassType Parse(BytecodeReader reader, BytecodeReader classTypeReader) { var nameOffset = classTypeReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); return(new ClassType { Name = nameReader.ReadString(), ID = classTypeReader.ReadUInt16(), ConstantBufferStride = classTypeReader.ReadUInt16(), Texture = classTypeReader.ReadUInt16(), Sampler = classTypeReader.ReadUInt16() }); }
public static LibHeaderChunk Parse(BytecodeReader reader, uint chunkSize) { var chunkReader = reader.CopyAtCurrentPosition(); var result = new LibHeaderChunk(); //multiple creator strings? var unknown1 = chunkReader.ReadUInt32(); Debug.Assert(unknown1 == 1, $"LibraryHeader.unknown1 is {unknown1}"); var creatorStringOffset = chunkReader.ReadUInt32(); //guessing flags, library chunk never seems to flags set. var unknown0 = chunkReader.ReadUInt32(); Debug.Assert(unknown0 == 0, "Unexpected value for LibHeaderChunk.Unknown0"); var functionCount = chunkReader.ReadUInt32(); //Contains function strings and function flags var functionInfoOffset = chunkReader.ReadUInt32(); var creatorStringReader = chunkReader.CopyAtOffset((int)creatorStringOffset); result.CreatorString = creatorStringReader.ReadString(); var functionInfoReader = reader.CopyAtOffset((int)functionInfoOffset); for (int i = 0; i < functionCount; i++) { // is 0 for lib_4_0, lib_4_1, lib_5_0 // is 1 for lib_4_0_level_9_1_vs_only, lib_4_0_level_9_3_vs_only // is 2 for lib_4_0_level_9_1_ps_only, lib_4_0_level_9_3_ps_only // is 3 for lib_4_0_level_9_1, lib_4_0_level_9_3 var mode = (ProfileMode)functionInfoReader.ReadUInt32(); var functionNameOffset = functionInfoReader.ReadUInt32(); var functionNameReader = reader.CopyAtOffset((int)functionNameOffset); var name = functionNameReader.ReadString(); result.FunctionDescs.Add(new LibraryDesc(name, mode)); } return(result); }
public static ClassInstance Parse(BytecodeReader reader, BytecodeReader classInstanceReader) { var nameOffset = classInstanceReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); var name = nameReader.ReadString(); return(new ClassInstance { Name = name, Type = classInstanceReader.ReadUInt16(), ElementCount = classInstanceReader.ReadUInt16(), ConstantBuffer = classInstanceReader.ReadUInt16(), ConstantBufferOffset = classInstanceReader.ReadUInt16(), Texture = classInstanceReader.ReadUInt16(), Sampler = classInstanceReader.ReadUInt16(), }); }
public static ResourceBinding Parse(BytecodeReader reader, BytecodeReader resourceBindingReader) { uint nameOffset = resourceBindingReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); return(new ResourceBinding { Name = nameReader.ReadString(), Type = (ShaderInputType)resourceBindingReader.ReadUInt32(), ReturnType = (ResourceReturnType)resourceBindingReader.ReadUInt32(), Dimension = (ShaderResourceViewDimension)resourceBindingReader.ReadUInt32(), NumSamples = resourceBindingReader.ReadUInt32(), BindPoint = resourceBindingReader.ReadUInt32(), BindCount = resourceBindingReader.ReadUInt32(), Flags = (ShaderInputFlags)resourceBindingReader.ReadUInt32() }); }
public static SignatureParameterDescription Parse(BytecodeReader reader, BytecodeReader parameterReader, ChunkType chunkType, SignatureElementSize size) { uint stream = 0; if (size == SignatureElementSize._7 || size == SignatureElementSize._8) { stream = parameterReader.ReadUInt32(); } uint nameOffset = parameterReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); var result = new SignatureParameterDescription { SemanticName = nameReader.ReadString(), SemanticIndex = parameterReader.ReadUInt32(), SystemValueType = (Name)parameterReader.ReadUInt32(), ComponentType = (RegisterComponentType)parameterReader.ReadUInt32(), Register = parameterReader.ReadUInt32(), Stream = stream, }; uint mask = parameterReader.ReadUInt32(); result.Mask = mask.DecodeValue <ComponentMask>(0, 7); result.ReadWriteMask = mask.DecodeValue <ComponentMask>(8, 15); if (size == SignatureElementSize._8) { MinPrecision minPrecision = (MinPrecision)parameterReader.ReadUInt32(); result.MinPrecision = minPrecision; } // This is my guesswork, but it works so far... if (chunkType == ChunkType.Osg5 || chunkType == ChunkType.Osgn || chunkType == ChunkType.Osg1) { result.ReadWriteMask = (ComponentMask)(ComponentMask.All - result.ReadWriteMask); } return(result); }
public static Pass Parse(BytecodeReader reader, BytecodeReader variableReader) { var result = new Pass(); var nameOffset = variableReader.ReadUInt32(); var annotationCount = variableReader.ReadUInt32(); var assignmentCount = variableReader.ReadUInt32(); for (int i = 0; i < annotationCount; i++) { result.Annotations.Add(Annotation.Parse(reader, variableReader)); } for (int i = 0; i < assignmentCount; i++) { result.Assignments.Add(Assignment.Parse(reader, variableReader)); } var nameReader = reader.CopyAtOffset((int)nameOffset); result.Name = nameReader.TryReadString(); return(result); }
public static EffectPass Parse(BytecodeReader reader, BytecodeReader passReader, ShaderVersion version) { var result = new EffectPass(); var nameOffset = passReader.ReadUInt32(); var nameReader = reader.CopyAtOffset((int)nameOffset); result.Name = nameReader.ReadString(); var assignmentCount = passReader.ReadUInt32(); var annotationCount = passReader.ReadUInt32(); for (int i = 0; i < annotationCount; i++) { result.Annotations.Add(EffectAnnotation.Parse(reader, passReader, version)); } for (int i = 0; i < assignmentCount; i++) { result.Assignments.Add(EffectAssignment.Parse(reader, passReader)); } return(result); }