So I tried to create an unlit shader in unity using the built-in render pipeline and blit it to the screen using the function: OnRenderImage(RenderTexture src, RenderTexture dest) in my C# code. I have been kind of loosely following this video:
(https://www.youtube.com/watch?v=DxfEbulyFcY&t=1138s)
among other things because my goal is to create a volumetric atmosphere shader. However, I seem to have multiple problems.
The shader draws an oval shape, not a sphere (I suspect that this has something to do with the aspect ratio of the window, it's still not welcome though)
The "sphere" is only drawn when the camera is at a certain angle or position. Meaning that if I tried to look at it from the back that it would just disappear
The position seems to be way off from what the position and radius of the volume sphere seems too not be correct
I have done my best to read up and do my research on volumetric rendering, but I still don't quite understand what's going on here.
C# code (Attached to camera)
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[ExecuteInEditMode, ImageEffectAllowedInSceneView]
public class ImageEffectManager : MonoBehaviour
{
public Shader effectShader;
public Transform volume;
Material mat;
private void OnRenderImage(RenderTexture src, RenderTexture dest)
{
if (mat == null && effectShader != null)
{
mat = new Material(effectShader);
}
//Set shader properties here:
mat.SetVector("_SphereCenter", volume.position);
mat.SetFloat("_SphereRadius", volume.GetComponent<SphereCollider>().radius);
//Draw the shader to the screen
Graphics.Blit(src, dest, mat);
}
}
HLSL Shader (goes into property effectShader)
// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
// Upgrade NOTE: replaced '\_Object2World' with 'unity_ObjectToWorld'
// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
Shader "Unlit/ImageEffectTest"
{
Properties
{
\_MainTex ("Texture", 2D) = "white" {}
\_SphereCenter ("Sphere Center", Vector) = (0, 0, 0, 0) // editor's note: I dont know why the '\' got put at the beginning of each property when I copy+pasted the code, but I guess it's there now.
\_SphereRadius ("Sphere Radius", Float) = 1
}
SubShader
{
Tags { "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Opaque" }
Blend One Zero
Cull Off Lighting Off ZWrite Off
LOD 100
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
// make fog work
#pragma multi_compile_fog
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float3 worldPos : TEXCOORD1;
};
sampler2D _MainTex;
float4 _MainTex_ST;
float3 _SphereCenter;
float _SphereRadius;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
return o;
}
float2 raySphere(float3 sphereCenter, float sphereRadius, float3 rayOrigin, float3 rayDir)
{
float3 offset = rayOrigin - sphereCenter;
float a = 1;
float b = 2 * dot(offset, rayDir);
float c = dot(offset, offset) - sphereRadius * sphereRadius;
float d = b * b - 4 * a * c;
if (d > 0)
{
float s = sqrt(d);
float dstToSphereNear = max(0, (-b - s) / (2 * a));
float dstToSphereFar = (-b + s) / (2 * a);
if (dstToSphereFar >= 0)
{
return float2(dstToSphereNear, dstToSphereFar - dstToSphereNear);
}
}
return float2(3.402823466e+38, 0);
}
float4 frag (v2f i) : SV_Target
{
float4 col = tex2D(_MainTex, i.uv);
float3 rayOrigin = _WorldSpaceCameraPos;
float3 rayDir = normalize(i.worldPos - _WorldSpaceCameraPos);
float2 hitInfo = raySphere(_SphereCenter, _SphereRadius, rayOrigin, rayDir);
float dstToAtmosphere = hitInfo.x;
float dstThroughAtmosphere = hitInfo.y;
return dstThroughAtmosphere / (_SphereRadius * 2);
}
ENDCG
}
}
}
Here's what I was trying to describe above
Here's an unlisted video I uploaded to make it easier to understand what's happening
I tried to switch some operators in the shader code, some macros, along with double-checking my work across some different sources such as this pretty helpful article: (https://www.alanzucconi.com/2016/07/01/volumetric-rendering/)
However, none of these made any kind of significant difference on the result that I was getting, so I finally decided to make this post.
Related
If add in "FallBack" nonexistent shader appers this error "Shader warning in 'Curved/CurvedAlpha': Shader is not supported on this GPU (none of subshaders/fallbacks are suitable)". So can i make a conclusion that this shader is not supported on this GPU after adding just one variable(look further)?
My videocard geforce gtx 1060 3gb.
Shader "Curved/CurvedAlpha" {
Properties {
_Color("Color", COLOR) = (1, 1, 1, 1)
_MainTex ("Base (RGB)", 2D) = "white" {}
_QOffset ("Offset", Vector) = (0,0,0,0)
_Dist ("Distance", Float) = 100.0
_Alpha ("Alpha", Range(0.0,1.0)) = 1.0
}
SubShader {
Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent"}
LOD 100
ZWrite On
Blend SrcAlpha OneMinusSrcAlpha
Pass
{
Lighting Off
CGPROGRAM
// Upgrade NOTE: excluded shader from DX11; has structs without semantics (struct v2f members factor)
#pragma exclude_renderers d3d11
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
half4 _Color;
sampler2D _MainTex;
float4 _QOffset;
float _Dist;
float _Alpha;
uniform float4 _MainTex_ST;
struct v2f {
float4 pos : SV_POSITION;
float2 uv : TEXCOORD0;
After addind "factor" and calculating it in vert function shader falls back in to a "Legacy Shaders/Transparent/VertexLit"
float4 factor: COLOR;
};
v2f vert (appdata_base v)
{
v2f o;
float4 vPos = mul (UNITY_MATRIX_MV, v.vertex);
float zOff = vPos.z/_Dist;
vPos += _QOffset*zOff*zOff;
o.pos = mul (UNITY_MATRIX_P, vPos);
o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
float factor = max(0, dot(v.normal, float3(0,1,0)));
o.factor = float4(factor,0,0,0);
return o;
}
fixed4 frag (v2f i) : COLOR
{
//fixed4 color = tex2D(_MainTex, i.uv) * _Color;
return tex2D(_MainTex, i.uv) * float4(_Color.r, _Color.g, _Color.b, _Alpha) * i.factor.x;
}
ENDCG
}
}
FallBack "Legacy Shaders/Transparent/VertexLit"
}
The problem was add lighting processing to curved shader.
When you get errors about shaders not being supported on a GPU, i've found that 90% of the time it is related to the ShaderLab part of the code, since this does not have the same detailed compiler errors as the CG code and typically just lazily claims that the shader is unsupported when in fact there is a syntax error.
In your case, i think you should spell it as Fallback instead of FallBack.
I use unity 2018.3.5f1. I would like to overlay a custom shader while rendering an image. Following is my onRenderImage Function.
void OnRenderImage(RenderTexture src, RenderTexture dest) {
// shaderMaterial renders the image with Barrel distortion and disparity effect
Graphics.Blit(camTextureHolder.mainTexture, nullRenderTexture, shaderMaterial);
// measure average frames per second
m_FpsAccumulator++;
if (Time.realtimeSinceStartup > m_FpsNextPeriod) {
m_CurrentFps = (int)(m_FpsAccumulator / fpsMeasurePeriod);
m_FpsAccumulator = 0;
m_FpsNextPeriod += fpsMeasurePeriod;
}
}
The issue is that the entire screen appears to be black while I'm trying to do so. May I know how do I fix this issue?
Update:
This is the code for the shader that I'm using
Shader "Custom/FakeAR"
{
Properties{
_MainTex("", 2D) = "white" {}
[HideInInspector]_FOV("FOV", Range(1, 2)) = 1.6
[HideInInspector]_Disparity("Disparity", Range(0, 0.3)) = 0.1
[HideInInspector]_Alpha("Alpha", Range(0, 2.0)) = 1.0
}
SubShader{
Pass{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
struct v2f {
float4 pos : POSITION;
float2 uv : TEXCOORD0;
};
// Default Vertex Shader
v2f vert(appdata_img v) {
v2f o;
o.pos = UnityObjectToClipPos(v.vertex);
o.uv = MultiplyUV(UNITY_MATRIX_TEXTURE0, v.texcoord.xy);
return o;
}
// Parameters
sampler2D _MainTex;
float _FOV;
// Alpha is the ratio of pixel density: width to height
float _Alpha;
// Disparity is the portion to separate
// larger disparity cause closer stereovision
float _Disparity;
// Fragment Shader: Remap the texture coordinates to combine
// barrel distortion and disparity video display
fixed4 frag(v2f i) : COLOR {
float2 uv1, uv2, uv3;
float t1, t2;
float offset;
// uv1 is the remap of left and right screen to a full screen
uv1 = i.uv - 0.5;
uv1.x = uv1.x * 2 - 0.5 + sign(i.uv.x < 0.5);
t1 = sqrt(1.0 - uv1.x * uv1.x - uv1.y * uv1.y);
t2 = 1.0 / (t1 * tan(_FOV * 0.5));
// uv2 is the remap of side screen with barrel distortion
uv2 = uv1 * t2 + 0.5;
// black color for out-of-range pixels
if (uv2.x >= 1 || uv2.y >= 1 || uv2.x <= 0 || uv2.y <= 0) {
return fixed4(0, 0, 0, 1);
}
else {
offset = 0.5 - _Alpha * 0.5 + _Disparity * 0.5 - _Disparity * sign(i.uv.x < 0.5);
// uv3 is the remap of image texture
uv3 = uv2;
uv3.x = uv2.x * _Alpha + offset;
return tex2D(_MainTex, uv3);
}
}
ENDCG
}
}
FallBack "Diffuse"
}
Is it because of the shader?
Well I think it's working it's just that the shader has nothing to render meaning it goes for black. You might want the shader to use the excisting camera texture. So maybe this?
void OnRenderImage(RenderTexture src, RenderTexture dest) {
// shaderMaterial renders the image with Barrel distortion and disparity effect
Graphics.Blit(src, dst, shaderMaterial);
// measure average frames per second
m_FpsAccumulator++;
if (Time.realtimeSinceStartup > m_FpsNextPeriod) {
m_CurrentFps = (int)(m_FpsAccumulator / fpsMeasurePeriod);
m_FpsAccumulator = 0;
m_FpsNextPeriod += fpsMeasurePeriod;
}
}
Try making the shader really default and see if it renders something. So try a shader that looks like this:
Shader "Examples/ExampleDisplacement"
{
Properties
{
_MainTex("Texture", 2D) = "white" {}
}
SubShader
{
// No culling or depth
Cull Off ZWrite Off ZTest Always
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
};
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = v.uv;
return o;
}
sampler2D _MainTex;
float4 frag (v2f i) : SV_Target
{
float4 col = tex2D(_MainTex, i.uv);
return col;
}
ENDCG
}
}
}
Hi fellow Unity devs,
I have been trying to modify the built in Unity shader for Skybox/Cubemap, such that it takes a second cubemap, and has a blend factor between the two.
I have attempted the following shader script, however it does not produce the intended result, is anybody who knows more about shader code than me please able to assist in my learning/results? I am finding it very difficult to learn how to use shader code, only been using Unity for about 2-3 months.
Shader "RenderFX/Skybox2" {
Properties {
_Tint ("Tint Color", Color) = (.5, .5, .5, .5)
[Gamma] _Exposure ("Exposure", Range(0, 8)) = 1.0
_Rotation ("Rotation", Range(0, 360)) = 0
_Rotation2 ("Rotation 2", Range(0, 360)) = 0
_Blend ("Blend", Range (0, 1) ) = 0.5
[NoScaleOffset] _Tex ("Cubemap (HDR)", Cube) = "grey" {}
_Skybox2 ("Skybox two", Cube) = ""
}
SubShader {
Tags { "Queue"="Background" "RenderType"="Background" "PreviewType"="Skybox" }
Cull Off ZWrite Off
Pass {
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma target 2.0
#include "UnityCG.cginc"
samplerCUBE _Tex;
half4 _Tex_HDR;
half4 _Tint;
half _Exposure;
float _Rotation;
float3 RotateAroundYInDegrees (float3 vertex, float degrees)
{
float alpha = degrees * UNITY_PI / 180.0;
float sina, cosa;
sincos(alpha, sina, cosa);
float2x2 m = float2x2(cosa, -sina, sina, cosa);
return float3(mul(m, vertex.xz), vertex.y).xzy;
}
struct appdata_t {
float4 vertex : POSITION;
};
struct v2f {
float4 vertex : SV_POSITION;
float3 texcoord : TEXCOORD0;
};
v2f vert (appdata_t v)
{
v2f o;
float3 rotated = RotateAroundYInDegrees(v.vertex, _Rotation);
o.vertex = UnityObjectToClipPos(rotated);
o.texcoord = v.vertex.xyz;
return o;
}
fixed4 frag (v2f i) : SV_Target
{
half4 tex = texCUBE (_Tex, i.texcoord);
half3 c = DecodeHDR (tex, _Tex_HDR);
c = c * _Tint.rgb * unity_ColorSpaceDouble.rgb;
c *= _Exposure;
return half4(c, 1);
}
ENDCG
}
Pass {
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma target 2.0
#include "UnityCG.cginc"
samplerCUBE _Skybox2;
half4 _Skybox2_HDR;
half4 _Tint;
half _Exposure;
float _Rotation2;
float _Blend;
float3 RotateAroundYInDegrees (float3 vertex, float degrees)
{
float alpha = degrees * UNITY_PI / 180.0;
float sina, cosa;
sincos(alpha, sina, cosa);
float2x2 m = float2x2(cosa, -sina, sina, cosa);
return float3(mul(m, vertex.xz), vertex.y).xzy;
}
struct appdata_t {
float4 vertex : POSITION;
};
struct v2f {
float4 vertex : SV_POSITION;
float3 texcoord : TEXCOORD0;
};
v2f vert (appdata_t v)
{
v2f o;
float3 rotated = RotateAroundYInDegrees(v.vertex, _Rotation2);
o.vertex = UnityObjectToClipPos(rotated);
o.texcoord = v.vertex.xyz;
return o;
}
fixed4 frag (v2f i) : SV_Target
{
half4 tex = texCUBE (_Skybox2, i.texcoord);
half3 c2 = DecodeHDR (tex, _Skybox2_HDR);
c2 = c2 * _Tint.rgb * unity_ColorSpaceDouble.rgb;
c2 *= _Exposure;
return half4(c2, 1);
}
ENDCG
}
Pass {
SetTexture[c]
SetTexture[c2] {
ConstantColor (0,0,0, [_Blend])
Combine texture Lerp(constant) previous
}
}
}
Fallback Off
}
The result is a grey view, and I don't think I am passing the c/c2 variables properly, or even if they CAN be passed like that. I am really stumped as to how I might achieve this effect.
The blend pass works fine for just the plain textures, but I need it to maintain the rotation values, not just the textures.
Thank you in advance to you shader/Unity experts out there! I hope one day to join your ranks.
I have began to create some shaders for my university group project however I have ran into a bit of a snag with my water shader. I am trying to create one which utilises two overlapping normal maps.
Whilst everything looks okay in the editor, when I then publish to the webplayer, the scene looks like its unlit.
Heres my code for the shader:
//
// Filename : WaterShader.shader
// Version : 2.0
// Date : 1st March 2014
//
Shader "Flight/WaterShader/2.0"
{
// Set up variables so we can access them in inspector mode
Properties
{
// Variable to control the colour tint
_Color ("Base Color", Color) = (1, 1, 1, 1)
// Variables for specular
_SpecularColor ("Specular Color", Color) = (1, 1, 1, 1)
_SpecularAmount ("Shininess", Float) = 10
// Variable for setting the base texture
_MainTex ("Water Texture", 2D) = "white" { }
// Variables to set the normal map 1
_BumpMapA ("Normal Map", 2D) = "bump" { }
_BumpDepthA ("Depth", Range(0.25, 10.0)) = 1
// Variables to set the normal map 2
_BumpMapB ("Normal Map", 2D) = "bump" { }
_BumpDepthB ("Depth", Range(0.25, 10.0)) = 1
}
SubShader
{
pass
{
Tags { "RenderType" = "Opaque" }
Lighting On
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma exclude_renderers flash
// Variables
sampler2D _MainTex;
float4 _MainTex_ST;
sampler2D _BumpMapA;
float4 _BumpMapA_ST;
float _BumpDepthA;
sampler2D _BumpMapB;
float4 _BumpMapB_ST;
float _BumpDepthB;
float4 _Color;
float4 _SpecularColor;
float _SpecularAmount;
float4 _LightColor0;
struct vertexInput
{
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 texcoord : TEXCOORD0;
float4 tangent : TANGENT;
};
struct vertexOutput
{
float4 pos : SV_POSITION;
float4 tex : TEXCOORD0;
float4 posWorld : TEXCOORD1;
float3 normalWorld : TEXCOORD2;
float3 tangentWorld : TEXCOORD3;
float3 binormalWorld : TEXCOORD4;
};
vertexOutput vert(vertexInput input)
{
vertexOutput output;
output.pos = mul(UNITY_MATRIX_MVP, input.vertex);
output.tex = input.texcoord;
output.posWorld = mul(_Object2World, input.vertex);
output.normalWorld = normalize( mul( float4( input.normal, 0.0f ), _World2Object ).xyz );
output.tangentWorld = normalize( mul( _Object2World, input.tangent ).xyz );
output.binormalWorld = normalize( cross( output.normalWorld, output.tangentWorld) * input.tangent.w );
return output;
}
float4 frag(vertexOutput input) : COLOR
{
// Set up variables
float3 viewDirection;
float3 lightDirection;
float3 normalDirection;
float lightIntensity;
float4 normalColorA;
float4 normalColorB;
float4 normalColor;
float3 normalLocalA;
float3 normalLocalB;
float3 normalLocal;
float3x3 normalWorld;
float4 textureColor;
float3 diffuseColor;
float3 specularColor;
float3 lightColor;
float4 finalColor;
// Begin calculations
// Calculate the angle we are looking at the pixel
viewDirection = normalize(_WorldSpaceCameraPos.xyz - input.posWorld.xyz );
if(_WorldSpaceLightPos0.w == 0.0)
{
lightIntensity = 1.0;
lightDirection = normalize(_WorldSpaceLightPos0.xyz);
}
else
{
float3 fragmentToLightSource = _WorldSpaceLightPos0.xyz - input.posWorld.xyz;
float distance = length(fragmentToLightSource);
lightIntensity = 1.0 / distance;
lightDirection = normalize(fragmentToLightSource);
}
// Sample the textures
textureColor = tex2D(_MainTex, input.tex.xy * _MainTex_ST.xy + _MainTex_ST.zw);
normalColorA = tex2D(_BumpMapA, input.tex.xy * _BumpMapA_ST.xy + _BumpMapA_ST.zw);
normalColorB = tex2D(_BumpMapB, input.tex.xy * _BumpMapB_ST.xy + _BumpMapB_ST.zw);
// Expand the normals and set the intensity of the normal map
normalLocalA = float3(2.0 * normalColorA.ag - float2(1.0, 1.0), 0.0);
normalLocalA.z = _BumpDepthA;
normalLocalB = float3(2.0 * normalColorB.ag - float2(1.0, 1.0), 0.0);
normalLocalB.z = _BumpDepthB;
// Combine the two normals
normalLocal = normalize(normalLocalA + normalLocalB);
// Calculate the normal in the world
normalWorld = float3x3( input.tangentWorld, input.binormalWorld, input.normalWorld );
normalDirection = normalize( mul( normalLocal, normalWorld ) );
// Calculate lighting
diffuseColor = lightIntensity * _LightColor0.xyz * saturate( dot(normalDirection, lightDirection) );
specularColor = diffuseColor * _SpecularColor.xyz * pow( saturate( dot( reflect(-lightDirection, normalDirection), viewDirection) ), _SpecularAmount );
// Combine lighting
lightColor = UNITY_LIGHTMODEL_AMBIENT.xyz + diffuseColor + specularColor;
// Apply lighting to the texture color
textureColor = float4( textureColor.xyz * lightColor * _Color.xyz, 1.0);
return textureColor;
}
ENDCG
}
}
FallBack "Specular"
}
In the editor it looks like this:
Where as in the webplayer it looks like this:
Anyone able to help me see where I have gone wrong? :)
You need a separate pass of pixel light in the scene for the web player. Replace your current SubShader Parameters with
SubShader
{
Tags {"RenderType" = "Opaque"}
Pass
{
Tags {"LightMode" = "ForwardAdd"}
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma exclude_renderers flash
So I've been looking across the web to find an answer to this question, but I seem to be missing something.
I've got a little project going that dynamically creates 3D terrain in XNA 4.0, but I want be able to draw a circle (or any other shape for that matter, but let's first go with a circle) on the terrain.
Now I've read some things about 'projective texturing' but I'll admit I'm at a complete loss when it comes to shader-language.
The idea is that I can (dynamically) create a basic shape, say a circle with a 2 'units' diameter, then draw that on the terrain to function as an indicator where the cursor is. (I am able to get the cursor position on the 3D terrain.)
Would anyone know how to do this, is it required to use shaders for this? Any help on the matter is apreciated!
Thanks in advance!
You can use a shader ...
you pass as parameter to the terrain shader, the 3D world position of your cursor, and a radius... to define a sphere,
the trick is pass the vertex world position from the vertex shader to the pixel shader, and
in the pixel shader you only have to tint the output color if the pixel is being drawed, is inside the sphere.
EDIT: I have found an old shader done by myself... with two types of selection circle and box, here you are:
uniform float4x4 xWorldViewProjection;
uniform float3 xCursorPos;
uniform float xCursorRadio;
uniform float4 xLightColor = float4(0.8, 0.8, 0.8,1);
uniform float4 xAmbientFactor = 0.4f;
uniform float3 xCamPos;
uniform int xCursorType=0; // 0: Circle 1: Box
void VS_Basico(
in float4 inPos : POSITION,
in float3 inNormal : NORMAL0,
in float4 inColor : COLOR0,
out float4 outPos: POSITION,
out float3 outNormal:TEXCOORD1,
out float3 outPos2 : TEXCOORD0,
out float4 outColor: COLOR0
)
{
outPos = mul (inPos, xWorldViewProjection);
outNormal = inNormal;
outPos2 = inPos.xyz;
outColor = inColor;
}
float4 PS_CursorPerPixelCircular ( in float4 inColor : COLOR, in float3 inPos:TEXCOORD0 ) : COLOR
{
float f = distance(inPos, xCursorPos);
float4 outColor = inColor;
if (f<xCursorRadio) {
outColor=lerp(float4(0,1,1,1), inColor, 0.4) ;
}
return outColor;
}
float4 PS_CursorPerPixelCuadrado ( in float4 inColor : COLOR, in float3 inPos:TEXCOORD0 ) : COLOR
{
float3 size = float3(xCursorRadio,xCursorRadio,xCursorRadio);
float3 minSize = xCursorPos - size;
float3 maxSize = xCursorPos + size;
float4 outColor = inColor;
if (inPos.x>=minSize.x && inPos.x<=maxSize.x && inPos.y>=minSize.y && inPos.y<=maxSize.y && inPos.z>=minSize.z && inPos.z<=maxSize.z )
{
outColor=lerp(float4(0,1,1,1), inColor, 0.4) ;
}
return outColor;
}
void PS_Basico(
in float4 inColor : COLOR0,
in float3 inPos:TEXCOORD0,
in float3 inNormal:TEXCOORD1,
out float4 outColor: COLOR0
)
{
float3 xLightPos = float3(40, 40, 0);
float3 LightDir = normalize(inPos - xLightPos);
float3 reflectionVector = reflect(LightDir, inNormal);
float3 eyeVector = inPos - xCamPos;
float specular = dot(normalize(reflectionVector), normalize(eyeVector));
specular = pow(specular, 256);
float difusse_factor = -dot(normalize(inNormal), LightDir);
if (difusse_factor<0) difusse_factor = 0;
float4 col = inColor * xAmbientFactor + inColor * difusse_factor * xLightColor;
if (xCursorType ==0)
{
col = PS_CursorPerPixelCircular(col, inPos);
} else {
col = PS_CursorPerPixelCuadrado(col, inPos);
}
col.a = 1;
col.rgb += specular;
/* col.xyz = col.xyz * (inPos.y+1) / 2;
col.y = 2*col.x;
col.z = 2*col.x;
*/
outColor = col;
//outColor = float4(inNormal, 1);
}
//-------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------
//--- TECNIQUES -----------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------
technique ColoredWired
{
pass Pass0
{
VertexShader = compile vs_2_0 VS_Basico();
PixelShader = compile ps_2_0 PS_Basico();
FILLMODE = WIREFRAME;
}
}
technique ColoredSolid
{
pass Pass0
{
VertexShader = compile vs_2_0 VS_Basico();
PixelShader = compile ps_2_0 PS_Basico();
FILLMODE = SOLID;
}
}