Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

LukasBanana

Alter Hase

  • »LukasBanana« ist der Autor dieses Themas

Beiträge: 1 097

Beruf: Shader Tools Programmer

  • Private Nachricht senden

1

06.12.2016, 17:36

XShaderCompiler (HLSL nach GLSL Übersetzer)

Hallo allerseits,

neben meinem LLGL Projekt, habe ich vor einigen Wochen wieder die Arbeit an meinem HLSL Cross Compiler Projekt aufgenommen.
Inzwischen kann man mit dem Compiler schon (teilweise) etwas anfangen :)
Soeben habe ich den erste Pre-Release (v0.02-alpha) auf github mit fertigen Binaries für Win32, MacOS und Linux hochgeladen.

Da es ein Pre-Release ist, solltet ihr allerdings noch nicht zu viel erwartet, aber ich bin nunmal ungeduldig und möchte das Projekt endlich einmal vorstellen :D

Dem Release liegt ein sehr kurzes GettingStarted Dokument bei, in dem die wichtigsten Shell Kommands erklärt sind.
Eingabe-Sprache ist HLSL (Shader Model 4 und 5), Ausgabe-Sprache ist GLSL (1.30 bis 4.50).

Der Compiler versucht möglichst 'schönen' Ausgabe Code zu erzeugen,
d.h. Verzicht auf unnötige Wrapper-Funktionen, optionales Beibehalten von Kommentaren
und sonstige möglichst geordnete (und teils konfigurierbare) Formattierung.

Feedback ist wie immer erwünscht :thumbsup:

Gruß und schönen Nikolausabend,
Lukas

Schrompf

Alter Hase

Beiträge: 1 470

Wohnort: Dresden

Beruf: Softwareentwickler

  • Private Nachricht senden

2

07.12.2016, 08:55

Schick. Habe wirklich nur drei Minuten mal drübergespäht. Mich freut, dass Du eine liberale Lizenz benutzt und dass Du eine optionale In-Code-Konvertierung vorsiehst, bei der man den CrossCompiler einfach reinkompilieren kann. Mich hat kurz gewundert, dass Du eigene MakeUnique- und MakeShared-Aufrufe gebaut hast, genauso wie es für ToString und FromString inzwischen STL-Funktionen gibt. Aber Du warst ja eh sehr zurückhaltend mit C++11. Und ich vermute, Teile davon gehen auf den Allocator-Support zurück. Ein ordentliches Allocator-Konzept hat es leider immer noch nicht in den C++-Standard geschafft.
Häuptling von Dreamworlds. Baut aktuell an nichts konkretem, weil das Vollzeitangestelltenverhältnis ihn fest im Griff hat. Baut daneben nur noch sehr selten an der Open Asset Import Library mit.

LukasBanana

Alter Hase

  • »LukasBanana« ist der Autor dieses Themas

Beiträge: 1 097

Beruf: Shader Tools Programmer

  • Private Nachricht senden

3

07.12.2016, 11:59

std::to_string verwende ich bereits wo es geht, aber "ToString" gibt es als Member-Funktionen.
"FromString" ist eher ein work-around, das stimmt.

std::make_unique ist allerdings erst seit C++14 im Standard,
dafür habe ich mein eigenes geschrieben, weil die Zielsprache strikt C++11 sein soll.

"MakeShared" habe ich (inkonsequent) angefangen zu nutzen,
wegen dem (von dir bereits erwähnten) Memory Pool - der ist aber im Moment nur experimentell.

LukasBanana

Alter Hase

  • »LukasBanana« ist der Autor dieses Themas

Beiträge: 1 097

Beruf: Shader Tools Programmer

  • Private Nachricht senden

4

12.03.2017, 15:04

Falls jemand von euch mit DirectX und OpenGL in C# programmiert: der XShaderCompiler hat jetzt auch einen komfortablen C# wrapper:

C#-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
using System;
using System.IO;

namespace Example
{
    class Program
    {
        static void Main()
        {
            // Create instance of the XShaderCompiler
            var compiler = new XscCompiler();

            // Fill the shader input descriptor structure
            var inputDesc = new XscCompiler.ShaderInput();
            inputDesc.SourceCode     = File.ReadAllText("Example.hlsl");
            inputDesc.ShaderVersion  = XscCompiler.InputShaderVersion.HLSL5;
            inputDesc.EntryPoint     = "VS";
            inputDesc.Target         = XscCompiler.ShaderTarget.VertexShader;

            // Fill the shader output descriptor structure
            // Use outputDesc.Options, outputDesc.Formatting, and outputDesc.MameMangling for more settings
            var outputDesc = new XscCompiler.ShaderOutput();

            // Optional output log (can also be a custom class)
            var log = XscCompiler.StandardLog;

            // Optional shader reflection data (for shader code feedback)
            var reflectData = new XscCompiler.ReflectionData();

            // Translate HLSL code into GLSL
            try
            {
                bool result = compiler.CompileShader(inputDesc, outputDesc, &log, &reflectData);

                if (result)
                {
                    // Write output shader code
                    File.WriteAllText("Example.VS.vert", shaderOutput.SourceCode);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
    }
}

Legend

Alter Hase

Beiträge: 731

Beruf: Softwareentwickler

  • Private Nachricht senden

5

13.03.2017, 12:21

Muss ich mir mal ansehen. Im Moment pflege ich die Shader für DirectX und OpenGL doppelt und dieser Pflegeaufwand ist wirklich etwas, was ich mir sparen wollen würde.
"Wir müssen uns auf unsere Kernkompetenzen konzentrieren!" - "Juhu, wir machen eine Farm auf!"

Netzwerkbibliothek von mir, C#, LGPL: https://sourceforge.net/projects/statetransmitt/

Legend

Alter Hase

Beiträge: 731

Beruf: Softwareentwickler

  • Private Nachricht senden

6

13.03.2017, 23:22

Ich habe eine Frage, ich bin mir nicht sicher wie ich das Ergebnis bewerten soll.

Ich habe diesen HLSL Pixelshader:

Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "Definitions.hlsli"

Texture2D tex0;

SamplerState tex0Sampler
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Wrap;
    AddressV = Wrap;
};

float4 pshader (VS_OUTPUT data) : SV_Target
{
//  float4 color = tex2D(tex0, data.TextureUV);
    float4 color = tex0.Sample (tex0Sampler, data.TextureUV);

    return (color);
}


Der wurde zu dem hier kompiliert:

Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// GLSL Fragment Shader "pshader"
// Generated by XShaderCompiler
// 13/03/2017 23:16:36

#version 130

in vec4 xsv_WORLDPOS0;
in vec4 xsv_NORMAL0;
in vec2 xsv_TEXCOORD0;

out vec4 SV_Target0;

uniform sampler2D tex0;

void main()
{
    vec4 color = texture(tex0, xsv_TEXCOORD0);
    SV_Target0 = (color);
}


out vec4 SV_Target0?

Meine manuelle Übersetzung sieht so aus:

Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
#version 140

varying vec4 fWorldPos;
varying vec4 fNormal;
varying vec2 fMultiTexCoord0;

uniform sampler2D tex0;

void main()
{
    gl_FragColor = texture(tex0, fMultiTexCoord0);
//  gl_FragColor = vec4(fMultiTexCoord0.x, fMultiTexCoord0.y, 0.0f, 1.0f);
}


Aufgerufen habe ich den Compiler so:

Quellcode

1
2
3
E:\Temp\XShaderCompiler\Build\build\Debug>xsc -T frag -E pshader pixelshader_unlit.hlsl
compile "pixelshader_unlit.hlsl" to "pixelshader_unlit.pshader.frag"
compilation successful
"Wir müssen uns auf unsere Kernkompetenzen konzentrieren!" - "Juhu, wir machen eine Farm auf!"

Netzwerkbibliothek von mir, C#, LGPL: https://sourceforge.net/projects/statetransmitt/

7

14.03.2017, 05:27

Warum kein C++14? Die einzige Plattform, auf der man Hlsl zu Glsl konvertieren wollte, ist Windows und alle Compiler dafür unterstützen C++14.

Schrompf

Alter Hase

Beiträge: 1 470

Wohnort: Dresden

Beruf: Softwareentwickler

  • Private Nachricht senden

8

14.03.2017, 07:51

out vec4 SV_Target0?


Macht denn das überhaupt einen Unterschied? Der Shader-Compiler dürfte doch mit Sicherheit die doppelte Zuweisung optimieren, und dann sieht's wieder aus wie Deine manuelle Version.
Häuptling von Dreamworlds. Baut aktuell an nichts konkretem, weil das Vollzeitangestelltenverhältnis ihn fest im Griff hat. Baut daneben nur noch sehr selten an der Open Asset Import Library mit.

Legend

Alter Hase

Beiträge: 731

Beruf: Softwareentwickler

  • Private Nachricht senden

9

14.03.2017, 08:57

out vec4 SV_Target0?


Macht denn das überhaupt einen Unterschied? Der Shader-Compiler dürfte doch mit Sicherheit die doppelte Zuweisung optimieren, und dann sieht's wieder aus wie Deine manuelle Version.


Mein Kenntnisstand ist, dass Fragmentshader ihre berechnete Farbe über gl_FragColor ausgeben müssen. In der manuellen Version wird gl_FragColor nicht von mir definiert.
"Wir müssen uns auf unsere Kernkompetenzen konzentrieren!" - "Juhu, wir machen eine Farm auf!"

Netzwerkbibliothek von mir, C#, LGPL: https://sourceforge.net/projects/statetransmitt/

LukasBanana

Alter Hase

  • »LukasBanana« ist der Autor dieses Themas

Beiträge: 1 097

Beruf: Shader Tools Programmer

  • Private Nachricht senden

10

14.03.2017, 10:47

Mein Kenntnisstand ist, dass Fragmentshader ihre berechnete Farbe über gl_FragColor ausgeben müssen.

gl_FragColor ist seit GLSL 1.30 veraltet, man kann es aber noch verwenden, wenn man will.
Seit GLSL ab Version 1.30 die varyings durch in/out Semantics abgelöst hat, deklariert man im Fragmentshader seine eigenen Fragement outputs.

Würde ich deinen Shader manuell übersetzen, könnte das z.B. so aussehen:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
#version 130

sampler2D tex0;

in vec2 TextureUV;

out vec4 color;

void main()
{
    color = texture(tex0, TextureUV);
}

Wenn du unbedingt gl_FragColor als Ausgabe haben willst, musst du dem XShaderCompiler sagen, dass er die GLSL Version 110 oder 120 erzwingen soll.
Standardmäßig ermittelt er die GLSL Version automatisch, und nimmt dabei GLSL 130 als minimal Wert.
In dem Command-Line Tool geht das mit xsc -Vout GLSL120 -T frag -E pshader pixelshader_unlit.hlsl

Gruß,
Lukas

Werbeanzeige