Binary

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

Description

This shader limits down a textured object to 2 colors (full example at http://www.youtube.com/watch?v=YQ5UrL8klhs&feature=channel_page )

Notes

This shader was made by Daniel Olson in June of 2009, you can contact Daniel Olson by e-mailing iPhone.MDMstudios@gmail.com

When using this shader, there will be 9 input variables that will help decide the final color of the current fragment.

1:Pre-Calculative Color; This color gets multiplied to your texture before any 'core' calculations take place, making it so that the outcome may change slightly.

2:Color One; This is the first of 2 colors that a fragment can be.

3:Color Two; This is the second of 2 colors that a fragment can be.

4:Ambient Color; This color gets added to the texture color before 'core' calculations take place, making it so you can see the texture when the object is not being hit by a light, and when the object is being hit by a light, the light will not effect the fragment as much.

5:Final Color Multiplication; The final outcome is multiplied by this color, which does nothing other then changing both Color One, and Color Two at the same time.

6:Base (RGB); The actual texture that will be used for the shader.

7:Equality Number; This value, although a float, will be converted into a int on run-time. Changing this value can do several things, such as inverting the fragment. For best results the Equality Number should be smaller then the Modulus Number.

8:Modulus Number; This float also will be converted into a int on run-time. The calculations that this value is used for is, if (asdf % ModulusNumber == equa) tex = _Col1; else tex = _Col2; Changing this value can cause similar effects to changing the Equality Number

9:Multiplication Number; this is the number that the average fragment color is multiplied by before the modulus calculations take place, changing this on a textureless plane with a light for example will change how many 'rings' you will see.

Code

Invalid language.

You need to specify a language like this: <source lang="html4strict">...</source>

Supported languages for syntax highlighting:

4cs, 6502acme, 6502kickass, 6502tasm, 68000devpac, abap, actionscript, actionscript3, ada, algol68, apache, applescript, apt_sources, asm, asp, autoconf, autohotkey, autoit, avisynth, awk, bascomavr, bash, basic4gl, bf, bibtex, blitzbasic, bnf, boo, c, c_loadrunner, c_mac, caddcl, cadlisp, cfdg, cfm, chaiscript, cil, clojure, cmake, cobol, coffeescript, cpp, cpp-qt, csharp, css, cuesheet, d, dcs, delphi, diff, div, dos, dot, e, ecmascript, eiffel, email, epc, erlang, euphoria, f1, falcon, fo, fortran, freebasic, fsharp, gambas, gdb, genero, genie, gettext, glsl, gml, gnuplot, go, groovy, gwbasic, haskell, hicest, hq9plus, html4strict, html5, icon, idl, ini, inno, intercal, io, j, java, java5, javascript, jquery, kixtart, klonec, klonecpp, latex, lb, lisp, llvm, locobasic, logtalk, lolcode, lotusformulas, lotusscript, lscript, lsl2, lua, m68k, magiksf, make, mapbasic, matlab, mirc, mmix, modula2, modula3, mpasm, mxml, mysql, newlisp, nsis, oberon2, objc, objeck, ocaml, ocaml-brief, oobas, oracle11, oracle8, oxygene, oz, pascal, pcre, per, perl, perl6, pf, php, php-brief, pic16, pike, pixelbender, pli, plsql, postgresql, povray, powerbuilder, powershell, proftpd, progress, prolog, properties, providex, purebasic, pycon, python, q, qbasic, rails, rebol, reg, robots, rpmspec, rsplus, ruby, sas, scala, scheme, scilab, sdlbasic, smalltalk, smarty, sql, systemverilog, tcl, teraterm, text, thinbasic, tsql, typoscript, unicon, uscript, vala, vb, vbnet, verilog, vhdl, vim, visualfoxpro, visualprolog, whitespace, whois, winbatch, xbasic, xml, xorg_conf, xpp, yaml, z80, zxbasic

```Shader "LimitedColors/Binary" {
Properties {
_Color ("Pre-Calculative Color", Color) = (1,1,1,1) // this color gets applied before texture calculations take place
_Col1 ("Color One", Color) = (.5,.5,.5,1) // one of the colors that the end fragment can become
_Col2 ("Color Two", Color) = (0,0,0,1) // the second color that the end fragment can become
_Ambient("Ambient Color", Color) = (1, 1, 1, 1) // the ambient light level.
_Final("Final Color Multiplication", Color) = (1, 1, 1, 1) // this color is applied after all calculations (including colors are applied) have been completed
_MainTex ("Base (RGB)", 2D) = "white" {} // main texture
_Equa ("Equality Number ", float) = 2 // helps to determain what color range _Col1 & _Col2 should be applied to
_Modulus ("Modulus Number", float) = 4 // helps to determain what color range _Col1 & _Col2 should be applied to
_Multi ("Multiplication Number ", float) = 10 // determains how many "rings" should be made
/* Note:
*	The last 3 'floats' are converted to ints
*/
}

Pass {
Name "Lighting On"
Tags { "LightMode" = "Pixel" } // do all of these calculations when a pixel light is using it
CGPROGRAM
// go through all the pragma and file includes
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_builtin
#pragma fragmentoption ARB_fog_exp2
#pragma fragmentoption ARB_precision_hint_fastest
#include "UnityCG.cginc"
#include "AutoLight.cginc"

// get our v2f struct ready
struct v2f {
V2F_POS_FOG;
LIGHTING_COORDS
float4 color : COLOR0;
float2  uv : TEXCOORD0;
};

// all of our uniform var's
sampler2D _MainTex;
float4 _Col1;
float4 _Col2;
float4 _Color;
float4 _Ambient;
float4 _Final;
float _Equa;
float _Modulus;
float _Multi;

// our actual texture calculation function
float4 TextureCalculations (float4 tex, float4 lighting) {
// get int version of floats
int equa = _Equa;
int mod = _Modulus;
int multi = _Multi;
// preform 'core' calculations
tex *= _Color;
tex[3] = 1;
lighting[3] = 1;
lighting += _Ambient;
tex *= lighting;
float avrg = tex[0] + tex[1] + tex[2];
avrg = avrg / 3;
avrg *= multi;
int tmp = avrg;
tmp += tmp % 2;
int asdf = avrg;
if (asdf % mod == equa)
tex = _Col1;
else
tex = _Col2;

return tex * _Final;
}

v2f vert (appdata_base v) {
// do basic lighting calculations, and UV calculations
v2f o;
PositionFog( v.vertex, o.pos, o.fog );
float3 ldir = normalize( ObjSpaceLightDir( v.vertex ) );
float diffuse = dot( v.normal, ldir );
o.color = diffuse * _ModelLightColor0;
o.uv = TRANSFORM_UV(0);
TRANSFER_VERTEX_TO_FRAGMENT(o);
return o;
}

float4 frag (v2f i) : COLOR {
float4 texcol = tex2D( _MainTex, i.uv ); // get a texture
i.color = i.color * LIGHT_ATTENUATION(i) * 2; // get lighting
texcol = TextureCalculations(texcol, i.color); // preform 'core' calculations
return texcol; // return results
}
ENDCG
}

Pass {
Name "Lighting Off"
// this one is quite similar to everything above, just more simple since it doesn't need to preform lighting calculations
Tags { "LightMode" = "VertexOrNone" }
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma fragmentoption ARB_fog_exp2
#include "UnityCG.cginc"

struct v2f {
V2F_POS_FOG;
float4 color : COLOR0;
float2  uv : TEXCOORD0;
};
sampler2D _MainTex;
float4 _Col1;
float4 _Col2;
float4 _Color;
float4 _Ambient;
float4 _Final;
float _Equa;
float _Modulus;
float _Multi;

//Calculate texture
float4 TextureCalculations (float4 tex, float4 lighting) {
int equa = _Equa;
int mod = _Modulus;
int multi = _Multi;

tex *= _Color;
tex[3] = 1;
lighting[3] = 1;
lighting += _Ambient;
tex *= lighting;
float avrg = tex[0] + tex[1] + tex[2];
avrg = avrg / 3;
avrg *= multi;
int tmp = avrg;
tmp += tmp % 2;
int asdf = avrg;
if (asdf % mod == equa)
tex = _Col1;
else
tex = _Col2;

return tex * _Final;
}

v2f vert (appdata_base v) {
v2f o;
PositionFog( v.vertex, o.pos, o.fog );
o.uv = TRANSFORM_UV(0);
return o;
}

float4 frag (v2f i) : COLOR {
float4 texcol = tex2D( _MainTex, i.uv );
i.color = 0;
texcol = TextureCalculations(texcol, i.color);
return texcol;
}
ENDCG
}

}
// get our fall back...
FallBack "Diffuse", 1
}```