Shader FX

Método de uso de la aplicación Shader FX y su implementación en Virtools Sombreado
Método de uso de la aplicación Shader FX y

su implementación en Virtools
Shader FX
1 Victor Hugo Franco Serrano / DGSCA UNAM

Método de uso de la aplicación Shader FX

y su implementación en Virtools
D.C.V. Victor Hugo Franco Serrano
Dept. de Realidad Virtual, DGSCA UNAM
vhfranco@unam.mx
Primera etapa:
Reconocimiento de la Interfaz y de las limitaciones de la versión educativa
En la parte superior se encuentra la zona de menús, en ella podrá encontrar las opciones
de guardar, reset, exportar, abrir, herramientas de asignación, agrupar, desagrupar,
configuraciones, ayudas entre otros.
a - La ventana de vista esquemática, en esta zona podrá crear y unir los nodos. Además de poder navegar
con el uso del mouse con las opciones de acercamiento / alejamiento, desplazamiento izquierda / derecha /
arriba / abajo, para ello se emplea el scroll del mouse, al pulsar botón izquierdo del mouse se puede
seleccionar cada nodo, además de poder seleccionar con recuadros de selección al presionar sin soltar y
trazar un cuadro, con el botón derecho sobre esta zona puede agregar elementos en todo momento.

b - El panel de configuración es el área en donde se ingresan parámetros a los nodos, como por ejemplo en el
nodo de textura puede cargar un mapa de bits o en el nodo de constante definir el valor de la misma en
números de punto flotante.
c - En esta zona se puede elegir por categoría los 5 tipos de nodos, dentro de los tipos existen diferentes
subtipos que se podrán agregar con la técnica de drag and drop, se selecciona un nodo y se arrastra hasta la
vista esquemática, se procede de igual forma con cualquier nodo que desee incorporar.
d - La barra de mensajes despliega información importante acerca cualquiera de los nodos y de las
actividades que realicemos, también despliega posibles errores como referencia para su corrección.
Dentro de las limitaciones del uso de la versión educativa se encuentran:
‐ Solo permite 8 nodos
‐ No se puede salvar
‐ La licencia es personal de aprendizaje
‐ No es de uso comercial

Aplicaciones que emplean el formato fx y su relación con direct x, Cg, cgsl,
hlsl
Render monkey – el problema del uso de render monkey es que no permite la exportación
en formato HLSL (*.fx), aunque es un buen recurso para desarrollo de shaders para
tiempo real basados en Open GL (GLSL)
Mental Mill – es una buena opción pero dificulta su uso el hecho de que no tenga un
exportador definido para virtools, permite exportar en formato HLSL (*.fx), aunque se le
deben hacer modificaciones en el código para su incorporación en Virtools. Permite la
exportación en formatos, CG, HLSL y GLSL.
FXcomposer – Permite la visualización, modificación y creación de shaders para tiempo

real en diferentes formatos, collada, HLSL, CGFX. Carece de una definición de HLSL
específica para Virtools.
Shader FX – Posee una definición de HLSL específica para Virtools, también contiene la
exportación para Quest 3d, XNA, Fx Composer y 3D Studio Max, soporta varios tipos de
materiales y se puede aplicar un material por canal, maneja independientemente las
coordenadas de textura UV. La creación de shaders puede ser supervisada íntegramente
en 3D Studio Max al permitir un despliegue en tiempo real del shader y pueden ser
fácilmente transportados a virtools.
- Descartar la posibilidad de mejor compatibilidad entre Virtools y alguna otra aplicación

para la creación de shaders tipo fx
En las pruebas realizadas, la compatibilidad entre Shader FX y Virtools era la más óptima,
puesto que a diferencia de las demás aplicaciones Shader FX posee una definición de

Método
o de uso de la aplicación
a Shad
der FX y su implementación en
e Virtools Som
mbreado
HLSL específica para

p Virtoolss que funcionna bastante bien, lo únicco que necesita es una
modificación en lo
os parámetro os de la luz, es bastante
e útil el poder visualizar en
e tiempo reeal
dentroo de 3D Stud
dio Max puess permite al modelador una pronta resolución
r de solucioness
grafica
as adecuadaas.
Crea
ación del primer shad
der básico
Shadeer1 básico - Uso de

canale ón, normaless2,
es de difusió
especcularidad y transparencia
En estta configurac
ción de shad
der se ha em
mpleado un material está ándar, los ca
anales que
contiene permite una
u configurración generral del materrial que será
á visualizado
o en tiempo
real.
El prim
mer paso es la configura
ación del ma
aterial:
Al sele
eccionar el material
m aparrecen las
opciones de Shade er Model, FXX, Sub
Materiaal ID, el núm
mero de lucees y
algunaas otras caraacterísticas del
d
materiaal.
Por compatibilidad
d es preferiblle usar
Shader Model 2.0, pero es possible usar
el Shadder Model 3.0 si es que la tarjeta
gráfica
a de su máquuina lo sopo
orta.
Se elig
ge aquí, la diirección del archivo
FX y el Sub Materiial, además del
número o de luces del
d shader.
1
Shader (Wikimedia
a Foundation, 2009)
2
Norm
males (Wikime
edia Foundatio
on, 2009)
4 Victor Hu
ugo Franco Serrano / DGSCA
D UNA
AM
Uso de texturas:
Para cada canal existen texturas independientes que contienen características

específicas:
Difusión Normales
La textura de difusión da un color general El mapa de normales contiene la

al shader y contiene elementos información de XYZ contenida en los
esenciales, funciona como una estampa. diferentes tonos, su función es la de
agregar relieve al shader.
Alfa Especularidad
El mapa alfa es el mapa de transparencia, El mapa de especularidad es el que se

en ella los valores van del blanco al encarga de bloquear o dar la posibilidad
negro, en donde negro es la mayor de existencia a los brillos del shader, al
transparencia y las escalas de grises igual que en la transparencia se maneja la
entre el blanco y negro son diferentes escala de grises y los valores absolutos,
niveles de transparencia. La textura por lo blanco y negro, en donde el blanco es
general es RGBA, en donde el canal alfa brillo total y el negro carece de brillo, las
es adicional, es el caso de texturas TGA diferentes escalas de grises son
de 32 bits por pixel. diferentes niveles de brillo.

Para asignar cada

canal se crea un
Texture Map, se
carga la textura y se
conecta el nodo con
el material.
En casos especiales
como el normal map o
el alfa map se deberá
de seleccionar
opciones diferentes.
Casos especiales:
Mapa de normales Mapa de transparencia
Una vez cargada la textura del Una vez cargada la textura del alfa map se
mapa de normales, tenemos que deberá conectar al material con el nodo que se
oprimir el check box de Normal encuentra en la parte inferior de la textura con la
Map para indicarle al programa que leyenda A, además de que se debe oprimir el
esta textura es del tipo normal check box Display alpha para poder ver la
map. textura del alfa map.
Al ser integradas las texturas, debemos

asignar el shader desde el menú tools, la
opción es Assign Material to Selection,
una vez realizado esto podremos
visualizar el shader en tiempo real dentro
del viewport de 3D Studio Max.

Método
a Shad
e Virtools Som
mbreado
Mane
ejo de coorrdenadas de
d textura:
Las coordenadas de te extura se pue eden

obtener porr medio de UV U Coordina ates,
estas coorddenadas pue eden ser
multiplicada
as por un va alor para pod der ser
integradas individualme ente a cada canal,
esto posibillita la repeticción individu
ual de
cada canal de textura en e el shaderr.
En la
l imagen de e la izquierda
podemos obserrvar un valorr de
repeetición de cooordenada UVU de 1,
en cambio
c a imagen de la
en la
dereecha observvamos un va alor de
repeetición de la coordenada a UV de
3, lo
os valores dee las coordeenadas
de textura
t no affectan directtamente
al shader, pero afectan al cómo
c
seráá visualizadoo.
dar en formato SFX y exportación al formato FX para virtools:

Guard
Al finaliizar la
configuuración del
shader debemos
de salvvar en el
formatoo nativo
SFX y exportarlo
e
para quue sea
compattible con
virtools.
7 Victor Hu
D UNA
AM
Para ello en el menú File seleccionamos la opción save as, tecleamos un nombre y le
damos ubicación al archivo.
Posteriormente exportaremos a el
formato FX, dentro del menú File
seleccionamos la opción Export FX…,
en la ventana emergente aparece la
opción Fx Format debemos
seleccionar Virtools y en la opción Up
Axiz debemos seleccionar Y - Up
(Direct X).
En la ventana Guardar como tecleamos el nombre y le damos ubicación al archivo FX

exportado.
Transcripción del shader generado a través de Shader FX

/*** Generated through Lumonix shaderFX by: Vic in 3dsmax at: 06/06/2008 07:37:49 p.m. ***/
// This FX shader was built to support Virtools.
float ValorUV1
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 1.0;
texture2D difusion_mapa;
sampler2D difusion_mapaSampler = sampler_state

{
Texture = <difusion_mapa>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
texture2D mapa_especular;
sampler2D mapa_especularSampler = sampler_state

{
Texture = <mapa_especular>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
float ValorUV2
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 1.0;
texture2D Alfa;
sampler2D AlfaSampler = sampler_state

{
Texture = <Alfa>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
texture2D mapa_normales;
sampler2D mapa_normalesSampler = sampler_state

{
Texture = <mapa_normales>;
MinFilter = LINEAR;
MagFilter = LINEAR;

MipFilter = LINEAR;
};
/************** light info **************/
float3 lightPos[1] : NEARESTLIGHT <string Space="World";>;
//----------------------------------
float4 lightCol[1] : NEARESTLIGHT <float4 Default={1,1,1,1};>;
//----------------------------------
float4x4 wvp : WORLDVIEWPROJECTION;

float4x4 worldI : INV_WORLD;
float4x4 worldIT : INV_TWORLD;
float4x4 viewInv : INV_VIEW;
float4x4 world : WORLD;
// input from application

struct a2v {
float4 position : POSITION;
float3 tangent : TANGENT;
float3 binormal : BINORMAL;
float3 normal : NORMAL;
float2 texCoord : TEXCOORD0;
};
// output to fragment program

struct v2f {
float3 lightVec : TEXCOORD0;
float3 eyeVec : TEXCOORD1;
};
//Diffuse and Specular Pass Vertex Shader

v2f v(a2v In, uniform float3 lightPosition)
{
v2f Out = (v2f)0;
Out.position = mul(In.position, wvp); //transform vert position to
homogeneous clip space
//this code was added by the standard material
float3x3 objTangentXf; //build object to tangent
space transform matrix
objTangentXf[0] = In.tangent;
objTangentXf[1] = -In.binormal;
objTangentXf[2] = In.normal;
float3 wsLPos = mul(In.position, world).xyz; //put the vert position in
world space
float3 wsLVec = lightPosition - wsLPos; //cast a ray to the light
float3 osLVec = mul(wsLVec, worldI).xyz; //transform the light vector to object space
Out.lightVec = mul(objTangentXf, osLVec); //tangent space light vector
passed out
float4 osIPos = mul(viewInv[3], worldI); //put world space eye position in
object space
float3 osIVec = osIPos.xyz - In.position.xyz; //object space eye vector
Out.eyeVec = mul(objTangentXf, osIVec); //tangent space eye vector
passed out
//this code was added by the IN UV Node

Out.texCoord = In.texCoord; //pass through texture
coordinates from channel 1
return Out;
}
//Diffuse and Specular Pass Pixel Shader

float4 f(v2f In, uniform float4 lightColor) : COLOR
{
float3 ret = float3(0,0,0);
float3 V = normalize(In.eyeVec); //creating the eye vector
float3 L = normalize(In.lightVec); //creating the light vector
float2 coordenadasUV = In.texCoord.xy;

float2 MathOperator_3776 = coordenadasUV * ValorUV1;
float4 difusion_mapa = tex2D(difusion_mapaSampler, MathOperator_3776.xy);

float3 input2 = difusion_mapa.rgb;

float2 MathOperator_4973 = coordenadasUV * ValorUV2;
float4 Alfa = tex2D(AlfaSampler, MathOperator_4973.xy);
float input7 = Alfa.a;
float4 mapa_especular = tex2D(mapa_especularSampler, MathOperator_3776.xy);

float3 input3 = mapa_especular.rgb;
float4 mapa_normales = tex2D(mapa_normalesSampler, MathOperator_4973.xy);

mapa_normales.xyz = mapa_normales.xyz * 2 - 1; //expand to -1 to 1 range
mapa_normales.rgb = normalize(mapa_normales.rgb); //normalized the normal
vector
float3 input8 = mapa_normales.rgb;
float3 N = input8; //using the Normal socket

float3 diffuseColor = input2; //using the Diffuse Color socket
float diffuse = saturate(dot(N,L)); //calculate the diffuse
diffuseColor *= diffuse; //the resulting diffuse color
ret += diffuseColor; //add diffuse light to final color
float3 specularColor = input3; //using the Specular Color socket
float glossiness = 20; //the Glossiness socket was empty -
using default value
float3 H = normalize(L + V); //Compute the half angle
float NdotH = saturate(dot(N,H)); //Compute NdotH
specularColor *= pow(NdotH, glossiness);//Raise to glossiness power and compute final
specular color
ret += specularColor; //add specular light to final color
ret *= lightColor; //multiply by the color of the light
float Opacity = input7;
float4 done = float4(ret, Opacity);
return done;
}
technique Complete <bool NeedTangentSpace = true; bool NeedColorAndNormal=true;>
{
pass light1
{
VertexShader = compile vs_1_1 v(lightPos[0]);
ZEnable = true;
CullMode = ccw;
AlphaBlendEnable = true;
ZWriteEnable = true;
SrcBlend = SrcAlpha;
DestBlend = InvSrcAlpha;
PixelShader = compile ps_2_0 f(lightCol[0]);
}
Revisión de compatibilidad entre los shaders generados y la aplicación

Virtools.
Para comprobar la compatibilidad del shader dentro de la aplicación Virtools necesitamos:
-Texturas de cada canal

Mapa de difusión Mapa de normales Alfa Especularidad

-Shader con formato fx -Geometría de prueba dentro de

virtools
shader vidrio.fx
Una vez generado esto dentro de la aplicación virtools se carga el shader para ello
debemos:
- En el menú editors debemos

seleccionar el shader editor
- Después debes cargar el shader

con el botón Load Shader from a file
-Una vez cargado el shader se debe compilar y revisar que la compatibilidad esta validada
Oprima el botón compile
Aparecerá el mensaje de compilación

exitosa
La compatibilidad esta validada
Aplicación del shader a un material
Una vez cargado y validado el shader procederemos a integrarlo al material que el objeto
tiene aplicado.

Se cargan las texturas del mapa de normales, mapa de difusión, mapa de transparencia y
mapa de especularidad al proyecto.
Cargas el modelo con el material que vas a usar y dentro del material editor:
Seleccionas la lista de shaders, deberá

aparecer el shader que se cargo, verifico
y compilo en los pasos anteriores
Una vez cargado el shader deberemos

presionar el botón Shader Params para
modificar las propiedades del shader.
Dentro de los
parámetros que
modificaremos se
encuentran los
canales de textura,
por medio del menú
descendente
seleccionaremos la
textura adecuada
para cada canal.
Se asignan las
texturas para cada
canal y
posteriormente se
dan valores de
repetición UV.

Método
a Shad
e Virtools Som
mbreado
El mod
delo podrá ser
s visualizado con el sh
hader aplica
ado
dentro
o de virtools..
Identtificación de
d posibles
s errores
Los errrores más comunes

c en la aplicación
n del método
o de shaderr son de 2 tip
pos:
-De mapeo de coo ordenadas UV
U asignada as a la geom
metría.
A la mitad
m sfera es possible visualizzar el error en donde la misma
de la es m superficie posee 2
variantes de ilumin ado izquierdo se muestrra brillante y del lado derecho se
nación del la
encueentra opaco.
- De manejo
m de la luz dentro de
d virtools
La luzz en virtools
s posee unaa definición
n específicaa que resultta en la neccesidad de
modifficación direecta del cód
digo, los errores de ilu m comunes tienden a
uminación más
ser la falta de luz
z en la zona
a de umbra a pues care ece totalmente de luz perdiendo
p e
el
volummen del obje eto:
Shade
er con corre
ección de lu
uz
En la
a visualizaciión del shader
podemos observvar la zona de umbra
bien definida
d y la
a superficie
e en donde
incide
e la luz possee un refle
ejo
mode erado.
13
3 Victor Hu
D UNA
AM
Método
a Shad
e Virtools Som
mbreado
S
Shader direccto sin corre
ección de luz
A dife
erencia de la visualizacción del
shade er corregido
o, este shadder presentta
una zona de gran obscurida ad en la
zona de umbra, lo que dificculta el
reconocimiento ded las formas
integrrantes del modelo
m 3d, además de e
tener un brillo de
emasiado in ntenso en la
a
zona en donde in ncide la luzz.
La po
osible solución es que dentro de la modificacción del códdigo se deb
be tomar en
n
cuenta la luz am
mbiental que
e recibe el objeto
o de fu
uentes no directas
d de luz, ademá
ás
de tom
mar en cuenta la inten
nsidad y collor de la em
misión del objeto.
o
Corre
ección de los
l errores
s encontrad
dos
-De mapeo de coo

ordenadas UV
U asignada
as a la geom
metría.
oordenadas UV pueden corregirse dentro

Las co d de 3D
D Studio Maxx aplicando un modificad
do
UVW.
- De manejo
m de la luz dentro de
d virtools
En estte caso el método

m deberrá incluir a un
u programa
ador para poder resolverr errores en la
línea de
d código.
Segunda etapa:
Experrimentación con las posibilidades de

e Shader FX
X
14
4 Victor Hu
D UNA
AM
- Aprendizaje del uso de los nodos de textura
Nodos de material Nodos de textura Nodos de entrada
Es la parte más importante del Los nodos de textura le dan al Los nodos de entrada son los
shader, le da estructura y shader información de texturas, que dan información desde el
conecta todos los demás nodos. color y constantes, difieren con engine o software 3d que se esté
los de entrada en que estos ocupando, llámese 3D Studio
últimos no brindan información Max o Virtools, son nodos a los
grafica al shader que no se les puede conectar
nada pues ellos son las partes
ultimas de la jerarquía del
shader.
Nodos Matemáticos Nodos de grupo Nodos Agrupados
La versión educativa no permite

Con ellos es posible realizar Son grupos de nodos que desagrupar elementos
operaciones simples entre dos realizan operaciones comunes agrupados, además de que solo
nodos, pero también como el cálculo de la permite un número limitado de
operaciones tan complejas como especularidad de una superficie nodos y no permite salvar.
la refracción o reflexión de un o terminado tipo fresnel.
objeto.

- Revisión, investigación e implementación de texturas seamless, cubemaps, mapas de

normales y de relieve)
- Aprendizaje del uso de los nodos de entrada, de los tipos operaciones matemáticas, de
tiempo, de vectores y coordenadas de textura
- Aprendizaje del uso de los nodos de grupo
- Creación de shader compuesto de más de un nodo y su combinación

con nodos de entrada, de textura y de grupo
Una vez investigados los elementos que conforman al shader debemos integrarlos con
Shader FX.
Para el shader de relieve con reflejo necesitamos:
Cube map
Mapa de normales Mapa de difusión

Al desarrollar el shader encontramos

que el material estándar emplea los
canales de ambiente, color de la
difusión, color de la especularidad y el
canal del mapa de normales.
Comenzando con el canal ambiente

vemos que se conecta a un nodo de
multiplicación y a su vez se multiplican
una constante y el mapa cubico, este
nivel refiere a la cantidad de reflejo
visible, conectado al nodo del mapa
cubico se encuentra un nodo de
reflexión, este vector de reflexión es
modificado por un vector del mundo
que a su vez es modificado por un
vector de superficie.
El canal de difusión y el canal de

mapa de normales se encuentran
conectados al material de forma
simple, pero la luz especular por el
contrario es la combinación del mapa
de normales con una constante que
conjunta con el color de la
especularidad dan brillo al shader.
Los valores UV de la difusión y el

mapa de normales se multiplican por
una constante.
La transcripción del shader es:

textureCUBE UICubeMap_860;
samplerCUBE UICubeMap_860Sampler = sampler_state

{
Texture = <UICubeMap_860>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
float UIConst_5178
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 0.2;
float UIConst_5063
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 1.0;
texture2D TextureMap_293;

sampler2D TextureMap_293Sampler = sampler_state

{
Texture = <TextureMap_293>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};

{
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
float4 DiffuseColor : Diffuse;
float UIConst_7974
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 0.5;
float4 SpecularColor : Specular;
/************** light info **************/
//----------------------------------
//----------------------------------


struct a2v {
};

struct v2f {
float3 eyeVec : TEXCOORD1;
float3 worldTangent : TEXCOORD2;

float3 worldBinormal : TEXCOORD3;
float3 worldNormal : TEXCOORD4;
};
//Ambient and Self-Illum Pass Vertex Shader

v2f av(a2v In, uniform float3 lightPosition)
{
v2f Out = (v2f)0;
//this code was added by the World Space Transform Node

Out.worldNormal = mul(In.normal, worldIT).xyz; //compute world space normal
Out.worldBinormal = mul(In.binormal, worldIT).xyz; //compute world space binormal
Out.worldTangent = mul(In.tangent, worldIT).xyz; //compute world space tangent
return Out;
}

//Ambient and Self-Illum Pass Pixel Shader

float4 af(v2f In, uniform float4 lightColor) : COLOR
{
float3 Normal = float3(0,0,1); //tangent space normal vector

float3 Nn = normalize(In.worldNormal); //input the vectors required for tangent to
world space transform
float3 Tn = normalize(In.worldTangent);
float3 Bn = normalize(In.worldBinormal);
float3 MathWorldXform_9840 = ( Nn * Normal.z ) + (Normal.x * Tn ) + ( Normal.y * -Bn);
viewInv[3].x = -viewInv[3].x; //negate eye vector for proper reflections
viewInv[3].y = -viewInv[3].y; //negate eye vector for proper reflections
viewInv[3].z = -viewInv[3].z; //negate eye vector for proper reflections
float3 viewDir = mul(viewInv[3], world) ; // Adjust for world space position of object
float3 MathReflect_8745 = reflect(viewDir, MathWorldXform_9840); //Compute the
reflection vector
float4 UICubeMap_860 = texCUBE(UICubeMap_860Sampler, MathReflect_8745.xyz);
float3 MathOperator_1441 = UICubeMap_860.rgb * UIConst_5178;
float3 input1 = MathOperator_1441;
float4 ret = float4(0,0,0,1);

ret = float4(input1, 1);
return ret;
}

{
v2f Out = (v2f)0;
float3x3 objTangentXf; //build object to tangent space
transform matrix
float3 wsLPos = mul(In.position, world).xyz; //put the vert position in world
space
Out.lightVec = mul(objTangentXf, osLVec); //tangent space light vector passed out
float4 osIPos = mul(viewInv[3], worldI); //put world space eye position in
object space
float3 osIVec = osIPos.xyz - In.position.xyz; //object space eye vector
Out.eyeVec = mul(objTangentXf, osIVec); //tangent space eye vector passed
out

Out.texCoord = In.texCoord; //pass through texture coordinates
from channel 1
return Out;
}

{
float3 V = normalize(In.eyeVec); //creating the eye vector
float2 INUV_272 = In.texCoord.xy;

float2 MathOperator_4752 = INUV_272 * UIConst_5063;
float4 TextureMap_293 = tex2D(TextureMap_293Sampler, MathOperator_4752.xy);
float4 TextureMap_5635 = tex2D(TextureMap_5635Sampler, MathOperator_4752.xy);
TextureMap_5635.xyz = TextureMap_5635.xyz * 2 - 1; //expand to -1 to 1 range
TextureMap_5635.rgb = normalize(TextureMap_5635.rgb); //normalized the normal
vector
float NdotL_diffuse = saturate(dot(L,TextureMap_5635.rgb)); //clamped dot product
float3 DiffuseLight = NdotL_diffuse * DiffuseColor;
float3 MathOperator_8070 = TextureMap_293.rgb * DiffuseLight;
float3 input2 = MathOperator_8070;
float3 HalfAngle = L + V;
float3 NormalizedHalfAngle = normalize(HalfAngle); //Normalize
float NdotH_specular = saturate(dot(NormalizedHalfAngle,TextureMap_5635.rgb));
//clamped dot product
float NdotH_pow_Glossiness = pow(NdotH_specular,UIConst_7974); //x to the power of y
float3 SpecularLight = SpecularColor * NdotH_pow_Glossiness;
float3 input3 = SpecularLight;

float3 input8 = TextureMap_5635.rgb;

float3 specularColor = input3; //using the Specular Color socket
float glossiness = 20; //the Glossiness socket was empty - using
default value
float3 H = normalize(L + V); //Compute the half angle
float NdotH = saturate(dot(N,H)); //Compute NdotH
specularColor *= pow(NdotH, glossiness);//Raise to glossiness power and compute final
specular color
ret += specularColor; //add specular light to final color
float4 done = float4(ret, 1);
return done;
}
{
pass ambient
{
VertexShader = compile vs_1_1 av(lightPos[0]);
ZEnable = true;
CullMode = ccw;
AlphaBlendEnable = false;
PixelShader = compile ps_2_0 af(lightCol[0]);
}
pass light1
{
ZEnable = true;
CullMode = ccw;
DestBlend = One;
SrcBlend = One;
ZFunc = LessEqual;
}
pass light2
{
ZEnable = true;
ZWriteEnable = false;
ZFunc = LessEqual;
CullMode = ccw;
SrcBlend = One;
DestBlend = One;
}
pass light3
{
ZEnable = true;
ZFunc = LessEqual;
CullMode = ccw;
SrcBlend = One;
DestBlend = One;
}
pass light4
{
ZEnable = true;
ZFunc = LessEqual;
CullMode = ccw;
SrcBlend = One;
DestBlend = One;
}

- Revisión de compatibilidad entre los shaders generados y la aplicación Virtools
Se procede de igual forma que en el primer shader:
Una vez generado esto dentro de la aplicación virtools se carga el shader para ello
debemos:
- En el menú editors debemos

seleccionar el shader editor
- Después debes cargar el shader

con el botón Load Shader from a file
-Una vez cargado el shader se debe compilar y revisar que la compatibilidad esta validada
Oprima el botón compile
Aparecerá el mensaje de compilación

exitosa
La compatibilidad esta validada
Aplicación del shader a un material
Una vez cargado y validado el shader procederemos a integrarlo al material que el objeto
tiene aplicado.
Se cargan las texturas del mapa de normales, mapa de difusión, mapa de transparencia y
mapa de especularidad al proyecto.
Cargas el modelo con el material que vas a usar y dentro del material editor:
Seleccionas la lista de shaders, deberá

aparecer el shader que se cargo, verifico
y compilo en los pasos anteriores

Una vez cargado el shader deberemos

presionar el botón Shader Params para
modificar las propiedades del shader.
Dentro de los
parámetros que
modificaremos se
encuentran los
canales de textura,
por medio del menú
descendente
seleccionaremos la
textura adecuada
para cada canal.
Se asignan las
texturas para cada
canal y
posteriormente se
dan valores de
repetición UV.

El shader resultante en
virtools
- Identificación de posibles errores
La mayoría de los errores se encuentran en relación con el ambiente de la figura y su

relación con la luz, los objetos no se encuentran iluminados en su totalidad, por ende se
debe realizar la corrección que se realizó dentro del primer shader básico que fue
analizado anteriormente.
Una vez revisada la compatibilidad entre el shader y el programa se deberán corregir los
problemas de mapeo UV y los problemas de la luz.
Corrección de los errores encontrados
-De mapeo de coordenadas UV asignadas a la geometría.

Las coordenadas UV pueden corregirse dentro de 3D Studio Max aplicando un modificado
UVW.
- De manejo de la luz dentro de virtools
En este caso el método deberá incluir a un programador para poder resolver errores en la
línea de código.

Tercera etapa:
Unión de más de un shader a través del uso de canales y el material

Multisubobjeto
Para realizar este shader necesitamos:

Un modelo tridimensional segmentado en diferentes subobjetos, los subobjetos son
definidos dentro de 3d studio max por medio de números, debe tener asignadas las
cooordenadas con los números 2, 3, 4 y 5 para poder usarlos individualmente en los
segmentos del objeto.
Necesitamos texturas:
Cube map
Pintura - Mapa de Pintura - Mapa de Yeso - Mapa de Yeso - Mapa de

difusión normales difusión normales
Metal - Mapa de Metal - Mapa de Vidrio - Mapa de Vidrio - Mapa de

difusión normales difusión normales

Los cuatro materiales

tienen una estructura
básica parecida,
poseen una
modificación individual
de su coordenadas de
textura y nodos de
difusión y normales
conectados al nodo
principal.
Aunque el primer caso

posee una operación
de reflexión en este
nodo tenemos
integrado un vector de
superficie conectado a
un vector que contiene
las coordenadas del
mundo por el cual los
cube maps se
disponen y se conecta
al nodo de reflexión.
Esta serie de nodos

funcionan como vector
del nodo de cube map
logrando visualizar la
reflexión en tiempo
real, estos valores son
multiplicados por una
constante que refiere a
la cantidad de reflejo
visible.

Dentro de la división de los elementos que se realizaron, 4 materiales, se aplicaron a un

objeto de manera simultánea con el uso de un material de tipo subobjeto, empleando el
canal 2 para pintura, 3 para metal ,4 para vidrio, 5 para yeso, además de ellos se
utilizaron valores independientes de repetición y el uso de un mapa de ambiente.
La transcripción del shader es:

float valor_UV_yeso
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 1.0;
texture2D yeso_difusion;
sampler2D yeso_difusionSampler = sampler_state

{
Texture = <yeso_difusion>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};

{
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
/************** light info **************/
//----------------------------------
//----------------------------------


struct a2v {
};

struct v2f {
};

{

v2f Out = (v2f)0;

transform matrix
space

from channel 1
return Out;
}

{
float2 coordenadas_UV_yeso = In.texCoord.xy;

float2 op_UV_yeso = coordenadas_UV_yeso * valor_UV_yeso;
float4 yeso_difusion = tex2D(yeso_difusionSampler, op_UV_yeso.xy);
float3 input2 = yeso_difusion.rgb;
float4 TextureMap_8636 = tex2D(TextureMap_8636Sampler, op_UV_yeso.xy);

vector

return done;
}
{
pass light1
{
ZEnable = true;
CullMode = ccw;
DestBlend = One;
}
}

En la imagen se encuentra ilustrado el

uso del material multisubobjeto con 4
shaders aplicados a la misma esfera,
cada uno de los shaders posee
coordenadas UV únicas.
Este manejo de shaders puede servir

para aplicar un mismo shader a uno o
varios objetos pero conservando la
posibilidad de integrar texturas
independientes a cada Sub Material ID.
- Implementación de más de un nodo de material estándar dentro del nodo

de técnicas
Las técnicas permiten albergar a más de un tipo de shader y aplicarlo a necesidad, por
ejemplo si tenemos un shader con 4 posibles técnicas podríamos designar cada una de
las técnicas individualmente, respetando los valores de coordenada UV de cada uno de
los elementos.
Técnica Vidrio Técnica Pintura Técnica Metal Técnica Yeso
Material Material Material Material

Multisubobjeto 1 Multisubobjeto 2 Multisubobjeto 3 Multisubobjeto 4
aplicando la técnica aplicando la técnica aplicando la técnica aplicando la técnica
vidrio contenida vidrio contenida vidrio contenida vidrio contenida
dentro del shader dentro del shader dentro del shader dentro del shader
/*============================================================================
============= vidrio TECHNIQUE =============
============================================================================*/
textureCUBE reflejo_ambiente;
samplerCUBE reflejo_ambienteSampler = sampler_state

{

Texture = <reflejo_ambiente>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
float valor_reflejo_ambiente
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 0.2;
float valor_UV_vidrio
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 1.0;
texture2D vidrio_difusion;
sampler2D vidrio_difusionSampler = sampler_state
{
Texture = <vidrio_difusion>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
texture2D vidrio_normalmap;
sampler2D vidrio_normalmapSampler = sampler_state

{
Texture = <vidrio_normalmap>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
/************** light info **************/
//----------------------------------
//----------------------------------


struct a2vT1 {
};

struct v2fT1 {
float3 worldTangent : TEXCOORD1;

float3 worldBinormal : TEXCOORD2;
float3 worldNormal : TEXCOORD3;
};
//Ambient and Self-Illum Pass Vertex Shader

v2fT1 avT1(a2vT1 In, uniform float3 lightPosition)
{

v2fT1 Out = (v2fT1)0;


Out.worldNormal = mul(In.normal, worldIT).xyz; //compute world space normal
Out.worldBinormal = mul(In.binormal, worldIT).xyz; //compute world space binormal
Out.worldTangent = mul(In.tangent, worldIT).xyz; //compute world space tangent
from channel 1
return Out;
}
//Ambient and Self-Illum Pass Pixel Shader

float4 afT1(v2fT1 In, uniform float4 lightColor) : COLOR
{
float3 Normal = float3(0,0,1); //tangent space normal vector

float3 Nn = normalize(In.worldNormal); //input the vectors required for tangent to
world space transform
float3 Tn = normalize(In.worldTangent);
float3 Bn = normalize(In.worldBinormal);
float3 ubicacion_mundo = ( Nn * Normal.z ) + (Normal.x * Tn ) + ( Normal.y * -Bn);
viewInv[3].x = -viewInv[3].x; //negate eye vector for proper reflections
viewInv[3].y = -viewInv[3].y; //negate eye vector for proper reflections
viewInv[3].z = -viewInv[3].z; //negate eye vector for proper reflections
float3 viewDir = mul(viewInv[3], world) ; // Adjust for world space position of object
float3 vector_reflejo = reflect(viewDir, ubicacion_mundo); //Compute the reflection
vector
float4 reflejo_ambiente = texCUBE(reflejo_ambienteSampler, vector_reflejo.xyz);
float3 op_val_reflejo = reflejo_ambiente.rgb * valor_reflejo_ambiente;
float3 input1 = op_val_reflejo;
float2 UV_vidrio = In.texCoord.xy;
float2 op_UV_vidrio = UV_vidrio * valor_UV_vidrio;
float4 vidrio_normalmap = tex2D(vidrio_normalmapSampler, op_UV_vidrio.xy);
vidrio_normalmap.xyz = vidrio_normalmap.xyz * 2 - 1; //expand to -1 to 1 range
vidrio_normalmap.rgb = normalize(vidrio_normalmap.rgb); //normalized the normal
vector
float input7 = vidrio_normalmap.a;
float4 ret = float4(0,0,0,1);

ret = float4(input1, 1);
ret.a = input7;
return ret;
}

v2fT1 vT1(a2vT1 In, uniform float3 lightPosition)
{
transform matrix
space

from channel 1
return Out;
}

float4 fT1(v2fT1 In, uniform float4 lightColor) : COLOR
{
float2 UV_vidrio = In.texCoord.xy;

float2 op_UV_vidrio = UV_vidrio * valor_UV_vidrio;
float4 vidrio_difusion = tex2D(vidrio_difusionSampler, op_UV_vidrio.xy);
float3 input2 = vidrio_difusion.rgb;
float4 vidrio_normalmap = tex2D(vidrio_normalmapSampler, op_UV_vidrio.xy);

vidrio_normalmap.xyz = vidrio_normalmap.xyz * 2 - 1; //expand to -1 to 1 range

vidrio_normalmap.rgb = normalize(vidrio_normalmap.rgb); //normalized the normal
vector
float input7 = vidrio_normalmap.a;
float3 input8 = vidrio_normalmap.rgb;

float Opacity = input7;
float4 done = float4(ret, Opacity);
return done;
}
technique vidrio <bool NeedTangentSpace = true; bool

NeedColorAndNormal=true;>
{
pass ambient
{
VertexShader = compile vs_1_1 avT1(lightPos[0]);
ZEnable = true;
CullMode = ccw;
DestBlend = InvSrcAlpha;
PixelShader = compile ps_2_0 afT1(lightCol[0]);
}
pass light1
{
VertexShader = compile vs_1_1 vT1(lightPos[0]);
ZEnable = true;
CullMode = ccw;
DestBlend = One;
ZFunc = LessEqual;
PixelShader = compile ps_2_0 fT1(lightCol[0]);
}
/*============================================================================
============= pinturacorroida TECHNIQUE =============
============================================================================*/
texture2D pintura_difusion;
sampler2D pintura_difusionSampler = sampler_state

{
Texture = <pintura_difusion>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
float valor_UV_pintura
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 1.0;
texture2D pintura_normalmap;
sampler2D pintura_normalmapSampler = sampler_state

{
Texture = <pintura_normalmap>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};

/************** light info **************/

struct a2vT2 {
};

struct v2fT2 {
};

{
transform matrix
space
//this code was added by the texture map Node

Out.texCoord = In.texCoord; //pass through texture coordinates from
channel 1
return Out;
}

{
float4 pintura_difusion = tex2D(pintura_difusionSampler, In.texCoord.xy);

float3 input2 = pintura_difusion.rgb;
float2 coord_UV_pintura = In.texCoord.xy;

float2 op_UV_pintura = coord_UV_pintura * valor_UV_pintura;
float4 pintura_normalmap = tex2D(pintura_normalmapSampler, op_UV_pintura.xy);
pintura_normalmap.xyz = pintura_normalmap.xyz * 2 - 1; //expand to -1 to 1 range
pintura_normalmap.rgb = normalize(pintura_normalmap.rgb); //normalized the normal
vector
float3 input8 = pintura_normalmap.rgb;

return done;
}
technique pinturacorroida <bool NeedTangentSpace = true; bool

{
pass light1
{

ZEnable = true;
CullMode = ccw;
DestBlend = One;
}
/*============================================================================
============= metal TECHNIQUE =============
============================================================================*/
float valor_UV_metal
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 1.0;
texture2D metal_difusion;
sampler2D metal_difusionSampler = sampler_state

{
Texture = <metal_difusion>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
texture2D metal_normalmap;
sampler2D metal_normalmapSampler = sampler_state

{
Texture = <metal_normalmap>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};
/************** light info **************/

struct a2vT3 {
};

struct v2fT3 {
};

{
transform matrix
space


from channel 1
return Out;
}

{
float2 UV_metal = In.texCoord.xy;

float2 op_UV_metal = UV_metal * valor_UV_metal;
float4 metal_difusion = tex2D(metal_difusionSampler, op_UV_metal.xy);
float3 input2 = metal_difusion.rgb;
float4 metal_normalmap = tex2D(metal_normalmapSampler, op_UV_metal.xy);

metal_normalmap.xyz = metal_normalmap.xyz * 2 - 1; //expand to -1 to 1 range
metal_normalmap.rgb = normalize(metal_normalmap.rgb); //normalized the normal
vector
float3 input8 = metal_normalmap.rgb;

return done;
}
technique metal <bool NeedTangentSpace = true; bool

{
pass light1
{
ZEnable = true;
CullMode = ccw;
DestBlend = One;
}
/*============================================================================
============= yeso TECHNIQUE =============
============================================================================*/
float valor_UV_yeso
<
float UIMin = 0.0;
float UIMax = 10.0;
float UIStep = 0.1;
> = 1.0;
texture2D yeso_difusion;
sampler2D yeso_difusionSampler = sampler_state

{
Texture = <yeso_difusion>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};

{
MinFilter = LINEAR;
MagFilter = LINEAR;

MipFilter = LINEAR;
};
/************** light info **************/

struct a2vT4 {
};

struct v2fT4 {
};

{
transform matrix
space

from channel 1
return Out;
}

{
float2 coordenadas_UV_yeso = In.texCoord.xy;

float2 op_UV_yeso = coordenadas_UV_yeso * valor_UV_yeso;
float4 yeso_difusion = tex2D(yeso_difusionSampler, op_UV_yeso.xy);
float3 input2 = yeso_difusion.rgb;
float4 TextureMap_8636 = tex2D(TextureMap_8636Sampler, op_UV_yeso.xy);

vector

return done;
}
technique yeso <bool NeedTangentSpace = true; bool


{
pass light1
{
ZEnable = true;
CullMode = ccw;
DestBlend = One;
}
Dentro del shader podemos ver cada una de las técnicas resaltadas, estas pueden ser
intercambiadas dentro de virtools según la necesidad por medio de la lista de active technique.
Indice:
Shader FX.............................................................................................................................1
Método de uso de la aplicación Shader FX ..........................................................................2
y su implementación en Virtools ...........................................................................................2
Primera etapa: ......................................................................................................................2
Reconocimiento de la Interfaz y de las limitaciones de la versión educativa ....................2
Aplicaciones que emplean el formato fx y su relación con direct x, Cg, cgsl, hlsl ............3
Creación del primer shader básico ...................................................................................4
Uso de texturas: ................................................................................................................5
Manejo de coordenadas de textura:..................................................................................7
Revisión de compatibilidad entre los shaders generados y la aplicación Virtools. ........10
-Texturas de cada canal ..............................................................................................10
-Shader con formato fx ................................................................................................11
-Geometría de prueba dentro de virtools.....................................................................11

Aplicación del shader a un material.............................................................................11

Identificación de posibles errores....................................................................................13
Corrección de los errores encontrados ...........................................................................14
Segunda etapa: ...............................................................................................................14
- Aprendizaje del uso de los nodos de textura ............................................................15
Aplicación del shader a un material ................................................................................21
- Identificación de posibles errores .................................................................................23
Corrección de los errores encontrados ...........................................................................23
Tercera etapa: .................................................................................................................24
Unión de más de un shader a través del uso de canales y el material Multisubobjeto ...24
- Implementación de más de un nodo de material estándar dentro del nodo de técnicas
........................................................................................................................................28
Indice: .................................................................................................................................36
Refrencias:..........................................................................................................................37
Refrencias:
Wikimedia Foundation. (26 de enero de 2009). Normal mapping. Recuperado el 13 de

febrero de 2009, de Wikipedia: http://en.wikipedia.org/wiki/Normal_mapping
Wikimedia Foundation. (3 de febrero de 2009). Shader. Recuperado el 13 de febrero de

2009, de Wikipedia: http://en.wikipedia.org/wiki/Shader

Shader FX

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Shader FX

Cargado por

Copyright:

Formatos disponibles

Método de uso de la aplicación Shader FX y su implementación en Virtools Sombreado

Método de uso de la aplicación Shader FX y

1 Victor Hugo Franco Serrano / DGSCA UNAM

Método de uso de la aplicación Shader FX

2 Victor Hugo Franco Serrano / DGSCA UNAM

Dentro de las limitaciones del uso de la versión educativa se encuentran:

FXcomposer – Permite la visualización, modificación y creación de shaders para tiempo

- Descartar la posibilidad de mejor compatibilidad entre Virtools y alguna otra aplicación

3 Victor Hugo Franco Serrano / DGSCA UNAM

HLSL específica para

Shadeer1 básico - Uso de

Para cada canal existen texturas independientes que contienen características

La textura de difusión da un color general El mapa de normales contiene la

El mapa alfa es el mapa de transparencia, El mapa de especularidad es el que se

5 Victor Hugo Franco Serrano / DGSCA UNAM

Para asignar cada

Mapa de normales Mapa de transparencia

Al ser integradas las texturas, debemos

6 Victor Hugo Franco Serrano / DGSCA UNAM

Las coordenadas de te extura se pue eden

dar en formato SFX y exportación al formato FX para virtools:

En la ventana Guardar como tecleamos el nombre y le damos ubicación al archivo FX

Transcripción del shader generado a través de Shader FX

// This FX shader was built to support Virtools.

sampler2D difusion_mapaSampler = sampler_state

sampler2D mapa_especularSampler = sampler_state

sampler2D AlfaSampler = sampler_state

sampler2D mapa_normalesSampler = sampler_state

8 Victor Hugo Franco Serrano / DGSCA UNAM

/************** light info **************/

float3 lightPos[1] : NEARESTLIGHT <string Space="World";>;

float4 lightCol[1] : NEARESTLIGHT <float4 Default={1,1,1,1};>;

float4x4 wvp : WORLDVIEWPROJECTION;

// input from application

float2 texCoord : TEXCOORD0;

// output to fragment program

float2 texCoord : TEXCOORD2;

//Diffuse and Specular Pass Vertex Shader

//this code was added by the IN UV Node

//Diffuse and Specular Pass Pixel Shader

float2 coordenadasUV = In.texCoord.xy;

9 Victor Hugo Franco Serrano / DGSCA UNAM

float3 input2 = difusion_mapa.rgb;

float4 mapa_especular = tex2D(mapa_especularSampler, MathOperator_3776.xy);

float4 mapa_normales = tex2D(mapa_normalesSampler, MathOperator_4973.xy);

float3 N = input8; //using the Normal socket

technique Complete <bool NeedTangentSpace = true; bool NeedColorAndNormal=true;>

Revisión de compatibilidad entre los shaders generados y la aplicación

Para comprobar la compatibilidad del shader dentro de la aplicación Virtools necesitamos:

-Texturas de cada canal

10 Victor Hugo Franco Serrano / DGSCA UNAM

-Shader con formato fx -Geometría de prueba dentro de

- En el menú editors debemos

- Después debes cargar el shader

Oprima el botón compile

Aparecerá el mensaje de compilación

La compatibilidad esta validada

Aplicación del shader a un material

11 Victor Hugo Franco Serrano / DGSCA UNAM

Seleccionas la lista de shaders, deberá

Una vez cargado el shader deberemos

12 Victor Hugo Franco Serrano / DGSCA UNAM

Los errrores más comunes

/ light info /

/ light info /