shader Archives - "Where to now?"

Tagshader

Android libgdx ShaderAssetLoader & StillModelLoader

May 11, 2013 / Jan Rabe / 0 Comments

I totally love how libgdx brings a lot of interfaces for your application to connect to the graphics library. For instance the asset manager is really thought through well in particular. It has some really useful methods like Assets.manager.getProgress(). Especially since you can easily write your own asset loader and be able to utilize the loading progress in your app.

1) Simply add your loader to the asset manager at some point.

AssetManager manager = new AssetManager();
manager.setLoader( StillModel.class, new StillModelAssetLoader( new InternalFileHandleResolver() ) );
manager.setLoader( ShaderProgram.class, new ShaderAssetLoader( new InternalFileHandleResolver() ) );

AssetManager manager = new AssetManager();

manager.setLoader( StillModel.class, new StillModelAssetLoader( new InternalFileHandleResolver() ) );

manager.setLoader( ShaderProgram.class, new ShaderAssetLoader( new InternalFileHandleResolver() ) );

2) load your assets at required places, e.g. loading screen
(Note: SHADER_PHONG = “data/Graphics/Shader/Phong”; and MODEL_TEAPOT = “data/Graphics/Shader/teapot.obj”)

manager.load( SHADER_PHONG, ShaderProgram.class );
manager.load( MODEL_TEAPOT, StillModel.class );

1 2	manager.load( SHADER_PHONG, ShaderProgram.class ); manager.load( MODEL_TEAPOT, StillModel.class );

3) get your shader or model wherever you need them

ShaderProgram phong = manager.get( SHADER_PHONG, ShaderProgram.class );
StillModel teapotMesh = manager.get( MODEL_TEAPOT, StillModel.class );

1 2	ShaderProgram phong = manager.get( SHADER_PHONG, ShaderProgram.class ); StillModel teapotMesh = manager.get( MODEL_TEAPOT, StillModel.class );

4) free the resource by unloading when you’re done with them (e.g. disposing your app; changing screens)

manager.unload( SHADER_PHONG );
manager.unload( MODEL_TEAPOT);

1 2	manager.unload( SHADER_PHONG ); manager.unload( MODEL_TEAPOT);

That’s the shader asset loader for loading custom shaders in libgdx. (Note: adapt your extensions)

public class ShaderAssetLoader extends SynchronousAssetLoader&lt;ShaderProgram, AssetLoaderParameters&gt; {

    private static final String VERTEX_SHADER_EXTENSION = ".vsh";
    private static final String FRAGMENT_SHADER_EXTENSION = ".fsh";

    public ShaderAssetLoader ( final FileHandleResolver resolver ) {
        super( resolver );
    }

    @Override
    public ShaderProgram load ( final AssetManager assetManager, final String fileName, final AssetLoaderParameters parameter ) {
        final ShaderProgram shader = new ShaderProgram( resolve( fileName + VERTEX_SHADER_EXTENSION ), resolve( fileName + FRAGMENT_SHADER_EXTENSION ) );
        if ( shader.isCompiled() == false ) {
            throw new IllegalStateException( shader.getLog() );
        }
        return shader;
    }

    @Override
    public Array getDependencies ( final String fileName, final AssetLoaderParameters parameter ) {
        return null;
    }
}

public class ShaderAssetLoader extends SynchronousAssetLoader<ShaderProgram, AssetLoaderParameters> {

private static final String VERTEX_SHADER_EXTENSION = ".vsh";

private static final String FRAGMENT_SHADER_EXTENSION = ".fsh";

public ShaderAssetLoader ( final FileHandleResolver resolver ) {

super( resolver );

}

@Override

public ShaderProgram load ( final AssetManager assetManager, final String fileName, final AssetLoaderParameters parameter ) {

final ShaderProgram shader = new ShaderProgram( resolve( fileName + VERTEX_SHADER_EXTENSION ), resolve( fileName + FRAGMENT_SHADER_EXTENSION ) );

if ( shader.isCompiled() == false ) {

throw new IllegalStateException( shader.getLog() );

}

return shader;

}

@Override

public Array getDependencies ( final String fileName, final AssetLoaderParameters parameter ) {

return null;

}

And here is the StillModel loader for loading 3D meshes:

public class StillModelAssetLoader extends SynchronousAssetLoader&lt;StillModel, AssetLoaderParameters&gt; {

    public StillModelAssetLoader ( FileHandleResolver resolver ) {
        super( resolver );
    }

    @Override
    public StillModel load ( AssetManager assetManager, String fileName, AssetLoaderParameters parameter ) {
        return ModelLoaderRegistry.loadStillModel( resolve( fileName ) );
    }

    @Override
    public Array getDependencies ( String fileName, AssetLoaderParameters parameter ) {
        return null;
    }
}

public class StillModelAssetLoader extends SynchronousAssetLoader<StillModel, AssetLoaderParameters> {

public StillModelAssetLoader ( FileHandleResolver resolver ) {

super( resolver );

}

@Override

public StillModel load ( AssetManager assetManager, String fileName, AssetLoaderParameters parameter ) {

return ModelLoaderRegistry.loadStillModel( resolve( fileName ) );

}

@Override

public Array getDependencies ( String fileName, AssetLoaderParameters parameter ) {

return null;

}

Conclusion: assets are handled well in libgdx :D

WebGL: Earth Texture Shader

December 29, 2012 / Jan Rabe / 0 Comments

At university my computer graphic professor Hartmut Schirmacher gave us an excercise to implement various effects on a sphere in webgl with shaders based on his given webgl framework. His framework made it fairly easy though. Well here it is:

The features are:

Day and night light with smooth transition
Day changes based on the month
Moving clouds, which alternate in intensity over time
Wireframe and equator ring for orientation purposes
Specular lights based on barythmetic map
Height based on topyographic map
~~Bump map~~ (work in progress)
Rotate with [Left click]
Drag with [Shift] + [Left click]
Zoom with [Alt] + [Left click]

All textures are taken from NASA’s Blue Marble collection.

This is my solution to cg2 exercersise a03.

WebGL: Robot

December 29, 2012 / Jan Rabe / 0 Comments

Another lovely javascript excerise. Just uncheck the animation to control it better.

This is my solution to cg2 exercersise a02.5-2.6.

WebGL: Backface Culling and Depth Test

December 29, 2012 / Jan Rabe / 0 Comments

One interesting part is the z-fighting, which doesn’t happen with polygon offset fill.

gl.polygonOffset(0.1, 0.1);
gl.enable(gl.POLYGON_OFFSET_FILL);
gl.drawElements(gl.TRIANGLES, this.indexBuffer.numIndices(), gl.UNSIGNED_SHORT, 0);
gl.disable(gl.POLYGON_OFFSET_FILL);

gl.polygonOffset(0.1, 0.1);

gl.enable(gl.POLYGON_OFFSET_FILL);

gl.drawElements(gl.TRIANGLES, this.indexBuffer.numIndices(), gl.UNSIGNED_SHORT, 0);

gl.disable(gl.POLYGON_OFFSET_FILL);

This is my solution to cg2 exercersise a02.1-2.4.

WebGL: warmup

December 29, 2012 / Jan Rabe / 0 Comments

What are the pros/cons of WebGL?
Read Quote of Henrik Bennetsen’s answer to What are the pros/cons of WebGL? on Quora

This is my “solution” to cg2 exercersise a00-warmup.

Shader to software skinning method conversation

December 17, 2012 / Jan Rabe / 3 Comments

An almost monolog on stackoverflow helped me to get skeleton animations at least usably working in render demo that I’ve put up in android market. By the way on how the shader computes mat4 * vec4 can be found in the opengles shading language specification.

All right I’ve got a mesh with around 8000+ vertices, it’s sekelon with up to 128 bones and all it’s bone keyframe transformations up to 400 each animation.

Ahri Skeleton

Ahri Mesh

On desktop I could use this in vertex shader in order to compute the skinning:

...
uniform mat4  u_BoneTransform[128];
in  vec3  in_Position;
in  vec3  in_Normal;
in  vec4  in_BoneID;
in  vec4  in_Weights;
...
void main(void) { 

    vec3 position = (in_Weights[0] * (u_BoneTransform[ int(in_BoneID[0]) ] * vec4(in_Position, 1.0)).xyz)+
                    (in_Weights[1] * (u_BoneTransform[ int(in_BoneID[1]) ] * vec4(in_Position, 1.0)).xyz)+
                    (in_Weights[2] * (u_BoneTransform[ int(in_BoneID[2]) ] * vec4(in_Position, 1.0)).xyz)+
                    (in_Weights[3] * (u_BoneTransform[ int(in_BoneID[3]) ] * vec4(in_Position, 1.0)).xyz);

    vec3 normal =   (in_Weights[0] * (u_BoneTransform[ int(in_BoneID[0]) ] * vec4(in_Normal, 0.0)).xyz) +
                    (in_Weights[1] * (u_BoneTransform[ int(in_BoneID[1]) ] * vec4(in_Normal, 0.0)).xyz) +
                    (in_Weights[2] * (u_BoneTransform[ int(in_BoneID[2]) ] * vec4(in_Normal, 0.0)).xyz) +
                    (in_Weights[3] * (u_BoneTransform[ int(in_BoneID[3]) ] * vec4(in_Normal, 0.0)).xyz);
    ...
}

...

uniform mat4 u_BoneTransform[128];

in vec3 in_Position;

in vec3 in_Normal;

in vec4 in_BoneID;

in vec4 in_Weights;

...

void main(void) {

vec3 position = (in_Weights[0] * (u_BoneTransform[ int(in_BoneID[0]) ] * vec4(in_Position, 1.0)).xyz)+

(in_Weights[1] * (u_BoneTransform[ int(in_BoneID[1]) ] * vec4(in_Position, 1.0)).xyz)+

(in_Weights[2] * (u_BoneTransform[ int(in_BoneID[2]) ] * vec4(in_Position, 1.0)).xyz)+

(in_Weights[3] * (u_BoneTransform[ int(in_BoneID[3]) ] * vec4(in_Position, 1.0)).xyz);

vec3 normal = (in_Weights[0] * (u_BoneTransform[ int(in_BoneID[0]) ] * vec4(in_Normal, 0.0)).xyz) +

(in_Weights[1] * (u_BoneTransform[ int(in_BoneID[1]) ] * vec4(in_Normal, 0.0)).xyz) +

(in_Weights[2] * (u_BoneTransform[ int(in_BoneID[2]) ] * vec4(in_Normal, 0.0)).xyz) +

(in_Weights[3] * (u_BoneTransform[ int(in_BoneID[3]) ] * vec4(in_Normal, 0.0)).xyz);

...

}

As you can see there are a lot of bones. On android I don’t have the luxury of wasting variables to make simple lookups. I’d need 128 mat4 * 4 vec4 = 512 shader uniform vector variables and my samsung galaxy s2 only supports 304. Anyway I can think of 2 solutions:

divide the mesh into an ‘ok’ amount of bones and render the mesh with less bone matrices
do the skinning in software and update the vertex/normal buffers

I’d prefer the first solution, because I’d have to update merely the bone matrices uniform each frame instead of the entire vertex buffer. At this point however I have no idea how to divide the mesh because each vertex can have up to 4 bone influences and so I implemented the 2nd choice for now. Work in progress…

Here is the equivalent java code:

/**
 * skinning
 * @param w weights ==  in_Weights
 * @param i bone influence indices == in_BoneID
 * @param m bone transformation matrix == u_BoneTransform[128]
 * @param t target vector == in_Position
 * @param f flag 1 == in_Position, 0 == in_Normal
 */
public static void marryBonesWithVector(float[] w, int[] i, Matrix4[] m, Vector3 t, float f) {
    t.set(
            // x influence for bone 1
            w[0] * (m[i[0]].values[0] * t.x + m[i[0]].values[4] * t.y + m[i[0]].values[8] * t.z + m[i[0]].values[12] * f) +
            // x influence for bone 2
            w[1] * (m[i[1]].values[0] * t.x + m[i[1]].values[4] * t.y + m[i[1]].values[8] * t.z + m[i[1]].values[12] * f) +
            // x influence for bone 3
            w[2] * (m[i[2]].values[0] * t.x + m[i[2]].values[4] * t.y + m[i[2]].values[8] * t.z + m[i[2]].values[12] * f) +
            // x influence for bone 4
            w[3] * (m[i[3]].values[0] * t.x + m[i[3]].values[4] * t.y + m[i[3]].values[8] * t.z + m[i[3]].values[12] * f),

            // y influence for bone 1
            w[0] * (m[i[0]].values[1] * t.x + m[i[0]].values[5] * t.y + m[i[0]].values[9] * t.z + m[i[0]].values[13] * f) +
            // y influence for bone 2
            w[1] * (m[i[1]].values[1] * t.x + m[i[1]].values[5] * t.y + m[i[1]].values[9] * t.z + m[i[1]].values[13] * f) +
            // y influence for bone 3
            w[2] * (m[i[2]].values[1] * t.x + m[i[2]].values[5] * t.y + m[i[2]].values[9] * t.z + m[i[2]].values[13] * f) +
            // y influence for bone 4
            w[3] * (m[i[3]].values[1] * t.x + m[i[3]].values[5] * t.y + m[i[3]].values[9] * t.z + m[i[3]].values[13] * f),

            // z influence for bone 1
            w[0] * (m[i[0]].values[2] * t.x + m[i[0]].values[6] * t.y + m[i[0]].values[10] * t.z + m[i[0]].values[14] * f) +
            // z influence for bone 1
            w[1] * (m[i[1]].values[2] * t.x + m[i[1]].values[6] * t.y + m[i[1]].values[10] * t.z + m[i[1]].values[14] * f) +
            // z influence for bone 1
            w[2] * (m[i[2]].values[2] * t.x + m[i[2]].values[6] * t.y + m[i[2]].values[10] * t.z + m[i[2]].values[14] * f) +
            // z influence for bone 1
            w[3] * (m[i[3]].values[2] * t.x + m[i[3]].values[6] * t.y + m[i[3]].values[10] * t.z + m[i[3]].values[14] * f)
    );
}

/**

* skinning

* @param w weights == in_Weights

* @param i bone influence indices == in_BoneID

* @param m bone transformation matrix == u_BoneTransform[128]

* @param t target vector == in_Position

* @param f flag 1 == in_Position, 0 == in_Normal

public static void marryBonesWithVector(float[] w, int[] i, Matrix4[] m, Vector3 t, float f) {

t.set(

// x influence for bone 1

w[0] * (m[i[0]].values[0] * t.x + m[i[0]].values[4] * t.y + m[i[0]].values[8] * t.z + m[i[0]].values[12] * f) +

// x influence for bone 2

w[1] * (m[i[1]].values[0] * t.x + m[i[1]].values[4] * t.y + m[i[1]].values[8] * t.z + m[i[1]].values[12] * f) +

// x influence for bone 3

w[2] * (m[i[2]].values[0] * t.x + m[i[2]].values[4] * t.y + m[i[2]].values[8] * t.z + m[i[2]].values[12] * f) +

// x influence for bone 4

w[3] * (m[i[3]].values[0] * t.x + m[i[3]].values[4] * t.y + m[i[3]].values[8] * t.z + m[i[3]].values[12] * f),

// y influence for bone 1

w[0] * (m[i[0]].values[1] * t.x + m[i[0]].values[5] * t.y + m[i[0]].values[9] * t.z + m[i[0]].values[13] * f) +

// y influence for bone 2

w[1] * (m[i[1]].values[1] * t.x + m[i[1]].values[5] * t.y + m[i[1]].values[9] * t.z + m[i[1]].values[13] * f) +

// y influence for bone 3

w[2] * (m[i[2]].values[1] * t.x + m[i[2]].values[5] * t.y + m[i[2]].values[9] * t.z + m[i[2]].values[13] * f) +

// y influence for bone 4

w[3] * (m[i[3]].values[1] * t.x + m[i[3]].values[5] * t.y + m[i[3]].values[9] * t.z + m[i[3]].values[13] * f),

// z influence for bone 1

w[0] * (m[i[0]].values[2] * t.x + m[i[0]].values[6] * t.y + m[i[0]].values[10] * t.z + m[i[0]].values[14] * f) +

// z influence for bone 1

w[1] * (m[i[1]].values[2] * t.x + m[i[1]].values[6] * t.y + m[i[1]].values[10] * t.z + m[i[1]].values[14] * f) +

// z influence for bone 1

w[2] * (m[i[2]].values[2] * t.x + m[i[2]].values[6] * t.y + m[i[2]].values[10] * t.z + m[i[2]].values[14] * f) +

// z influence for bone 1

w[3] * (m[i[3]].values[2] * t.x + m[i[3]].values[6] * t.y + m[i[3]].values[10] * t.z + m[i[3]].values[14] * f)

);

}

Earth Seasons Shader for Android

December 16, 2012 / Jan Rabe / 0 Comments

In computer graphic 2 we were supposed to create a earth seasons shader. Here is the one I did for android:

Simple vertex shader

precision mediump float;

// uniforms
uniform mat4 u_ModelViewMatrix;
uniform mat4 u_WorldView;
uniform mat4 u_WorldViewProjection;
uniform vec3 u_LightPosition;

// in
attribute vec3 in_Position;
attribute vec3 in_Normal;
attribute vec2 in_TexCoords;

// out
varying vec3 v_Position;
varying vec3 v_Normal;
varying vec3 v_EyeDir;
varying vec2 v_TexCoords;

void main() {
    mat4 m_ModelWorldView = u_WorldView * u_ModelViewMatrix;
    // position
    v_Position =  (m_ModelWorldView * vec4(in_Position, 1.0)).xyz;
    gl_Position = u_WorldViewProjection * vec4(v_Position,1.0);
    // normal
    v_Normal = ( normalize( m_ModelWorldView * vec4(in_Normal, 0.0) ) ).xyz;
    // lightning
    v_EyeDir = -v_Position.xyz;
    // uv
    v_TexCoords = in_TexCoords;
}

precision mediump float;

// uniforms

uniform mat4 u_ModelViewMatrix;

uniform mat4 u_WorldView;

uniform mat4 u_WorldViewProjection;

uniform vec3 u_LightPosition;

// in

attribute vec3 in_Position;

attribute vec3 in_Normal;

attribute vec2 in_TexCoords;

// out

varying vec3 v_Position;

varying vec3 v_Normal;

varying vec3 v_EyeDir;

varying vec2 v_TexCoords;

void main() {

mat4 m_ModelWorldView = u_WorldView * u_ModelViewMatrix;

// position

v_Position = (m_ModelWorldView * vec4(in_Position, 1.0)).xyz;

gl_Position = u_WorldViewProjection * vec4(v_Position,1.0);

// normal

v_Normal = ( normalize( m_ModelWorldView * vec4(in_Normal, 0.0) ) ).xyz;

// lightning

v_EyeDir = -v_Position.xyz;

// uv

v_TexCoords = in_TexCoords;

}

and the fragment/pixel shader:

precision mediump float;

// phong material
struct PhongMaterial
{
   vec4 ambient;     // Acm
   vec4 diffuse;     // Dcm
   vec4 specular;    // Scm
   float shininess;  // Srm
};

// uniforms
uniform PhongMaterial material;

uniform mat4 u_WorldViewProjection;

uniform sampler2D texture_01; // day and seasonal
uniform sampler2D texture_02; // night
uniform sampler2D texture_03; // clouds
uniform sampler2D texture_04; // specular
uniform sampler2D texture_05; // bump map
uniform int u_ShowClouds;
int u_LightOn = 1;
uniform vec3 u_LightPosition;
uniform vec3 u_LightDirection;
uniform vec3 u_LightIntensity;
vec3 u_LightColor = vec3(1.0, 1.0, 1.0);
uniform vec2 u_CloudShift;
uniform float u_CloudIntensity;
int u_ShowNight = 1;

vec3 ambientLight = vec3(0.4, 0.4, 0.4);

// in
varying vec3 v_Position;
varying vec3 v_Normal;
varying vec3 v_EyeDir;
varying vec2 v_TexCoords;

vec3 getDayNightColor(sampler2D day, sampler2D night, vec2 uv, float cosineAngleSunToNormal) {
    vec3 dayColor = texture2D( day, uv ).rgb;
    vec3 nightColor = texture2D( night, uv ).rgb;

    // sharpen the edge beween the transition
    cosineAngleSunToNormal = clamp( cosineAngleSunToNormal * 5.0, -1.0, 1.0);

    // convert to 0 to 1 for mixing
    float mixAmount = cosineAngleSunToNormal * 0.5 + 0.5;

    // Select day or night texture based on mixAmount.
    return mix( nightColor, dayColor, mixAmount );
}

// clouds
vec4 clouds(vec3 baseColor, sampler2D cloudTexture, vec2 uv, float intensity, float cosineAngleSunToNormal) {
  // cloud map
  float c = texture2D(cloudTexture, uv).r;

   // sharpen the edge beween the transition
  cosineAngleSunToNormal = clamp( cosineAngleSunToNormal * 5.0, -1.0, 1.0);

  // convert to 0 to 1 for mixing
  float mixAmount = cosineAngleSunToNormal * 0.5 + 0.2;

  // mix intensity
  c = pow(c,intensity);

  // mixed cloud color
  vec4 mixedColor = vec4((1.0-c) * baseColor + c * vec3(1,1,1),1.0);

  return mix(vec4(baseColor,1.0),mixedColor, mixAmount);
}

/*
 Calculate surface color based on Phong illumination model.
 - pos:  position of point on surface, in eye coordinates
 - n:    surface normal at pos
 - v:    direction pointing towards the viewer, in eye coordinates
 + assuming directional light

 */
vec3 phong(vec3 pos, vec3 n, vec3 v, PhongMaterial material) {

    // ambient part
    vec3 ambient = material.ambient.rgb * ambientLight;

    // back face towards viewer?
    float ndotv = dot(n,v);
    if(ndotv<0.0)
        return vec3(0,0,0);

    // light enabled?
    if(u_LightOn != 1)
        return ambient + texture2D(texture_01, v_TexCoords).rgb;

    // vector from light to current point
    vec3 l = normalize(u_LightDirection);

    // cos of angle between light and surface. 0 = light behind surface
    float ndotl = dot(n,-l);

    // diffuse contribution
    vec3 diffuse;

    // day night
    if(u_ShowNight == 1)
        // compute day and night contribution
        diffuse = ambient + getDayNightColor(texture_01, texture_02, v_TexCoords, ndotl);
    else {
        // no light only ambient color
        if(ndotl<=0.0)
            return ambient;

        // compute day contribution only
        diffuse = texture2D(texture_01,v_TexCoords).rgb * u_LightColor * ndotl;
    }

    // clouds & night
    if(u_ShowClouds == 1)
        diffuse = clouds(diffuse, texture_03, mod(v_TexCoords+u_CloudShift,1.0), u_CloudIntensity, ndotl).rgb;

    // reflected light direction = perfect reflection direction
    vec3 r = reflect(l,n);

    // angle between reflection dir and viewing dir
    float rdotv = max( dot(r,v), 0.0);

    // shininess
    float shininess = material.shininess;

    // specular contribution
    vec3 ps = material.specular.rgb * u_LightColor * pow(rdotv,shininess);

    // mix specular map with specular
    vec3 specular =  ps;

    // return sum of all contributions
    return ambient + diffuse + specular;
}

void main() {

    // normalize normal after projection
    vec3 normalEC = normalize(v_Normal);

    // do we use a perspective or an orthogonal projection matrix?
    bool usePerspective = u_WorldViewProjection[2][3] != 0.0;

    // for perspective mode, the viewing direction (in eye coords) points
    // from the vertex to the origin (0,0,0) --> use -ecPosition as direction.
    // for orthogonal mode, the viewing direction is simply (0,0,1)
    vec3 viewdirEC = usePerspective ? normalize(-v_Position.xyz) : vec3(0,0,1);

    // calculate color using phong illumination
    vec3 phongColor = phong( v_Position.xyz, normalEC, viewdirEC, material);

    // set fragment color
    gl_FragColor = vec4(phongColor,1.0);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

precision mediump float;

// phong material

struct PhongMaterial

{

vec4 ambient; // Acm

vec4 diffuse; // Dcm

vec4 specular; // Scm

float shininess; // Srm

};

// uniforms

uniform PhongMaterial material;

uniform mat4 u_WorldViewProjection;

uniform sampler2D texture_01; // day and seasonal

uniform sampler2D texture_02; // night

uniform sampler2D texture_03; // clouds

uniform sampler2D texture_04; // specular

uniform sampler2D texture_05; // bump map

uniform int u_ShowClouds;

int u_LightOn = 1;

uniform vec3 u_LightPosition;

uniform vec3 u_LightDirection;

uniform vec3 u_LightIntensity;

vec3 u_LightColor = vec3(1.0, 1.0, 1.0);

uniform vec2 u_CloudShift;

uniform float u_CloudIntensity;

int u_ShowNight = 1;

vec3 ambientLight = vec3(0.4, 0.4, 0.4);

// in

varying vec3 v_Position;

varying vec3 v_Normal;

varying vec3 v_EyeDir;

varying vec2 v_TexCoords;

vec3 getDayNightColor(sampler2D day, sampler2D night, vec2 uv, float cosineAngleSunToNormal) {

vec3 dayColor = texture2D( day, uv ).rgb;

vec3 nightColor = texture2D( night, uv ).rgb;

// sharpen the edge beween the transition

cosineAngleSunToNormal = clamp( cosineAngleSunToNormal * 5.0, -1.0, 1.0);

// convert to 0 to 1 for mixing

float mixAmount = cosineAngleSunToNormal * 0.5 + 0.5;

// Select day or night texture based on mixAmount.

return mix( nightColor, dayColor, mixAmount );

}

// clouds

vec4 clouds(vec3 baseColor, sampler2D cloudTexture, vec2 uv, float intensity, float cosineAngleSunToNormal) {

// cloud map

float c = texture2D(cloudTexture, uv).r;

// sharpen the edge beween the transition

cosineAngleSunToNormal = clamp( cosineAngleSunToNormal * 5.0, -1.0, 1.0);

// convert to 0 to 1 for mixing

float mixAmount = cosineAngleSunToNormal * 0.5 + 0.2;

// mix intensity

c = pow(c,intensity);

// mixed cloud color

vec4 mixedColor = vec4((1.0-c) * baseColor + c * vec3(1,1,1),1.0);

return mix(vec4(baseColor,1.0),mixedColor, mixAmount);

}

Calculate surface color based on Phong illumination model.

- pos: position of point on surface, in eye coordinates

- n: surface normal at pos

- v: direction pointing towards the viewer, in eye coordinates

+ assuming directional light

vec3 phong(vec3 pos, vec3 n, vec3 v, PhongMaterial material) {

// ambient part

vec3 ambient = material.ambient.rgb * ambientLight;

// back face towards viewer?

float ndotv = dot(n,v);

if(ndotv<0.0)

return vec3(0,0,0);

// light enabled?

if(u_LightOn != 1)

return ambient + texture2D(texture_01, v_TexCoords).rgb;

// vector from light to current point

vec3 l = normalize(u_LightDirection);

// cos of angle between light and surface. 0 = light behind surface

float ndotl = dot(n,-l);

// diffuse contribution

vec3 diffuse;

// day night

if(u_ShowNight == 1)

// compute day and night contribution

diffuse = ambient + getDayNightColor(texture_01, texture_02, v_TexCoords, ndotl);

else {

// no light only ambient color

if(ndotl<=0.0)

return ambient;

// compute day contribution only

diffuse = texture2D(texture_01,v_TexCoords).rgb * u_LightColor * ndotl;

}

// clouds & night

if(u_ShowClouds == 1)

diffuse = clouds(diffuse, texture_03, mod(v_TexCoords+u_CloudShift,1.0), u_CloudIntensity, ndotl).rgb;

// reflected light direction = perfect reflection direction

vec3 r = reflect(l,n);

// angle between reflection dir and viewing dir

float rdotv = max( dot(r,v), 0.0);

// shininess

float shininess = material.shininess;

// specular contribution

vec3 ps = material.specular.rgb * u_LightColor * pow(rdotv,shininess);

// mix specular map with specular

vec3 specular = ps;

// return sum of all contributions

return ambient + diffuse + specular;

}

void main() {

// normalize normal after projection

vec3 normalEC = normalize(v_Normal);

// do we use a perspective or an orthogonal projection matrix?

bool usePerspective = u_WorldViewProjection[2][3] != 0.0;

// for perspective mode, the viewing direction (in eye coords) points

// from the vertex to the origin (0,0,0) --> use -ecPosition as direction.

// for orthogonal mode, the viewing direction is simply (0,0,1)

vec3 viewdirEC = usePerspective ? normalize(-v_Position.xyz) : vec3(0,0,1);

// calculate color using phong illumination

vec3 phongColor = phong( v_Position.xyz, normalEC, viewdirEC, material);

// set fragment color

gl_FragColor = vec4(phongColor,1.0);

}

Maybe this isn’t the most efficient way but it is a way and one that works nonetheless. (:

Theme by Anders Norén — Up ↑

My Tweets

Frequently visiting

My Cloud

Amazing people

Favorite Tools

APIs

Online Tools

Tutorials

My Latest Animes

Tagshader

Android libgdx ShaderAssetLoader & StillModelLoader

WebGL: Earth Texture Shader

WebGL: Robot

WebGL: Backface Culling and Depth Test

WebGL: warmup

Shader to software skinning method conversation

Earth Seasons Shader for Android