Transformed vertex?

Generally you can't. Vertices that come into the vertex program are already scaled.

What you could do though is: not scale the vertices in Unity, instead expose some sort of "scale" property in the shader/material, and do the scaling in the vertex program.

But the easiest way I think is just to UV map the object. In case of a builtin sphere, it is already UV mapped, so you can just grab the existing texture coordinate. That is the reason why UV mapping was invented, you know - to tell how the texture wraps around the object.

 

The decision to pre-scale meshes is a tradeoff decision:

Just letting the hardware scale the meshes is the "cleanest" solution, but in case of the programmable shaders it would require either 1) multiple shader versions for the cases where meshes are non-scaled, uniformly scaled, arbitrarily scaled or 2) a single shader that always normalizes transformed normals. The first approach is the optimal, but makes everyone create 3 times more vertex shaders. The second approach is simple, but suboptimal in performance (especially when you run on cards like Intel GMA950).

So what Unity currently does (that of course could change in the future), is silently instantiate scale meshes on the CPU. This solves the "multiple shaders" issue. And it's pretty fast if you don't change scale at run time. Of course can be a bit slow if someone is constantly changing the scale of the objects, but that is a pretty uncommon scenario.

 

Yeah, just passing inverse scale as a shader parameter looks like the easiest solution. I'm not sure if that's worth putting as a built-in functionality though.

Just add such a script to our object (untested):

Code (csharp):

1. void Update()
2. {
3.     var scale = transform.lossyScale;
4.     renderer.material.SetVector( "_Scale",
5.         Vector4(1.0/scale.x,1.0/scale.y,1.0/scale.z,1.0) );
6. }

And in the shader declare the variable inside Cg code:

Code (csharp):

1. uniform float4 _Scale;

and you're ready to go.