pema99
commented
2 months ago Unless you need more granular control, one intended way to use the library is using the entry points found in ShaderParser.cs.
For example var decls = ShaderParser.ParseTopLevelDeclarations(source, config); instead of manually invoking HLSLParser and HLSLLexer.
The main gnarly parts of your code are attempts at analyzing the parsed syntax tree. The intended way to walk a syntax tree for analysis is by making a type that inherits from HLSLSyntaxVisitor. It implements the Visitor pattern in similar to Roslyn (google these terms if you don't know what I'm talking about). The API is in general inspired by Roslyn.
Here's how I would write your program (assuming I understand it correctly):
class StructSizeVisitor : HLSLSyntaxVisitor
{
// Output
public int ParticleStructSize = 0;
// Helpers
int GetScalarTypeSize(ScalarType scalarType)
{
switch (scalarType)
{
case ScalarType.Int:
case ScalarType.Uint:
case ScalarType.Float:
return 4;
case ScalarType.Half:
return 2;
case ScalarType.Double:
return 8;
default:
return 0; // Add whichever types you care about
}
}
// Visitor impl
public override void VisitStructTypeNode(StructTypeNode node)
{
// Only care about particle struct
if (node.Name.GetName() == "Particle" && ParticleStructSize == 0)
{
foreach (var field in node.Fields)
{
switch (field.Kind)
{
case ScalarTypeNode scalar:
ParticleStructSize += GetScalarTypeSize(scalar.Kind);
break;
case VectorTypeNode vector:
ParticleStructSize += vector.Dimension * GetScalarTypeSize(vector.Kind);
break;
case MatrixTypeNode matrix:
ParticleStructSize += matrix.FirstDimension * matrix.SecondDimension * GetScalarTypeSize(matrix.Kind);
break;
default:
break;
}
}
}
else
{
base.VisitStructTypeNode(node);
}
}
}
class Program
{
public static void Main()
{
string shaderFileContent = ...;
shaderFileContent = File.ReadAllText(shaderFilePath);
var decls = ShaderParser.ParseTopLevelDeclarations(shaderFileContent,
new HLSLParserConfig() { PreProcessorMode = PreProcessorMode.StripDirectives });
var visitor = new StructSizeVisitor();
visitor.VisitMany(decls);
Console.WriteLine(visitor.ParticleStructSize);
}
}I've also loaded your library as a local unity package and git submodule. It kinda works, but it required me to append a ~ to the end of the .Experiments and .Tests directories so they do not get loaded by unity as they throw a lot of errors.
You can use a release instead of embedding the git repo directly. I distribute the library both as multiple files (without all the .Experiments stuff etc.) and as a single file for ease of use. For the Unity use case, you could just download that single script file use it - it contains the entire library. While it sort of works, the repo isn't intended for direct use as a submodule.
HB-Stratos
Hi there! First of all, let me note that I've never dealt with a parser like this before, so I may miss things that may be obvious.
So what I've been trying to do is this: Read a compute shader, find a struct of a specific name, and determine the size of the compute buffer stride I will need to fit this struct in. As I'm building a manager for potentially artist-written compute shaders, I can't rely on manually cloning the struct on c# side to do reflection on. I also can't use what limited reflection Unity offers in ShaderUtil because ComputeShaders are not Shaders in unity.
After many, many hours of trying, I've kindof managed to hack together something that does most of what I want, but I can't help but notice that it is quite clunky and likely not how this library was intended to be used. I have read the tests and they have helped. Sadly they appear to not dive deep into trees and convert nodes, or if they do I haven't found it myself. That is why I have come here to ask how I would accomplish my goal in line with how the library was meant to be used.
At the risk of posting some very messy code, here's how I'm currently doing things:
Expand
```c# { //TODO make this dynamic string shaderFilePath = "Assets/WorkingDir/ParticleSystem2/TestParticle.compute"; string shaderFileContent = ""; if (File.Exists(shaderFilePath)) shaderFileContent = File.ReadAllText(shaderFilePath); else Debug.LogWarning("File not found at: " + shaderFilePath); var hlslParserConfig = new HLSLParserConfig() { PreProcessorMode = PreProcessorMode.StripDirectives }; var hlslTokens = HLSLLexer.Lex(shaderFileContent, null, null, true, out _); var hlslParsed = HLSLParser.ParseTopLevelDeclarations( hlslTokens, hlslParserConfig, out _, out _ ); var hlslStructs = hlslParsed .Where(node => node.GetType() == typeof(StructDefinitionNode)) .ToList(); var hlslParticleStruct = hlslStructs .Where(node => node.Tokens.First(token => token.Kind == UnityShaderParser.HLSL.TokenKind.IdentifierToken ).Identifier == "Particle" ) .ToArray()[0]; var hlslParticleStructKeywords = hlslParticleStruct .Tokens.Where(token => Enum.GetName(typeof(UnityShaderParser.HLSL.TokenKind), token.Kind) .Contains("Keyword") ) .Skip(1) // skip the struct keyword itself .ToArray(); int bufferSize = 0; foreach (TokenYou can also find the entire project I am currently working on here: https://github.com/HB-Stratos/KSPShaderDev
Thanks in advance for any help and tips, and for writing this tool in the first place!
P.S.: I've also loaded your library as a local unity package and git submodule. It kinda works, but it required me to append a ~ to the end of the .Experiments and .Tests directories so they do not get loaded by unity as they throw a lot of errors. Unfortunately this means that my local git is different than the one on here, which will likely break if I try to update this repo, or if anyone else tries to clone my project repo.