Shader GLSLFX

I file GLSLFX creano un ponte tra l’applicazione e i file dello shader glsl.
Consente di utilizzare qualsiasi shader glsl senza dover modificare il codice.

Formato file

Il formato di file GLSLFX è un file XML. I commenti sono supportati.

Intestazione e nodo principale

L’elemento nodo radice XML è denominato glslfx.

<?xml version="1.0" encoding="UTF-8"?>

<glslfx version="1.0.0" author="allegorithmic.com">

    <!-- BODY -->

    <!-- ... -->

</glslfx>

Corpo

Tecnica

Elemento XML che descrive una tecnica. Una tecnica è una variazione del FX corrente. Un GLSLFX può contenere più tecniche, ma è necessario definirne almeno una.

La geometria verrà renderizzata con una delle tecniche definite dall’applicazione.

L’elemento XML può avere più elementi figlio. Gli elementi definiti in una tecnica hanno la precedenza su quelli definiti a livello globale.

Ad esempio, viene utilizzato per ignorare alcuni valori di uniformi e ottenere la variazione FX per questa tecnica.

Passata di rendering

Elemento XML che descrive un passaggio di rendering. Una passata di rendering descrive il rendering della geometria.

Una tecnica può contenere più passaggi di rendering che verranno eseguiti in sequenza. Una tecnica che non contiene passaggi di rendering equivale a una tecnica che contiene passaggi di rendering “su schermo”.

Gli elementi definiti in una passata di rendering hanno la precedenza su quelli definiti nella tecnica principale.

Shader

Impostate i file di shader GLSL per ciascun tipo.

Definizione elemento XML:

Proprietà

Consentire di impostare parte dello stato OpenGL.

Uniformi

Consente di ignorare alcune uniformi definite a livello globale o nella tecnica principale. Ciò consente di modificare il comportamento dello shader per questa tecnica o passaggio di rendering.

Per ulteriori dettagli sulla definizione delle uniformi, vedere la sezione seguente.

+++Esempio

+++

Destinazioni rendering

Per i passaggi di rendering “fuori schermo”, è necessario definire le destinazioni di rendering nel passaggio di rendering.

Informazioni sui formati

Per i formati profondità, sono supportati tutti i formati OpenGL solo profondità (senza stencil):

Per i formati colore, il nome è basato sui nomi enum OpenGL, senza il prefisso ‘GL_’, in lettere minuscole.
I formati a tre canali (RGB) non sono supportati. Utilizza invece un formato RGBA.
Profondità di bit per canale supportato:

Un’eccezione a queste regole è il formato GL_R11F_G11F_B10F, che è supportato.:

Campionatori

Se si consente di ignorare alcuni campionatori definiti a livello globale, questi non possono essere definiti in una tecnica. Ciò consente di definire un utilizzo del campionatore per questo passaggio di rendering o di leggere da una destinazione di rendering di un passaggio di rendering precedente.

Per ulteriori dettagli sulla definizione dei campionatori, vedere la sezione Campionatori.

+++Esempio

+++

Formato vertice di input

Ciò consente di definire la semantica di ogni attributo definito nello shader dei vertici.

Definizione elemento XML:

Nome: ‘vertexformat’

Attributi:

Esempio:

<?xml version="1.0" encoding="UTF-8"?>

<glslfx version="1.0.0" author="allegorithmic.com">

     <!-- BODY -->

     <!-- ... -->

     <!-- INPUT VERTEX FORMAT -->

     <vertexformat name="iVS_Position" semantic="position"/>

     <vertexformat name="iVS_Normal" semantic="normal"/>

     <vertexformat name="iVS_UV" semantic="texcoord0"/>

     <vertexformat name="iVS_Tangent" semantic="tangent0"/>

     <vertexformat name="iVS_Binormal" semantic="binormal0"/>

</glslfx>

Campionatori

Ciò consente di definire l’uso di ciascun campionatore.
Viene utilizzato dall’applicazione per determinare la texture da impostare nei campionatori specificati.

Definizione elemento XML:

Nome: ‘sampler’

Attributi:

   <!-- SAMPLERS -->

    <sampler name="baseColorMap" usage="basecolor,diffuse"/>

     <!-- ... -->

‘isHidden’: valore booleano che indica se il campionatore deve essere visualizzato nell’interfaccia grafica

     <!-- SAMPLERS -->

    <sampler name="bluenoiseMask" usage="bluenoisemask" ishidden="true"/>

     <!-- ... -->

Modalità di disposizione:

Filtro Texture

Esempio:

<?xml version="1.0" encoding="UTF-8"?>

<glslfx version="1.0.0" author="allegorithmic.com">

     <!-- BODY -->

     <!-- ... -->

     <!-- SAMPLERS -->

     <sampler name="baseColorMap" usage="basecolor,diffuse"/>

     <sampler name="heightMap" usage="height"/>

     <sampler name="normalMap" usage="normal"/>

     <sampler name="detailNormalMap" usage="detailNormal"/>

     <sampler name="environmentMap" usage="environment"/>

     <sampler name="bluenoiseMask" usage="bluenoisemask" ishidden="true"/>

     <sampler name="sssDiffuseMap" usage="sssDiffuse"/>

</glslfx>

Uniformi

Questo consente di aggiungere ulteriori informazioni sulle uniformi di ogni shader.

Definizione elemento XML:

Nome: ‘uniforme’

Attributi:

‘name’: nome dell’uniforme nel file shader.

‘semantico’: semantico dell’uniforme. Tutte le matrici sono float16.

Esempio:

<?xml version="1.0" encoding="UTF-8"?>

<glslfx version="1.0.0" author="allegorithmic.com">

     <!-- BODY -->

     <!-- ... -->

     <!-- MATRICES -->

     <uniform name="worldMatrix" semantic="world"/>

     <uniform name="worldViewProjMatrix" semantic="worldviewprojection"/>

     <uniform name="worldViewMatrix" semantic="worldview"/>

     <uniform name="worldInverseTransposeMatrix" semantic="worldinversetranspose"/>

     <uniform name="viewInverseMatrix" semantic="viewinverse"/>

     <uniform name="modelViewMatrix" semantic="modelview"/>

     <uniform name="projectionMatrix" semantic="projection"/>

</glslfx>

Esempio:

<?xml version="1.0" encoding="UTF-8"?>

<glslfx version="1.0.0" author="allegorithmic.com">

    <!-- BODY -->

    <!-- ... -->

    <!-- SCENE PARAMETERS -->

    <uniform name="AmbiColor" semantic="ambient"/>

    <uniform name="Lamp0Pos" semantic="lightposition0"/>

    <uniform name="Lamp0Color" semantic="lightcolor0"/>

    <uniform name="Lamp1Pos" semantic="lightposition1"/>

    <uniform name="Lamp1Color" semantic="lightcolor1"/>

</glslfx>

Altri parametri

Altre informazioni aggiuntive possono essere aggiunte a ciascuna uniforme per:

Poiché le uniformi possono essere sostituite per ogni tecnica, consente di visualizzare una configurazione GUI specifica per ogni tecnica.

Definizione elemento XML:

Nome: ‘uniforme’

Attributi:

Esempio: tassellatura/parallasse

File Shader vertice parallasse

Disponibile in .\tessellation_parallax\parallax\vs.glsl

Contenuto:

#version 120

attributo vec4 iVS_Position;
attributo vec4 iVS_Normal;
attributo vec2 iVS_UV;
attributo vec4 iVS_Tangent;
attributo vec4 iVS_Binormal;

variazione vec3 iFS_Normal;
variazione vec2 iFS_UV;
variazione vec3 iFS_Tangent;
variabile vec3 iFS_Binormal;
variazione vec3 iFS_PointWS;

matrice uniforme mat4 worldMatrix;
matrice uniforme mat4 worldViewProjMatrix;

void main()
{
gl_Position = worldViewProjMatrix * iVS_Position;
iFS_Normal = iVS_Normal.xyz;
iFS_UV = iVS_UV;
iFS_Tangent = iVS_Tangent.xyz;
iFS_Binormal = iVS_Binormal.xyz;
iFS_PointWS = (worldMatrix * iVS_Position).xyz;
}

File dello shader del vertice di tassellatura

Disponibile in .\tessellation_parallax\tessellation\vs.glsl

Contenuto:

​>>

​#version 120

attributo vec4 iVS_Position;
attributo vec4 iVS_Normal;
attributo vec2 iVS_UV;
attributo vec4 iVS_Tangent;
attributo vec4 iVS_Binormal;

variazione di vec4 oVS_Normal;
variazione di vec2 oVS_UV;
variabile vec4 oVS_Tangent;
variabile vec4 oVS_Binormal;

void main()
{
gl_Position = iVS_Position;
oVS_Normal = iVS_Normal;
oVS_UV = iVS_UV;
oVS_Tangent = iVS_Tangent;
oVS_Binormal = iVS_Binormal;
}

File dello shader di controllo della tassellatura

Disponibile in .\tessellation_parallax\tessellation\tcs.glsl

Contenuto:

​>>

​#version 400 core
​#extension GL_ARB_tessellation_shader : attiva

layout(vertici = 3) out;

in vec4 oVS_Normal[];
in vec2 oVS_UV[];
in vec4 oVS_Tangent[];
in vec4 oVS_Binormal[];

out vec4 oTCS_Normal[];
out vec2 oTCS_UV[];
out vec4 oTCS_Tangent[];
out vec4 oTCS_Binormal[];

Fattore di tassellatura del galleggiante uniforme;

void main()
{
gl_TessLevelOuter[0] = tassellationFactor;
gl_TessLevelOuter[1] = tassellationFactor;
gl_TessLevelOuter[2] = tassellationFactor;
gl_TessLevelInner[0] = tassellationFactor;
gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;

oTCS_Normal[gl_InvocationID] = oVS_Normal[gl_InvocationID];
oTCS_UV[gl_InvocationID] = oVS_UV[gl_InvocationID];
TCS_Tangent[gl_InvocationID] = oVS_Tangent[gl_InvocationID];
oTCS_Binormal[gl_InvocationID] = oVS_Binormal[gl_InvocationID];
}

File dello shader di valutazione della tassellatura

Disponibile in .\tessellation_parallax\tessellation\tcs.glsl

Contenuto:

​>>

​#version 400 core

layout(triangoli, uguale_spaziatura, ccw) in;

in vec4 oTCS_Normal[];
in vec2 oTCS_UV[];
in vec4 oTCS_Tangent[];
in vec4 oTCS_Binormal[];

matrice uniforme mat4 worldMatrix;
matrice uniforme mat4 worldViewProjMatrix;

Uniform Sampler2D heightMap;

piastrellatura a virgola mobile uniforme = 1,0 f;
altezza mobile uniformeMapScale = 1.0f;

out vec3 iFS_Normal;
out vec2 iFS_UV;
out vec3 iFS_Tangent
out vec3 iFS_Binormal;
out vec3 iFS_PointWS;

vec3 interpolate3D(vec3 v0, vec3 v1, vec3 v2, vec3 uvw)
{
restituire uvw.x * v0 + uvw.y * v1 + uvw.z * v2;
}

vec2 interpolate2D(vec2 v0, vec2 v1, vec2 v2, vec3 uvw)
{
restituire uvw.x * v0 + uvw.y * v1 + uvw.z * v2;
}

void main()
{
vec3 uvw = gl_TessCoord.xyz;

vec3 newPos = interpolate3D(gl_in[0].gl_Position.xyz, gl_in[1].gl_Position.xyz, gl_in[2].gl_Position.xyz, uvw);
vec3 newNormal = normalize(interpolate3D(oTCS_Normal[0].xyz, oTCS_Normal[1].xyz, oTCS_Normal[2].xyz, uvw));
vec3 newTangent = normalize(interpolate3D(oTCS_Tangent[0].xyz, oTCS_Tangent[1].xyz, oTCS_Tangent[2].xyz, uvw));
vec3 newBinormal = normalize(interpolate3D(oTCS_Binormal[0].xyz, oTCS_Binormal[1].xyz, oTCS_Binormal[2].xyz, uvw));
vec2 newUV = interpolate2D(oTCS_UV[0], oTCS_UV[1], oTCS_UV[2], uvw);

float heightTexSample = texture(heightMap, newUV * Affiancamento).x * 2.0 - 1.0;
newPos += newNormal * heightTexSample * heightMapScale;

vec4 obj_pos = vec4(newPos, 1);
gl_Position = worldViewProjMatrix * obj_pos;

iFS_UV = Affiancamento newUV *;
iFS_Tangent = newTangent;
iFS_Binormal = newBinormal;
iFS_Normal = newNormal;
iFS_PointWS = (worldMatrix * obj_pos).xyz;
}

File Shader frammento

Disponibile in .\tessellation_parallax\fs.glsl

Contenuto:

​>>

​#version 120

// #define ALG_NORMAL_DIRECTX
​#define ALG_NORMAL_OPENGL

​#ifdef ALG_NORMAL_DIRECTX
// RIFLETTI #define_NORMALE_X
​#define RIFLETTI_NORMALE_Y
// #define RIFLETTI_NORMALE_Z
​#endif //#ifdef ALG_NORMAL_DIRECTX

​#ifdef ALG_NORMAL_OPENGL
// RIFLETTI #define_NORMALE_X
​#define RIFLETTI_NORMALE_Y
// #define RIFLETTI_NORMALE_Z
​#endif //#ifdef ALG_NORMAL_OPENGL

variazione vec3 iFS_Normal;
variazione vec2 iFS_UV;
variazione vec3 iFS_Tangent;
variabile vec3 iFS_Binormal;
variazione vec3 iFS_PointWS;

lampada uniforme vec30Pos = vec3(0.0f,0.0f,70.0f);
uniforme vec3 Lamp0Color = vec3(1.0f,1.0f,1.0f);
lampada uniforme vec31Pos = vec3(70.0f,0.0f,0.0f);
uniforme vec3 Lamp1Color = vec3(0.198f,0.198f,0.198f);
bool flipNormal uniforme = true;
TilingDetail float uniforme = 3.0f;
SpecExpon a virgola mobile uniforme = 50,0;
float uniforme Ks = 1,0;
int parallax uniforme_mode = 0;
Fattore di tassellatura del galleggiante uniforme = 4,0;
altezza mobile uniformeMapScale = 1.0f;
profondità float uniforme_detail = 0,5f;
float uniforme Kr = 0,5f;
int uniforme KF_on = 1;
flottante uniforme KF = 1,0f;
colore uniforme vec3 Ambi = vec3(0,07f,0,07f,0,07f);
piastrellatura a virgola mobile uniforme = 1,0 f;
int enableTilingInFS uniforme = 0;

Uniform Sampler2D heightMap;
sample2D normalMap uniforme;
Uniform sampler2D detailNormalMap;
emissiveMap del campionatore uniforme2D;
common sampler2D diffusoMap;
uniformesampler2D specularMap;
uniformecampionatore2D opacityMap;
Uniform samplerCube environmentMap;

matrice uniforme mat4 worldMatrix;
matrice uniforme mat4 worldInverseTransposeMatrix;
matrice uniforme mat4 viewInverseMatrix;

vec4 litFct(float NdotL, float NdotH, float specExp)
{
ambiente flottante = 1,0;
diffusione a virgola mobile = max(NdotL, 0,0);
specular float = step(0.0, NdotL) * pow(max(0.0, NdotH), specExp);
ritorno vec4(ambiente, diffusione, specular, 1,0);
}

vec3 lerpFct(vec3 v0, vec3 v1, percentuale variabile)
{
return v0 + (v1-v0) * percento;
}

// Ombreggiatura Phong
void phong_ombreggiature(
in vec3 LightColor
in vec3 normalWS,
in vec3 pointToLightDirWS,
in vec3 pointToCameraDirWS,
inout vec3 DiffuseContrib
inout vec3 SpecularContrib)
{
vec3 Hn = normalize(pointToCameraDirWS + pointToLightDirWS);
vec4 litV = litFct(dot(normalWS, pointToLightDirWS), dot(normalWS, Hn), SpecExpon);
DiffuseContrib = litV.y * LightColor;
SpecularContrib = litV.y * litV.z * Ks * LightColor;
}

vec3 fixNormalSample(vec3 v)
{
risultato vec3 = v - vec3(0,5,0,5,0,5);

​#ifdef RIFLETTI_NORMALE_X
risultato.x = -risultato.x;
​#endif // ifdef FLIP_NORMAL_X
​#ifdef RIFLETTI_NORMALE_Y
risultato.y = -risultato.y;
​#endif // ifdef FLIP_NORMAL_Y
​#ifdef FLIP_NORMAL_Z
result.z = -result.z;
​#endif // ifdef FLIP_NORMAL_Z

risultato di ritorno;
}

vec3 normalVecOSToWS(vec3 normale)
{
ritorno normale;
}

void main()
{
vec3 cameraPosWS = viewInverseMatrix[3].xyz;
vec3 pointToLight0DirWS = normalize(Lamp0Pos - iFS_PointWS);
vec3 pointToLight1DirWS = normalize(Lamp1Pos - iFS_PointWS);
vec3 pointToCameraDirWS = normalizza(cameraPosWS);
vec3 normalOS = normalize(iFS_Normal);
vec3 tangentOS = normalize(iFS_Tangent);
vec3 binormalOS = normalize(iFS_Binormal);

// ------------------------------------------
// Accertarsi che il TBN sia ortonorizzato
binormalOS = normalize(cross(normalOS, tangentOS));
tangentOS = normalize(cross(binormalOS, normalOS));

vec3 cumululatedNormalOS = normalOS;

// ------------------------------------------
// Aggiorna UV
float a = dot(normalOS,-pointToCameraDirWS);
vec3 s = vec3(dot(pointToCameraDirWS,tangentOS), dot(pointToCameraDirWS,binormalOS), a);
vec2 uv = enableTilingInFS == 0? iFS_UV : (iFS_UV * affiancamento);
height a virgola mobile = texture2D(heightMap,uv).x * 2.0 - 1.0 ;
float parallax = parallax_mode == 0 ? (tassellationFactor / 100000.f + heightMapScale / 500.f) : (heightMapScale / 50.f);
+= uv (height * s.xy * parallasse) ;

// ------------------------------------------
// Aggiungi normale da normalMap
vec3 normalTS = texture2D(normalMap,uv).xyz;
normalTS = fixNormalSample(normalTS);
vec3 normalMapOS = normalTS.x*tangentOS + normalTS.y*binormalOS;
cumululatedNormalOS = cumululatedNormalOS + normalMapOS;
cumululatedNormalOS = normalize(cumulatedNormalOS);

// ------------------------------------------
// Aggiungi normalmap dei dettagli
vec3 normalDetailTS = texture2D(detailNormalMap,uv*TilingDetail).xyz;
normalDetailTS = fixNormalSample(normalDetailTS);
vec3 variableNormalDetailTS = lerpFct(vec3(0.0,0.0,0.5),normalDetailTS,Profondità_detail);
vec3 normalDetailOS = variableNormalDetailTS.x*tangentOS + variableNormalDetailTS.y*binormalOS;
cumululatedNormalOS = cumululatedNormalOS + normalDetailOS;
cumululatedNormalOS = normalize(cumulatedNormalOS);

if (lunghezza(normaleTS)<0,0001)
cumululatedNormalOS = normalOS;

vec3 cumululatedNormalWS = normalVecOSToWS(cumulatedNormalOS);

// ------------------------------------------
// Calcola diffusione e Specular

// Contributo leggero 0
vec3 diffContrib = vec3(0, 0, 0);
vec3 specContrib = vec3(0, 0, 0);
phong_ombreggiatura(Lamp0Color, cumulatedNormalWS, pointToLight0DirWS, pointToCameraDirWS, diffContrib, specContrib);

// Contributo leggero 1
vec3 diffContrib2 = vec3(0, 0, 0);
vec3 specContrib2 = vec3(0, 0, 0);
phong_ombreggiatura(Lamp1Color, cumulatedNormalWS, pointToLight1DirWS, pointToCameraDirWS, diffContrib2, specContrib2);

diffContrib += diffContrib2;
specContrib += specContrib2;

vec4 diffusaColor = texture2D(diffusaMap,uv);

vec3 specularColor = texture 2D(specularMap,uv).rgb;
vec3 R = reflection(pointToCameraDirWS,cumululatedNormalWS);
vec3 reflColor = Kr &#42; textureCube(environmentMap,R.xyz).bgr;

float FallofRefl;

if (KF >= 0,0)
FallofRefl = max((1-dot(pointToCameraDirWS/(KFs),cumulatedNormalWS))),0)&#42;KF_on;
else
FallofRefl = (1-max((((1-dot(pointToCameraDirWS/(-KFs),cumulatedNormalWS)))),0))&#42;KF_on;

if (KF_su == 0)
FallofRefl=1,0;

vec3 Ambiant_final = diffusoColor.rgb&#42;AmbiColor;

// ------------------------------------------
vec3 emissive = texture2D(emissiveMap,uv).xyz;

vec3 finalcolor = Ambiant_final
​+ specularColor&#42;specContrib
​+ diffusioneColor.rgb&#42;diffContrib
​+ (reflColor&#42;specularColor&#42;FallofRefl)
​+ emissivo;

// Colore finale
vec4 finalColor4 = vec4(finalcolor, texture2D(opacityMap,uv));

gl_FragColor = finalColor4;
}

File GLSLFX

Il file glslfx definisce due tecniche per il rendering della geometria:

Disponibile in .\tessellation_parallax\fs.glsl

Contenuto:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE sbsbatchnode SYSTEM "glslfx.dtd">

<glslfx version="1.0.0" author="allegorithmic.com">

    <!-- TECHNIQUES -->

    <technique name="Tesselation">

        <!-- PROPERTIES -->

        <property name="blend_enabled" value="true"/>

        <property name="blend_func" value="src_alpha,one_minus_src_alpha"/>

        <property name="cull_face_enabled" value="true"/>

        <property name="cull_face_mode" value="back"/>

        <!-- SHADERS -->

        <shader type="vertex" filename="tessellation_parallax/tessellation/vs.glsl" primitiveType="patch4"/>

        <shader type="tess_control" filename="tessellation_parallax/tessellation/tcs.glsl"/>

        <shader type="tess_eval" filename="tessellation_parallax/tessellation/tes.glsl"/>

        <shader type="fragment" filename="tessellation_parallax/fs.glsl"/>

        <!-- UNIFORMS -->

        <uniform name="parallax_mode" guiName="Parallax Mode" min="0" max="0" />

        <uniform name="enableTilingInFS" guiName="Tiling Enabled In FS" min="0" max="0" />

        <uniform name="tessellationFactor" guiName="Tessellation Factor" default="4" min="1" max="64" guiStep="1" guiWidget="slider"/>

    </technique>

    <technique name="Parallax">

        <!-- PROPERTIES -->

        <property name="blend_enabled" value="true"/>

        <property name="blend_func" value="src_alpha,one_minus_src_alpha"/>

        <property name="cull_face_enabled" value="true"/>

        <property name="cull_face_mode" value="back"/>

        <!-- SHADERS -->

        <shader type="vertex" filename="tessellation_parallax/parallax/vs.glsl"/>

        <shader type="fragment" filename="tessellation_parallax/fs.glsl"/>

        <!-- UNIFORMS -->

        <uniform name="parallax_mode" guiName="Parallax Mode" min="1" max="1" />

        <uniform name="enableTilingInFS" guiName="Tiling Enabled In FS" min="1" max="1" />

    </technique>

    <!-- INPUT VERTEX FORMAT -->

    <vertexformat name="iVS_Position" semantic="position"/>

    <vertexformat name="iVS_Normal" semantic="normal"/>

    <vertexformat name="iVS_UV" semantic="texcoord0"/>

    <vertexformat name="iVS_Tangent" semantic="tangent0"/>

    <vertexformat name="iVS_Binormal" semantic="binormal0"/>

    <!-- SAMPLERS -->

    <sampler name="diffuseMap" usage="diffuse"/>

    <sampler name="heightMap" usage="height"/>

    <sampler name="normalMap" usage="normal"/>

    <sampler name="detailNormalMap" usage="detailNormal"/>

    <sampler name="emissiveMap" usage="emissive"/>

    <sampler name="specularMap" usage="specular"/>

    <sampler name="opacityMap" usage="opacity"/>

    <sampler name="environmentMap" usage="environment"/>

    <!-- MATRICES -->

    <uniform name="worldMatrix" semantic="world"/>

    <uniform name="worldViewProjMatrix" semantic="worldviewprojection"/>

    <uniform name="worldViewMatrix" semantic="worldview"/>

    <uniform name="worldInverseTransposeMatrix" semantic="worldinversetranspose"/>

    <uniform name="viewInverseMatrix" semantic="viewinverse"/>

    <uniform name="modelViewMatrix" semantic="modelview"/>

    <uniform name="projectionMatrix" semantic="projection"/>

    <!-- SCENE PARAMETERS -->

    <uniform name="AmbiColor" semantic="ambient"/>

    <uniform name="Lamp0Pos" semantic="lightposition0"/>

    <uniform name="Lamp0Color" semantic="lightcolor0"/>

    <uniform name="Lamp1Pos" semantic="lightposition1"/>

    <uniform name="Lamp1Color" semantic="lightcolor1"/>

    <!-- UNIFORMS -->

    <uniform name="tiling" guiName="Tiling" default="1" min="1" guiWidget="slider" guiMax="10"/>

    <uniform name="heightMapScale" guiGroup="Height" guiName="Scale" default="1" min="0" guiWidget="slider" guiMin="-50" guiMax="50" />

    <uniform name="TilingDetail" guiGroup="Detail Normal" guiName="Tiling" default="3" min="1" guiWidget="slider" guiMax="10"/>

    <uniform name="Depth_detail" guiGroup="Detail Normal" guiName="Intensity" default="0.5" min="0" max="1" guiStep="0.05" guiWidget="slider"/>

    <uniform name="SpecExpon" guiGroup="Specular" guiName="Power" default="50" min="1" guiWidget="slider" guiMax="128"/>

    <uniform name="Ks" guiGroup="Specular" guiName="Intensity" default="1" min="0" guiWidget="slider" guiMax="3"/>

    <uniform name="Kr" guiGroup="Reflection" guiName="Intensity" default="0.5" min="0" max="1" guiStep="0.01" guiWidget="slider"/>

    <uniform name="KF_on" guiGroup="Reflection" guiName="Falloff" default="1" min="0" max="1" guiStep="1" guiWidget="slider"/>

    <uniform name="KFs" guiGroup="Reflection" guiName="Falloff Size" default="1" min="-1" max="1" guiStep="0.05" guiWidget="slider"/>

</glslfx>