Sombreadores GLSLFX

Os arquivos GLSLFX fazem a ponte entre o aplicativo e os arquivos de sombreador glsl.
Permite usar qualquer sombreador glsl sem ter que modificar o código.

Formato de arquivo

O formato de arquivo GLSLFX é XML. Os comentários são aceitos.

Nó de cabeçalho e raiz

O elemento de nó raiz XML é chamado glslfx.

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

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

    <!-- BODY -->

    <!-- ... -->

</glslfx>

Corpo

Técnica

Elemento XML que descreve uma técnica. Uma técnica é uma variação do FX atual. Um GLSLFX pode conter várias técnicas, mas pelo menos uma técnica precisa ser definida.

A geometria será renderizada com uma das técnicas definidas pelo aplicativo.

O elemento XML pode ter vários filhos. Os elementos definidos em uma técnica substituem os elementos definidos globalmente.

Por exemplo, é usado para substituir alguns valores uniformes e obter variação de FX para essa técnica.

Passe de Renderização

Elemento XML que descreve uma passagem de renderização. Uma passagem de renderização descreve a renderização da geometria.

Uma técnica pode conter várias passagens de renderização que serão executadas sequencialmente. Uma técnica que não contém nenhuma passagem de renderização é equivalente a uma técnica que contém uma passagem de renderização “na tela”.

Os elementos definidos em uma passagem de renderização substituem os elementos definidos na técnica pai.

Sombreamentos

Defina os arquivos de sombreador GLSL para cada tipo.

Definição do elemento XML:

Propriedades

Permite configurar parte do estado OpenGL.

Uniformulários

Permite substituir alguns uniformes definidos globalmente ou na técnica pai. Isso permite alterar o comportamento do sombreador para essa técnica ou passagem de renderização.

Consulte a seção Uniformes abaixo para obter mais detalhes sobre a definição.

+++Exemplo

+++

Destinos de renderização

Para passagens de renderização ‘fora da tela’, os destinos de renderização devem ser definidos na passagem de renderização.

Sobre formatos

Para formatos de profundidade, todos os formatos OpenGL somente de profundidade (sem estêncil) são compatíveis:

Para os formatos de cores, o nome é baseado nos nomes enum do OpenGL, sem o prefixo ‘GL_’, em minúsculas.
Não há suporte para três formatos de canal (RGB); em vez disso, use um formato RGBA.
Profundidade de bits por canal compatível:

Uma exceção a essas regras é o formato GL_R11F_G11F_B10F, que é compatível.:

Amostragem

Permitir que o substitua alguns amostradores definidos globalmente, eles não podem ser definidos em uma técnica. Isso permite definir um uso do sampler para essa passagem de renderização ou para ler de um destino de renderização de uma passagem de renderização anterior.

Consulte a seção Samplers para obter mais detalhes sobre suas definições.

+++Exemplo

+++

Formato de vértice de entrada

Isso permite definir a semântica de cada atributo definido no sombreador de vértice.

Definição de Elemento XML:

Nome: ‘vertexformat’

Atributos:

Exemplo:

<?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>

Amostragem

Isso permite definir o uso de cada amostrador.
É usado pelo aplicativo para saber qual textura definir nos classificadores especificados.

Definição de Elemento XML:

Nome: ‘sampler’

Atributos:

   <!-- SAMPLERS -->

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

     <!-- ... -->

‘isHidden’: Booleano que indica se o sampler deve aparecer na GUI

     <!-- SAMPLERS -->

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

     <!-- ... -->

Modo de quebra automática:

Filtro de Textura

Exemplo:

<?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>

Uniformulários

Isso permite que você adicione informações adicionais em cada uniforme de sombreador.

Definição de Elemento XML:

Nome: ‘uniforme’

Atributos:

‘nome’: o nome do uniforme no arquivo de sombreador.

‘semântica’: A semântica do uniforme. (Todas as matrizes são float16).

Exemplo:

<?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>

Exemplo:

<?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>

Outros parâmetros

Outras informações adicionais podem ser adicionadas a cada uniforme para:

Como os Uniformes podem ser substituídos por cada técnica, permite exibir uma configuração de interface gráfica específica para cada técnica.

Definição de Elemento XML:

Nome: ‘uniforme’

Atributos:

Exemplo: mosaico/paralaxe

Arquivo de sombreador de vértices da paralaxe

Localizado em .\tessellation_parallax\parallax\vs.glsl

Conteúdo:

> #version 120

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

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

uniforme mat4 worldMatrix;
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;
}

Arquivo de Sombreador de Vértice de Mosaico

Localizado em .\tessellation_parallax\tessellation\vs.glsl

Conteúdo:

​>>

​#version 120

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

variando vec4 oVS_Normal;
variando vec2 oVS_UV;
variando vec4 oVS_Tangent;
variando 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;
}

Arquivo de Sombreador de Controle de Mosaico

Localizado em .\tessellation_parallax\tessellation\tcs.glsl

Conteúdo:

​>>

​#version núcleo 400
​#extension GL_ARB_tessellation_shader : habilitar

layout(vértices = 3) out;

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

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

fator de mosaico de flutuador uniforme;

void main()
{
gl_TessLevelOuter[0] = tessellationFactor;
gl_TessLevelOuter[1] = tessellationFactor;
gl_TessLevelOuter[2] = tessellationFactor;
gl_TessLevelInner[0] = tessellationFactor;
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];
oTCS_Tangent[gl_InvocationID] = oVS_Tangent[gl_InvocationID];
oTCS_Binormal[gl_InvocationID] = oVS_Binormal[gl_InvocationID];
}

Arquivo de Sombreador de Avaliação do Mosaico

Localizado em .\tessellation_parallax\tessellation\tcs.glsl

Conteúdo:

​>>

​#version núcleo 400

layout(triângulos, igual_espaçamento, ccw) em;

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

uniforme mat4 worldMatrix;
uniforme mat4 worldViewProjMatrix;

sampler2D heightMap uniforme;

revestimento de flutuador uniforme = 1.0f;
heightMapScale de flutuação uniforme = 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)
{
return uvw.x * v0 + uvw.y * v1 + uvw.z * v2;
}

vec2 interpolate2D(vec2 v0, vec2 v1, vec2 v2, vec3 uvw)
{
return 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 * tiling).x * 2.0 - 1.0;
newPos += newNormal * heightTextSample * heightMapScale;

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

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

Arquivo sombreador de fragmentos

Localizado em .\tessellation_parallax\fs.glsl

Conteúdo:

​>>

​#version 120

// #define ALG_NORMAL_DIRECTX
​#define ALG_NORMAL_OPENGL

​#ifdef ALG_NORMAL_DIRECTX
// #define FLIP_NORMAL_X
​#define FLIP_NORMAL_Y
// #define FLIP_NORMAL_Z
​#endif //#ifdef ALG_NORMAL_DIRECTX

​#ifdef ALG_NORMAL_OPENGL
// #define FLIP_NORMAL_X
​#define FLIP_NORMAL_Y
// #define FLIP_NORMAL_Z
​#endif //#ifdef ALG_NORMAL_OPENGL

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

Lâmpada vec3 uniforme0Pos = vec3(0.0f,0.0f,70.0f);
Lâmpada vec30Color uniforme = vec3(1.0f,1.0f,1.0f);
Lâmpada vec3 uniforme1Pos = vec3(70.0f,0.0f,0.0f);
Lâmpada vec3 uniforme1Color = vec3(0.198f,0.198f,0.198f);
flipNormal bool uniforme = true;
uniformemente float TilingDetail = 3.0f;
SpecExpon de flutuação uniforme = 50,0;
flutuador uniforme Ks = 1,0;
uniforme int parallax_mode = 0;
tessellationFactor de flutuador uniforme = 4,0;
heightMapScale de flutuação uniforme = 1.0f;
uniformemente float Profundidade_detail = 0.5f;
flutuador uniforme Kr = 0,5f;
uniforme int KF_on = 1;
flutuador uniforme KFs = 1.0f;
vec3 AmbiColor uniforme = vec3(0.07f,0.07f,0.07f);
revestimento de flutuador uniforme = 1.0f;
uniforme int enableTilingInFS = 0;

sampler2D heightMap uniforme;
sampler2D normalMap uniforme;
sampler2D uniforme detailNormalMap;
sampler2D emissiveMap uniforme;
sampler2D diffuseMap uniforme;
sampler2D specularMap uniforme;
sampler2D opacityMap uniforme;
samplerCube environmentMap uniforme;

uniforme mat4 worldMatrix;
uniforme mat4 worldInverseTransposeMatrix;
MatrizInversauniforme de visualização mat4;

vec4 litFct(float NdotL, float NdotH, float specExp)
{
ambiente flutuante = 1,0;
float diffuse = max(NdotL, 0.0);
specular flutuante = step(0.0, NdotL) * pow(max(0.0, NdotH), specExp);
return vec4(ambiente, difuso, specular, 1.0);
}

vec3 lerpFct(vec3 v0, vec3 v1, porcentagem de flutuação)
{
retornar v0 + (v1-v0) * por cento;
}

// Phong Sombreamento
void phong_sombreamento(
em vec3 LightColor,
em vec3 normalWS,
em vec3 pointToLightDirWS,
em 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)
{
resultado de vec3 = v - vec3(0,5,0,5,0,5);

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

resultado de retorno;
}

vec3 normalVecOSToWS(vec3 normal)
{
retorno normal;
}

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

// ------------------------------------------
// Verifique se o TBN está Orthonormalizado
binormalOS = normalize(cross(normalOS, tangentOS));
tangentOS = normalize(cross(binormalOS, normalOS));

vec3 cumulatedNormalOS = normalOS;

// ------------------------------------------
// Atualizar UV
float a = dot(normalOS,-pointToCameraDirWS);
vec3 s = vec3(dot(pointToCameraDirWS,tangentOS), dot(pointToCameraDirWS,binormalOS), a);
vec2 uv = enableTilingInFS == 0 ? iFS_UV : (iFS_UV * lado a lado);
float height = textura2D(heightMap,uv).x * 2.0 - 1.0 ;
float parallax = parallax_mode == 0 ? (tessellationFactor / 100000.f + heightMapScale / 500.f) : (heightMapScale / 50.f);
uv += (height * s.xy * paralaxe) ;

// ------------------------------------------
// Adicionar Normal a partir de normalMap
vec3 normalTS = textura2D(normalMap,uv).xyz;
normalTS = fixNormalSample(normalTS);
vec3 normalMapOS = normalTS.x*tangentOS + normalTS.y*binormalOS;
cumulatedNormalOS = cumulatedNormalOS + normalMapOS;
cumulatedNormalOS = normalize(cumulatedNormalOS);

// ------------------------------------------
// Adicionar o mapa normal detalhado
vec3 normalDetailTS = textura2D(detailNormalMap,uv*TilingDetail).xyz;
normalDetailTS = fixNormalSample(normalDetailTS);
variável vec3NormalDetailTS = lerpFct(vec3(0.0,0.0,0.5),normalDetailTS,Profundidade_detail);
vec3 normalDetailOS = variableNormalDetailTS.x*tangentOS + variableNormalDetailTS.y*binormalOS;
cumulatedNormalOS = cumulatedNormalOS + normalDetailOS;
cumulatedNormalOS = normalize(cumulatedNormalOS);

if (length(normalTS)<0,0001)
cumulatedNormalOS = normalOS;

vec3 cumulatedNormalWS = normalVecOSToWS(cumulatedNormalOS);

// ------------------------------------------
// Calcular Difusão e Specular

// Contribuição clara 0
vec3 diffContrib = vec3(0, 0, 0);
vec3 specContrib = vec3(0, 0, 0);
phong_sombreamento(Lamp0Color, cumulatedNormalWS, pointToLight0DirWS, pointToCameraDirWS, diffContrib, specContrib);

// Contribuição Light 1
vec3 diffContrib2 = vec3(0, 0, 0);
vec3 specContrib2 = vec3(0, 0, 0);
phong_sombreamento(Lamp1Color, cumulatedNormalWS, pointToLight1DirWS, pointToCameraDirWS, diffContrib2, specContrib2);

diffContrib += diffContrib2;
specContrib += specContrib2;

vec4 diffuseColor = texture2D(diffuseMap,uv);

vec3 specularColor = textura2D(specularMap,uv).rgb;
vec3 R = reflect(pointToCameraDirWS,cumulatedNormalWS);
vec3 reflColor = Kr &#42; textureCube(environmentMap,R.xyz).bgr;

float FallofRefl

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

if (KF_on == 0)
FallofRefl=1.0;

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

// ------------------------------------------
emissivo vec3 = textura2D(emissiveMap,uv).xyz;

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

// Cor final
vec4 finalColor4 = vec4(finalcolor, textura 2D(opacityMap,uv));

gl_FragColor = finalColor4;
}

Arquivo GLSLFX

O arquivo glslfx define duas técnicas para renderizar a geometria:

Localizado em .\tessellation_parallax\fs.glsl

Conteúdo:

<?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>