Just dreaming...

Not sure if I understood the reason behind the first paragraph about indexing some textures with some other texture... :?

What if you think the other way around: you have less saturation when something gets less light, right? So with increasing attenuation colors become less saturated (but probably just as bright? or attenuated as well?). That would be pretty easy to do I guess... Not sure if that's what you're after though.

 

Here's my attempt at something similar (still not sure if I understood that correctly). This is a vertex lit shader that desaturates "unlit" areas, optionally darkening them as well (Darkening slider). Fragment program hardware required.

Code (csharp):

1.  
2. Shader "Desaturated Darks" {
3. Properties {
4.     _Color ("Main Color", Color) = (1,1,1,1)
5.     _SpecColor ("Spec Color", Color) = (1,1,1,1)
6.     _Emission ("Emmisive Color", Color) = (0,0,0,0)
7.     _Shininess ("Shininess", Range (0.01, 1)) = 0.7
8.     _MainTex ("Base (RGB)", 2D) = "white" {}
9.     _Darkening ("Darkening", Range (0,1)) = 0.5
10. }
11. SubShader {
12. Pass {
13.     Material {
14.         Diffuse [_Color]
15.         Ambient (0,0,0,0)
16.         Shininess [_Shininess]
17.         Specular [_SpecColor]
18.         Emission [_Emission]
19.     }
20.     Lighting On
21.     SeparateSpecular On
22.    
23. CGPROGRAM
24. // profiles arbfp1
25. // fragment frag
26. // fragmentoption ARB_fog_exp2
27. // fragmentoption ARB_precision_hint_fastest
28.  
29. #include "UnityCG.cginc"
30.  
31. uniform sampler2D _MainTex;
32. uniform float _Darkening;
33. uniform float4 _Color;
34.  
35. half4 frag( v2f_vertex_lit i ) : COLOR
36. {
37.     // texture
38.     half4 texcol = tex2D( _MainTex, i.uv ) * _Color;
39.    
40.     // intensity of the lighting
41.     half brightness =
42.         Luminance( i.diff.xyz + i.spec.xyz * texcol.a ) * 2;
43.    
44.     // color of completely unlit  desaturated areas
45.     half unlit = Luminance(
46.         lerp( texcol.xyz, texcol.xyz * i.diff.xyz, _Darkening ) );
47.    
48.     // final color based on lighting intensity
49.     half4 c;
50.     c.xyz = lerp( half3(unlit), texcol.xyz, brightness );
51.    
52.     c.w = texcol.w * i.diff.w;
53.     return c;
54. }
55. ENDCG
56.  
57.     SetTexture [_MainTex] {}
58. }    
59. }
60. Fallback " VertexLit", 1
61. }

 

Yes, this can be easily turned into a full pixel lit shader, and it would not be expensive. I could do that if the effect is actually what you want.

Regarding objects affecting saturation: well, something in the game with some radius that affects the way things look - that sounds very much like a point light to me

About channels of the textures: sure, that's easy to do. However that would require writing three versions of the shaders I think: one that uses R, one for G and one for B. Sampling a single channel is easy in Cg, something like:

Code (csharp):

1. float myvalue = tex2D( _MainTex, i.uv ).r; // this gets R

However, if you pack completely separate textures into different channels and then do DXT compression on that, the results can be worse than expected. DXT works on colors and the way eye sees them (lower sensitivity to blue intensity etc.), so packing completely arbitrary data does not produce good results. And without DXT you're not actually saving memory

 

Here it is: http://www.unifycommunity.com/wiki/index.php?title=DesaturatedDarks