Skip to content

Add HLSL compilation support #89

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
ArthurVasseur wants to merge 3 commits into
base: main
Choose a base branch
from
Draft

Add HLSL compilation support #89

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
87f4163
Add HLSL compilation support
ArthurVasseur Mar 31, 2026
c880aac
Implement matrix inverse helper functions and add corresponding tests
ArthurVasseur Apr 5, 2026
0c2acba
Add DXC validation for generated HLSL in unit tests
ArthurVasseur Apr 8, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
161 changes: 161 additions & 0 deletions include/NZSL/HlslWriter.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,161 @@
// Copyright (C) 2026 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Shading Language" project
// For conditions of distribution and use, see copyright notice in Config.hpp

#pragma once

#ifndef NZSL_HLSLWRITER_HPP
#define NZSL_HLSLWRITER_HPP

#include <NZSL/BackendParameters.hpp>
#include <NZSL/Config.hpp>
#include <NZSL/Ast/ExpressionVisitorExcept.hpp>
#include <NZSL/Ast/Module.hpp>
#include <NZSL/Ast/StatementVisitorExcept.hpp>
#include <NZSL/Ast/TransformerExecutor.hpp>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>

namespace nzsl
{
class NZSL_API HlslWriter : Ast::ExpressionVisitorExcept, Ast::StatementVisitorExcept

Check warning on line 23 in include/NZSL/HlslWriter.hpp

View check run for this annotation

SonarQubeCloud / SonarCloud Code Analysis

Class has 92 methods, which is greater than the 35 authorized. Split it into smaller classes. 


See more on https://sonarcloud.io/project/issues?id=NazaraEngine_ShaderLang&issues=AZ1Ff0N09DoLcXMm8_8I&open=AZ1Ff0N09DoLcXMm8_8I&pullRequest=89
{
public:
struct Environment;
struct Output;
struct Parameters;

inline HlslWriter();
HlslWriter(const HlslWriter&) = delete;
HlslWriter(HlslWriter&&) = delete;
~HlslWriter() = default;

inline Output Generate(Ast::Module& module, const BackendParameters& parameters = {}, const Parameters& hlslParameters = {});
Output Generate(std::optional<ShaderStageType> shaderStage, Ast::Module& module, const BackendParameters& parameters = {}, const Parameters& hlslParameters = {});

void SetEnv(Environment environment);

struct Environment
{
unsigned int shaderModelMajorVersion = 6;
unsigned int shaderModelMinorVersion = 0;
};

struct Parameters
{
};

struct Output
{
std::string code;
};

static void RegisterPasses(Ast::TransformerExecutor& executor);

private:
void Append(const Ast::AliasType& aliasType);
void Append(const Ast::ArrayType& type);
void Append(Ast::BuiltinEntry builtin);
void Append(const Ast::DynArrayType& type);
void Append(const Ast::ExpressionType& type);
void Append(const Ast::ExpressionValue<Ast::ExpressionType>& type);
void Append(const Ast::FunctionType& functionType);
void Append(const Ast::ImplicitArrayType& type);
void Append(const Ast::ImplicitMatrixType& type);
void Append(const Ast::ImplicitVectorType& type);
void Append(Ast::InterpolationQualifier interpolation);
void Append(const Ast::IntrinsicFunctionType& intrinsicFunctionType);
void Append(const Ast::MatrixType& matrixType);
void Append(const Ast::MethodType& methodType);
void Append(const Ast::ModuleType& methodType);
void Append(Ast::MemoryLayout layout);
void Append(const Ast::NamedExternalBlockType& namedExternalBlockType);
void Append(Ast::NoType);
void Append(Ast::PrimitiveType type);
void Append(const Ast::PushConstantType& pushConstantType);
void Append(const Ast::SamplerType& samplerType);
void Append(const Ast::StorageType& storageType);
void Append(const Ast::StructType& structType);
void Append(const Ast::TextureType& textureType);
void Append(const Ast::Type& type);
void Append(const Ast::UniformType& uniformType);
void Append(const Ast::VectorType& vecType);
template<typename T> void Append(const T& param);
template<typename T1, typename T2, typename... Args> void Append(const T1& firstParam, const T2& secondParam, Args&&... params);
template<typename... Args> void Append(const std::variant<Args...>& param);
void AppendArray(const Ast::ExpressionType& varType, const std::string& varName = {});
void AppendComment(std::string_view section);
void AppendHelperFunctions();
void AppendCommentSection(std::string_view section);
void AppendFunctionDeclaration(const Ast::DeclareFunctionStatement& node, const std::string& nameOverride, bool forward = false);
void AppendHeader();
void AppendLine(std::string_view txt = {});
template<typename... Args> void AppendLine(Args&&... params);
void AppendModuleComments(const Ast::Module& module);
void AppendSemantic(const Ast::StructDescription::StructMember& member, bool isFragmentOutput = false);
void AppendStatementList(std::vector<Ast::StatementPtr>& statements);
template<typename T> void AppendValue(const T& value);
void AppendVariableDeclaration(const Ast::ExpressionType& varType, const std::string& varName);

void EnterScope();
void LeaveScope(bool skipLine = true);

void HandleEntryPoint(Ast::DeclareFunctionStatement& node);
void HandleSourceLocation(const SourceLocation& sourceLocation, DebugLevel requiredLevel);

void RegisterConstant(std::size_t constIndex, std::string constName);
void RegisterStruct(std::size_t structIndex, Ast::StructDescription* desc, std::string structName);
void RegisterVariable(std::size_t varIndex, std::string varName);

void ScopeVisit(Ast::Statement& node);

void Visit(Ast::ExpressionPtr& expr, bool encloseIfRequired = false);

using ExpressionVisitorExcept::Visit;
void Visit(Ast::AccessFieldExpression& node) override;
void Visit(Ast::AccessIdentifierExpression& node) override;
void Visit(Ast::AccessIndexExpression& node) override;
void Visit(Ast::AssignExpression& node) override;
void Visit(Ast::BinaryExpression& node) override;
void Visit(Ast::CallFunctionExpression& node) override;
void Visit(Ast::CastExpression& node) override;
void Visit(Ast::ConstantArrayValueExpression& node) override;
void Visit(Ast::ConstantValueExpression& node) override;
void Visit(Ast::IdentifierValueExpression& node) override;
void Visit(Ast::IntrinsicExpression& node) override;
void Visit(Ast::SwizzleExpression& node) override;
void Visit(Ast::TypeConstantExpression& node) override;
void Visit(Ast::UnaryExpression& node) override;

using StatementVisitorExcept::Visit;
void Visit(Ast::BranchStatement& node) override;
void Visit(Ast::BreakStatement& node) override;
void Visit(Ast::ContinueStatement& node) override;
void Visit(Ast::DeclareAliasStatement& node) override;
void Visit(Ast::DeclareConstStatement& node) override;
void Visit(Ast::DeclareExternalStatement& node) override;
void Visit(Ast::DeclareFunctionStatement& node) override;
void Visit(Ast::DeclareOptionStatement& node) override;
void Visit(Ast::DeclareStructStatement& node) override;
void Visit(Ast::DeclareVariableStatement& node) override;
void Visit(Ast::DiscardStatement& node) override;
void Visit(Ast::ExpressionStatement& node) override;
void Visit(Ast::ImportStatement& node) override;
void Visit(Ast::MultiStatement& node) override;
void Visit(Ast::NoOpStatement& node) override;
void Visit(Ast::ReturnStatement& node) override;
void Visit(Ast::ScopedStatement& node) override;
void Visit(Ast::WhileStatement& node) override;

struct State;

Environment m_environment;
State* m_currentState;
};
}

#include <NZSL/HlslWriter.inl>

Check warning on line 159 in include/NZSL/HlslWriter.hpp

View check run for this annotation

SonarQubeCloud / SonarCloud Code Analysis

Move this #include directive to the top of the file. 


See more on https://sonarcloud.io/project/issues?id=NazaraEngine_ShaderLang&issues=AZ1Ff0N09DoLcXMm8_8H&open=AZ1Ff0N09DoLcXMm8_8H&pullRequest=89

#endif // NZSL_HLSLWRITER_HPP
16 changes: 16 additions & 0 deletions include/NZSL/HlslWriter.inl
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,16 @@
// Copyright (C) 2026 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Shading Language" project
// For conditions of distribution and use, see copyright notice in Config.hpp

namespace nzsl
{
inline HlslWriter::HlslWriter() :
m_currentState(nullptr)
{
}

inline auto HlslWriter::Generate(Ast::Module& shader, const BackendParameters& parameters, const Parameters& hlslParameters) -> Output
{
return Generate(std::nullopt, shader, parameters, hlslParameters);
}
}
Loading
Loading