Perlin noise: no subshaders can run on this graphics card

ivkoni · January 10, 2010, 9:21pm

Hi guys,

I trying to write my second shader ever, (first one ended in disaster). This time I am trying to implement the perlin noise example from the procedural examples (Crumple mesh modifier)

What I tried is to precompute and store the necessary arrays from the Perlin class (g3 and p) in a file and then include it in my CG program. The rest is pretty much copy paste of the Perlin.cs code from the example.

I however get the error :

Shader 'Perlin_test': no subshaders can run on this graphics card

I have NVIDIA Quadro NVS 140M video card. I am also usnig unity Pro

Here is the code of my shader:

Shader "Perlin_test"
{
	Properties 
	{				
		
		scale 	("scale", Float) = 1
		speed 	("speed", Float) = 1

	}	
	SubShader 
	{
		Pass 
		{			
			
CGPROGRAM 
#pragma target 3.0	
#pragma vertex vert
#pragma fragment frag

#include "perlinnoise.fxh"

uniform float4 _Time;
uniform float scale;
uniform float speed;

float s_curve(float t)
	{
		return t * t * (3.0F - 2.0F * t);
	}
	
	float lerp (float t, float a, float b)
	{ 
		return a + t * (b - a);
	}

void setup (float value, out int b0, out int b1, out float r0, out float r1)
	{ 
        float t = value + N;
        //b0 = ((int)t)  BM;
        //b1 = (b0+1)  BM;
		b0 = ((int)t) % BM;
        b1 = (b0+1) % BM;
        r0 = t - (int)t;
        r1 = r0 - 1.0F;
	}

float at2(float rx, float ry, float x, float y) { return rx * x + ry * y; }
float at3(float rx, float ry, float rz, float x, float y, float z) { return rx * x + ry * y + rz * z; }

float perlinNoise(float x, float y, float z)
	{
		int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
		float rx0, rx1, ry0, ry1, rz0, rz1, sy, sz, a, b, c, d, t, u, v;
		int i, j;
		
		setup(x, bx0, bx1, rx0, rx1); //<--- no use out when passing???
		setup(y, by0, by1, ry0, ry1); //<--- no use out when passing???
		setup(z, bz0, bz1, rz0, rz1); //<--- no use out when passing???
		
		i = pTable[ bx0 ];
		j = pTable[ bx1 ];
		
		b00 = pTable[ i + by0 ];
		b10 = pTable[ j + by0 ];
		b01 = pTable[ i + by1 ];
		b11 = pTable[ j + by1 ];
		
		t  = s_curve(rx0);
		sy = s_curve(ry0);
		sz = s_curve(rz0);
		
		u = at3(rx0,ry0,rz0, g3Table[ b00 + bz0]*3, g3Table[ b00 + bz0]*3+1, g3Table[ b00 + bz0]*3+2);
		v = at3(rx1,ry0,rz0, g3Table[ b10 + bz0]*3, g3Table[ b10 + bz0]*3+1, g3Table[ b10 + bz0]*3+2);
		a = lerp(t, u, v);
		
		u = at3(rx0,ry1,rz0, g3Table[ b01 + bz0]*3, g3Table[ b01 + bz0]*3+1, g3Table[ b01 + bz0]*3+2);
		v = at3(rx1,ry1,rz0, g3Table[ b11 + bz0]*3, g3Table[ b11 + bz0]*3+1, g3Table[ b11 + bz0]*3+2);
		b = lerp(t, u, v);
		
		c = lerp(sy, a, b);
		
		u = at3(rx0,ry0,rz1, g3Table[ b00 + bz1]*3, g3Table[ b00 + bz1]*3+1, g3Table[ b00 + bz1]*3+2);
		v = at3(rx1,ry0,rz1, g3Table[ b10 + bz1]*3, g3Table[ b10 + bz1]*3+1, g3Table[ b10 + bz1]*3+2);
		a = lerp(t, u, v);
		
		u = at3(rx0,ry1,rz1, g3Table[ b01 + bz1]*3, g3Table[ b01 + bz1]*3+1, g3Table[ b01 + bz1]*3+2);
		v = at3(rx1,ry1,rz1,g3Table[ b11 + bz1]*3, g3Table[ b11 + bz1]*3+1, g3Table[ b11 + bz1]*3+2);
		b = lerp(t, u, v);
		
		d = lerp(sy, a, b);
		
		return lerp(sz, c, d);
	}

struct a2v
{
	float4 vertex	: POSITION;
	float4 color	: COLOR;
};

struct v2f {
    float4 pos : POSITION;
    float4 color : COLOR;
};


v2f vert(a2v IN) 
{ 
	v2f OUT;

	float timex = _Time.y * speed + 0.1365143;
	float timey = _Time.y * speed + 1.21688;
	float timez = _Time.y * speed + 2.5564;
				
	IN.vertex.x += perlinNoise(timex + IN.vertex.x, timex + IN.vertex.y, timex + IN.vertex.z) * scale;
	IN.vertex.y += perlinNoise(timey + IN.vertex.x, timey + IN.vertex.y, timey + IN.vertex.z) * scale;
	IN.vertex.z += perlinNoise(timez + IN.vertex.x, timez + IN.vertex.y, timez + IN.vertex.z) * scale;

	float4 pos = float4(IN.vertex.xyz, 1.0);

	OUT.pos 	= mul(glstate.matrix.mvp, pos);
	OUT.color = IN.color;
	
	return OUT; 
}

half4 frag( v2f IN ) : COLOR {
    half4 OUT;
	OUT = IN.color;
	return OUT;
}


ENDCG 
		} // Pass
	} // SubShader
} // Shader

and here is my include file:

const int B = 8;
const int BM = 7;
const int N = 128;

float const g3Table[54] = 
{
0.7548294,0.7548294,0.1078328,
0.5345225,0.5345225,0.2672612,
0.6666667,0.6666667,0.3333333,
-0.3312946,-0.3312946,-0.3312946,
-0.2407717,-0.2407717,0.4815434,
-0.2182179,-0.2182179,-0.8728715,
-0.808122,-0.808122,-0.5050763,
-0.766261,-0.766261,-0.2873479,
0.7548294,0.7548294,0.1078328,
0.5345225,0.5345225,0.2672612,
0.6666667,0.6666667,0.3333333,
-0.3312946,-0.3312946,-0.3312946,
-0.2407717,-0.2407717,0.4815434,
-0.2182179,-0.2182179,-0.8728715,
-0.808122,-0.808122,-0.5050763,
-0.766261,-0.766261,-0.2873479,
0.7548294,0.7548294,0.1078328,
0.5345225,0.5345225,0.2672612
};


int const pTable[18] = 
{
0,6,1,5,3,2,7,4,0,6,
1,5,3,2,7,4,0,6
};

all I could find about this message is that it is not a very good message.
Would somebody be able to see why the shader doesn’t work and how I could fix it, if possible.

thanks a lot

multivac · January 10, 2010, 10:04pm

try adding your included file to the shader itself.
maybe you can actually include files like that,but i don’t remember seeing it documented in the shaderlab manual.
EDIT: The shader works for me if i embed the include file.

ivkoni · January 10, 2010, 10:51pm

Thanks mate. That’s a great idea. (I had it in an include file because it was quite large in the beginning, but I kept getting errors on exceeding constant limit size, so I truncated it to 1/16 of what it was)…

I am still in the same boat though. Same error message. I am starting to think my card really can’t handle it. 763 instructions needed to compile program at line 15 ← quite a lot, I guess.

Would you mind telling me what is your video card?
Also does the shader do what it is expected: kinda like the Crumple mesh modifier procedural example?
Finally, how is performance? What is the fps from the stats window?

multivac · January 10, 2010, 11:38pm

I have an ATI HD3850.
It basically makes the mesh wobble at preset scale and speed,the noise doesn’t have much randomness though,it basically loops a pattern.Not sure if thats what you wanted.
Performance hit is neglible,tried it on 10 spheres and had fps of about 4000.

ivkoni · January 11, 2010, 12:16am

Thanks again. Yes, this is exactly what it is supposed to do. I had to cut down the pattern to 1/16 because of some limit errors I was getting… otherwise, increasing g3 and p should make the pattern longer… Also performance seems really good. I am getting bad performace (about 50 fps) with the original crumple mesh example, I was hoping putting the code in a shader would fix this.

Sorry, I have one more request to make, I hope you don’t mind: can you please post the entire shader code, with the embeded include statement that you made. I don’t see how I could have made a mistake there, but with CG syntax, I can never be 100% sure. Also it would be easier for other people to just copy and paste, if they want to use it.

thanks a lot

multivac · January 11, 2010, 12:32am

sure,here it is:

Shader "Perlin_test" 
{ 
   Properties 
   {             
       
      scale    ("scale", Float) = 1 
      speed    ("speed", Float) = 1 

   }    
   SubShader 
   { 
      Pass 
      {          
          
CGPROGRAM 
#pragma target 3.0    
#pragma vertex vert 
#pragma fragment frag 


const int B = 8; 
const int BM = 7; 
const int N = 128; 

float const g3Table[54] = 
{ 
0.7548294,0.7548294,0.1078328, 
0.5345225,0.5345225,0.2672612, 
0.6666667,0.6666667,0.3333333, 
-0.3312946,-0.3312946,-0.3312946, 
-0.2407717,-0.2407717,0.4815434, 
-0.2182179,-0.2182179,-0.8728715, 
-0.808122,-0.808122,-0.5050763, 
-0.766261,-0.766261,-0.2873479, 
0.7548294,0.7548294,0.1078328, 
0.5345225,0.5345225,0.2672612, 
0.6666667,0.6666667,0.3333333, 
-0.3312946,-0.3312946,-0.3312946, 
-0.2407717,-0.2407717,0.4815434, 
-0.2182179,-0.2182179,-0.8728715, 
-0.808122,-0.808122,-0.5050763, 
-0.766261,-0.766261,-0.2873479, 
0.7548294,0.7548294,0.1078328, 
0.5345225,0.5345225,0.2672612 
}; 


int const pTable[18] = 
{ 
0,6,1,5,3,2,7,4,0,6, 
1,5,3,2,7,4,0,6 
};

uniform float4 _Time; 
uniform float scale; 
uniform float speed; 

float s_curve(float t) 
   { 
      return t * t * (3.0F - 2.0F * t); 
   } 
    
   float lerp (float t, float a, float b) 
   { 
      return a + t * (b - a); 
   } 

void setup (float value, out int b0, out int b1, out float r0, out float r1) 
   { 
        float t = value + N; 
        //b0 = ((int)t)  BM; 
        //b1 = (b0+1)  BM; 
      b0 = ((int)t) % BM; 
        b1 = (b0+1) % BM; 
        r0 = t - (int)t; 
        r1 = r0 - 1.0F; 
   } 

float at2(float rx, float ry, float x, float y) { return rx * x + ry * y; } 
float at3(float rx, float ry, float rz, float x, float y, float z) { return rx * x + ry * y + rz * z; } 

float perlinNoise(float x, float y, float z) 
   { 
      int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11; 
      float rx0, rx1, ry0, ry1, rz0, rz1, sy, sz, a, b, c, d, t, u, v; 
      int i, j; 
       
      setup(x, bx0, bx1, rx0, rx1); //<--- no use out when passing??? 
      setup(y, by0, by1, ry0, ry1); //<--- no use out when passing??? 
      setup(z, bz0, bz1, rz0, rz1); //<--- no use out when passing??? 
       
      i = pTable[ bx0 ]; 
      j = pTable[ bx1 ]; 
       
      b00 = pTable[ i + by0 ]; 
      b10 = pTable[ j + by0 ]; 
      b01 = pTable[ i + by1 ]; 
      b11 = pTable[ j + by1 ]; 
       
      t  = s_curve(rx0); 
      sy = s_curve(ry0); 
      sz = s_curve(rz0); 
       
      u = at3(rx0,ry0,rz0, g3Table[ b00 + bz0]*3, g3Table[ b00 + bz0]*3+1, g3Table[ b00 + bz0]*3+2); 
      v = at3(rx1,ry0,rz0, g3Table[ b10 + bz0]*3, g3Table[ b10 + bz0]*3+1, g3Table[ b10 + bz0]*3+2); 
      a = lerp(t, u, v); 
       
      u = at3(rx0,ry1,rz0, g3Table[ b01 + bz0]*3, g3Table[ b01 + bz0]*3+1, g3Table[ b01 + bz0]*3+2); 
      v = at3(rx1,ry1,rz0, g3Table[ b11 + bz0]*3, g3Table[ b11 + bz0]*3+1, g3Table[ b11 + bz0]*3+2); 
      b = lerp(t, u, v); 
       
      c = lerp(sy, a, b); 
       
      u = at3(rx0,ry0,rz1, g3Table[ b00 + bz1]*3, g3Table[ b00 + bz1]*3+1, g3Table[ b00 + bz1]*3+2); 
      v = at3(rx1,ry0,rz1, g3Table[ b10 + bz1]*3, g3Table[ b10 + bz1]*3+1, g3Table[ b10 + bz1]*3+2); 
      a = lerp(t, u, v); 
       
      u = at3(rx0,ry1,rz1, g3Table[ b01 + bz1]*3, g3Table[ b01 + bz1]*3+1, g3Table[ b01 + bz1]*3+2); 
      v = at3(rx1,ry1,rz1,g3Table[ b11 + bz1]*3, g3Table[ b11 + bz1]*3+1, g3Table[ b11 + bz1]*3+2); 
      b = lerp(t, u, v); 
       
      d = lerp(sy, a, b); 
       
      return lerp(sz, c, d); 
   } 

struct a2v 
{ 
   float4 vertex   : POSITION; 
   float4 color   : COLOR; 
}; 

struct v2f { 
    float4 pos : POSITION; 
    float4 color : COLOR; 
}; 


v2f vert(a2v IN) 
{ 
   v2f OUT; 

   float timex = _Time.y * speed + 0.1365143; 
   float timey = _Time.y * speed + 1.21688; 
   float timez = _Time.y * speed + 2.5564; 
             
   IN.vertex.x += perlinNoise(timex + IN.vertex.x, timex + IN.vertex.y, timex + IN.vertex.z) * scale; 
   IN.vertex.y += perlinNoise(timey + IN.vertex.x, timey + IN.vertex.y, timey + IN.vertex.z) * scale; 
   IN.vertex.z += perlinNoise(timez + IN.vertex.x, timez + IN.vertex.y, timez + IN.vertex.z) * scale; 

   float4 pos = float4(IN.vertex.xyz, 1.0); 

   OUT.pos    = mul(glstate.matrix.mvp, pos); 
   OUT.color = IN.color; 
    
   return OUT; 
} 

half4 frag( v2f IN ) : COLOR { 
    half4 OUT; 
   OUT = IN.color; 
   return OUT; 
} 


ENDCG 
      } // Pass 
   } // SubShader 
} // Shader

Unity’s compiler can and will behave oddly for no discernible reason if you want something complex out of it,so better get used to it. :?

EDIT:
Here’s the ASM it made from it also,if the Cg wont run,see what it says about compiled version.

Shader "Perlin_test" 
{ 
   Properties 
   {             
       
      scale    ("scale", Float) = 1 
      speed    ("speed", Float) = 1 

   }    
   SubShader 
   { 
      Pass 
      {          
          
Program "" {
// Vertex combos: 1, instructions: 604 to 604
// Fragment combos: 1, instructions: 1 to 1, texreads: 0 to 0
SubProgram "opengl " {
Keywords { }
Bind "vertex", Vertex
Bind "color", Color
Local 1, ([BM],0,0,0)
Local 2, ([N],0,0,0)
Local 3, ([g3Table0],0,0,0)
Local 4, ([g3Table1],0,0,0)
Local 5, ([g3Table2],0,0,0)
Local 6, ([g3Table3],0,0,0)
Local 7, ([g3Table4],0,0,0)
Local 8, ([g3Table5],0,0,0)
Local 9, ([g3Table6],0,0,0)
Local 10, ([g3Table7],0,0,0)
Local 11, ([g3Table8],0,0,0)
Local 12, ([g3Table9],0,0,0)
Local 13, ([g3Table10],0,0,0)
Local 14, ([g3Table11],0,0,0)
Local 15, ([g3Table12],0,0,0)
Local 16, ([g3Table13],0,0,0)
Local 17, ([g3Table14],0,0,0)
Local 18, ([g3Table15],0,0,0)
Local 19, ([g3Table16],0,0,0)
Local 20, ([g3Table17],0,0,0)
Local 21, ([g3Table18],0,0,0)
Local 22, ([g3Table19],0,0,0)
Local 23, ([g3Table20],0,0,0)
Local 24, ([g3Table21],0,0,0)
Local 25, ([g3Table22],0,0,0)
Local 26, ([g3Table23],0,0,0)
Local 27, ([g3Table24],0,0,0)
Local 28, ([g3Table25],0,0,0)
Local 29, ([g3Table26],0,0,0)
Local 30, ([g3Table27],0,0,0)
Local 31, ([g3Table28],0,0,0)
Local 32, ([g3Table29],0,0,0)
Local 33, ([g3Table30],0,0,0)
Local 34, ([g3Table31],0,0,0)
Local 35, ([g3Table32],0,0,0)
Local 36, ([g3Table33],0,0,0)
Local 37, ([g3Table34],0,0,0)
Local 38, ([g3Table35],0,0,0)
Local 39, ([g3Table36],0,0,0)
Local 40, ([g3Table37],0,0,0)
Local 41, ([g3Table38],0,0,0)
Local 42, ([g3Table39],0,0,0)
Local 43, ([g3Table40],0,0,0)
Local 44, ([g3Table41],0,0,0)
Local 45, ([g3Table42],0,0,0)
Local 46, ([g3Table43],0,0,0)
Local 47, ([g3Table44],0,0,0)
Local 48, ([g3Table45],0,0,0)
Local 49, ([g3Table46],0,0,0)
Local 50, ([g3Table47],0,0,0)
Local 51, ([g3Table48],0,0,0)
Local 52, ([g3Table49],0,0,0)
Local 53, ([g3Table50],0,0,0)
Local 54, ([g3Table51],0,0,0)
Local 55, ([g3Table52],0,0,0)
Local 56, ([g3Table53],0,0,0)
Local 57, ([pTable0],0,0,0)
Local 58, ([pTable1],0,0,0)
Local 59, ([pTable2],0,0,0)
Local 60, ([pTable3],0,0,0)
Local 61, ([pTable4],0,0,0)
Local 62, ([pTable5],0,0,0)
Local 63, ([pTable6],0,0,0)
Local 64, ([pTable7],0,0,0)
Local 65, ([pTable8],0,0,0)
Local 66, ([pTable9],0,0,0)
Local 67, ([pTable10],0,0,0)
Local 68, ([pTable11],0,0,0)
Local 69, ([pTable12],0,0,0)
Local 70, ([pTable13],0,0,0)
Local 71, ([pTable14],0,0,0)
Local 72, ([pTable15],0,0,0)
Local 73, ([pTable16],0,0,0)
Local 74, ([pTable17],0,0,0)
Local 75, [_Time]
Local 76, ([scale],0,0,0)
Local 77, ([speed],0,0,0)
"3.0-!!ARBvp1.0
# 604 instructions
PARAM c[83] = { { 0.13651431, 2, 3, 1 },
		program.local[1..77],
		state.matrix.mvp,
		{ 0.5, 0, 1.21688, 2.5564001 } };
TEMP R0;
TEMP R1;
TEMP R2;
TEMP R3;
TEMP R4;
TEMP R5;
ADDRESS A0;
MOV R0.x, c[77];
MUL R0.y, R0.x, c[75];
ADD R0.w, R0.y, c[0].x;
ADD R1.y, R0.w, vertex.position.z;
ADD R0.x, R1.y, c[2];
ABS R1.x, R0;
RCP R0.z, c[1].x;
FLR R1.x, R1;
SLT R1.z, R1.y, -c[2].x;
ADD R1.y, -R1.x, -R1.x;
MAD R3.y, R1, R1.z, R1.x;
MUL R1.x, R3.y, R0.z;
FRC R1.x, R1;
MUL R1.z, R1.x, c[1].x;
ABS R1.x, R1.z;
ADD R1.x, R1, c[82];
FLR R1.w, R1.x;
ADD R1.y, R0.w, vertex.position.x;
ADD R0.x, R0, -R3.y;
ADD R2.x, -R1.w, -R1.w;
SLT R2.y, R1.z, c[82];
MAD R1.w, R2.x, R2.y, R1;
ADD R1.x, R1.y, c[2];
ABS R1.z, R1.x;
FLR R1.z, R1;
SLT R2.x, R1.y, -c[2];
ADD R1.y, -R1.z, -R1.z;
MAD R2.y, R1, R2.x, R1.z;
MUL R1.z, R2.y, R0;
ADD R1.x, R1, -R2.y;
ADD R1.y, R1.w, c[0].w;
MUL R1.y, R0.z, R1;
FRC R1.z, R1;
MUL R2.z, R1, c[1].x;
ABS R1.z, R2;
FRC R1.y, R1;
MUL R1.y, R1, c[1].x;
ABS R2.x, R1.y;
ADD R1.z, R1, c[82].x;
ADD R2.x, R2, c[82];
ADD R2.y, R1.x, -c[0].w;
SLT R2.w, R2.z, c[82].y;
FLR R1.z, R1;
ADD R2.z, -R1, -R1;
MAD R1.z, R2, R2.w, R1;
SLT R2.z, R1.y, c[82].y;
FLR R2.x, R2;
ADD R1.y, -R2.x, -R2.x;
MAD R2.x, R1.y, R2.z, R2;
ADD R2.z, R0.w, vertex.position.y;
ADD R1.y, R1.z, c[0].w;
MUL R1.y, R1, R0.z;
FRC R2.w, R1.y;
ADD R0.w, R2.z, c[2].x;
MUL R3.w, R2, c[1].x;
ABS R1.y, R0.w;
FLR R1.y, R1;
SLT R2.w, R2.z, -c[2].x;
ADD R2.z, -R1.y, -R1.y;
MAD R2.z, R2, R2.w, R1.y;
ABS R1.y, R3.w;
MUL R2.w, R2.z, R0.z;
ADD R0.w, R0, -R2.z;
ADD R1.y, R1, c[82].x;
FLR R1.y, R1;
FRC R2.w, R2;
MUL R2.w, R2, c[1].x;
ABS R3.x, R2.w;
ADD R3.x, R3, c[82];
ADD R2.z, R0.w, -c[0].w;
ADD R3.z, -R1.y, -R1.y;
SLT R3.w, R3, c[82].y;
MAD R1.y, R3.z, R3.w, R1;
FLR R3.x, R3;
SLT R3.z, R2.w, c[82].y;
ADD R2.w, -R3.x, -R3.x;
MAD R3.z, R2.w, R3, R3.x;
ARL A0.x, R1.y;
ADD R3.w, c[A0.x + 57].x, R3.z;
ARL A0.x, R3.w;
ADD R4.x, R2, c[A0.x + 57];
ARL A0.x, R1.z;
ADD R4.y, R3.z, c[A0.x + 57].x;
ARL A0.x, R4.y;
ADD R4.z, R2.x, c[A0.x + 57].x;
ADD R2.w, R3.z, c[0];
MUL R2.w, R0.z, R2;
FRC R2.w, R2;
MUL R3.x, R2.w, c[1];
ABS R2.w, R3.x;
ADD R2.w, R2, c[82].x;
SLT R3.z, R3.x, c[82].y;
FLR R2.w, R2;
ADD R3.x, -R2.w, -R2.w;
MAD R2.w, R3.x, R3.z, R2;
ARL A0.x, R1.z;
ADD R3.x, R2.w, c[A0.x + 57];
ARL A0.x, R1.y;
ADD R1.z, c[A0.x + 57].x, R2.w;
ARL A0.x, R3.x;
ADD R1.y, R2.x, c[A0.x + 57].x;
ARL A0.x, R1.z;
ADD R2.x, c[A0.x + 57], R2;
ARL A0.x, R2.x;
MOV R2.x, c[A0.x + 3];
MAD R2.w, R2.x, c[0].z, c[0];
MUL R3.z, R2, R2.w;
MUL R2.w, c[A0.x + 3].x, R2.y;
ARL A0.x, R1.y;
ADD R1.y, R0.x, -c[0].w;
MAD R2.w, R2, c[0].z, R3.z;
MOV R3.y, c[A0.x + 3].x;
MAD R3.z, R3.y, c[0], c[0].w;
MAD R2.x, R2, c[0].z, c[0].y;
MAD R2.x, R1.y, R2, R2.w;
MUL R2.w, R1.x, c[A0.x + 3].x;
MUL R3.z, R2, R3;
ARL A0.x, R4.z;
MAD R2.w, R2, c[0].z, R3.z;
MAD R3.y, R3, c[0].z, c[0];
MAD R2.w, R1.y, R3.y, R2;
MOV R3.y, c[A0.x + 3].x;
MAD R4.z, R3.y, c[0], c[0].w;
MUL R3.z, R1.x, c[A0.x + 3].x;
ARL A0.x, R4.x;
MUL R4.z, R0.w, R4;
ADD R2.x, R2, -R2.w;
MOV R4.x, c[A0.x + 3];
MAD R4.z, R3, c[0], R4;
MAD R3.z, R4.x, c[0], c[0].w;
MAD R3.y, R3, c[0].z, c[0];
MAD R3.y, R1, R3, R4.z;
MUL R4.z, R0.w, R3;
MUL R3.z, R2.y, c[A0.x + 3].x;
MAD R3.z, R3, c[0], R4;
MAD R4.x, R4, c[0].z, c[0].y;
MAD R1.y, R1, R4.x, R3.z;
ADD R4.x, R1.y, -R3.y;
MAD R3.z, -R1.x, c[0].y, c[0];
MUL R1.y, R1.x, R1.x;
MUL R1.y, R1, R3.z;
MAD R3.y, R1, R4.x, R3;
MAD R2.x, R1.y, R2, R2.w;
ARL A0.x, R4.y;
ADD R2.w, R1, c[A0.x + 57].x;
ARL A0.x, R3.x;
ADD R3.x, R1.w, c[A0.x + 57];
ARL A0.x, R3.w;
ADD R3.z, R1.w, c[A0.x + 57].x;
ARL A0.x, R2.w;
MOV R3.w, c[A0.x + 3].x;
MAD R4.x, R3.w, c[0].z, c[0].w;
ARL A0.x, R2.w;
MUL R2.w, R1.x, c[A0.x + 3].x;
ARL A0.x, R3.z;
MUL R4.x, R0.w, R4;
ADD R2.x, R2, -R3.y;
MOV R3.z, c[A0.x + 3].x;
MAD R4.x, R2.w, c[0].z, R4;
MAD R2.w, R3.z, c[0].z, c[0];
MAD R3.w, R3, c[0].z, c[0].y;
MAD R3.w, R0.x, R3, R4.x;
MUL R4.x, R0.w, R2.w;
MUL R2.w, R2.y, c[A0.x + 3].x;
ARL A0.x, R1.z;
ADD R1.z, c[A0.x + 57].x, R1.w;
ARL A0.x, R3.x;
MOV R1.w, c[A0.x + 3].x;
ARL A0.x, R3.x;
MUL R1.x, R1, c[A0.x + 3];
ARL A0.x, R1.z;
MUL R2.y, R2, c[A0.x + 3].x;
MAD R2.w, R2, c[0].z, R4.x;
MAD R3.z, R3, c[0], c[0].y;
MAD R2.w, R0.x, R3.z, R2;
MAD R3.z, R1.w, c[0], c[0].w;
MUL R3.x, R2.z, R3.z;
ADD R2.w, R2, -R3;
MOV R1.z, c[A0.x + 3].x;
MAD R3.x, R1, c[0].z, R3;
MAD R1.x, R1.z, c[0].z, c[0].w;
MUL R1.x, R2.z, R1;
MAD R1.w, R1, c[0].z, c[0].y;
MAD R1.w, R0.x, R1, R3.x;
MAD R1.x, R2.y, c[0].z, R1;
MAD R1.z, R1, c[0], c[0].y;
MAD R1.x, R0, R1.z, R1;
ADD R1.x, R1, -R1.w;
MAD R1.z, R1.y, R2.w, R3.w;
MAD R1.x, R1.y, R1, R1.w;
ADD R1.y, R1.x, -R1.z;
MAD R1.x, -R0.w, c[0].y, c[0].z;
MUL R0.w, R0, R0;
MUL R0.w, R0, R1.x;
MAD R1.x, R0.w, R1.y, R1.z;
MAD R0.w, R0, R2.x, R3.y;
ADD R1.y, R0.w, -R1.x;
MAD R0.w, -R0.x, c[0].y, c[0].z;
MUL R0.x, R0, R0;
MUL R0.x, R0, R0.w;
ADD R0.w, R0.y, c[82].z;
MAD R0.x, R0, R1.y, R1;
MAD R0.x, R0, c[76], vertex.position;
ADD R1.z, R0.x, R0.w;
ADD R1.x, R1.z, c[2];
ADD R2.z, vertex.position.y, R0.w;
ADD R2.w, vertex.position.z, R0;
ABS R1.y, R1.x;
SLT R1.w, R1.z, -c[2].x;
FLR R1.y, R1;
ADD R1.z, -R1.y, -R1.y;
MAD R1.y, R1.z, R1.w, R1;
MUL R1.z, R0, R1.y;
ADD R1.y, R1.x, -R1;
FRC R1.z, R1;
MUL R1.w, R1.z, c[1].x;
ABS R1.z, R1.w;
ADD R1.z, R1, c[82].x;
ADD R3.w, R1.y, -c[0];
FLR R1.z, R1;
SLT R2.x, R1.w, c[82].y;
ADD R1.w, -R1.z, -R1.z;
MAD R2.x, R1.w, R2, R1.z;
ADD R1.z, R2.x, c[0].w;
MUL R1.z, R0, R1;
FRC R1.z, R1;
MUL R1.w, R1.z, c[1].x;
ABS R1.z, R1.w;
ADD R1.z, R1, c[82].x;
FLR R1.z, R1;
SLT R2.y, R1.w, c[82];
ADD R1.w, -R1.z, -R1.z;
MAD R2.y, R1.w, R2, R1.z;
MUL R1.x, R1.y, R1.y;
MAD R1.z, -R1.y, c[0].y, c[0];
MUL R1.z, R1.x, R1;
ADD R1.x, R2.z, c[2];
ABS R1.w, R1.x;
ADD R0.w, R2, c[2].x;
FLR R1.w, R1;
SLT R3.x, R2.z, -c[2];
ADD R2.z, -R1.w, -R1.w;
MAD R4.x, R2.z, R3, R1.w;
ABS R1.w, R0;
ADD R1.x, R1, -R4;
MUL R2.z, R0, R4.x;
ADD R4.x, R1, -c[0].w;
SLT R3.x, R2.w, -c[2];
FLR R1.w, R1;
ADD R2.w, -R1, -R1;
MAD R1.w, R2, R3.x, R1;
FRC R2.w, R2.z;
MUL R3.y, R2.w, c[1].x;
MUL R2.z, R0, R1.w;
FRC R2.w, R2.z;
ADD R0.w, R0, -R1;
MUL R2.w, R2, c[1].x;
ABS R2.z, R3.y;
ABS R3.x, R2.w;
ADD R2.z, R2, c[82].x;
ADD R3.x, R3, c[82];
ADD R1.w, R0, -c[0];
SLT R3.z, R3.y, c[82].y;
FLR R2.z, R2;
ADD R3.y, -R2.z, -R2.z;
MAD R2.z, R3.y, R3, R2;
ADD R3.y, R2.z, c[0].w;
MUL R3.y, R0.z, R3;
SLT R3.z, R2.w, c[82].y;
FLR R3.x, R3;
ADD R2.w, -R3.x, -R3.x;
MAD R3.x, R2.w, R3.z, R3;
ADD R2.w, R3.x, c[0];
FRC R3.y, R3;
MUL R3.z, R3.y, c[1].x;
MUL R2.w, R0.z, R2;
FRC R3.y, R2.w;
MUL R3.y, R3, c[1].x;
ABS R2.w, R3.z;
ADD R2.w, R2, c[82].x;
ABS R4.z, R3.y;
FLR R2.w, R2;
SLT R4.y, R3.z, c[82];
ADD R3.z, -R2.w, -R2.w;
MAD R3.z, R3, R4.y, R2.w;
ADD R4.y, R4.z, c[82].x;
ARL A0.x, R2.y;
ADD R2.w, c[A0.x + 57].x, R3.z;
FLR R4.y, R4;
SLT R4.z, R3.y, c[82].y;
ADD R3.y, -R4, -R4;
MAD R3.y, R3, R4.z, R4;
ARL A0.x, R2.w;
ADD R4.y, c[A0.x + 57].x, R3;
ARL A0.x, R2.x;
ADD R4.z, R3, c[A0.x + 57].x;
ARL A0.x, R4.y;
MOV R3.z, c[A0.x + 3].x;
MAD R4.w, R3.z, c[0].z, c[0];
MUL R4.y, c[A0.x + 3].x, R3.w;
MUL R5.x, R4, R4.w;
ARL A0.x, R4.z;
ADD R4.w, R3.y, c[A0.x + 57].x;
ARL A0.x, R4.w;
MAD R4.y, R4, c[0].z, R5.x;
MOV R4.w, c[A0.x + 3].x;
MAD R5.x, R4.w, c[0].z, c[0].w;
MAD R3.z, R3, c[0], c[0].y;
MAD R3.z, R1.w, R3, R4.y;
MUL R4.y, R1, c[A0.x + 3].x;
ARL A0.x, R2.x;
ADD R2.x, R2.z, c[A0.x + 57];
MUL R5.x, R4, R5;
ARL A0.x, R2.x;
MAD R4.w, R4, c[0].z, c[0].y;
MAD R4.y, R4, c[0].z, R5.x;
MAD R4.y, R1.w, R4.w, R4;
ADD R4.w, R3.y, c[A0.x + 57].x;
ADD R3.z, R3, -R4.y;
ARL A0.x, R2.y;
ADD R2.y, c[A0.x + 57].x, R2.z;
ARL A0.x, R4.w;
MAD R3.z, R1, R3, R4.y;
MUL R4.w, R1.y, c[A0.x + 3].x;
MOV R4.y, c[A0.x + 3].x;
ARL A0.x, R2.y;
ADD R2.z, R3.y, c[A0.x + 57].x;
MAD R3.y, R4, c[0].z, c[0].w;
ARL A0.x, R2.z;
MUL R3.y, R1.x, R3;
MOV R2.z, c[A0.x + 3].x;
MAD R4.w, R4, c[0].z, R3.y;
MAD R3.y, R2.z, c[0].z, c[0].w;
MAD R4.y, R4, c[0].z, c[0];
MAD R4.w, R1, R4.y, R4;
MUL R4.y, R1.x, R3;
MUL R3.y, R3.w, c[A0.x + 3].x;
ARL A0.x, R2.y;
ADD R2.y, R3.x, c[A0.x + 57].x;
MAD R3.y, R3, c[0].z, R4;
MAD R2.z, R2, c[0], c[0].y;
MAD R1.w, R1, R2.z, R3.y;
ARL A0.x, R2.y;
ADD R1.w, R1, -R4;
MAD R1.w, R1.z, R1, R4;
ADD R2.y, R3.z, -R1.w;
MUL R3.z, R3.w, c[A0.x + 3].x;
MOV R2.z, c[A0.x + 3].x;
ARL A0.x, R2.x;
MAD R2.x, R2.z, c[0].z, c[0].w;
ADD R3.y, R3.x, c[A0.x + 57].x;
ARL A0.x, R3.y;
MUL R2.x, R1, R2;
MOV R3.y, c[A0.x + 3].x;
MAD R2.x, R3.z, c[0].z, R2;
MAD R3.z, R3.y, c[0], c[0].w;
MAD R2.z, R2, c[0], c[0].y;
MAD R2.x, R0.w, R2.z, R2;
MUL R2.z, R1.y, c[A0.x + 3].x;
MUL R3.z, R1.x, R3;
MAD R2.z, R2, c[0], R3;
ARL A0.x, R4.z;
ADD R3.z, R3.x, c[A0.x + 57].x;
MAD R3.y, R3, c[0].z, c[0];
MAD R2.z, R0.w, R3.y, R2;
ARL A0.x, R3.z;
ADD R2.x, R2, -R2.z;
MUL R3.y, R1, c[A0.x + 3].x;
MOV R1.y, c[A0.x + 3].x;
ARL A0.x, R2.w;
ADD R2.w, c[A0.x + 57].x, R3.x;
MAD R3.x, R1.y, c[0].z, c[0].w;
ARL A0.x, R2.w;
MUL R3.x, R4, R3;
MAD R2.x, R1.z, R2, R2.z;
MAD R3.y, R3, c[0].z, R3.x;
MOV R2.w, c[A0.x + 3].x;
MAD R3.x, R2.w, c[0].z, c[0].w;
MAD R1.y, R1, c[0].z, c[0];
MAD R1.y, R0.w, R1, R3;
MUL R3.y, R3.w, c[A0.x + 3].x;
MUL R3.x, R4, R3;
MAD R3.x, R3.y, c[0].z, R3;
MAD R2.w, R2, c[0].z, c[0].y;
MAD R2.w, R0, R2, R3.x;
ADD R2.w, R2, -R1.y;
MAD R1.y, R1.z, R2.w, R1;
ADD R1.z, R1.y, -R2.x;
MAD R1.y, -R1.x, c[0], c[0].z;
MUL R1.x, R1, R1;
MUL R1.x, R1, R1.y;
MAD R1.y, R1.x, R1.z, R2.x;
MAD R1.x, R1, R2.y, R1.w;
ADD R1.z, R1.x, -R1.y;
MAD R1.x, -R0.w, c[0].y, c[0].z;
MUL R0.w, R0, R0;
MUL R0.w, R0, R1.x;
MAD R1.x, R0.w, R1.z, R1.y;
ADD R0.w, R0.y, c[82];
MAD R0.y, R1.x, c[76].x, vertex.position;
ADD R1.z, R0.y, R0.w;
ADD R1.y, R1.z, c[2].x;
ABS R1.x, R1.y;
ADD R2.y, R0.x, R0.w;
FLR R1.x, R1;
SLT R1.w, R1.z, -c[2].x;
ADD R1.z, -R1.x, -R1.x;
MAD R2.x, R1.z, R1.w, R1;
MUL R1.x, R0.z, R2;
FRC R1.x, R1;
MUL R1.z, R1.x, c[1].x;
ABS R1.x, R1.z;
SLT R2.z, R1, c[82].y;
ADD R1.x, R1, c[82];
FLR R1.x, R1;
ADD R1.w, -R1.x, -R1.x;
MAD R3.x, R1.w, R2.z, R1;
ADD R1.z, R2.y, c[2].x;
ABS R1.w, R1.z;
ADD R1.y, R1, -R2.x;
ADD R1.x, R3, c[0].w;
FLR R1.w, R1;
SLT R2.z, R2.y, -c[2].x;
ADD R2.y, -R1.w, -R1.w;
MAD R2.w, R2.y, R2.z, R1;
MUL R1.w, R0.z, R1.x;
MUL R1.x, R0.z, R2.w;
FRC R1.w, R1;
MUL R2.z, R1.w, c[1].x;
ABS R1.w, R2.z;
FRC R1.x, R1;
MUL R2.y, R1.x, c[1].x;
ABS R1.x, R2.y;
ADD R1.w, R1, c[82].x;
ADD R1.x, R1, c[82];
ADD R1.z, R1, -R2.w;
FLR R1.w, R1;
FLR R1.x, R1;
SLT R3.y, R2, c[82];
ADD R2.y, -R1.x, -R1.x;
MAD R3.y, R2, R3, R1.x;
ADD R1.x, R3.y, c[0].w;
MUL R1.x, R0.z, R1;
ADD R2.y, -R1.w, -R1.w;
SLT R2.z, R2, c[82].y;
MAD R3.z, R2.y, R2, R1.w;
ADD R2.y, vertex.position.z, R0.w;
FRC R1.x, R1;
MUL R2.z, R1.x, c[1].x;
ABS R0.w, R2.z;
ADD R1.w, R2.y, c[2].x;
ABS R1.x, R1.w;
ADD R0.w, R0, c[82].x;
FLR R1.x, R1;
SLT R3.w, R2.y, -c[2].x;
ADD R2.y, -R1.x, -R1.x;
MAD R2.y, R2, R3.w, R1.x;
FLR R0.w, R0;
MUL R3.w, R0.z, R2.y;
FRC R3.w, R3;
MUL R3.w, R3, c[1].x;
ADD R1.x, -R0.w, -R0.w;
SLT R2.z, R2, c[82].y;
MAD R2.z, R1.x, R2, R0.w;
ABS R0.w, R3;
ADD R1.x, R0.w, c[82];
ARL A0.x, R2.z;
ADD R0.w, c[A0.x + 57].x, R3.z;
ARL A0.x, R3.y;
ADD R3.y, R3.z, c[A0.x + 57].x;
ADD R4.z, R3.x, c[A0.x + 57].x;
SLT R4.x, R3.w, c[82].y;
FLR R1.x, R1;
ADD R3.w, -R1.x, -R1.x;
MAD R1.x, R3.w, R4, R1;
ADD R3.w, R1.x, c[0];
MUL R0.z, R0, R3.w;
ARL A0.x, R2.z;
ADD R4.x, c[A0.x + 57], R3;
FRC R0.z, R0;
MUL R0.z, R0, c[1].x;
ABS R3.z, R0;
ADD R3.z, R3, c[82].x;
FLR R2.z, R3;
SLT R3.x, R0.z, c[82].y;
ADD R0.z, -R2, -R2;
MAD R2.z, R0, R3.x, R2;
ARL A0.x, R3.y;
ADD R0.z, R2, c[A0.x + 57].x;
ARL A0.x, R0.z;
MOV R2.x, c[A0.x + 3];
MAD R0.z, R2.x, c[0], c[0].w;
ADD R3.x, R1.y, -c[0].w;
MUL R2.w, R3.x, R0.z;
MUL R0.z, R1, c[A0.x + 3].x;
MAD R2.w, R0.z, c[0].z, R2;
ADD R0.z, R1.w, -R2.y;
ARL A0.x, R0.w;
ADD R3.z, c[A0.x + 57].x, R2;
ARL A0.x, R3.z;
ADD R2.y, R0.z, -c[0].w;
MAD R2.x, R2, c[0].z, c[0].y;
MAD R3.z, R2.y, R2.x, R2.w;
MOV R1.w, c[A0.x + 3].x;
MAD R2.x, R1.w, c[0].z, c[0].w;
ADD R2.w, R1.z, -c[0];
MUL R3.w, R3.x, R2.x;
MUL R2.x, c[A0.x + 3], R2.w;
ARL A0.x, R4.x;
ADD R4.y, R2.z, c[A0.x + 57].x;
MAD R2.x, R2, c[0].z, R3.w;
MAD R1.w, R1, c[0].z, c[0].y;
MAD R1.w, R2.y, R1, R2.x;
ADD R3.w, R1, -R3.z;
MAD R2.x, -R1.z, c[0].y, c[0].z;
MUL R1.w, R1.z, R1.z;
MUL R1.w, R1, R2.x;
ARL A0.x, R4.y;
MOV R2.x, c[A0.x + 3];
MAD R3.z, R1.w, R3.w, R3;
MAD R3.w, R2.x, c[0].z, c[0];
ARL A0.x, R4.z;
ADD R2.z, R2, c[A0.x + 57].x;
ARL A0.x, R4.y;
MUL R4.y, R2.w, c[A0.x + 3].x;
ARL A0.x, R2.z;
MUL R3.w, R1.y, R3;
MOV R2.z, c[A0.x + 3].x;
MAD R3.w, R4.y, c[0].z, R3;
MAD R4.y, R2.z, c[0].z, c[0].w;
MAD R2.x, R2, c[0].z, c[0].y;
MAD R2.x, R2.y, R2, R3.w;
MUL R3.w, R1.z, c[A0.x + 3].x;
MUL R4.y, R1, R4;
ARL A0.x, R4.x;
MAD R3.w, R3, c[0].z, R4.y;
MAD R2.z, R2, c[0], c[0].y;
MAD R2.y, R2, R2.z, R3.w;
ADD R2.z, R1.x, c[A0.x + 57].x;
ADD R2.x, R2, -R2.y;
MAD R2.x, R1.w, R2, R2.y;
ARL A0.x, R2.z;
MOV R2.y, c[A0.x + 3].x;
MAD R3.w, R2.y, c[0].z, c[0];
ARL A0.x, R4.z;
ADD R4.x, R1, c[A0.x + 57];
ARL A0.x, R2.z;
MUL R2.z, R2.w, c[A0.x + 3].x;
ARL A0.x, R4.x;
MUL R3.w, R1.y, R3;
MOV R4.x, c[A0.x + 3];
MAD R3.w, R2.z, c[0].z, R3;
MAD R2.y, R2, c[0].z, c[0];
MAD R2.y, R0.z, R2, R3.w;
MAD R2.z, R4.x, c[0], c[0].w;
MUL R3.w, R1.y, R2.z;
MUL R2.z, R1, c[A0.x + 3].x;
MAD R2.z, R2, c[0], R3.w;
ARL A0.x, R3.y;
ADD R3.y, R1.x, c[A0.x + 57].x;
MAD R3.w, R4.x, c[0].z, c[0].y;
MAD R3.w, R0.z, R3, R2.z;
ARL A0.x, R3.y;
MOV R2.z, c[A0.x + 3].x;
ARL A0.x, R0.w;
ADD R0.w, c[A0.x + 57].x, R1.x;
ADD R4.x, R2.y, -R3.w;
MAD R2.y, R2.z, c[0].z, c[0].w;
MUL R1.x, R3, R2.y;
ARL A0.x, R3.y;
MUL R1.z, R1, c[A0.x + 3].x;
ARL A0.x, R0.w;
MAD R1.z, R1, c[0], R1.x;
MOV R0.w, c[A0.x + 3].x;
MAD R1.x, R0.w, c[0].z, c[0].w;
MAD R2.y, R2.z, c[0].z, c[0];
MAD R1.z, R0, R2.y, R1;
ADD R3.z, R3, -R2.x;
MUL R1.x, R3, R1;
MUL R2.y, R2.w, c[A0.x + 3].x;
MAD R1.x, R2.y, c[0].z, R1;
MAD R0.w, R0, c[0].z, c[0].y;
MAD R0.w, R0.z, R0, R1.x;
ADD R0.w, R0, -R1.z;
MAD R0.w, R1, R0, R1.z;
MAD R1.x, R1.w, R4, R3.w;
ADD R1.z, R0.w, -R1.x;
MAD R0.w, -R1.y, c[0].y, c[0].z;
MUL R1.y, R1, R1;
MUL R0.w, R1.y, R0;
MAD R1.x, R0.w, R1.z, R1;
MAD R0.w, R0, R3.z, R2.x;
ADD R1.y, R0.w, -R1.x;
MAD R0.w, -R0.z, c[0].y, c[0].z;
MUL R0.z, R0, R0;
MUL R0.z, R0, R0.w;
MAD R0.z, R0, R1.y, R1.x;
MAD R0.z, R0, c[76].x, vertex.position;
MOV R0.w, c[0];
DP4 result.position.w, R0, c[81];
DP4 result.position.z, R0, c[80];
DP4 result.position.y, R0, c[79];
DP4 result.position.x, R0, c[78];
MOV result.color, vertex.color;
END
# 604 instructions, 6 R-regs
"
}

SubProgram "d3d9 " {
Keywords { }
Bind "vertex", Vertex
Bind "color", Color
Local 4, ([BM],0,0,0)
Local 5, ([N],0,0,0)
Local 6, ([g3Table0],0,0,0)
Local 7, ([g3Table1],0,0,0)
Local 8, ([g3Table2],0,0,0)
Local 9, ([g3Table3],0,0,0)
Local 10, ([g3Table4],0,0,0)
Local 11, ([g3Table5],0,0,0)
Local 12, ([g3Table6],0,0,0)
Local 13, ([g3Table7],0,0,0)
Local 14, ([g3Table8],0,0,0)
Local 15, ([g3Table9],0,0,0)
Local 16, ([g3Table10],0,0,0)
Local 17, ([g3Table11],0,0,0)
Local 18, ([g3Table12],0,0,0)
Local 19, ([g3Table13],0,0,0)
Local 20, ([g3Table14],0,0,0)
Local 21, ([g3Table15],0,0,0)
Local 22, ([g3Table16],0,0,0)
Local 23, ([g3Table17],0,0,0)
Local 24, ([g3Table18],0,0,0)
Local 25, ([g3Table19],0,0,0)
Local 26, ([g3Table20],0,0,0)
Local 27, ([g3Table21],0,0,0)
Local 28, ([g3Table22],0,0,0)
Local 29, ([g3Table23],0,0,0)
Local 30, ([g3Table24],0,0,0)
Local 31, ([g3Table25],0,0,0)
Local 32, ([g3Table26],0,0,0)
Local 33, ([g3Table27],0,0,0)
Local 34, ([g3Table28],0,0,0)
Local 35, ([g3Table29],0,0,0)
Local 36, ([g3Table30],0,0,0)
Local 37, ([g3Table31],0,0,0)
Local 38, ([g3Table32],0,0,0)
Local 39, ([g3Table33],0,0,0)
Local 40, ([g3Table34],0,0,0)
Local 41, ([g3Table35],0,0,0)
Local 42, ([g3Table36],0,0,0)
Local 43, ([g3Table37],0,0,0)
Local 44, ([g3Table38],0,0,0)
Local 45, ([g3Table39],0,0,0)
Local 46, ([g3Table40],0,0,0)
Local 47, ([g3Table41],0,0,0)
Local 48, ([g3Table42],0,0,0)
Local 49, ([g3Table43],0,0,0)
Local 50, ([g3Table44],0,0,0)
Local 51, ([g3Table45],0,0,0)
Local 52, ([g3Table46],0,0,0)
Local 53, ([g3Table47],0,0,0)
Local 54, ([g3Table48],0,0,0)
Local 55, ([g3Table49],0,0,0)
Local 56, ([g3Table50],0,0,0)
Local 57, ([g3Table51],0,0,0)
Local 58, ([g3Table52],0,0,0)
Local 59, ([g3Table53],0,0,0)
Local 60, ([pTable0],0,0,0)
Local 61, ([pTable1],0,0,0)
Local 62, ([pTable2],0,0,0)
Local 63, ([pTable3],0,0,0)
Local 64, ([pTable4],0,0,0)
Local 65, ([pTable5],0,0,0)
Local 66, ([pTable6],0,0,0)
Local 67, ([pTable7],0,0,0)
Local 68, ([pTable8],0,0,0)
Local 69, ([pTable9],0,0,0)
Local 70, ([pTable10],0,0,0)
Local 71, ([pTable11],0,0,0)
Local 72, ([pTable12],0,0,0)
Local 73, ([pTable13],0,0,0)
Local 74, ([pTable14],0,0,0)
Local 75, ([pTable15],0,0,0)
Local 76, ([pTable16],0,0,0)
Local 77, ([pTable17],0,0,0)
Local 78, [_Time]
Local 79, ([scale],0,0,0)
Local 80, ([speed],0,0,0)
Matrix 0, [glstate_matrix_mvp]
"vs_3_0
dcl_position v0
dcl_color v1
dcl_position o0
dcl_color o1
def c81, 0.13651431, 0.00000000, 1.00000000, -1.00000000
def c82, 2.00000000, 3.00000000, 0.50000000, 1.00000000
def c83, 1.21687996, 2.55640006, 0, 0
mov r0.x, c78.y
mul r0.x, c80, r0
add r0.z, r0.x, c81.x
add r0.y, r0.z, v0.z
slt r0.w, r0.y, -c5.x
add r0.y, r0, c5.x
abs r1.x, r0.y
frc r1.y, r1.x
add r1.x, r1, -r1.y
max r0.w, -r0, r0
slt r0.w, c81.y, r0
add r1.z, -r0.w, c81
mul r1.z, r1.x, r1
mad r2.x, r0.w, -r1, r1.z
rcp r1.y, c4.x
mul r0.w, r2.x, r1.y
frc r0.w, r0
mul r1.x, r0.w, c4
slt r0.w, r1.x, c81.y
abs r1.x, r1
add r1.x, r1, c82.z
frc r1.z, r1.x
max r0.w, -r0, r0
slt r0.w, c81.y, r0
add r0.y, r0, -r2.x
add r1.x, r1, -r1.z
add r1.w, -r0, c81.z
mul r1.z, r1.x, r1.w
mad r1.w, r0, -r1.x, r1.z
add r0.w, r1, c81.z
mul r1.x, r1.y, r0.w
add r0.w, r0.z, v0.x
frc r2.w, r1.x
slt r1.x, r0.w, -c5
add r0.w, r0, c5.x
abs r1.z, r0.w
frc r2.y, r1.z
max r1.x, -r1, r1
slt r1.x, c81.y, r1
add r1.z, r1, -r2.y
add r2.z, -r1.x, c81
mul r2.y, r1.z, r2.z
mad r2.y, r1.x, -r1.z, r2
add r0.w, r0, -r2.y
mul r3.y, r2.w, c4.x
mul r1.z, r2.y, r1.y
abs r1.x, r3.y
frc r2.z, r1
add r1.x, r1, c82.z
frc r1.z, r1.x
add r2.x, r0.w, c81.w
add r1.x, r1, -r1.z
mul r2.z, r2, c4.x
slt r1.z, r2, c81.y
abs r2.z, r2
add r2.z, r2, c82
frc r2.w, r2.z
max r1.z, -r1, r1
slt r1.z, c81.y, r1
add r2.z, r2, -r2.w
add r3.x, -r1.z, c81.z
mul r2.w, r2.z, r3.x
mad r1.z, r1, -r2, r2.w
slt r3.x, r3.y, c81.y
max r2.w, -r3.x, r3.x
add r2.z, r1, c81
mul r2.z, r2, r1.y
slt r2.w, c81.y, r2
add r3.x, -r2.w, c81.z
mul r3.x, r1, r3
frc r2.z, r2
mad r2.w, r2, -r1.x, r3.x
mul r2.z, r2, c4.x
abs r1.x, r2.z
slt r2.z, r2, c81.y
max r2.z, -r2, r2
add r3.x, r1, c82.z
add r0.z, r0, v0.y
slt r1.x, r0.z, -c5
add r0.z, r0, c5.x
abs r3.y, r0.z
frc r3.z, r3.y
add r3.y, r3, -r3.z
frc r3.z, r3.x
max r1.x, -r1, r1
slt r1.x, c81.y, r1
add r3.w, -r1.x, c81.z
mul r3.w, r3.y, r3
mad r1.x, r1, -r3.y, r3.w
mul r3.y, r1.x, r1
add r0.z, r0, -r1.x
add r3.x, r3, -r3.z
frc r3.y, r3
mul r3.z, r3.y, c4.x
slt r3.y, r3.z, c81
abs r3.z, r3
add r3.z, r3, c82
frc r3.w, r3.z
max r3.y, -r3, r3
slt r3.y, c81, r3
add r3.z, r3, -r3.w
slt r2.z, c81.y, r2
add r4.x, -r3.y, c81.z
mul r4.x, r3.z, r4
mad r3.z, r3.y, -r3, r4.x
add r3.w, -r2.z, c81.z
mul r3.y, r3.x, r3.w
mad r2.z, r2, -r3.x, r3.y
mova a0.x, r2.z
add r3.y, c[a0.x + 60].x, r3.z
add r3.w, r3.z, c81.z
mul r3.x, r1.y, r3.w
mova a0.y, r3
add r3.w, r2, c[a0.y + 60].x
mova a0.y, r1.z
add r4.y, r3.z, c[a0.y + 60].x
mova a0.w, r4.y
add r3.z, r2.w, c[a0.w + 60].x
frc r2.z, r3.x
mul r2.z, r2, c4.x
abs r3.x, r2.z
slt r2.z, r2, c81.y
max r2.z, -r2, r2
slt r1.z, c81.y, r2
mova a0.z, r3.w
add r3.x, r3, c82.z
frc r3.w, r3.x
add r3.x, r3, -r3.w
add r2.z, -r1, c81
mul r2.z, r3.x, r2
mad r1.z, r1, -r3.x, r2
add r2.z, r1, c[a0.y + 60].x
add r1.z, c[a0.x + 60].x, r1
mova a0.x, r2.z
add r3.x, r2.w, c[a0.x + 60]
mova a0.x, r1.z
add r2.w, c[a0.x + 60].x, r2
mova a0.x, r2.w
mova a0.y, r3.x
mov r2.y, c[a0.x + 6].x
mad r1.x, r2.y, c82.y, c82.w
add r2.y, r0.z, c81.w
mul r2.w, r2.y, r1.x
mov r3.x, c[a0.x + 6]
mul r1.x, c[a0.x + 6], r2
mova a0.w, r3.z
mad r3.z, r1.x, c82.y, r2.w
mov r2.w, c[a0.y + 6].x
add r1.x, r0.y, c81.w
mad r3.x, r3, c82.y, c82
mad r3.x, r1, r3, r3.z
mad r2.w, r2, c82.y, c82
mul r3.z, r2.y, r2.w
mul r2.w, r0, c[a0.y + 6].x
mad r3.w, r2, c82.y, r3.z
mov r2.w, c[a0.y + 6].x
mov r3.z, c[a0.w + 6].x
mad r2.w, r2, c82.y, c82.x
mad r2.w, r1.x, r2, r3
mad r3.z, r3, c82.y, c82.w
mul r3.w, r0.z, r3.z
mul r3.z, r0.w, c[a0.w + 6].x
mad r4.x, r3.z, c82.y, r3.w
mov r3.w, c[a0.w + 6].x
mov r3.z, c[a0.z + 6].x
mad r3.w, r3, c82.y, c82.x
mad r4.z, r1.x, r3.w, r4.x
mad r3.z, r3, c82.y, c82.w
mul r4.x, r0.z, r3.z
mul r3.w, r2.x, c[a0.z + 6].x
mov r3.z, c[a0.z + 6].x
add r3.x, r3, -r2.w
mad r3.w, r3, c82.y, r4.x
mad r3.z, r3, c82.y, c82.x
mad r1.x, r1, r3.z, r3.w
add r3.w, r1.x, -r4.z
mad r3.z, -r0.w, c82.x, c82.y
mul r1.x, r0.w, r0.w
mul r1.x, r1, r3.z
mad r3.z, r1.x, r3.w, r4
mad r2.w, r1.x, r3.x, r2
mova a0.x, r4.y
add r3.x, r1.w, c[a0.x + 60]
mova a0.x, r2.z
add r2.z, r1.w, c[a0.x + 60].x
mova a0.z, r3.x
mova a0.x, r2.z
mova a0.y, r3
add r3.x, r1.w, c[a0.y + 60]
mov r2.z, c[a0.z + 6].x
mova a0.y, r3.x
mad r2.z, r2, c82.y, c82.w
mul r3.x, r0.z, r2.z
mul r2.z, r0.w, c[a0.z + 6].x
mad r3.y, r2.z, c82, r3.x
mov r3.x, c[a0.z + 6]
mov r2.z, c[a0.y + 6].x
mad r3.x, r3, c82.y, c82
mad r3.w, r0.y, r3.x, r3.y
mad r2.z, r2, c82.y, c82.w
mul r3.y, r0.z, r2.z
mul r3.x, r2, c[a0.y + 6]
mov r2.z, c[a0.y + 6].x
mova a0.y, r1.z
add r1.z, c[a0.y + 60].x, r1.w
mova a0.y, r1.z
add r2.w, r2, -r3.z
mad r3.x, r3, c82.y, r3.y
mad r2.z, r2, c82.y, c82.x
mad r2.z, r0.y, r2, r3.x
add r3.x, r2.z, -r3.w
mov r2.z, c[a0.x + 6].x
mad r1.w, r2.z, c82.y, c82
mul r1.z, r2.y, r1.w
mul r0.w, r0, c[a0.x + 6].x
mad r1.w, r0, c82.y, r1.z
mov r1.z, c[a0.x + 6].x
mov r0.w, c[a0.y + 6].x
mad r1.z, r1, c82.y, c82.x
mad r1.z, r0.y, r1, r1.w
mul r1.w, r2.x, c[a0.y + 6].x
mad r0.w, r0, c82.y, c82
mul r2.x, r2.y, r0.w
mov r0.w, c[a0.y + 6].x
mad r1.w, r1, c82.y, r2.x
mad r0.w, r0, c82.y, c82.x
mad r0.w, r0.y, r0, r1
add r0.w, r0, -r1.z
mad r1.w, r1.x, r3.x, r3
mad r0.w, r1.x, r0, r1.z
add r1.x, r0.w, -r1.w
mad r0.w, -r0.z, c82.x, c82.y
mul r0.z, r0, r0
mul r0.z, r0, r0.w
mad r0.w, r0.z, r1.x, r1
mad r0.z, r0, r2.w, r3
add r1.x, r0.z, -r0.w
mad r0.z, -r0.y, c82.x, c82.y
mul r0.y, r0, r0
mul r0.y, r0, r0.z
mad r0.z, r0.y, r1.x, r0.w
mad r1.x, r0.z, c79, v0
add r0.y, r0.x, c83.x
add r0.w, r1.x, r0.y
slt r0.z, r0.w, -c5.x
add r0.w, r0, c5.x
abs r1.z, r0.w
frc r1.w, r1.z
max r0.z, -r0, r0
slt r0.z, c81.y, r0
add r1.z, r1, -r1.w
add r2.x, -r0.z, c81.z
mul r1.w, r1.z, r2.x
mad r1.z, r0, -r1, r1.w
mul r0.z, r1.y, r1
frc r0.z, r0
mul r1.w, r0.z, c4.x
slt r0.z, r1.w, c81.y
abs r1.w, r1
add r1.w, r1, c82.z
frc r2.x, r1.w
max r0.z, -r0, r0
slt r0.z, c81.y, r0
add r0.w, r0, -r1.z
add r1.w, r1, -r2.x
add r2.y, -r0.z, c81.z
mul r2.x, r1.w, r2.y
mad r1.w, r0.z, -r1, r2.x
add r0.z, r1.w, c81
mul r0.z, r1.y, r0
frc r0.z, r0
mul r0.z, r0, c4.x
abs r2.x, r0.z
add r2.x, r2, c82.z
frc r2.y, r2.x
slt r0.z, r0, c81.y
add r2.y, r2.x, -r2
max r0.z, -r0, r0
slt r2.x, c81.y, r0.z
add r0.z, v0.y, r0.y
slt r2.z, r0, -c5.x
add r0.z, r0, c5.x
abs r2.w, r0.z
frc r3.x, r2.w
max r2.z, -r2, r2
slt r2.z, c81.y, r2
add r2.w, r2, -r3.x
add r3.y, -r2.z, c81.z
mul r3.x, r2.w, r3.y
mad r4.x, r2.z, -r2.w, r3
add r3.z, -r2.x, c81
mul r3.y, r2, r3.z
mad r2.x, r2, -r2.y, r3.y
add r0.z, r0, -r4.x
mul r2.y, r1, r4.x
mova a0.x, r2
mova a0.z, r1.w
frc r2.x, r2.y
mul r1.w, r2.x, c4.x
slt r1.z, r1.w, c81.y
abs r2.x, r1.w
max r1.w, -r1.z, r1.z
add r1.z, r2.x, c82
slt r1.w, c81.y, r1
frc r2.x, r1.z
add r2.x, r1.z, -r2
add r2.y, -r1.w, c81.z
mul r2.y, r2.x, r2
mad r2.x, r1.w, -r2, r2.y
add r1.w, r2.x, c81.z
mul r1.w, r1.y, r1
add r4.z, r2.x, c[a0.z + 60].x
mad r2.y, -r0.w, c82.x, c82
mul r1.z, r0.w, r0.w
mul r1.z, r1, r2.y
frc r3.x, r1.w
add r0.y, v0.z, r0
slt r1.w, r0.y, -c5.x
add r0.y, r0, c5.x
abs r2.y, r0
frc r2.z, r2.y
add r2.z, r2.y, -r2
max r1.w, -r1, r1
slt r1.w, c81.y, r1
add r2.w, -r1, c81.z
mul r2.w, r2.z, r2
mad r3.z, r1.w, -r2, r2.w
mul r2.z, r1.y, r3
mul r2.y, r3.x, c4.x
abs r1.w, r2.y
frc r2.w, r2.z
add r1.w, r1, c82.z
frc r2.z, r1.w
add r0.y, r0, -r3.z
add r1.w, r1, -r2.z
mul r2.w, r2, c4.x
slt r2.z, r2.w, c81.y
abs r2.w, r2
add r2.w, r2, c82.z
frc r3.x, r2.w
max r2.z, -r2, r2
slt r2.z, c81.y, r2
add r2.w, r2, -r3.x
add r3.y, -r2.z, c81.z
mul r3.x, r2.w, r3.y
mad r2.z, r2, -r2.w, r3.x
slt r2.y, r2, c81
max r2.w, -r2.y, r2.y
slt r2.w, c81.y, r2
add r2.y, r2.z, c81.z
mul r2.y, r1, r2
add r3.x, -r2.w, c81.z
mul r3.x, r1.w, r3
mad r3.y, r2.w, -r1.w, r3.x
add r3.w, r3.y, c[a0.z + 60].x
frc r2.y, r2
mul r2.y, r2, c4.x
slt r1.w, r2.y, c81.y
abs r2.y, r2
add r2.y, r2, c82.z
frc r2.w, r2.y
add r2.w, r2.y, -r2
add r2.y, c[a0.x + 60].x, r3
add r2.x, c[a0.x + 60], r2
max r1.w, -r1, r1
slt r1.w, c81.y, r1
add r3.x, -r1.w, c81.z
mul r3.x, r2.w, r3
mad r2.w, r1, -r2, r3.x
mova a0.y, r2
add r1.w, c[a0.y + 60].x, r2
mova a0.y, r1.w
add r3.x, r0.w, c81.w
mov r3.y, c[a0.y + 6].x
mad r4.x, r3.y, c82.y, c82.w
add r3.y, r0.z, c81.w
mov r3.z, c[a0.y + 6].x
mul r1.w, c[a0.y + 6].x, r3.x
mul r4.x, r3.y, r4
mad r4.y, r1.w, c82, r4.x
mova a0.w, r3
add r1.w, r2, c[a0.w + 60].x
mova a0.w, r1
mov r4.x, c[a0.w + 6]
add r1.w, r0.y, c81
mad r3.z, r3, c82.y, c82.x
mad r3.z, r1.w, r3, r4.y
mad r4.x, r4, c82.y, c82.w
mul r4.y, r3, r4.x
mul r4.x, r0.w, c[a0.w + 6]
mad r4.y, r4.x, c82, r4
mov r4.x, c[a0.w + 6]
mad r4.x, r4, c82.y, c82
mad r4.x, r1.w, r4, r4.y
mova a0.y, r4.z
add r4.y, r2.w, c[a0.y + 60].x
mova a0.z, r4.y
mova a0.x, r2
add r2.w, r2, c[a0.x + 60].x
mova a0.w, r2
add r3.z, r3, -r4.x
mad r3.z, r1, r3, r4.x
mov r4.x, c[a0.z + 6]
mad r4.x, r4, c82.y, c82.w
mov r2.w, c[a0.z + 6].x
mul r4.y, r0.w, c[a0.z + 6].x
mul r2.x, r0.z, r4
mad r4.x, r4.y, c82.y, r2
mov r2.x, c[a0.w + 6]
mad r2.w, r2, c82.y, c82.x
mad r4.y, r1.w, r2.w, r4.x
mad r2.x, r2, c82.y, c82.w
mul r4.x, r0.z, r2
mul r2.w, r3.x, c[a0.w + 6].x
mad r2.w, r2, c82.y, r4.x
add r4.x, r2.z, c[a0.y + 60]
mova a0.y, r4.x
mov r2.x, c[a0.w + 6]
mad r2.x, r2, c82.y, c82
mad r1.w, r1, r2.x, r2
add r2.x, r2.z, c[a0.x + 60]
mova a0.x, r2
mov r4.x, c[a0.y + 6]
add r1.w, r1, -r4.y
mad r1.w, r1.z, r1, r4.y
add r2.x, r3.z, -r1.w
mov r3.z, c[a0.x + 6].x
mad r3.z, r3, c82.y, c82.w
mad r4.x, r4, c82.y, c82.w
mul r2.w, r3.x, c[a0.x + 6].x
mul r3.z, r0, r3
mad r3.z, r2.w, c82.y, r3
mov r2.w, c[a0.x + 6].x
mova a0.x, r3.w
add r3.w, r2.z, c[a0.x + 60].x
mova a0.x, r2.y
add r2.y, c[a0.x + 60].x, r2.z
mova a0.x, r2.y
mov r2.y, c[a0.x + 6].x
mad r2.w, r2, c82.y, c82.x
mad r2.w, r0.y, r2, r3.z
mul r4.x, r0.z, r4
mul r3.z, r0.w, c[a0.y + 6].x
mad r3.z, r3, c82.y, r4.x
mov r4.x, c[a0.y + 6]
mova a0.y, r3.w
mad r3.w, r4.x, c82.y, c82.x
mad r3.w, r0.y, r3, r3.z
mov r3.z, c[a0.y + 6].x
mov r2.z, c[a0.y + 6].x
mad r3.z, r3, c82.y, c82.w
add r2.w, r2, -r3
mul r0.w, r0, c[a0.y + 6].x
mul r3.z, r3.y, r3
mad r0.w, r0, c82.y, r3.z
mad r2.z, r2, c82.y, c82.x
mad r0.w, r0.y, r2.z, r0
mul r2.z, r3.x, c[a0.x + 6].x
mad r2.y, r2, c82, c82.w
mul r3.x, r3.y, r2.y
mov r2.y, c[a0.x + 6].x
mad r2.z, r2, c82.y, r3.x
mad r2.y, r2, c82, c82.x
mad r2.y, r0, r2, r2.z
add r2.y, r2, -r0.w
mad r2.z, r1, r2.w, r3.w
mad r0.w, r1.z, r2.y, r0
add r1.z, r0.w, -r2
mad r0.w, -r0.z, c82.x, c82.y
mul r0.z, r0, r0
mul r0.z, r0, r0.w
mad r0.w, r0.z, r1.z, r2.z
mad r0.z, r0, r2.x, r1.w
add r1.z, r0, -r0.w
mad r0.z, -r0.y, c82.x, c82.y
mul r0.y, r0, r0
mul r0.y, r0, r0.z
mad r0.z, r0.y, r1, r0.w
add r0.y, r0.x, c83
mad r0.x, r0.z, c79, v0.y
add r0.w, r0.x, r0.y
slt r0.z, r0.w, -c5.x
add r2.x, r0.w, c5
abs r0.w, r2.x
frc r1.z, r0.w
max r0.z, -r0, r0
slt r0.z, c81.y, r0
add r0.w, r0, -r1.z
add r1.w, -r0.z, c81.z
mul r1.z, r0.w, r1.w
mad r2.y, r0.z, -r0.w, r1.z
mul r0.z, r1.y, r2.y
add r2.x, r2, -r2.y
frc r0.z, r0
mul r0.w, r0.z, c4.x
slt r0.z, r0.w, c81.y
abs r0.w, r0
add r0.w, r0, c82.z
frc r1.z, r0.w
max r0.z, -r0, r0
slt r0.z, c81.y, r0
add r0.w, r0, -r1.z
add r1.w, -r0.z, c81.z
mul r1.z, r0.w, r1.w
mad r3.w, r0.z, -r0, r1.z
add r0.w, r1.x, r0.y
slt r0.z, r0.w, -c5.x
add r2.z, r0.w, c5.x
abs r0.w, r2.z
frc r1.z, r0.w
max r0.z, -r0, r0
slt r0.z, c81.y, r0
add r0.w, r0, -r1.z
add r1.w, -r0.z, c81.z
add r2.y, r2.x, c81.w
mul r1.z, r0.w, r1.w
add r2.w, r3, c81.z
mul r1.w, r1.y, r2
mad r2.w, r0.z, -r0, r1.z
mul r0.w, r1.y, r2
frc r0.z, r1.w
frc r1.z, r0.w
mul r1.w, r1.z, c4.x
slt r1.z, r1.w, c81.y
mul r0.z, r0, c4.x
abs r0.w, r0.z
abs r1.w, r1
add r1.w, r1, c82.z
frc r3.x, r1.w
max r1.z, -r1, r1
slt r1.z, c81.y, r1
add r2.z, r2, -r2.w
add r1.w, r1, -r3.x
add r3.y, -r1.z, c81.z
mul r3.x, r1.w, r3.y
mad r3.x, r1.z, -r1.w, r3
add r0.w, r0, c82.z
frc r3.y, r0.w
add r1.z, r0.w, -r3.y
add r0.w, r3.x, c81.z
slt r0.z, r0, c81.y
max r1.w, -r0.z, r0.z
mul r0.w, r1.y, r0
slt r1.w, c81.y, r1
frc r0.z, r0.w
mul r0.z, r0, c4.x
abs r0.w, r0.z
add r3.y, -r1.w, c81.z
mul r3.y, r1.z, r3
slt r0.z, r0, c81.y
mad r4.x, r1.w, -r1.z, r3.y
add r0.w, r0, c82.z
frc r1.z, r0.w
max r0.z, -r0, r0
add r3.z, r0.w, -r1
slt r3.y, c81, r0.z
add r0.y, v0.z, r0
slt r0.z, r0.y, -c5.x
add r0.y, r0, c5.x
abs r0.w, r0.y
frc r1.z, r0.w
max r0.z, -r0, r0
slt r0.z, c81.y, r0
add r0.w, r0, -r1.z
add r1.w, -r0.z, c81.z
mul r1.z, r0.w, r1.w
mad r0.z, r0, -r0.w, r1
add r1.w, -r3.y, c81.z
mul r0.w, r3.z, r1
mad r0.w, r3.y, -r3.z, r0
mova a0.x, r0.w
mul r1.z, r1.y, r0
frc r1.z, r1
mul r1.w, r1.z, c4.x
slt r1.z, r1.w, c81.y
abs r1.w, r1
add r1.w, r1, c82.z
frc r3.y, r1.w
max r1.z, -r1, r1
slt r1.z, c81.y, r1
add r0.y, r0, -r0.z
add r1.w, r1, -r3.y
add r3.z, -r1, c81
mul r3.y, r1.w, r3.z
mad r1.z, r1, -r1.w, r3.y
mova a0.y, r3.x
add r3.x, r1.z, c81.z
mul r1.y, r1, r3.x
frc r3.x, r1.y
add r1.y, r3.w, c[a0.y + 60].x
add r0.w, c[a0.x + 60].x, r4.x
add r1.w, r4.x, c[a0.y + 60].x
mova a0.w, r1.y
mul r3.x, r3, c4
slt r1.y, r3.x, c81
abs r3.x, r3
add r3.x, r3, c82.z
frc r3.y, r3.x
max r1.y, -r1, r1
slt r1.y, c81, r1
add r3.x, r3, -r3.y
add r3.z, -r1.y, c81
mul r3.y, r3.x, r3.z
add r3.z, c[a0.x + 60].x, r3.w
mad r1.y, r1, -r3.x, r3
mova a0.x, r1.w
add r3.x, r1.y, c[a0.x + 60]
mova a0.y, r3.x
mov r3.x, c[a0.y + 6]
mov r3.y, c[a0.y + 6].x
mad r3.x, r3, c82.y, c82.w
mova a0.z, r3
mul r3.x, r2.y, r3
mul r2.w, r2.z, c[a0.y + 6].x
mad r2.w, r2, c82.y, r3.x
mova a0.x, r0.w
add r3.x, c[a0.x + 60], r1.y
mova a0.x, r3
mov r0.z, c[a0.x + 6].x
mad r0.z, r0, c82.y, c82.w
mul r3.w, r2.y, r0.z
mov r0.z, c[a0.x + 6].x
add r3.x, r0.y, c81.w
mad r3.y, r3, c82, c82.x
mad r3.z, r3.x, r3.y, r2.w
add r3.y, r2.z, c81.w
mul r2.w, c[a0.x + 6].x, r3.y
mad r2.w, r2, c82.y, r3
mad r0.z, r0, c82.y, c82.x
mad r0.z, r3.x, r0, r2.w
add r3.w, r0.z, -r3.z
add r2.w, r1.y, c[a0.z + 60].x
mova a0.x, r2.w
mov r4.x, c[a0.x + 6]
mad r2.w, -r2.z, c82.x, c82.y
mul r0.z, r2, r2
mul r0.z, r0, r2.w
mad r2.w, r4.x, c82.y, c82
mad r3.z, r0, r3.w, r3
add r3.w, r1.y, c[a0.w + 60].x
mova a0.y, r3.w
mul r1.y, r3, c[a0.x + 6].x
mul r2.w, r2.x, r2
mad r3.w, r1.y, c82.y, r2
mov r2.w, c[a0.y + 6].x
mov r1.y, c[a0.x + 6].x
add r4.x, r1.z, c[a0.z + 60]
mad r1.y, r1, c82, c82.x
mad r1.y, r3.x, r1, r3.w
mad r2.w, r2, c82.y, c82
mul r3.w, r2.x, r2
mul r2.w, r2.z, c[a0.y + 6].x
mad r3.w, r2, c82.y, r3
mov r2.w, c[a0.y + 6].x
mad r2.w, r2, c82.y, c82.x
mad r2.w, r3.x, r2, r3
mova a0.x, r4
add r1.y, r1, -r2.w
mad r1.y, r0.z, r1, r2.w
add r3.w, r1.z, c[a0.w + 60].x
mov r3.x, c[a0.x + 6]
mova a0.y, r3.w
add r2.w, r3.z, -r1.y
mad r3.x, r3, c82.y, c82.w
mul r3.z, r2.x, r3.x
mul r3.x, r3.y, c[a0.x + 6]
mad r3.w, r3.x, c82.y, r3.z
mov r3.x, c[a0.x + 6]
mova a0.x, r1.w
add r1.w, r1.z, c[a0.x + 60].x
mova a0.x, r1.w
mov r3.z, c[a0.y + 6].x
mad r3.x, r3, c82.y, c82
mov r1.w, c[a0.x + 6].x
mad r1.w, r1, c82.y, c82
mad r3.x, r0.y, r3, r3.w
mad r3.z, r3, c82.y, c82.w
mul r3.w, r2.x, r3.z
mul r3.z, r2, c[a0.y + 6].x
mad r3.z, r3, c82.y, r3.w
mov r3.w, c[a0.y + 6].x
mova a0.y, r0.w
add r0.w, c[a0.y + 60].x, r1.z
mova a0.y, r0.w
mad r3.w, r3, c82.y, c82.x
mad r3.z, r0.y, r3.w, r3
mov r0.w, c[a0.y + 6].x
mad r0.w, r0, c82.y, c82
mul r1.w, r2.y, r1
mul r1.z, r2, c[a0.x + 6].x
mad r1.w, r1.z, c82.y, r1
mul r0.w, r2.y, r0
mov r1.z, c[a0.x + 6].x
mad r1.z, r1, c82.y, c82.x
mad r1.z, r0.y, r1, r1.w
mul r2.y, r3, c[a0.y + 6].x
mov r1.w, c[a0.y + 6].x
mad r1.w, r1, c82.y, c82.x
mad r0.w, r2.y, c82.y, r0
mad r0.w, r0.y, r1, r0
add r3.x, r3, -r3.z
add r0.w, r0, -r1.z
mad r1.w, r0.z, r3.x, r3.z
mad r0.z, r0, r0.w, r1
add r0.w, r0.z, -r1
mul r1.z, r2.x, r2.x
mad r0.z, -r2.x, c82.x, c82.y
mul r0.z, r1, r0
mad r0.w, r0.z, r0, r1
mad r0.z, r0, r2.w, r1.y
add r1.y, r0.z, -r0.w
mad r0.z, -r0.y, c82.x, c82.y
mul r0.y, r0, r0
mul r0.y, r0, r0.z
mad r0.y, r0, r1, r0.w
mad r1.z, r0.y, c79.x, v0
mov r1.w, c81.z
mov r1.y, r0.x
dp4 o0.w, r1, c3
dp4 o0.z, r1, c2
dp4 o0.y, r1, c1
dp4 o0.x, r1, c0
mov o1, v1
"
}

SubProgram "opengl " {
Keywords { }
"3.0-!!ARBfp1.0
# 1 instructions, 0 texture reads
MOV result.color, fragment.color.primary;
END
# 1 instructions, 0 R-regs
"
}

SubProgram "d3d9 " {
Keywords { }
"ps_3_0
dcl_color v0
mov_pp oC0, v0
"
}

}
#LINE 166
 
      } // Pass 
   } // SubShader 
} // Shader

ivkoni · January 11, 2010, 2:25am

thanks mate. The same thing at first glance. I am worried about the 604 ALU instructions count. That is a sh*t lot, I think. I would have to optimize this.

I tried another faster perlin noise HLSL shader from Nvidia’s webpage. Pretty much copy paste with a few changes to avoid syntax errors in CG. This works when I run nvidia’s demo, but something is wrong with my translation it seems since nothing happens. It does compile fine, and I see the mesh, but there is no movement of the vertices
Here’s the code:

Shader "Perlin_test2" 
{ 
   Properties 
   {              
	  Sharpness ("Sharpness", Float) = 1.0
	  Displacement ("Displacement", Float) = 1.0
   }    
   SubShader 
   { 
      Pass 
      {          
          
CGPROGRAM 
  
#pragma vertex vert 
#include <vnoise-table.fxh>

float4x4 NoiseMatrix  = float4x4 (1,0,0,0, 
											0,1,0,0, 
											0,0,1,0, 
											0,0,0,1);
											
float4 dd[5] = {float4(0,2,3,1), float4(2,2,2,2), float4(3,3,3,3), float4(4,4,4,4), float4(5,5,5,5) };

uniform float4 _Time; 
uniform float Sharpness; 
uniform float Displacement; 

float3 s_curve(float3 t) { return t*t*( float3(3,3,3) - float3(2,2,2)*t); }

float perlinNoise(float3 v, const uniform float4 pg[FULLSIZE])
{
    v = v + float3(10000.0f, 10000.0f, 10000.0f);   // hack to avoid negative numbers

    float3 i = frac(v * NOISEFRAC) * BSIZE;   // index between 0 and BSIZE-1
    float3 f = frac(v);            // fractional position

    // lookup in permutation table
    float2 p;
    p.x = pg[ i[0]     ].w;
    p.y = pg[ i[0] + 1 ].w;
    p = p + i[1];

    float4 b;
    b.x = pg[ p[0] ].w;
    b.y = pg[ p[1] ].w;
    b.z = pg[ p[0] + 1 ].w;
    b.w = pg[ p[1] + 1 ].w;
    b = b + i[2];

    // compute dot products between gradients and vectors
    float4 r;
    r[0] = dot( pg[ b[0] ].xyz, f );
    r[1] = dot( pg[ b[1] ].xyz, f - float3(1.0f, 0.0f, 0.0f) );
    r[2] = dot( pg[ b[2] ].xyz, f - float3(0.0f, 1.0f, 0.0f) );
    r[3] = dot( pg[ b[3] ].xyz, f - float3(1.0f, 1.0f, 0.0f) );

    float4 r1;
    r1[0] = dot( pg[ b[0] + 1 ].xyz, f - float3(0.0f, 0.0f, 1.0f) );
    r1[1] = dot( pg[ b[1] + 1 ].xyz, f - float3(1.0f, 0.0f, 1.0f) );
    r1[2] = dot( pg[ b[2] + 1 ].xyz, f - float3(0.0f, 1.0f, 1.0f) );
    r1[3] = dot( pg[ b[3] + 1 ].xyz, f - float3(1.0f, 1.0f, 1.0f) );

    // interpolate
    f = s_curve(f);
    r = lerp( r, r1, f[2] );
    r = lerp( r.xyyy, r.zwww, f[1] );
    return lerp( r.x, r.y, f[0] );
}

struct a2v 
{ 
   float4 vertex   : POSITION; 
   float3 normal       : NORMAL;
   float4 texcoord0    : TEXCOORD0;
}; 

struct v2f { 
    float4 pos : POSITION; 
    float4 color : COLOR; 
}; 


v2f vert(a2v IN) 
{ 
   v2f OUT; 

	float4 noisePos = mul(IN.vertex + _Time.y,NoiseMatrix);
    float i = (perlinNoise(noisePos.xyz, NTab ) + 1.0f) * 0.5f;
    OUT.color = float4(i, i, i, 1.0f);
    // displacement along normal
    i = i - 0.5;
    i = sign(i) * pow(i,Sharpness);
    float4 position = IN.vertex + (float4(IN.normal,1) * i * Displacement);
    position.w = 1.0f;
    OUT.pos = mul(glstate.matrix.mvp, position); 
    return OUT;

} 


ENDCG 
      } // Pass 
   } // SubShader 
} // Shader

there is an include file, which is attached. I also embeded it, but still same result. I put the include file here: C:\Program Files\Unity\Editor\Data\CGIncludes and I am pretty sure it is included fine.

The original nvidia’s HSLS shader is also attached if someone wants to take a look.

How do I trouble shoot something like this?
Is there a way I can print stuff to the console from the shader? How can I see the values of the variables being used?

EDIT: I found a post saying it is not possible to print values or variables used in a shader.

I can’t add the files as attachments for some reason. Pasted below, sorry for the long post:

// NOISE TABLE, seed value: 0 /////////////////////

#define BSIZE 32
#define FULLSIZE 66
#define NOISEFRAC 0.03125

const float4 NTab[66] = {float4(-0.854611,-0.453029,0.25378,0),
		float4(-0.84528,-0.456307,-0.278002,1),
		float4(-0.427197,0.847095,-0.316122,2),
		float4(0.670266,-0.496104,0.551928,3),
		float4(-0.675674,-0.713842,0.184102,4),
		float4(-0.0373602,-0.600265,0.798928,5),
		float4(-0.939116,-0.119538,0.322135,6),
		float4(0.818521,0.278224,0.502609,7),
		float4(0.105335,-0.765291,0.635007,8),
		float4(-0.634436,-0.298693,0.712933,9),
		float4(-0.532414,-0.603311,-0.593761,10),
		float4(0.411375,0.0976618,0.906219,11),
		float4(0.798824,-0.416379,-0.434175,12),
		float4(-0.691156,0.585681,-0.423415,13),
		float4(0.612298,0.0777332,0.786797,14),
		float4(0.264612,-0.262848,0.927842,15),
		float4(-0.70809,0.0548396,-0.703989,16),
		float4(0.933195,-0.294222,-0.206349,17),
		float4(0.788936,-0.466718,-0.399692,18),
		float4(-0.540183,-0.824413,0.168954,19),
		float4(0.469322,-0.184125,0.863617,20),
		float4(-0.84773,0.292229,-0.44267,21),
		float4(0.450832,0.650314,-0.611427,22),
		float4(0.906378,-0.247125,-0.342647,23),
		float4(-0.995052,0.0271277,-0.0955848,24),
		float4(-0.0252277,-0.778349,0.627325,25),
		float4(0.991428,0.128623,0.0229457,26),
		float4(-0.842581,-0.290688,0.453384,27),
		float4(-0.662511,-0.500545,-0.557256,28),
		float4(0.650245,-0.692099,-0.313338,29),
		float4(0.636901,0.768918,-0.0558766,30),
		float4(-0.437006,0.872104,-0.220138,31),
		float4(-0.854611,-0.453029,0.25378,0),
		float4(-0.84528,-0.456307,-0.278002,1),
		float4(-0.427197,0.847095,-0.316122,2),
		float4(0.670266,-0.496104,0.551928,3),
		float4(-0.675674,-0.713842,0.184102,4),
		float4(-0.0373602,-0.600265,0.798928,5),
		float4(-0.939116,-0.119538,0.322135,6),
		float4(0.818521,0.278224,0.502609,7),
		float4(0.105335,-0.765291,0.635007,8),
		float4(-0.634436,-0.298693,0.712933,9),
		float4(-0.532414,-0.603311,-0.593761,10),
		float4(0.411375,0.0976618,0.906219,11),
		float4(0.798824,-0.416379,-0.434175,12),
		float4(-0.691156,0.585681,-0.423415,13),
		float4(0.612298,0.0777332,0.786797,14),
		float4(0.264612,-0.262848,0.927842,15),
		float4(-0.70809,0.0548396,-0.703989,16),
		float4(0.933195,-0.294222,-0.206349,17),
		float4(0.788936,-0.466718,-0.399692,18),
		float4(-0.540183,-0.824413,0.168954,19),
		float4(0.469322,-0.184125,0.863617,20),
		float4(-0.84773,0.292229,-0.44267,21),
		float4(0.450832,0.650314,-0.611427,22),
		float4(0.906378,-0.247125,-0.342647,23),
		float4(-0.995052,0.0271277,-0.0955848,24),
		float4(-0.0252277,-0.778349,0.627325,25),
		float4(0.991428,0.128623,0.0229457,26),
		float4(-0.842581,-0.290688,0.453384,27),
		float4(-0.662511,-0.500545,-0.557256,28),
		float4(0.650245,-0.692099,-0.313338,29),
		float4(0.636901,0.768918,-0.0558766,30),
		float4(-0.437006,0.872104,-0.220138,31),
		float4(-0.854611,-0.453029,0.25378,0),
		float4(-0.84528,-0.456307,-0.278002,1)};

///////////////////////////// eof ///

/*********************************************************************NVMH3****
File:  $Id: //sw/devtools/SDK/9.5/SDK/MEDIA/HLSL/vnoise.fx#3 $

Copyright NVIDIA Corporation 2002-2004
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.


Comments:
	HLSL noise implementation for vertex program profile

	This is based on Perlin's original code:
	[url]http://mrl.nyu.edu/~perlin/doc/oscar.html[/url]
	 Thanks to Simon Green - KB

	It combines the permutation and gradient tables into one array of
		float4's to conserve constant memory.
	The table is duplicated twice to avoid modulo operations.

Notes:
	Should use separate tables for 1, 2 and 3D versions

******************************************************************************/

#include <include\\vnoise-table.fxh>

float Script : STANDARDSGLOBAL <
    string UIWidget = "none";
    string ScriptClass = "object";
    string ScriptOrder = "standard";
    string ScriptOutput = "color";
    string Script = "Technique=vnoise;";
> = 0.8;

float timer : TIME <string UIWidget="None";>;

///////////// functions 

// this is the smoothstep function f(t) = 3t^2 - 2t^3, without the normalization
float3 s_curve(float3 t) { return t*t*( float3(3,3,3) - float3(2,2,2)*t); }
float2 s_curve(float2 t) { return t*t*( float2(3,3) - float2(2,2)*t); }
float  s_curve(float  t) { return t*t*(3.0-2.0*t); }

// 3D version
float noise(float3 v,
			const uniform float4 pg[FULLSIZE])
{
    v = v + float3(10000.0f, 10000.0f, 10000.0f);   // hack to avoid negative numbers

    float3 i = frac(v * NOISEFRAC) * BSIZE;   // index between 0 and BSIZE-1
    float3 f = frac(v);            // fractional position

    // lookup in permutation table
    float2 p;
    p.x = pg[ i[0]     ].w;
    p.y = pg[ i[0] + 1 ].w;
    p = p + i[1];

    float4 b;
    b.x = pg[ p[0] ].w;
    b.y = pg[ p[1] ].w;
    b.z = pg[ p[0] + 1 ].w;
    b.w = pg[ p[1] + 1 ].w;
    b = b + i[2];

    // compute dot products between gradients and vectors
    float4 r;
    r[0] = dot( pg[ b[0] ].xyz, f );
    r[1] = dot( pg[ b[1] ].xyz, f - float3(1.0f, 0.0f, 0.0f) );
    r[2] = dot( pg[ b[2] ].xyz, f - float3(0.0f, 1.0f, 0.0f) );
    r[3] = dot( pg[ b[3] ].xyz, f - float3(1.0f, 1.0f, 0.0f) );

    float4 r1;
    r1[0] = dot( pg[ b[0] + 1 ].xyz, f - float3(0.0f, 0.0f, 1.0f) );
    r1[1] = dot( pg[ b[1] + 1 ].xyz, f - float3(1.0f, 0.0f, 1.0f) );
    r1[2] = dot( pg[ b[2] + 1 ].xyz, f - float3(0.0f, 1.0f, 1.0f) );
    r1[3] = dot( pg[ b[3] + 1 ].xyz, f - float3(1.0f, 1.0f, 1.0f) );

    // interpolate
    f = s_curve(f);
    r = lerp( r, r1, f[2] );
    r = lerp( r.xyyy, r.zwww, f[1] );
    return lerp( r.x, r.y, f[0] );
}

// 2D version
float noise(float2 v,
			const uniform float4 pg[FULLSIZE])
{
    v = v + float2(10000.0f, 10000.0f);

    float2 i = frac(v * NOISEFRAC) * BSIZE;   // index between 0 and BSIZE-1
    float2 f = frac(v);            // fractional position

    // lookup in permutation table
    float2 p;
    p[0] = pg[ i[0]   ].w;
    p[1] = pg[ i[0]+1 ].w;
    p = p + i[1];

    // compute dot products between gradients and vectors
    float4 r;
    r[0] = dot( pg[ p[0] ].xy,   f);
    r[1] = dot( pg[ p[1] ].xy,   f - float2(1.0f, 0.0f) );
    r[2] = dot( pg[ p[0]+1 ].xy, f - float2(0.0f, 1.0f) );
    r[3] = dot( pg[ p[1]+1 ].xy, f - float2(1.0f, 1.0f) );

    // interpolate
    f = s_curve(f);
    r = lerp( r.xyyy, r.zwww, f[1] );
    return lerp( r.x, r.y, f[0] );
}

// 1D version
float noise(float v,
		const uniform float4 pg[FULLSIZE])
{
    v = v + 10000.0f;

    float i = frac(v * NOISEFRAC) * BSIZE;   // index between 0 and BSIZE-1
    float f = frac(v);            // fractional position

    // compute dot products between gradients and vectors
    float2 r;
    r[0] = pg[i].x * f;
    r[1] = pg[i + 1].x * (f - 1.0f);

    // interpolate
    f = s_curve(f);
    return lerp( r[0], r[1], f);
}

//////////////////////////////////////////////////////////////

float4x4 WorldViewProj : WORLDVIEWPROJECTION <string UIWidget="None";>;
float4x4 NoiseMatrix = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1};

float Displacement <
	string UIWidget = "slider";
	float UIMin = 0.0;
	float UIMax = 2.0;
	float UIStep = 0.01;
> = 1.0f;

float Sharpness <
	string UIWidget = "slider";
	float UIMin = 0.1;
	float UIMax = 5.0;
	float UIStep = 0.1;
> = 1.0f;

float4 dd[5] = {
	0,2,3,1, 2,2,2,2, 3,3,3,3, 4,4,4,4, 5,5,5,5 };

/////////////////////////////

struct appData 
{
    float4 Position     : POSITION;
    float4 Normal       : NORMAL;
    float4 TexCoord0    : TEXCOORD0;
};

// define outputs from vertex shader
struct vertexOutData
{
    float4 HPosition    : POSITION;
    float4 Color0       : COLOR0;
};

////////

vertexOutData mainVS(appData IN) {
    vertexOutData OUT;
    float4 noisePos = mul(IN.Position+timer,NoiseMatrix);
    float i = (noise(noisePos.xyz, NTab) + 1.0f) * 0.5f;
    OUT.Color0 = float4(i, i, i, 1.0f);
    // displacement along normal
    i = i - 0.5;
    i = sign(i) * pow(i,Sharpness);
    float4 position = IN.Position + (IN.Normal * i * Displacement);
    position.w = 1.0f;
    OUT.HPosition = mul(position,WorldViewProj);
    return OUT;
}

//////////////////////

technique vnoise <
	string Script = "Pass=p0;";
> {
	pass p0 <
	string Script = "Draw=geometry;";
> {
		VertexShader = compile vs_2_0 mainVS();
	}
}

///////////////////////////////////////////////////////////////// eof //

ivkoni · January 11, 2010, 5:09am

I am under the impression that I cannot declare variables outside of functions in CG and then use them inside the functions as it seems to be the case with HSLS. For example, the below code compiles fine, but returns black color, even though test4 is gray. Does this depend on some directive?
Can I use variables declared outside of functions?
Do I always need to define the variables in the Properties block in order to be available in the functions?
Sorry, but I really cannot get the logic behind the whole shader lab / CG mix.

Shader "Perlin_test2" 
{ 
   
   SubShader 
   { 
      Pass 
      {          
          
CGPROGRAM 
  
#pragma vertex vert 

float4 test4 = float4(0.5,0.5,0.5,0.5);

struct a2v 
{ 
   float4 vertex   : POSITION; 
   float3 normal       : NORMAL;
   float4 texcoord0    : TEXCOORD0;
}; 

struct v2f { 
    float4 pos : POSITION; 
    float4 color : COLOR; 
}; 


v2f vert(a2v IN) 
{ 
   v2f OUT; 
   
    OUT.color = test4;
    OUT.pos = mul(glstate.matrix.mvp, IN.vertex); 
    return OUT;

} 


ENDCG 
      } // Pass 
   } // SubShader 
} // Shader

ivkoni · January 11, 2010, 9:50pm

I found this thread which confirms that I won’t be able to do what I want to do due to limitations in unity: initial variable values will not actually work (you need to assign them from scripts or the shader properties) and arrays don’t really work either.

http://forum.unity3d.com/viewtopic.php?t=31565

I only wish these limitations were mentioned somewhere with big red letters so a shader newbie will not have to find them the hard way. (like also that you need to call your variable vertex, and not whatever you want).

Unity is a great piece of software, no shame in pointing some minor omissions which are probably due to be added soon anyway.

I must admit though that in the compiled version of the shader (pasted below) it is visible that the array is made of 0s. I saw this, but I didn’t pay too much attention to it at first.

Finally, a searchable shaderlab reference would also be cool

anon_38331066 · January 12, 2010, 5:57am

Hi ivkoni,

I did some test on perlin noise someday ago…

http://forum.unity3d.com/viewtopic.php?p=224740

Hope those information are useful to you

Have fun !

ivkoni · January 12, 2010, 12:18pm

thanks apple_motion.
Yeah, I’ve seen your post. Pretty cool.
However, I want to use perlin noise in a vertex shader, not fragment.

anon_38331066 · January 14, 2010, 5:48am

I see. the issue should be come from the permutation table since we can’t read the texture data in the vertex shader. (well, in GLSL seem to fine… :p)

However, it may possible to pass in those data by 16 uniform matrix4x4 as an array. (I not test it yet, but sound possible. If I have time I will do the test too

Edit: Although, the matrix array can’t be passed directly, but the following should work

var S:Shader;

function Start () 
{
	var m = new Matrix4x4[16];
	
	m[15].SetRow (0, Vector4(1,0,0,1));
	
	if(S)
	{
		for(i=0;i<16;i++)
		{
			S.SetGlobalMatrix ("pt_"+i, m[i]);
		}		
		renderer.material = new Material (S);
	}
}

Shader "permutation_table" 
{
	Properties 
	{
	}
	SubShader 
	{
		Pass
		{
//---------------------------------- CGPROGRAM ----

CGPROGRAM
#pragma vertex 	vertex_shader
#define gl_mvp glstate.matrix.mvp

float4x4 pt_0;
float4x4 pt_1;
float4x4 pt_2;
float4x4 pt_3;
float4x4 pt_4;
float4x4 pt_5;
float4x4 pt_6;
float4x4 pt_7;
float4x4 pt_8;
float4x4 pt_9;
float4x4 pt_10;
float4x4 pt_11;
float4x4 pt_12;
float4x4 pt_13;
float4x4 pt_14;
float4x4 pt_15;

struct src 
{
	float4 vertex	: POSITION;
	float4 color	: COLOR;
};

void vertex_shader( src IN,
					out float4 position : POSITION,
					out float4 color 	: COLOR		)
{														
	float4x4 pt[] = { 	pt_0, pt_1, pt_2, pt_3,
						pt_4, pt_5, pt_6, pt_7,
						pt_8, pt_9, pt_10,pt_11,
						pt_12,pt_13,pt_14,pt_15 };

	color    = pt[15][0];
	position = mul(gl_mvp, IN.vertex);
}

ENDCG

//---------------------------------- ENDCG -----		
		}// Pass
	}// SubShader 
}//Shader

ivkoni · January 14, 2010, 8:01pm

Thank you very much sir. I will try this approach when I get a chance. Looks very promising.

When you say:

Did you try it in unity?

from the reference:

I would like to try it with GLSL as well, but there isn’t a simple example showing how to use it…

ivkoni · January 15, 2010, 2:11am

hehe

nice try, but no cigar:

Cg in program 'vert': error C6016: Profile requires arrays with non-constant indexes to be uniform at line 180

and if I put uniform:

Cg in program 'vert': error C5056: 'uniform' not allowed on local variable 'pg' at line 169

and if I pass it in as a const uniform from another function:

Cg in program 'vert': error C6016: Profile requires arrays with non-constant indexes to be uniform at line 180

Arrays simply don’t work in unity’s implementation of CG. I also found a post by Aras confirming it. I will stop trying to use them now…

anon_38331066 · January 15, 2010, 4:03am

Agreed, we should take a rest on this topic. I tried last night but no luck too. Its create another issue

Well, array do work on shader but it need to take a special care…

for example… (pt_0 to pt_15 are float4x4)

	float4x4 p0[] = { 	pt_0, pt_1, pt_2, pt_3,
						pt_4, pt_5, pt_6, pt_7,
						pt_8, pt_9, pt_10,pt_11,
						pt_12,pt_13,pt_14,pt_15 };
	
	int i, j, k;
	
	float p = 0;
	for(i=0;i<16;i++) 
	{
		for(j=0;j<4;j++)
		{
			for(k=0;k<4;k++)
			{
				p = p +p0[i][j][k];
			}
		}
	}	
	return p;

… this is work after the “for” loops are unrolled, the indexes still constant, but it will create too many instruction that may over the limit of the system.

GLSL? I saw some books said that texture function work in vertex shader. of course, not in unity.

ivkoni · January 15, 2010, 5:11pm

Thank you very much for your time and effort on this. I really appreaciate it. Hopefully support for global vars and arrays will be added sometime in the future.

system · January 17, 2010, 12:11am

Here’s a different way of doing it based on Hugo Elias’ 2d perlin noise generator from his website with a few tweaks to convince the Cg compiler to optimise. It compiles to a huge shader, so it only works on Direct3D vs3.0.

Shader "Shaders/Perlin" 
{ 
   Properties 
   {             
       
      _Scale    ("Scale", Float) = 1 
      _Speed    ("Speed", Float) = 1 
	  _Seed	("Seed",Float) = 0.123456789
	  _Persist ("Persist" , Float ) = 2.0

   }    
   SubShader 
   { 
      Pass 
      {    
CGPROGRAM
#pragma target 3.0   
#pragma only_renderers d3d9
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_builtin
#pragma fragmentoption ARB_fog_exp2
#pragma fragmentoption ARB_precision_hint_fastest
#include "UnityCG.cginc"

struct a2v 
{ 
   float4 vertex : POSITION;
   float4 color   : COLOR; 
}; 

struct v2f { 
    float4 vertex : POSITION;
    float4 color : COLOR; 
}; 

uniform float _Seed;

// simple GPU random number generator
//	based on from [url]http://www.m3xbox.com/GPU_blog/?p=28[/url]
float Rand( float2 inpos )
{
	float2 input =  inpos;
	const float2 randvec = float2(15.12345, 91.98765);
	float	 randangle = dot( input ,  randvec );
	float rand = sin( randangle ) * 115309.76543;
	return 1.0 - 2.0 * fract(rand);
}

float Rand4( float2 pos,float2 in1, float2 in2, float2 in3, float2 in4)
{
       vec2 s = vec2 (12.9898,78.233);        
	   vec4 tmp = vec4( dot(in1,s),dot(in2,s),dot(in3,s),dot(in4,s));        
	   vec4 res =fract(tan(tmp)  * 43758.5453); 
	   vec2 p = fract( pos );
	   vec2 q = 1.0 - p;
	   vec4 w=vec4(q.x*q.y,p.x*q.y,p.x*p.y,q.x*p.y);        
	   return dot(res,w); 
}

// 2D Perlin noise from
// [url]http://freespace.virgin.net/hugo.elias/models/m_perlin.htm[/url]
float SmoothNoise( float2 inpos )
{
	float xplus1   = inpos.x+1;
	float xminus1 = inpos.x -1;
	float yplus1   = inpos.y+1;
	float yminus1 = inpos.y -1;	
	
	// corners
	float corners = Rand4(inpos,float2( xminus1 , yminus1 ),float2( xplus1 , yminus1 ),
		float2( xminus1 , yplus1 ) , float2( xplus1 , yplus1 ));
	corners /= 16;
	
	// sides
	float sides = Rand4( inpos,float2( xminus1 , inpos.y )  , float2( xplus1 , inpos.y ) ,
			float2( inpos.x , yminus1 )  ,  float2( inpos.x , yplus1 ) );

	sides /= 8;
	
	// centre
	float centre = Rand( inpos ) / 4;

	return corners + sides + centre; 
}

float InterpolateNoise( float2 inpos )
{
	float2 integer 		= floor( inpos );
	float2 fractional 	= frac( inpos );
	
	float xplus1 = integer.x +1;
	float yplus1 = integer.y +1;
	
	float v1 = SmoothNoise( integer );
	float v2 = SmoothNoise( float2( xplus1 , integer.y ) );
	float v3 = SmoothNoise( float2( integer.x , yplus1 ) );
	float v4 = SmoothNoise( float2( xplus1, yplus1 ) );
	
	float i1 = lerp( v1 , v2 , fractional.x );
	float i2 = lerp( v3 , v4 , fractional.x );
	
	return lerp( i1 , i2 , fractional.y );
}

uniform float _Persist;

float Perlin2D( float2 inpos )
{

	float total = 0;
	for(int i = 0; i<4; i++)
	{
		float frequency = pow( 2 , i );
		float amplitude = pow( _Persist , i );
			
		total += InterpolateNoise( inpos * frequency ) * amplitude;		
	}
	
	return total;
}


uniform float _Speed;
uniform float _Scale;

v2f vert(a2v IN) 
{ 
	v2f OUT; 
	
   float timex = _Time.y * _Speed + 0.1365143; 
   float timey = _Time.y * _Speed + 1.21688; 
   float timez = _Time.y * _Speed + 2.5564;
	
	IN.vertex.x += Perlin2D( ( IN.vertex.xy +timex )  * _Scale);
	IN.vertex.y += Perlin2D( ( IN.vertex.xy +timey )  * _Scale);
	IN.vertex.z += Perlin2D( ( IN.vertex.xy +timez )  * _Scale);
	
	OUT.vertex    = mul(glstate.matrix.mvp, IN.vertex); 
	OUT.color = IN.color; 
    
	return OUT; 
}

half4 frag( v2f IN ) : COLOR { 
    half4 OUT; 
   OUT = IN.color; 
   return OUT; 
} 


ENDCG
	  }
	}
	FallBack "Diffuse"
}

anon_38331066 · January 17, 2010, 3:42am

Thanks gaustwick !

Yeah ! it is huge, its genatate over 6000+ instrutions and can’t run of my mac (of course :p)

But don’t mind, the random number generator on GPU is super useful. I looking for that for long time. Many Thanks again.

I will upload my version of perlin noise on vetex, when I learned how the merge in the code

amirebrahimi_1 · January 17, 2010, 3:55am

Just to throw in my own implementation that works on both GL/D3D for vertex noise and does not #pragma target 3.0 take a look at the attachment. This was used in an attempt to implement “painting with polygons” in Unity (google for that if you’re interested about the technique).

I didn’t bother cutting out the code just for initializing the constant table or the perlin code, so you’ll have to do that yourself

250871–9026–$noise_170.unitypackage (7.41 KB)

anon_38331066 · January 17, 2010, 4:53am

Thanks aebrahimi,

just a question, what is the different between vec4 and float4 in Cg? does all “vec” are conserved in constant memory and float are not ??

Topic		Replies	Views
Perlin noise - procedural shader Unity Engine Shaders	13	33965	February 6, 2014
Generating Water Textures with Perlin Noise Unity Engine Shaders	4	10887	July 5, 2012
on a quest for GPU Perlin noise Unity Engine Shaders	3	4332	September 3, 2013
Turbulence Library - Massive collection of complex and fast noise on the GPU (481245) Community Showcases	185	58459	May 4, 2017
Mie scatter + Reighleigh Scatter Shader No subshaders on GFX card, WHY?!?@# Unity Engine Shaders	7	2315	February 28, 2014

Perlin noise: no subshaders can run on this graphics card

Related topics