Can you use a specular map with a fixed pipeline?

I don't know enough about Cg yet to be able to pick apart the specular shaders, so I don't know what the common way of handling a specular map is. My theory is that you'd just take the specular lighting calculation and use a "lightmap" on it. There aren't any examples of this technique that I can find, however.

 

specularity only exists with lights and real lights (pixel lights) don't exist in fixed function. fixed function interpolates basing on polygons which is commonly insufficient for any kind of real specularity.

But you can naturally treat it as some kind of lightmap.
That isn't really cheap but you can use the specularity map to brighten a lightmap through an additive pass.

Question is how much you gain from that or if it even makes any difference because good lightmaps should already have these informations baked in by default.

 

You can't bake in information that is variable in-game. I'm not talking about using a lightmap in the standard sense, where it just acts as another light. But it would work similarly (that is, it just darkens/colorizes what is already there) - if you only take the result of the specular calculation, and then multiply in some color, I would think you'd end up with something like this. Unless somebody tells me otherwise, I'm going to try making such a shader today.

(And yes, I know it won't look like much of anything if I just have 4 vertices like in that example.)

 

I guess I don't understand.

Lightmaps are static, they can't be dynamic as they are used to lighten the otherwise massive costs of the lighting that ffp hardware just is not able to cope with.

But perhaps you mean the variable on the specular end.
Thats naturally possible if you alter it for some reason.

Doing such a shader is definitely possible. There are different approaches to it from blending to overwriting data etc.
I think you only need to build the passes in the correct order (lightmap + specular first then the lm-spec + diffuse) to have it working.

used similar approaches back in DX7 for "texture lights" by switching textures on the higher textures stages in and out.

 

Thanks, Daniel. That was the approach I took, so I'm glad to hear I was on the right track. As I mentioned in the grayscale bumpmap thread, my girlfriend is supposed to make a bump, specular, and self-illumination map this week. We'd never worked with either before yesterday (except normal maps, which aren't covered in the class yet :wink, but I think I get the gist of things. However, as the name of the shader suggests, I think the "bump map" portion is kind of stupid.

You think there is any way to combine these things with a 2-texture card?

Code (csharp):

1. Shader "Full-Color Glow  Specular + Lame 'Bumpmap'" {
2.    
3.  
4. Properties
5. {
6.     _Shininess ("Shininess", Range (0,1) ) = .7
7.     _Bumpiness ("Bumpiness", Range (0,1) ) = .3
8.     _MainTex ("Texture (RGB)", 2D) = ""
9.     _MaskedGlow ("Self Illumination with Mask", 2D) = ""
10.     _SpecularBump ("Specular Map (RGB) + Bumpmap (A)", 2D) = ""
11. }
12.  
13.  
14. SubShader
15. {
16.     Lighting On
17.     Blend AppSrcAdd AppDstAdd
18.    
19.     // Diffuse
20.     Pass
21.     {
22.         Material
23.         {
24.             Diffuse (1,1,1)        
25.         }
26.        
27.         // Subtract the inverted heightmap.
28.         SetTexture [_SpecularBump]
29.         {
30.             combine primary - one - texture alpha
31.         }
32.        
33.         // Add bumps.
34.         SetTexture [_]
35.         {
36.             constantcolor (0,0,0, [_Bumpiness])
37.             combine previous lerp (constant) primary
38.         }
39.        
40.         // 'Light' the texture.
41.         SetTexture [_MainTex]
42.         {
43.             combine texture * previous
44.         }
45.        
46.         // Blend in self-illumination texture.
47.         SetTexture [_MaskedGlow]
48.         {
49.             combine texture lerp (texture) previous
50.         }
51.     }
52.    
53.     // Specular
54.     Pass
55.     {
56.         Material
57.         {          
58.             Specular (1,1,1)
59.             Shininess [_Shininess]
60.         }
61.        
62.         // subtract the inverted heightmap
63.         SetTexture [_SpecularBump]
64.         {
65.             combine primary - one - texture alpha
66.         }
67.        
68.         // Add bumps.
69.         SetTexture [_]
70.         {
71.             constantcolor (0,0,0, [_Bumpiness])
72.             combine previous lerp (constant) primary
73.         }
74.        
75.         // Colorize the grey-white specular highlights.
76.         SetTexture [_SpecularBump]
77.         {
78.             combine texture * previous
79.         }
80.     }
81. }
82.  
83.  
84. }

 

Unless I'm wrong (did only do small things yet with it), those shaders won't work anyway because your passes use more textures than you have per pass, at least if you intend to target pre 3GS hardware.

 

The pre-3GS iphones only have a 2 texture unity graphic chip, which basically means that any texture after the second one in a pass is ignored. Above passes are 3 and 5 texture passes unless I missunderstood how combiners work, which means either invalid or 3GS only.