DGL • Thema anzeigen - glsl PreCompiler

glsl PreCompiler

Moderator: DGL-Team

Seite 1 von 1

[ 8 Beiträge ]

Druckansicht

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Bergmann89

Betreff des Beitrags: glsl PreCompiler

Verfasst: Sa Jul 05, 2014 18:36

DGL Member

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC

Hey Leute,

wir sind dabei einen Teil unserer Engine umzubauen und haben uns dazu entschlossen euch daran teilhaben zu lassen. Das Ganze ist ein PreCompiler für GLSL, mit dessen Hilfe man über IFDEF und INCLUDE dynamischen Shader-Code zusammen bauen kann. Zumindest war es das bis jetzt. Das hat zwar bis jetzt ganz gut funktioniert, aber hier und da sind wir an einige Grenzen gestoßen. Deshalb haben wir uns entschlossen den Teil etwas aufzubohren. Daraus ist eine Art Klassenstruktur für GLSL-Shader entstanden, die ich im folgenden etwas genauer beschreiben will.

Wie sieht das Ganze aus?

Code:

 
{$INCLUDE 'base.frag'}
 
{$CLASS 'geometry' $EXTENDS 'base' 'base2'}
    {$META $VERSION '120'}
    
    {$DEFINE 'FACE_MODE_FRONT' '0'}
    {$DEFINE 'FACE_MODE_BACK'  '1'}
    {$DEFINE 'FACE_MODE_BOTH'  '2'}
    
    {$DEFINE 'ROUGHMAP_MULTIPLIER_NONE'  '0'}
    {$DEFINE 'ROUGHMAP_MULTIPLIER_LOW'   '1'}
    {$DEFINE 'ROUGHMAP_MULTIPLIER_HIGH'  '2'}
    
    {$ATTRIB 'colormap' 'bool' 'false'}
    {$ATTRIB 'normalmap' 'bool' 'false'}
    {$ATTRIB 'facemode' 'int' $ECHO 'FACE_MODE_FRONT'}
    {$ATTRIB 'roughmap_multiplier' 'int' $ECHO 'ROUGHMAP_MULTIPLIER_NONE'}
    
    {$FUNC 'shadow' 'float' 'shadowMapST' 'vec2' 'receiver' 'float'}
        vec2  stepSize = uShadowMapShift / (float(PCF_BOX_FILTER_RADIUS) * uShadowMapSize);
        vec2  texCoord = shadowMapST - float(PCF_BOX_FILTER_RADIUS) * stepSize;
        float startY   = texCoord.y;
        float sum      = 0.0; 
        for (int x = -PCF_BOX_FILTER_RADIUS; x <= PCF_BOX_FILTER_RADIUS; x++) {
            for (int y = -PCF_BOX_FILTER_RADIUS; y <= PCF_BOX_FILTER_RADIUS; y++) {
                sum        += step(receiver, ShadowLookup(texCoord));
                texCoord.y += stepSize.y;
            }
            texCoord.x += stepSize.x;
            texCoord.y  = startY;
        }
        return smoothstep(0.0, 1.0, sum / float(PCF_BOX_SAMPLE_COUNT));
    {$END}
    
    {$FUNC 'CalcNormalFromNormalMap' 'void'}
        {$UNIFORM 'uNormalMap' 'sampler2D'}
        {$UNIFORM 'uStrength' 'float'}
        
        {$VARYING 'vNormal' 'vec3'}
        {$VARYING 'eye' 'vec3'}
        
        {$VAR 'texCoord' 'vec2' 'gl_TexCoord[0].st'}
        {$VAR 'eye' 'vec3' 'normalize(-vVertex)'}
        {$VAR 'normal' 'vec3'}
        {$VAR 'roughMapValue' 'float', '1.0'}
 
        vec3 q0    = dFdx(eye.xyz);
        vec3 q1    = dFdy(eye.xyz);
        vec2 st0   = dFdx(texCoord.st);
        vec2 st1   = dFdy(texCoord.st);
        vec3 T     = normalize( q0 * st1.t - q1 * st0.t);
        vec3 S     = normalize(-q0 * st1.s + q1 * st0.s);
        mat3 M     = mat3(-T, -S, vNormal);
        vec4 nTex  = texture2D(uNormalMap, texCoord);
        normal     = normalize(M * ((nTex.rgb - vec3(0.5)) * vec3(uStrength, uStrength, 1.0)));
        {$IF roughmap_multiplier != '0'}
            roughMapValue = nTex.a;
        {$END}
        
        float x = {$CALL 'shadow' '0.0' '0.1'}
    {$END}
    
    {$FUNC 'CalcNormal' 'void'}
        {$IF 'normalmap'}
            {$CALL 'CalcNormalFromNormalMap'}
        {$ELSE}
            {$VARYING 'vNormal' 'vec3'}
            {$VAR 'normal' 'vec3' 'vNormal'}
            {$VAR 'roughMapValue' 'float' '1.0'}
        {$END}
    {$END}
    
    {$FUNC 'CalcColor' 'void'}
        {$INHERITED 'base2'}
        {$IF 'colormap'}
            {$VAR 'colorMapColor' 'vec4' 'texture2D(uColorMap, texCoord)'}
            {$CONST 'color' 'colorMapColor'}
        {$ELSE}
            {$CONST 'color' 'gl_Color'}
        {$END}
    {$END}
    
    {$MAIN}
        {$CALL 'CalcColor'}
        {$CALL 'CalcNormal'}
        [...]
    {$END}
{$END}

Was bedeutet das nun alles?
Compiler Direktiven haben prizipiell die Form {$IRGENDWAS ...}. Folgende Direktiven gibt es:

{$INCLUDE} - fügt dem Code-Baum eine weitere Shader-Datei hinzu
{$CLASS 'ClassName' [$EXTENDS 'BaseClass' ...]} - definiert eine Klasse mit einem bestimmten Namen und ggf. mehreren Basis-Klassen
{$DEFINE 'Name' 'Value'} - erzeugt eine Art Konstante, die nur dem PreCompiler bekannt ist und dient mehr oder weniger nur der Übersicht und um Magic Numbers zu umgehen
{$ATTRIB 'Name' 'Type' ['Initial Value']} - definiert ein Attribut, welches durch die Applikation gesetzt werden kann. Über diese Attribute kommuniziert die Applikation mit dem PreCompiler und legt indirekt fest welche Code-Teile im finalen Shader eingepflegt werden
{$FUNC 'Name' 'ReturnType' ['ParameterName' 'ParameterType' ...]} - definiert eine Funktion, welche auch später eine Funktion im Shader repräsentiert. Funktionen sind prizipiell immer virtuell und können von Kindklassen überschrieben werden.
{$UNIFORM 'Name' 'Type'} - definiert eine uniform Variable
{$VARYING 'Name' 'Type'} - definiert eine varying Variable
{$VAR 'Name' 'Type' ['Initial Value']} - definiert eine globale Shader Variable (eine Art Member-Variable)
{$IF 'logical statement'} - einfache Code-Verzweigung, hier werden die Werte der Klassen-Attribute ausgewertet
{$CALL 'FunctionName' ['Parameter' ...]} - ruft eine Funktion auf
{$MAIN} - spezielle Funktion die in einer Klassen-Hierarchie mindestens von einer Klasse definiert werden muss

(Parameter in eckigen Klammern sind optional)

Wie arbeitet das Alles?
Zunächste wird die Datei geladen und interpretiert. Anschleißened kann Applikation verschiedene Einstellungen am Shader ändern. Beim generieren des Codes wird in der $MAIN-Funktion gestartet und sich von dort aus duch den Code-Baum gearbeitet. Code-Teile die nicht benötigt werden, werden nicht im finalen Shader-Code eingefügt. Das gilt ebenso für Variabel, Uniforms, Varyings und und und ...

Das ist ersteinmal die grobe Idee dazu. Bis jetzt ist noch nix implementiert. Was haltet ihr davon? Was findet ihr gut? Was würdet ihr anders / besser machen? Wir würden das gern mit euch diskutieren. Vlt will das System ja auch der ein oder andere für seine Projekte nutzen?

Links:
Gitlab WebFrontend
Lizenz
Dokumentation (speichern unter)
Zum Meinungs-Thread

Downloads:
git clone: gitlab@git.ccs-baumann.de:bitspace/ShaderFile.git
Download lastest Source (as zip)
libShaderFile (v1.0.0.5 i386 Linux)
libShaderFile (v1.0.0.5 x86_64 Linux)
libShaderFile (v1.0.0.5 i386 Win32)
libShaderFile (v1.0.0.5 x86_64 Win64)

Gruß, das bitSpaceTeam

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Nach oben

Bergmann89

Betreff des Beitrags: Re: glsl PreCompiler

Verfasst: So Sep 14, 2014 15:52

DGL Member

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC

Hey Leute,

hat alles bisl länger gedauert als geplant, aber jetzt steht die Funktionalität soweit, das man mal was zeigen kann. Deshalb gibts jetzt ein paar einfache Beispiele, wie wir das ganze System nutzen wollen.
Prinzipiell kann man den PreCompiler auf 2 Arten nutzen:

prozedural: mit simplen Methoden und Include-Files (ähnlich wie man das von C kennt)
Pseudo-Klassen: mit virtuellen Methoden die von einer übergeordneten Klasse überschrieben werden können

Beispiel für simple Include-Files
Folgendes Beispiel beinhaltet 2 Datein:

Simple.frag: enthält die main und soll einfach die Farbe eines Fragments berechnen
Color.frag: enthält die eigentlichen Routinen zur Berechnung der Farbe und wird von Simple.frag eingefügt und aufgerufen. Weiterhin gibt es ein Attribut, welches bestimmt wie die Farbe berechnet werden soll (konstant oder aus einer Textur)

Color.frag:

Code:

{$ATTRIB UseColorMap 'false'}
 
{$IF $NOT UseColorMap}
    const vec4 COLOR = vec4(1.0, 0.75, 0.25, 1.0);
{$END}
 
{$FUNC 'vec4' GetColor}
    {$IF UseColorMap}
        {$UNIFORM 'sampler2D' uColorMap}
        return texture2D(uColorMap, gl_TexCoord[0].st);
    {$ELSE}
        return COLOR;
    {$END}
{$END}

Simple.frag:

Code:

{$INCLUDE 'Color.frag'}
 
{$MAIN}
    gl_FragColor = {$CALL GetColor};
{$END}

Programm-Code:

Code:

var ShaderFile: TengShaderFile;
var ShaderClass: IengShaderPartClass;
var Code: String;
 
ShaderFile := TengShaderFile.Create;
try
  ShaderFile.LoadFromFile('Simple.frag');
  ShaderClass := ShaderFile.Generator['']; // empty class name = file/global class
  ShaderClass.Attributes['UseColorMap'].Value := true;
  Code := ShaderClass.GenerateCode;
  // do something with 'Code'
finally
  FreeAndNil(ShaderFile);
end;

resultierender Shader-Code:

Code:

uniform sampler2D uColorMap;
 
vec4 GetColor(void)
{
    return texture2D(uColorMap, gl_TexCoord[0].st);
}
 
void main(void)
{
    gl_FragColor = GetColor();
}

Beispiel für Klassen
Jetzt wird's etwas komplizierter. Im Beispiel gibts es (ähnlich wie oben) 2 Klassen:

Simple: beinhaltet (wie oben) die main und berechnet die Farbe eines Fragments. Sie ist von der Color-Klasse abgeleitet und greift in die Berechnung der Farbe ein (siehe Simple.GetColor)
Color: die Color-Klasse berechnet (ebenfalls wie oben) die Farbe eines Fragments. Jenachdem welchen Wert das Attribut hat wird die Farbe wieder konstant gesetzt, oder aus einer Textur geladen

Code:

{$CLASS Color}
    {$ATTRIB UseColorMap 'false'}
    
    {$IF $NOT UseColorMap}
        const vec4 COLOR = (0.2, 0.4, 0.6, 0.8);
    {$END}
    
    {$FUNC 'vec4' GetColor 'vec2' 'texCoord'}
        {$IF UseColorMap}
            {$UNIFORM 'sampler2D' uColorMap}
            vec4 c = texture2D(uColorMap, texCoord);
            return c;
        {$ELSE}
            return COLOR;
        {$END}
    {$END}
{$END}
 
{$CLASS Simple $EXTENDS Color}
    {$ATTRIB UseColorMapOffset 'false'}
    {$ATTRIB UseColorModifier  'false'}
    
    {$FUNC 'vec4' GetColor 'vec2' 'texCoord'}
        {$IF UseColorMap $AND UseColorMapOffset}
            texCoord.s += 0.1;
            texCoord.t += 0.2;
        {$END}
        return {$IF UseColorModifier}
            {$UNIFORM 'vec4' uColorModifier}
            uColorModifier * 
        {$END}{$INHERITED};
    {$END}
    
    {$MAIN}
        gl_FragColor = {$CALL GetColor 'gl_TexCoord[0].st'};
    {$END}
{$END}

resultierender Shader-Code:

Code:

// UseColorMap = true
// UseColorMapOffset = true
// UseColorModifier = true
 
uniform vec4 uColorModifier;
uniform sampler2D uColorMap;
 
vec4 GetColor(vec2 texCoord)
{
    texCoord.s += 0.1;
    texCoord.t += 0.2;
    vec4 c = texture2D(uColorMap, texCoord);
    return uColorModifier * (c);
}
 
void main(void)
{
    gl_FragColor = GetColor(gl_TexCoord[0].st);
}

Zum Schluss gibt es noch einmal eine aktualisierte Liste mit allen PreCompiler-Tokens, da sich dort auch das ein oder andere geändert hat oder neu dazu gekommen ist.

[] - bedeutet optional
[X ...] - kann beliebig oft wiederholt werden
'Value' - sind Werte die in Variablen gesetzt werden können, diese Werte werden 1 zu 1 übernommen, es erfolgt keine Prüfung

Token:

{$CLASS ClassName [$EXTENDS BaseClass [...]]}
Definiert eine Klasse mit den Vorfahren "BaseClass"
{$INHERITED [BaseClass] [Parameter, ...]}
Ruft eine Methode der Basis-Klasse auf. Bei Mehrdeutigkeit muss der Name der Basis-Klasse angegeben werden. Wenn die Paramter nicht angegeben werden, dann werden die Parameter 1 zu 1 übergeben
{$INCLUDE 'Filename'}
Fügt eine Quell-Datei in den Code-Baum ein
{$META 'Fuu' 'Bar'}
Definiert Meta-Daten für den Shader (kann vom Programm ausgelesen werden)
{$META $VERSION 'version'}
Spezieller Wert für Meta-Daten. Gibt die minimale Shader-Version an.
{$META $EXTENSION 'GL_ARB_geometry_shader4' 'enable'}
Spezieller Wert für Meta-Daten. Aktiviert eine Extention.
{$META $LAYOUT '(line_strip, max_vertices = 6) out'}
Spezieller Wert für Meta-Daten. Setzt das Layout eines Geometry Shaders.

{$DEFINE TEST_DEFINE '0'}
Definiert eine PreCompiler Konstante
{$ATTRIB InvertRoughmap ['Initial Value' | DefineName]}
Definiert ein Attribute.
{$ECHO Identifier}
Gibt den Wert eines Attributes oder eines Defines aus (schreibt den Wert in den ShaderCode).

{$VAR 'Type' Name ['Initial Value']}
Definiert eine Member Variable. Wird dann im ShaderCode zu einer globalen Variable.
{$VARYING 'Type' Name}
Definiert ein Varying.
{$UNIFORM 'Type' uShadowMap}
Definiert ein Uniform.

{$CALL MethodeName['Parameter']}
Ruft eine Methode auf.
{$PROC MethodeName['ParameterType' 'ParameterName' ...] [$INLINE]} Code... {$END} {$MAIN}
Definiert eine neue Prozedur.
{$FUND 'ReturnType' 'MethodeName' ['ParameterType' 'ParameterName'] [$INLINE]} Code... {$END}
Definiert eine neue Funktion.

{$IF Expression} Code ... {$ELIF Expresion} Code... {$ELSE} Code... {$END}
Code-Verzweigung
{$MESSAGE 'message'}
Gibt eine Nachricht aus.
{$WARNING 'message'}
Gibt eine Warnung aus.
{$ERROR 'message'}
Wirf eine Exception beim generieren des Codes

Expression Operatoren:

$NOT Expression
$DEFINED Identifier
Expression $OR Expression
Expression $AND Expression
Expression $XOR Expression
Arithmetik: + | - | * | /
Normale Vergleichsoperatoren: > | < | >= | <= | <>

Soweit erstma zum aktuellen Stand. Die Unit zum selbst probieren gibts es im Laufe der folgenden Woche. Wir müssen uns erstmal überlegen wie genau wie das zur Verfügung stellen und wie wir das dann pflegen.

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Nach oben

Bergmann89

Betreff des Beitrags: Re: glsl PreCompiler

Verfasst: Fr Sep 26, 2014 20:20

DGL Member

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC

Hey Leute,

wieder mit etwas Verspätung heute das Update mit Download & Co (siehe erster Post). Wir haben den glslPreCompiler mit in den OpenGLCore aufgenommen (heißt dort uglcShaderFile). Das haben wir so gemacht, da wir den Code so besser verwalten können und nicht für jede Datei ein extra Repo/Versionnierung haben.
Der Thread hier bleibt trotzdem und wird auch in Zukunft alles was mit dem PreCompiler zu tun hat beinhalten.

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Nach oben

Bergmann89

Betreff des Beitrags: Re: glsl PreCompiler

Verfasst: Do Okt 02, 2014 17:06

DGL Member

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC

Hey,

bei der Unit haben noch einige Abhängigkeiten gefehlt. Ich hab versucht die aufzulösen, aber das ist zu sehr verstrickt. Deshalb gibts die Units jetzt mit zum Download im ersten Post. Das passt jetzt auch nicht mehr richtig in den LazOpenGLCore rein, deshalb haben wird das da wieder raus genommen. Sry für das hin und her :/

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Nach oben

Bergmann89

Betreff des Beitrags: Re: glsl PreCompiler

Verfasst: Sa Sep 12, 2015 21:24

DGL Member

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC

Hey Leute,

es gibt ein Update zum Projekt. Ich hab alles refactored und aufgeräumt. Jetzt gibt es das Projekt als komplett eigenständiges Repository. Die Links dazu findet ihr im ersten Posting.
Für die nächsten Wochen ist die Umsetzung einer dynamischen Library geplant, dass das Projekt auch in anderen Sprachen genutzt werden kann. Folgende Sprachen sind bis jetzt geplant: C, C++ und Delphi. Natürlich darf sich dann auch jeder gern einen eigenen Header für die Sprache seiner Wahl schreiben, aber diese 3 Sprachen werden sozusagen out-of-the-box unterstützt.

Eine umfassende Doku wie man das ganz nun nutzt kommt natürlich auch noch. Im Vergleich zu älteren Versionen hat sich aber nicht viel geändert. Ich würde mich sehr freuen, wenn jmd ein wenig damit rum spielt und mir etwas Feedback geben könnte.

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Nach oben

Bergmann89

Betreff des Beitrags: Re: glsl PreCompiler

Verfasst: So Sep 27, 2015 16:45

DGL Member

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC

Hey Leute,

es ist vollbracht. Ich hab soeben v1.0.0.1 von libShaderFile gebaut. Die lib steht als Windows und Linux Binary jeweils für 32bit ud 64bit zur Verfügung. Die Links findet ihr im ersten Post. Außerdem hab ich eine umfassende Dokumentation mit simplen Code-Schnipseln geschrieben. Komplette kompilierbare Code Beispiele für C, C++, FPC/Lazarus und Delphi gibt es ebenfalls. Ich hoffe damit ist jeder versorgt. Falls es doch noch Fragen und Wünsche geben sollte, dann kann er mir gern nen Post dazu im Meinungs-Thread verfassen. Einfaches Feedback zur Nützlichkeit oder Ähnlichem sind natürlich auch gern gesehen.

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Nach oben

Bergmann89

Betreff des Beitrags: Re: glsl PreCompiler

Verfasst: Di Okt 13, 2015 19:41

DGL Member

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC

Hey Leute,

hab grad ein Update (v1.0.0.3) hochgeladen. Die neue Version enthält die Möglichkeit die Shader-Files über ein Callback bzw. ein Interface zu laden. Damit ist man nicht gezwungen den ShaderCode als Datei auf der Festplatte zu lagern, sondern könnte den Code auch aus einer Datenbank, Virtuellem Dateisystem oder ähnlichem laden.

Diese Funktion war zwar im Code schon implementiert, aber noch nicht in der Bibliothek. Für diejenigen, die den Source direkt genutzt haben gibt es keine Änderungen.

Download gibts wie immer im ersten Post.

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Nach oben

Bergmann89

Betreff des Beitrags: Re: glsl PreCompiler

Verfasst: Di Okt 27, 2015 17:45

DGL Member

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC

Hey Leute,

hab grad ein Update (v1.0.0.4) mit ein paar kleinen BugFixes hochgeladen. Links wie immer im ersten Post.

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.

Nach oben

Seite 1 von 1

[ 8 Beiträge ]

Foren-Übersicht » Sonstiges » Projekte

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 2 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.