google / directxshadercompiler Goto Github PK

This project forked from microsoft/directxshadercompiler

This repo hosts the source for the DirectX Shader Compiler which is based on LLVM/Clang.

License: Other

CMake 0.37% C++ 76.31% C 3.77% Roff 0.01% Shell 0.09% Assembly 0.07% LLVM 7.92% Makefile 0.01% Python 1.06% Perl 0.03% Batchfile 0.08% JavaScript 0.04% HLSL 9.14% PowerShell 0.01% Objective-C 0.36% HTML 0.23% Cuda 0.05% C# 0.44% AppleScript 0.01% Emacs Lisp 0.02%

directxshadercompiler's Introduction

DirectX Shader Compiler

The DirectX Shader Compiler project includes a compiler and related tools used to compile High-Level Shader Language (HLSL) programs into DirectX Intermediate Language (DXIL) representation. Applications that make use of DirectX for graphics, games, and computation can use it to generate shader programs.

For more information, see the Wiki.

Features and Goals

The starting point of the project is a fork of the LLVM and Clang projects, modified to accept HLSL and emit a validated container that can be consumed by GPU drivers.

At the moment, the DirectX HLSL Compiler provides the following components:

dxc.exe, a command-line tool that can compile HLSL programs for shader model 6.0 or higher
dxcompiler.dll, a DLL providing a componentized compiler, assembler, disassembler, and validator
dxilconv.dll, a DLL providing a converter from DXBC (older shader bytecode format)
various other tools based on the above components

The Microsoft Windows SDK releases include a supported version of the compiler and validator.

The goal of the project is to allow the broader community of shader developers to contribute to the language and representation of shader programs, maintaining the principles of compatibility and supportability for the platform. It's currently in active development across two axes: language evolution (with no impact to DXIL representation), and surfacing hardware capabilities (with impact to DXIL, and thus requiring coordination with GPU implementations).

Pre-built Releases

Binary packages containing the output of this project are available from appveyor. Development kits containing only the dxc.exe driver app, the dxcompiler.dll, and the dxil.dll signing binary are available here, or in the releases tab.

SPIR-V CodeGen

As an example of community contribution, this project can also target the SPIR-V intermediate representation. Please see the doc for how HLSL features are mapped to SPIR-V, and the wiki page for how to build, use, and contribute to the SPIR-V CodeGen.

Building Sources

Note: Instead of building manually, you can download the artifacts built by Appveyor for the latest master branch at here.

Note: If you intend to build from sources on Linux/macOS, follow these instructions.

Before you build, you will need to have some additional software installed. This is the most straightforward path - see Building Sources on the Wiki for more options, including Visual Studio 2015 and Ninja support.

Git.
Python - version 3.x is required
Visual Studio 2017 - select the following workloads:
- Universal Windows Platform Development
- Desktop Development with C++
Windows SDK - version 10.0.18362.0 or newer
Windows Driver Kit - same version as the SDK

After cloning the project, you can set up a build environment shortcut by double-clicking the utils\hct\hctshortcut.js file. This will create a shortcut on your desktop with a default configuration.

Tests are built using the TAEF framework which is included in the Windows Driver Kit.

To build, run this command on the HLSL Console.

hctbuild

You can also clean, build and run tests with this command.

hctcheckin

To see a list of additional commands available, run hcthelp

Running Tests

To run tests, open the HLSL Console and run this command after a successful build.

hcttest

Some tests will run shaders and verify their behavior. These tests also involve a driver that can run these execute these shaders. See the next section on how this should be currently set up.

Running Shaders

To run shaders compiled as DXIL, you will need support from the operating system as well as from the driver for your graphics adapter. Windows 10 Creators Update is the first version to support DXIL shaders. See the Wiki for information on using experimental support or the software adapter.

Hardware Support

Hardware GPU support for DXIL is provided by the following vendors:

NVIDIA

NVIDIA's r396 drivers (r397.64 and later) provide release mode support for DXIL 1.1 and Shader Model 6.1 on Win10 1709 and later, and experimental mode support for DXIL 1.2 and Shader Model 6.2 on Win10 1803 and later. These drivers also support DXR in experimental mode.

Drivers can be downloaded from geforce.com.

AMD

AMD’s driver (Radeon Software Adrenalin Edition 18.4.1 or later) provides release mode support for DXIL 1.1 and Shader Model 6.1. Drivers can be downloaded from AMD's download site.

Intel

Intel's 15.60 drivers (15.60.0.4849 and later) support release mode for DXIL 1.0 and Shader Model 6.0 as well as release mode for DXIL 1.1 and Shader Model 6.1 (View Instancing support only).

Drivers can be downloaded from the following link Intel Graphics Drivers

Direct access to 15.60 driver (latest as of of this update) is provided below:

Installer

Release Notes related to DXIL

Making Changes

To make contributions, see the CONTRIBUTING.md file in this project.

Documentation

You can find documentation for this project in the docs directory. These contain the original LLVM documentation files, as well as two new files worth nothing:

HLSLChanges.rst: this is the starting point for how this fork diverges from the original llvm/clang sources
DXIL.rst: this file contains the specification for the DXIL format
tools/clang/docs/UsingDxc.rst: this file contains a user guide for dxc.exe

License

DirectX Shader Compiler is distributed under the terms of the University of Illinois Open Source License.

See LICENSE.txt and ThirdPartyNotices.txt for details.

Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact [email protected] with any additional questions or comments.

directxshadercompiler's People

Contributors

Stargazers

Watchers

Forkers

kamayuq littleblank yoshipaulbrophy tuboss mohammadt3anii the-mad-pirate yazici romangrechin neotim muskanmahajan37

directxshadercompiler's Issues

Handle 32bit float literals

Goals

Cover 32 bit float literals including
- Zero
- Normalized
- Denormalized
- Infinity
- NaN

Translate pass-through vertex shader

Goal

Translate the pass-through shader in #3

Add SPIR-V type manager for composite types

Goals

Design type manager for composite types
Design how to handle decorations on complicated tpes
Cover vectors, matrices, arrays, structs

Provide some experimental build?

Hi,
can enable artifacts in Appveyor?
so we have SPIR-V experimental builds to play..
thanks..

Link in effcee for FileCheck style tests

Handle for statement

Goal

Support basic for statements
Support nested for statements
No need to support early returns and loop breaks for now

Support vector type

Goal

Support vector types
Support arithmetic operators on vector types

Add more unit tests for Types and Decorations

Need test case for

vectors of different types/number-of-elements
structs with different struct decorations
structs with different member decorations
etc.

Assignment for scalar types

Goal

Support = for scalar types

Add support for Linux

Goal:

Compile clang libraries on Linux
Compile supporting LLVM libraries on Linux
Bring up hlsl2spirv on Linux
Don't care about DXIL codegen

Blocker: None

Simplify file parsing in tests

Right now we read in the test source code line by line, create a string for each line and then append the strings to a stream. We can instead read in the whole file and search for the RUN directive. Then only one temporary string for holding the RUN directive needs to be created.

Translate function calls

Goal

Support function calls
Support non-entry-point functions

Avoid emitting OpVariable for constant variables

when facing
const int a = 10;
we could theoretically just translate to:
%const_id = OpConstant %int 10

and we can use %const_id anywhere a is used.

We currently create the constant as well as a variable, and we use %var

%const_id = OpConstant %int 10
%var = OpVariable %_ptr_Function_int Function %int_10

Use DiagnosticEngine to report unimplemented features

Add Appveyor configuration

Goal:

Appveyor configuration for building and testing

Blocker: None

Handle entry point

Goals

Emit the correct OpEntryPoint for void main() {} as pixel shader

Handle if statement

Goal

Support basic if statement without early returns
Support nested if statements

Add SPIR-V module builder

Goal:

Add a SPIR-V module builder
Directly generate SPIR-V words
Handle module, function, and basic block structures

Add SPIR-V type manager for scalar types

Goal:

Design SPIR-V type manager
Cover OpTypeVoid, OpTypeBool, OpTypeInt, OpTypeFloat

Need -mfmt=<format> to specify output format

Similar to https://github.com/google/shaderc/tree/master/glslc#453--mfmtformat, we need to be able to specify the SPIR-V output format.
Most importantly, -mfmt=c is useful when we want to include a shader in the graphics pipeline.

Translate pass-through compute shader using "Raw Buffers"

Translate pass-through compute shader using "Structured Buffers"

"dxc.exe -help" has stopped working!

Handle execution mode

Goals

Emit the correct OpExecutionMode for void main() {} as pixel shader

Translate pixel shader writing constant value

Goal:

Translate float4 PSMain(): SV_TARGET { return float4(1.0f, 1.0f, 1.0f, 1.0f); }

Enable ninja build on Windows

Goal

Support Ninja generator in hctbuild & hcttest

Clean up structures & ModuleBuilder

Goal

Embed Module into ModuleBuilder
Create struct for Instruction
etc.

Add SPIR-V instruction builder

Goal:

Add a low-level SPIR-V instruction builder
Have one builder method for each instruction
Builder methods should reflect instruction layout
Optimally generate this builder from the grammar

Blocker: #1

Add basic googletest fixture for codegen test

Goals

Add a basic googletest fixture to read source file, call the compiler, and then compare result
Should support CHECK-WHOLE-PROGRAM directive

Translate constants for scalar types

Goals

cover bool, int, uint, float
For float, more detailed tasks in #58

Add SPIRV-Headers as an optional dependency

Goals

Pull in SPIRV-Headers as dependency
Use headers from SPIRV-Headers
Switch to use SPIR-V 1.0

Handle compound bitwise assignment for boolean values

E.g., for the following HLSL:

void main() {
  bool2 a, b;
  b &= a;
}

The AST is

    `-CompoundAssignOperator 0x1947ba00300 <line:6:3, col:8> 'bool2':'vector<bool, 2>' lvalue '&=' ComputeLHSTy='vector<bool, 2>' ComputeResultTy='vector<bool, 2>'
      |-DeclRefExpr 0x1947b9ffa50 <col:3> 'bool2':'vector<bool, 2>' lvalue Var 0x1947b9ff9b0 'b' 'bool2':'vector<bool, 2>'
      `-ImplicitCastExpr 0x1947ba002e8 <col:8> 'vector<bool, 2>' <HLSLCC_IntegralToBoolean>
        `-ImplicitCastExpr 0x1947ba002d0 <col:8> 'vector<int, 2>' <HLSLCC_IntegralCast>
          `-ImplicitCastExpr 0x1947b9ffaa0 <col:8> 'bool2':'vector<bool, 2>' <LValueToRValue>
            `-DeclRefExpr 0x1947b9ffa78 <col:8> 'bool2':'vector<bool, 2>' lvalue Var 0x1947b9ff930 'a' 'bool2':'vector<bool, 2>

Current codegen will emit OpBitwiseAnd for boolean types, which is forbidden by SPIR-V spec. Should fix this.

Emit debug name for functions

Get passthrough pixel shader and its SPIR-V representation

Goal:

Write up passthrough pixel shader
Write up its SPIR-V representation

Blocker: None

Consider simplifying the InstBuilder API

@antiagainst
At some point we should think again about whether it still makes sense to use a "word consumer" for the instruction builder. Instead, we could have the ".x()" function return the word vector.

For instance, I just wrote the following code in a pull request:

std::vector<uint32_t> execModeInstr;
spirv::InstBuilder ib([&execModeInstr](std::vector<uint32_t> &&words) {
  execModeInstr = std::move(words);
});
ib.opExecutionMode(funcId, spv::ExecutionMode::OriginUpperLeft).x();

If the above change is made, the above code would be simplified to:

auto& instr = InstrBuilder().opExecutionMode(funcId, spv::ExecutionMode::OriginUpperLeft).x();

If there is any good example of the WordConsumer functor being useful, we can keep things as they are.

Rebase and upstream existing code

Upstream code in spirv branch to Microsoft codebase
Remove googletest code checked in; structure as an external project

Add bare bone code to dump SPIR-V header

Goal:

Add a bare bone Emit SPIR-V ASTFrontendAction
Add a bare bone SPIR-V module builder
Add option to dxc to call the new action and builder to dump SPIR-V header

Blocker: None

Register generator number

Goal:

Blocker: None

Translate Clang AST scalar types into SPIR-V instructions

Goal:

Cover void, integers, and floats

Add representation for constants

Add SPIRV-Tools as an optional dependency

Goal

Pull in SPIRV-Tools as an optional dependency

Handle normal function parameters

Goal

Generate OpFunctionParameter for normal function parameters (without semantics)

Handle storage class when generating vector swizzles

Add SPIR-V type manager for image and opaque types

Goals

Design how to handle image and opaque types
Include Decoration handling

Handle function parameters

Get passthrough vertex shader and its SPIR-V representation

Goal:

Write up passthrough vertex shader
Write up its SPIR-V representation

Blocker: None

Set up unit testing mechanism

Goal:

Investigate existing testing mechanisms
Gate testing SPIR-V unit tests with a new option
Add test for dumping SPIR-V header

Blocker: #1

Translate pass-through pixel shader

Goal

Fully translate the following shader:

float4 main(float4 input: COLOR) : SV_TARGET {
  return input;
}

Add separate command line tool hlsl2spirv

Goal:

Add a separate command line tool hlsl2spirv for SPIR-V generation
Using CompilerInstance and FrontendAction directly
No need to support dxc command line options yet

Blocker: None

Add doc for SPIR-V codegen

Goals

Add SPIR-V.rst in docs/
Cover designs and logistics
Cover mappings between HLSL and SPIR-V

google / directxshadercompiler Goto Github PK

directxshadercompiler's Introduction

DirectX Shader Compiler

Features and Goals

Pre-built Releases

SPIR-V CodeGen

Building Sources

Running Tests

Running Shaders

Hardware Support

NVIDIA

AMD

Intel

Making Changes

Documentation

License

Code of Conduct

directxshadercompiler's People

Contributors

Stargazers

Watchers

Forkers

directxshadercompiler's Issues

Recommend Projects

Recommend Topics

Recommend Org