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);
}
public static List <string> VertexSourceLookup(VertexFormat vertexFormat, ShaderVersion vertexShaderVersion)
{
var toReturn = new List <string>()
{
ShaderVersionUtilites.VersionTag(vertexShaderVersion)
};
if (vertexFormat == VertexFormat.Plain)
{
toReturn.AddRange(_VertexSourceGL_Simplest);
}
else if (vertexFormat == VertexFormat.WithColor)
{
toReturn.AddRange(_VertexSourceGL_Color);
}
else if (vertexFormat == VertexFormat.WithTexture)
{
toReturn.AddRange(_VertexSourceGL_Tex);
}
else if (vertexFormat == VertexFormat.WithColorAndTexture)
{
toReturn.AddRange(_VertexSourceGL_ColorAndTex);
}
return(toReturn);
}
internal void UpdateVersion(ShaderVersion version)
{
foreach (var param in Parameters)
{
param.UpdateVersion(ChunkType, version);
}
}
public static bool Init(ShaderVersion shaderVersion = ShaderVersion.GLSL140)
{
if (initialized)
{
return(true);
}
Version = shaderVersion;
try
{
SolidUIShader = InitShader(UISolidVertexSource, UISolidFragmentSource);
TexturedUIShader = InitShader(UITexturedVertexSource, UITexturedFragmentSource);
FontShader = InitShader(FontVertexSource, FontFragmentSource);
GradientShader = InitShader(gradientVertexShaderSource, gradientFragmentShaderSource);
HueShader = InitShader(hueVertexShaderSource, hueFragmentShaderSource);
initialized = true;
}
catch (Exception)
{
}
return(initialized);
}
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 OpenGLBaseShaderManager(OpenGLBaseStateChangeWrapper glStateChanger, ShaderVersion shaderVersion)
{
d_glStateChanger = glStateChanger;
d_shaderVersion = shaderVersion;
d_shadersInitialised = false;
}
public static EffectHeader Parse(BytecodeReader chunkReader)
{
var result = new EffectHeader();
result.Version = ShaderVersion.ParseFX(chunkReader);
result.ConstantBuffers = chunkReader.ReadUInt32();
result.GlobalVariables = chunkReader.ReadUInt32();
result.ObjectCount = chunkReader.ReadUInt32();
result.SharedConstantBuffers = chunkReader.ReadUInt32();
result.SharedGlobalVariables = chunkReader.ReadUInt32();
result.SharedObjectCount = chunkReader.ReadUInt32();
result.Techniques = chunkReader.ReadUInt32();
result.FooterOffset = chunkReader.ReadUInt32();
result.StringCount = chunkReader.ReadUInt32();
result.LocalTextureCount = chunkReader.ReadUInt32();
result.DepthStencilStateCount = chunkReader.ReadUInt32();
result.BlendStateCount = chunkReader.ReadUInt32();
result.RasterizerStateCount = chunkReader.ReadUInt32();
result.LocalSamplerCount = chunkReader.ReadUInt32();
result.RenderTargetViewCount = chunkReader.ReadUInt32();
result.DepthStencilViewCount = chunkReader.ReadUInt32();
result.ShaderCount = chunkReader.ReadUInt32();
result.InlineShaderCount = chunkReader.ReadUInt32();
if (result.Version.MajorVersion >= 5)
{
result.GroupCount = chunkReader.ReadUInt32();
result.UAVCount = chunkReader.ReadUInt32();
result.InterfaceVariableCount = chunkReader.ReadUInt32();
result.InterfaceVariableElementCount = chunkReader.ReadUInt32();
result.ClassInstanceElementCount = chunkReader.ReadUInt32();
}
return(result);
}
/// <summary>
/// Creates a new instance of the <see cref="ShaderProfile"/> struct.
/// </summary>
/// <param name="version">The shader stage type.</param>
/// <param name="major">The major version.</param>
/// <param name="minor">The minor version.</param>
/// <param name="profileMajor">The profile major version.</param>
/// <param name="profileMinor">The profile minor version.</param>
public ShaderProfile(ShaderVersion version, int major, int minor, int profileMajor, int profileMinor)
{
Version = version;
Major = major;
Minor = minor;
ProfileMajor = profileMajor;
ProfileMinor = profileMinor;
}
/// <summary>
/// Creates a new instance of the <see cref="ShaderProfile"/> struct.
/// </summary>
/// <param name="version">The shader stage type.</param>
/// <param name="major">The major version.</param>
/// <param name="minor">The minor version.</param>
/// <param name="profileMajor">The profile major version.</param>
/// <param name="profileMinor">The profile minor version.</param>
public ShaderProfile(ShaderVersion version, int major, int minor, int profileMajor, int profileMinor)
{
Version = version;
Major = major;
Minor = minor;
ProfileMajor = profileMajor;
ProfileMinor = profileMinor;
}
///// <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);
}
static void ShowOutput(string shader, ShaderVersion version)
{
var workingDirectory = TestContext.CurrentContext.TestDirectory;
var source = File.ReadAllText(Path.Combine(workingDirectory, shader));
var output = ShaderBuilder.ShowOutput(source, version);
File.WriteAllText(Path.Combine(workingDirectory, shader + "." + version + ".output"), output);
}
public static string ShowOutput(string source, ShaderVersion shaderVersion)
{
var result = Process(source, shaderVersion);
if (result == null)
{
throw new ArgumentNullException("Shader translator", "Shader translator for " + shaderVersion.ToString() + " platform is null");
}
return(result.ShowOutput());
}
public PixelShader10(Device device,
string shaderSource,
string entryPoint,
ShaderVersion shaderVersion,
ShaderFlags shaderFlags = ShaderFlags.None,
EffectFlags effectFlags = EffectFlags.None) :
base(shaderSource, entryPoint, shaderVersion, shaderFlags, effectFlags)
{
m_device = device;
CreatePixelShader();
}
public static byte[] Build(string source, ShaderVersion shaderVersion, bool optimize)
{
var result = Process(source, shaderVersion);
if (result == null)
{
throw new ArgumentNullException("Shader translator", "Shader translator for " + shaderVersion.ToString() + " platform is null");
}
return(result.Build(optimize));
}
public Scope Construct(ShaderVersion shaderVersion)
{
var result = new Scope();
result.Symbols.Add("int", new Symbol()
{
Kind = SymbolKind.Type, Name = "int"
});
return(result);
}
protected ShaderBase(string shaderSource,
string entryPoint,
ShaderVersion shaderVersion,
ShaderFlags shaderFlags = ShaderFlags.None,
EffectFlags effectFlags = EffectFlags.None)
{
m_shaderByteCode = ShaderBytecode.Compile(shaderSource,
entryPoint,
shaderVersion.ToShaderVersionString(),
shaderFlags,
effectFlags);
}
static void Compile(string shader, ShaderVersion version, bool optimize)
{
var workingDirectory = TestContext.CurrentContext.TestDirectory;
var source = File.ReadAllText(Path.Combine(workingDirectory, shader));
string output = null;
var compiled = ShaderBuilder.BuildAndShowOutput(source, version, optimize, out output);
File.WriteAllText(Path.Combine(workingDirectory, shader + "." + version + ".output"), output);
File.WriteAllBytes(Path.Combine(workingDirectory, shader + "." + version + ".compiled"), compiled);
}
internal void UpdateVersion(ShaderVersion version)
{
if (Reader == null)
{
return;
}
Reader.ReadUInt32(); //Unknown
switch (version.ProgramType)
{
case ProgramType.VertexShader:
Info = VSInfo.Parse(Reader);
break;
case ProgramType.HullShader:
Info = HSInfo.Parse(Reader);
break;
case ProgramType.DomainShader:
Info = DSInfo.Parse(Reader);
break;
case ProgramType.GeometryShader:
Info = GSInfo.Parse(Reader);
break;
case ProgramType.PixelShader:
Info = PSInfo.Parse(Reader);
break;
default:
Reader.ReadBytes(ValidationInfo.UnionSize);
break;
}
if (Info != null && Info.StructSize < ValidationInfo.UnionSize)
{
//Padding
Reader.ReadBytes(ValidationInfo.UnionSize - Info.StructSize);
}
MinimumExpectedWaveLaneCount = Reader.ReadUInt32();
MaximumExpectedWaveLaneCount = Reader.ReadUInt32();
if (ChunkSize > 20)
{
var shaderKind = (PSVShaderKind)Reader.ReadByte();
UsesViewID = Reader.ReadByte();
GSMaxVertexCount = Reader.ReadByte();
SigInputElements = Reader.ReadByte();
SigOutputElements = Reader.ReadByte();
SigPatchConstOrPrimElements = Reader.ReadByte();
SigInputVectors = Reader.ReadByte();
SigOutputVectors = Reader.ReadBytes(4);
}
Reader = null;
}
/// <summary>
/// Serves as a hash function for a particular type. <see cref="M:System.Object.GetHashCode"/> is suitable for
/// use in hashing algorithms and data structures like a hash table.
/// </summary>
/// <returns>
/// A hash code for the current <see cref="T:System.Object"/>.
/// </returns>
public override int GetHashCode()
{
unchecked {
int result = ShaderVersion.GetHashCode();
foreach (string define in Defines)
{
result = (result * 397) ^ define.GetHashCode();
}
return(result);
}
}
public static string VersionTag(ShaderVersion vertexShaderVersion)
{
if (vertexShaderVersion == ShaderVersion.Version150Compatability)
{
return("#version 150 compatibility\n");
}
else if (vertexShaderVersion == ShaderVersion.Version300Core)
{
return("#version 300 core\n");
}
else
{
throw new System.InvalidOperationException("Unsupported Shader Type.");
}
}
protected ShaderBase(string embeddedSourceResourceName,
Assembly resourceAssembly,
string entryPoint,
ShaderVersion shaderVersion,
ShaderFlags shaderFlags = ShaderFlags.None,
EffectFlags effectFlags = EffectFlags.None)
{
string shaderSource = GetResourceString(embeddedSourceResourceName, resourceAssembly);
m_shaderByteCode = ShaderBytecode.Compile(shaderSource,
entryPoint,
shaderVersion.ToShaderVersionString(),
shaderFlags,
effectFlags);
}
public VertexShader10(Device device,
string embeddedSourceResourceName,
string entryPoint,
ShaderVersion shaderVersion,
ShaderFlags shaderFlags = ShaderFlags.None,
EffectFlags effectFlags = EffectFlags.None) :
base(embeddedSourceResourceName,
entryPoint,
shaderVersion,
shaderFlags,
effectFlags)
{
m_device = device;
CreatePixelShader();
}
protected void ParseInstance(BytecodeReader reader, uint chunkSize)
{
Version = ShaderVersion.ParseShex(reader);
var sizeInUint32 = reader.ReadUInt32();
var dxilMagic = reader.ReadUInt32();
DxilVersion = reader.ReadUInt32();
var bitcodeOffset = reader.ReadUInt32();
Debug.Assert(bitcodeOffset == 16, "Unexpected bitcode offset found");
var bitcodeLength = reader.ReadInt32();
var bitcodeReader = reader.CopyAtCurrentPosition();
Bitcode = bitcodeReader.ReadBytes(bitcodeLength);
}
public static SamplerDeclarationToken Parse(BytecodeReader reader, ShaderVersion version)
{
var token0 = reader.ReadUInt32();
var operand = Operand.Parse(reader, token0.DecodeValue <OpcodeType>(0, 10));
var result = new SamplerDeclarationToken
{
SamplerMode = token0.DecodeValue <SamplerMode>(11, 14),
Operand = operand
};
if (version.IsSM51)
{
result.SpaceIndex = reader.ReadUInt32();
}
return(result);
}
public static ConstantBufferDeclarationToken Parse(BytecodeReader reader, ShaderVersion version)
{
var token0 = reader.ReadUInt32();
var result = new ConstantBufferDeclarationToken
{
AccessPattern = token0.DecodeValue <ConstantBufferAccessPattern>(11, 11),
Operand = Operand.Parse(reader, token0.DecodeValue <OpcodeType>(0, 10))
};
if (version.IsSM51)
{
result.m_ConstantBufferSize = reader.ReadUInt32();
result.SpaceIndex = reader.ReadUInt32();
}
return(result);
}
public static Sfi0Chunk Parse(BytecodeReader reader, ShaderVersion version, uint chunkSize)
{
var flags = (ShaderRequiresFlags)reader.ReadInt32();
var result = new Sfi0Chunk();
result.Flags = flags;
Debug.Assert(chunkSize == 8,
$"Unexpected Sfi0 Chunk Size");
Debug.Assert((flags & (ShaderRequiresFlags.UavsAtEveryStage)) == 0,
$"Unexpected SfiFlags {Convert.ToString((int)flags, 2)} {flags.ToString()}");
Debug.Assert(!int.TryParse(flags.ToString(), out _),
$"Unexpected SfiFlags {Convert.ToString((int)flags, 2)} {flags.ToString()}");
var unknown0 = reader.ReadUInt32();
Debug.Assert(unknown0 == 0, "Sfi0 unknown value");
result._version = version;
return(result);
}
public static ShaderTranslator Process(string source, ShaderVersion shaderVersion)
{
ShaderParser parser = new ShaderParser();
parser.Process(source);
Type translatorType;
if (_supportedTranslators.TryGetValue(shaderVersion, out translatorType))
{
ShaderTranslator result = Activator.CreateInstance(translatorType, parser) as ShaderTranslator;
result.Process();
return(result);
}
return(null);
}
internal void UpdateVersion(ChunkType chunkType, ShaderVersion version)
{
ProgramType programType = version.ProgramType;
if (chunkType == ChunkType.Pcsg && programType == ProgramType.HullShader)
{
ReadWriteMask = (ComponentMask)(ComponentMask.All - ReadWriteMask);
}
// Vertex and pixel shaders need special handling for SystemValueType in the output signature.
if ((programType == ProgramType.PixelShader || programType == ProgramType.VertexShader) &&
(chunkType == ChunkType.Osg5 || chunkType == ChunkType.Osgn || chunkType == ChunkType.Osg1))
{
if (Register == 0xffffffff)
{
switch (SemanticName.ToUpper())
{
case "SV_DEPTH":
SystemValueType = Name.Depth;
break;
case "SV_COVERAGE":
SystemValueType = Name.Coverage;
break;
case "SV_DEPTHGREATEREQUAL":
SystemValueType = Name.DepthGreaterEqual;
break;
case "SV_DEPTHLESSEQUAL":
SystemValueType = Name.DepthLessEqual;
break;
case "SV_STENCILREF":
SystemValueType = Name.StencilRef;
break;
}
}
else if (programType == ProgramType.PixelShader)
{
SystemValueType = Name.Target;
}
}
}
public static ShaderFile CreateEmpty(ShaderVersion shaderVersion = ShaderVersion.GlslEs300, IGlobalScopeFactory globalScopeFactory = null)
{
globalScopeFactory = globalScopeFactory ?? new GlobalScopeFactory();
ShaderFile result = new ShaderFile();
result.SyntaxTree = new Root()
{
Version = shaderVersion
};
var globalScope = globalScopeFactory.Construct(shaderVersion);
SemanticModelBuilderVisitor sBuilder = new SemanticModelBuilderVisitor();
SemanticModelBuilderContext sContext = new SemanticModelBuilderContext();
sBuilder.Visit(result.SyntaxTree, sContext);
result.SemanticContext = new SemanticContext(sContext.Result, globalScope);
return(result);
}
private void cboShaderVersion_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (!isInitialising)
{
ShaderVersion theShaderVersion = cboShaderVersion.SelectedItem as ShaderVersion;
if (theShaderVersion != null)
{
IniFiles myFiles = new IniFiles(SWGANHPAth + "swg2uu_opt.cfg");
if (theShaderVersion.DeleteKeys)
{
myFiles.DeleteKey("Direct3d9", "maxVertexShaderVersion");
myFiles.DeleteKey("Direct3d9", "maxPixelShaderVersion");
}
else
{
myFiles.WriteValue("Direct3d9", "maxVertexShaderVersion", theShaderVersion.MaxVertexShaderVersion);
myFiles.WriteValue("Direct3d9", "maxPixelShaderVersion", theShaderVersion.MaxPixelShaderVersion);
}
}
}
e.Handled = true;
}
public static ResourceDeclarationToken Parse(BytecodeReader reader, ShaderVersion version)
{
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);
var result = new ResourceDeclarationToken
{
ResourceDimension = resourceDimension,
SampleCount = sampleCount,
Operand = operand,
ReturnType = returnType
};
if (version.IsSM51)
{
result.SpaceIndex = reader.ReadUInt32();
}
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
});
}
internal static BytecodeChunk Parse(BytecodeReader chunkContentReader, uint chunkSize)
{
var result = new Level9ShaderChunk();
uint chunkSize2 = chunkContentReader.ReadUInt32();
result.Version = ShaderVersion.ParseAon9(chunkContentReader);
uint shaderSize = chunkContentReader.ReadUInt32();
var shaderOffset = chunkContentReader.ReadUInt32();
var cbMappingCount = chunkContentReader.ReadUInt16();
var cbMappingOffset = chunkContentReader.ReadUInt16();
var loopRegisterMappingCount = chunkContentReader.ReadUInt16();
var loopRegisterMappingOffset = chunkContentReader.ReadUInt16();
var unk0MappingCount = chunkContentReader.ReadUInt16();
var unk0MappingOffset = chunkContentReader.ReadUInt16();
var samplerMappingCount = chunkContentReader.ReadUInt16();
var samplerMappingOffset = chunkContentReader.ReadUInt16();
var runtimeConstantMappingCount = chunkContentReader.ReadUInt16();
var runtimeConstantMappingOffset = chunkContentReader.ReadUInt16();
if (cbMappingCount > 0)
{
var mappingReader = chunkContentReader.CopyAtOffset(cbMappingOffset);
for (int i = 0; i < cbMappingCount; i++)
{
result.ConstantBufferMappings.Add(ConstantBufferMapping.Parse(mappingReader));
}
}
if (loopRegisterMappingCount > 0)
{
var mappingReader = chunkContentReader.CopyAtOffset(loopRegisterMappingOffset);
for (int i = 0; i < loopRegisterMappingCount; i++)
{
result.LoopRegisterMappings.Add(LoopRegisterMapping.Parse(mappingReader));
}
}
if (unk0MappingCount > 0)
{
Debug.Assert(false, "Unknown Level9 Mapping");
var mappingReader = chunkContentReader.CopyAtOffset(unk0MappingOffset);
for (int i = 0; i < unk0MappingCount; i++)
{
result.Unknown0Mappings.Add(Unknown1Mapping.Parse(mappingReader));
}
}
if (samplerMappingCount > 0)
{
var mappingReader = chunkContentReader.CopyAtOffset(samplerMappingOffset);
for (int i = 0; i < samplerMappingCount; i++)
{
result.SamplerMappings.Add(SamplerMapping.Parse(mappingReader));
}
// FXC dissassembly sorts sampler mappings
result.SamplerMappings = result.SamplerMappings
.OrderBy(s => s.TargetSampler)
.ToList();
}
if (runtimeConstantMappingCount > 0)
{
var mappingReader = chunkContentReader.CopyAtOffset(runtimeConstantMappingOffset);
for (int i = 0; i < runtimeConstantMappingCount; i++)
{
result.RuntimeConstantMappings.Add(RuntimeConstantMapping.Parse(mappingReader));
}
}
var shaderChunkReader = chunkContentReader.CopyAtOffset((int)shaderOffset);
var byteCode = shaderChunkReader.ReadBytes((int)shaderSize);
using (var memoryStream = new MemoryStream(byteCode))
{
result.ShaderModel = DX9Shader.ShaderReader.ReadShader(memoryStream);
}
return(result);
}
public static EffectObjectVariable Parse(BytecodeReader reader, BytecodeReader variableReader, ShaderVersion version, bool isShared = false)
{
var result = new EffectObjectVariable();
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 = variableReader.ReadUInt32();
if (semanticOffset != 0)
{
var semanticReader = reader.CopyAtOffset((int)semanticOffset);
result.Semantic = semanticReader.ReadString();
}
else
{
result.Semantic = "";
}
result.BufferOffset = variableReader.ReadUInt32();
if (isShared)
{
return(result);
}
// Initializer data
if (result.Type.ObjectType == EffectObjectType.String)
{
for (int i = 0; i < result.ElementCount; i++)
{
var stringValueOffset = variableReader.ReadUInt32();
var stringValueReader = reader.CopyAtOffset((int)stringValueOffset);
result.Strings.Add(stringValueReader.ReadString());
}
}
if (IfHasAssignments(result.Type))
{
for (int i = 0; i < result.ElementCount; i++)
{
var assignmentCount = variableReader.ReadUInt32();
var assignments = new List <EffectAssignment>();
result.Assignments.Add(assignments);
for (int j = 0; j < assignmentCount; j++)
{
assignments.Add(EffectAssignment.Parse(reader, variableReader));
}
}
}
if (result.Type.ObjectType == EffectObjectType.GeometryShaderWithStream)
{
for (int i = 0; i < result.ElementCount; i++)
{
result.GSSOInitializers.Add(EffectGSSOInitializer.Parse(reader, variableReader));
}
}
else if (IsShader5(result.Type))
{
for (int i = 0; i < result.ElementCount; i++)
{
result.ShaderData5.Add(EffectShaderData5.Parse(reader, variableReader));
}
}
else if (IsShader(result.Type))
{
for (int i = 0; i < result.ElementCount; i++)
{
result.ShaderData.Add(EffectShaderData.Parse(reader, variableReader));
}
}
var annotationCount = variableReader.ReadUInt32();
for (int i = 0; i < annotationCount; i++)
{
result.Annotations.Add(EffectAnnotation.Parse(reader, variableReader, version));
}
return(result);
}
public static EffectBuffer Parse(BytecodeReader reader, BytecodeReader bufferReader, ShaderVersion version, bool isShared)
{
var result = new EffectBuffer();
var nameOffset = result.NameOffset = bufferReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
result.Name = nameReader.ReadString();
result.BufferSize = bufferReader.ReadUInt32();
result.BufferType = (ConstantBufferType)bufferReader.ReadUInt32();
result.VariableCount = bufferReader.ReadUInt32();
result.RegisterNumber = bufferReader.ReadUInt32();
if (!isShared)
{
var unknown0 = bufferReader.ReadUInt32();
//TODO: Unknown0
//Debug.Assert(result.Unknown0 == 0, $"EffectBuffer.Unknown0: {result.Unknown0}");
}
for (int i = 0; i < result.VariableCount; i++)
{
result.Variables.Add(EffectNumericVariable.Parse(reader, bufferReader, version, isShared));
}
return(result);
}
public static void InitShaders(ShaderVersion version = ShaderVersion.GLSL140)
{
Version = version;
try
{
SimpleTexturedShader = InitShader(SimpleTexturedVertexShader, SimpleTexturedFragmentShader);
SimpleColoredShader = InitShader(SimpleColoredVertexShader, SimpleColoredFragmentShader);
SineShader = InitShader(SineVertexShader, SimpleColoredFragmentShader);
FontShader = InitShader(FontVertexSource, FontFragmentSource);
Font3DShader = InitShader(Font3DVertexSource, FontFragmentSource);
}
catch (Exception e)
{
Console.WriteLine("Your GPU does not support programmable shaders.");
}
}
