//translate lighting info into modelspace
modelSpaceVertexNormal = normal;
modelSpaceVertexPosition = vec3(modelMatrix * vec4(heightPosition,1.0));
modelSpacePointLightPositions[0] = vec3(modelMatrix * vec4(pointLightPositions[0],1.0));				

void main()
{
    //calculate vectors
    vec3 L = normalize(modelSpacePointLightPositions[0] - modelSpaceVertexPosition);
    vec3 N = normalize(modelSpaceVertexNormal);
    vec3 V = normalize(cameraPosition);

    //calculate lambert
    float lambertTerm = dot(N,L);

    //ambient is easiest, lets get that first
    pointAmbient = pointLightAmbients[0] * materialAmbient;

    pointDiffuse = lambertTerm * materialDiffuse * pointLightDiffuses[0];

    //calculations for specular
    vec3 R = reflect(L, N);
    float specular = pow( max(dot(R, V), 0.0), shininess);
    pointSpecular = specular * materialSpecular * pointLightSpeculars[0];

    pointIllumination = pointAmbient + pointDiffuse + pointSpecular;
    pointIllumination.a = 1.0;



    //RGBA
    //gl_FragColor = vec4(1.0,0.0,0.0,0.3);
    //gl_FragColor = pointLightSpeculars[0];
    gl_FragColor = pointIllumination;
}

//translate lighting info into viewspace
modelSpaceVertexNormal = normalMatrix * normal;
modelSpaceVertexPosition = vec3(modelViewMatrix * vec4(heightPosition,1.0));
modelSpacePointLightPositions[0] = vec3(viewMatrix * vec4(pointLightPositions[0],1.0));

Tres Burritos fucked around with this message at 01:38 on Sep 29, 2014

Joda fucked around with this message at 05:56 on Oct 6, 2014

HiriseSoftware fucked around with this message at 04:47 on Oct 10, 2014

// cube_vertices and cube_colors are just the data for a cube w/ corners from (-1,-1,-1) to (1,1,1)
void drawCube(const glm::vec3& position,
              const glm::vec3& size,
              const float angle,
              const glm::vec3& pose){
  glRotatef(angle, pose.x, pose.y, pose.z);
  glScalef(size.x, size.y, size.z);
  glTranslatef(position.x, position.y, position.z);

  /* We have a color array and a vertex array */
  glEnableClientState(GL_VERTEX_ARRAY);
  glEnableClientState(GL_COLOR_ARRAY);
  glVertexPointer(3, GL_FLOAT, 0, cube_vertices);
  glColorPointer(3, GL_FLOAT, 0, cube_colors);
  /* Send data : 24 vertices */
  glDrawArrays(GL_QUADS, 0, 24);

  /* Cleanup states */
  glDisableClientState(GL_COLOR_ARRAY);
  glDisableClientState(GL_VERTEX_ARRAY);

}

        drawCube(glm::vec3(0,0,0), glm::vec3(1,1,1), 0, glm::vec3(1,0,0));
        drawCube(glm::vec3(5,0,0), glm::vec3(1,1,1), 0, glm::vec3(1,0,0));
        drawCube(glm::vec3(0,5,0), glm::vec3(1,1,1), 0, glm::vec3(1,0,0));
        drawCube(glm::vec3(0,0,5), glm::vec3(1,1,1), 0, glm::vec3(1,0,0));

        drawCube(glm::vec3(0,0,0), glm::vec3(1,1,1), 0, glm::vec3(1,0,0));
        drawCube(glm::vec3(5,0,0), glm::vec3(1,1,1), 0, glm::vec3(1,0,0));
        drawCube(glm::vec3(0,5,0), glm::vec3(1,1,1), 45, glm::vec3(1,0,0));
        drawCube(glm::vec3(0,0,5), glm::vec3(1,1,1), 0, glm::vec3(1,0,0));

  glTranslatef(-position.x, -position.y, -position.z);
  glScalef(1/size.x, 1/size.y, 1/size.z);
  glRotatef(-angle, pose.x, pose.y, pose.z);

fritz fucked around with this message at 17:43 on Oct 17, 2014

/* Allocate and assign a Vertex Array Object to our handle */
glGenVertexArrays(1, &vao);
 
/* Bind our Vertex Array Object as the current used object */
glBindVertexArray(vao);

The_Franz fucked around with this message at 21:15 on Oct 24, 2014

roomforthetuna fucked around with this message at 18:16 on Oct 26, 2014

// Setup (the order of creation doesn't matter, just the binds)
glGenVertexArrays( ... ); // Create VAO
glBindVertexArray( ... ); // Bind it

glGenBuffers( ... ); // Create vertex buffer
glBindBuffer( GL_ARRAY_BUFFER, ... ); // This binding is NOT part of the VAO state

glGenBuffers( ... ); // Create index buffer 
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, ... ); // This binding IS part of the VAO state

glVertexAttribPointer( ... ); // The bound vertex buffer is stored in this attribute now!
glEnableVertexAttribArray( .. ); // Turn on that attribute



// Unbind the buffers just to make the point
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
glBindVertexArray( 0 );



// Draw
glClear( ... );
glEnable( ... );

glUseProgram( ... );
glUniform1ui( ... );

glBindVertexArray( ... ); // Index buffer and attrib pointers are now bound
glDrawElements( ... ); // Wheeeeee

Spatial fucked around with this message at 23:24 on Oct 28, 2014

roomforthetuna fucked around with this message at 02:25 on Oct 29, 2014

The_Franz fucked around with this message at 16:21 on Nov 4, 2014

[s][/s]
Shader "Unlit/Palette" 
{
	Properties 
	{
		_MainTex ("Base (Palette Indices)", 2D) = "white" {}
		_PaletteTex ("Palette (RGB)", 2D) = "white" {}
		_PaletteWidth ("Palette Width", Float) = 0
		_PaletteHeight ("Palette Height", Float) = 1
		_PaletteOffset ("Palette Offset", Float) = 0
		_PaletteLength ("Palette Length (all = 0)", Float) = 0
		_TransparentColourIndex ("Transparent Colour Index (-1 for none)", Float) = -1
	}

	SubShader 
	{
		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
		LOD 100
	
		ZWrite Off
		Blend SrcAlpha OneMinusSrcAlpha 

		Pass 
		{  
			CGPROGRAM
				#pragma vertex vert
				#pragma fragment frag
			
				#include "UnityCG.cginc"

				struct appdata_t {
					float4 vertex : POSITION;
					float2 texcoord : TEXCOORD0;
				};

				struct v2f {
					float4 vertex : SV_POSITION;
					half2 texcoord : TEXCOORD0;
				};

				sampler2D _MainTex;
				sampler2D _PaletteTex;
				float _PaletteWidth;
				float _PaletteHeight;
				float _PaletteOffset;
				float _PaletteLength;
				float _TransparentColourIndex;
				float4 _MainTex_ST;
			
				v2f vert (appdata_t v)
				{
					v2f o;
					o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
					o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);
					return o;
				}
			
				fixed4 frag (v2f i) : SV_Target
				{
					float4 col = tex2D(_MainTex, i.texcoord);
					unsigned int palIndex = floor((col.r * 255) + (col.g * 255) + (col.b * 255));

					_PaletteWidth = floor(_PaletteWidth);

					if(_PaletteLength == 0)
						_PaletteLength = _PaletteWidth;

					if(palIndex == floor(_TransparentColourIndex))
						return float4(0,0,0,0);

					float2 palettePosition = float2(((palIndex % floor(_PaletteLength)) + floor(_PaletteOffset)) % _PaletteWidth, 0);

					if(floor(palettePosition.x) == floor(_TransparentColourIndex))
						palettePosition.x = (palettePosition.x + 1) % _PaletteWidth;

					return tex2D(_PaletteTex, float2((palettePosition.x / _PaletteWidth) + 0.01, 0));
				}
			ENDCG
		}
	}
}

brian fucked around with this message at 11:18 on Nov 5, 2014