Fastest shader not using any lights ???

In the unité videos I heard Aras (or his companion) talk about how to render your meshes with the highest speed.

For an upcoming project we expect a lot of users to have very low end hardware like those intel gma cards.

In the unité video there is talk about a shader to render textures which uses NO LIGHTS at all. So I think it just uses the rgb colors of the texture or so.

Is this shader available somewhere?

I found this on the forum

Code (csharp):

1.  
2. Shader "Texture Simple" {
3.    Properties {
4.       _MainTex ("Base (RGB)", 2D) = "white"
5.    }
6.    SubShader {
7.       Pass {
8.          SetTexture [_MainTex]
9.       }
10.    }
11. }

Is this the shader talked about ?
Is this absolutely the fastest rendering texture of all possible shaders? (with less quality of course)


Would this be a lot faster then "diffuse fast" on gma cards?



Regards,

Bart

 

So can we say that in terms of render speed (and certainly on lower end 3d solutions) if we order the shaders by speed (and not by quality) we get

TEXTURE SIMPLE > VERTEXLIT > DIFFUSE FAST > DIFFUSE

Where ">" means "faster then"?



And for vertexlit, what does that actually do ? Just take vertex colors inside the mesh and do some gouraud shading with the texture?



I tried my demo today with texture simple, diffuse fast and diffuse and almost got no difference in fps count. all 3 tests went at around 130fps while displaying 6800tris on a gma950 card.

 

Would it be benificial to include something like "Lighting Off" or "Cull Back" in the shader above? And where should I put these lines?

I'm trying to really write te fastest possible shader at all. Lighting is not important since I want to display the textures at full color with not lights at all. All faces to be drawn will also be front facing.

 

Hey, nice to see something minimal is possible, but I'm actually looking into how to do something even simpler. Sorry to resurrect this old thread (1 year old) but it seems to be pretty much on topic.

Initially all I want to do is the equivalent of gouraud shading using vertex colors. In OpenGL the code would be glShadeModel(GL_SMOOTH) to switch on vertex color interpolation, and I'd be passing it a vertex array and a color array only. No normals, no texturing, no lighting whatsoever. The vertex colors would be RGBA and I'd need to be able to switch alphablending on and off.

Would I be better of doing this with a fixed function setup and would fixed function actually be faster at this than using a shader?

Also I need to do a slight hybrid whereby I need an 8-bit alpha texture (GL_ALPHA8) whose alpha value is used to alphablend the resulting output. So there would be RGBA vertex colors, gouraud/smooth color interpolation, vertex alpha can alphablend, plus a source alpha channel texture provides per-pixel alpha blending. Can that be done without fragment/vertex shaders, and if not, what might such a shader look like?

Also this is really for flat 2D so is it possible to turn off things like the depth buffer/depth testing to gain some performance when I know there won't be any depth to the scene?

Thanks in advance.

 

Wow, this is great, thank you so much. It looks fairly simple once you've written it out but I'm new to writing shaders so you took a lot of time off my hands. I'll give these a try and see how it goes.

Just one question... if I want the vertex colors to have smooth shading still and also alpha values, but also want the alpha texture to apply an alphablend, do I just need to add a second texture combiner pass? ie e.g. say my vertices for a triangle have three sets of different RGBA colors, and the alpha in the vertex causes an interpolated alpha fade across the triangle, I also want this effect but at the same time as a per-pixel texture based blend. So do I just need to multiply the alpha texture by the vertex alpha somehow?

Thanks again.

 

I guess so. I haven't been able to try it yet. I think there needs to be two alpha blends. ... the first is the interpolated alpha based on vertex alpha values, and then after this there needs to be a second transparency operation based on the per-pixel texture alpha. If that's what you're code is doing already then great.

An example..

Lets say a vertex is red with full alpha, ie $FF0000FF, and the opposite vertex is blue with half alpha, ie $0000FF80. About halway between the two points will be the interpolated value $800080B0, ie halway between red and blue, and halfway between full alpha and half alpha. If we were to draw this triangle on the screen at this point, with alphablending, the source color $800080 would be scaled to about 3/4 of its value and added to 1/4 of the destination pixel's value, producing a final alphablended pixel.

But lets say we now introduce an alpha texture which gets applied prior to writing out the final result. After the above process, and prior to actually doing the alphablend, I need to scale the interpolated alpha value based on an alpha texture. So let's say that halway between the vertices is an alpha pixel value of $80, about half intensity. This needs to scale the interpolated alpha value by half, from $B0 to about $68 or so. Then finally there is one alphablend operation between the interpolated pixel color $800080 and the background, using the scaled alpha of $68.

Did I spell that our clearly enough? Is that what your shader above is doing, ie does it take both vertex alpha and texture alpha into account, or just the texture alpha?

[Edit] actually after writing this out and re-reading what you just said, it looks like that's what your third code is doing, since it multiplies the texture alpha by the `primary` color ie the vertex alpha, but only for the alpha values, and keeps the RGB without multiplying. It looks like it does what I needed, right?

 

Ok good, I'm looking forward to giving this a whirl very soon. It's basically to provide a flat-shaded shape mostly composed of geometry to form the shape but with some highly variegated parts, and only in 2D.

 

I got this shader working last night, with the alpha from the vertex and the alpha from the texture. It works great. Thanks again.

I did have to tweak it very slightly to make it work, as Unity was giving some errors. I think the main thing was some case sensitivity in the `bind` commands.

 

Oh well. It's good enough, and working now. Must've been something I messed up or changed without understanding.

The performance seems pretty good so far, am drawing about 3500 alpha-texture surfaces in the 100-200 fps range.

 

No, I had a bunch of procedurally generated meshes, each with one instance of the material and then used the combine children script.

 

I have a problem, this is a little bit transparent for me :/