source: GTP/trunk/App/Demos/Illum/IBRBillboardCloudTrees/Shark3D/demo_v5x0x7_t164x31u_enterpr_kwin32/bin/res/levelutil/shader/prog/ogl_glsl/partic_ogl_glsl_vs1x0.s3d_shadercode_run @ 2330

///////////////////////////////////////////////////////////////////////////////
//
//      ##  ######
//       ######  ###
//  ## ###############        Shark 3D Engine (www.shark3d.com)
//   ########## # # #
//    ########                Copyright (c) 1996-2006 Spinor GmbH.
//   ######### # # #          All rights reserved.
//  ##   ##########
//      ##
//
///////////////////////////////////////////////////////////////////////////////

@include "levelutil/shader/prog/ogl_glsl/" \
        "include_stddef_ogl_glsl_vs1x0.s3d_shadercode_run"

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

S3D_BONE_DECL_STD(boneWgh, boneSubscr)
S3D_MATBONE_DECL_STD(matBone)

uniform vec4 anim;        // Animation time between 0 and 1
uniform vec4 colorAlpha;  // Color and alpha factor
uniform vec4 param;       // x=Particle radius, y=Move-along-normal-factor
uniform vec4 moveLin;     // Linear movement vector
uniform vec4 moveQuadr;   // Quadratic movement vector
uniform vec4 moveVari;    // Variation amount, see below
uniform vec4 moveJiggle;  // Jiggle amount vector, see below.
uniform vec4 shrink;      // x=fadeIn, y=fadeOut, z=flickerAmp, w=flickerVel
uniform vec4 other;       // x=asyncFactor, y=repeat, z=jiggleVel, w=unused

///////////////////////////////////////////////////////////////////////////////
// Seed values:

vec4 seedVariX = vec4(8576, 6968, 8285, 1375);
vec4 seedVariY = vec4(9257, 7911, 4491, 4178);
vec4 seedVariZ = vec4(9621, 7416, 9166, 1405);
vec4 seedJiggleX = vec4(9809, 4760, 6104, 3046);
vec4 seedJiggleY = vec4(7590, 5729, 8471, 1556);
vec4 seedJiggleZ = vec4(9904, 0636, 4127, 5254);
vec4 seedAnim = vec4(8891, 1068, 3747, 5529);
vec4 seedRotU = vec4(3147, 0722, 3324, 7158);
vec4 seedRotV = vec4(7020, 4337, 7956, 1530);

///////////////////////////////////////////////////////////////////////////////
// Utility functions:

float quickSin(float phase)
{
    float rel = fract(phase) - 0.5;
    float val = - 16.0 * rel * (0.5 - abs(rel));
    return val;
}

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

void main(void)
{
    float animRandom =  dot(gl_Vertex, seedAnim);
    float curAnim = fract(other.x * animRandom + other.y * anim.x);
    
    // The movement direction is varied by a pseudo-random value.
    vec3 variRandom;
    variRandom.x = dot(gl_Vertex, seedVariX);
    variRandom.y = dot(gl_Vertex, seedVariY);
    variRandom.z = dot(gl_Vertex, seedVariZ);
    vec3 variUnit = (2.0 * fract(variRandom) - 1.0);
    vec3 variDelta = variUnit * moveVari.xyz;

    // The particles jiggle in direction of a pseudo-random value.
    vec3 jiggleRandom;
    jiggleRandom.x = dot(gl_Vertex, seedJiggleX);
    jiggleRandom.y = dot(gl_Vertex, seedJiggleY);
    jiggleRandom.z = dot(gl_Vertex, seedJiggleZ);
    vec3 jiggleUnit = (2.0 * fract(jiggleRandom) - 1.0);
    vec3 jiggleDelta = jiggleUnit * moveJiggle.xyz 
                    * quickSin(curAnim * other.z);
    
    // Move particle in object coordinates:
    vec3 moveTot = moveLin.xyz;             // Move into constant direction
    moveTot += gl_Normal * param.y;         // Move along normal vector
    moveTot += curAnim * moveQuadr.xyz;     // Move along a quadratic curve
    moveTot += variDelta;                   // Move into a random direction
    vec4 posObj = gl_Vertex;
    posObj.xyz += curAnim * moveTot;           // Add move
    posObj.xyz += jiggleDelta;              // Jitter

    // Transformation from object into view coordinates:
    S3D_BONE_TRANSF_STD(matBoneFinal, matBone, boneWgh, boneSubscr);
    vec4 posView = matBoneFinal * posObj;
    
    // Calculate effective particle radius.
    // This includes fading in, fading out and flickering.
    float fadeIn = curAnim * shrink.x;
    float fadeOut = (1.0 - curAnim) * shrink.y;
    float fade = min(1.0, min(fadeIn, fadeOut));
    float flicker = 1.0 - shrink.z * quickSin(curAnim * shrink.w); 
    float radius = param.x * flicker * fade;
    
    // Until now we only have the particle center.
    // Now we alculate the corner coordinates.
    // The particle is rotated by a pseudo-random angle:
    vec2 rotRandom;
    rotRandom.x = dot(gl_Vertex, seedRotU);
    rotRandom.y = dot(gl_Vertex, seedRotV);
    vec2 rotDir = normalize(fract(rotRandom) - vec2(0.5, 0.5));
    vec2 rotU = radius * 1.4142 * rotDir;
    vec2 rotV = vec2(- rotU.y, rotU.x);
    vec2 coord = (gl_MultiTexCoord0.xy - vec2(0.5, 0.5));
    posView.xy += rotU * coord.x + rotV * coord.y;

    // Projection:
    gl_Position = gl_ProjectionMatrix * posView; //
    gl_TexCoord[0] = gl_MultiTexCoord0;
    gl_FogFragCoord = posView.z / posView.w;

    vec4 diffuseOut = gl_FrontMaterial.emission;
    vec4 specularOut = vec4(0);

@ifdef S3D_LIGHT_CNT
// Work-around to detect nvidia:
#ifdef __GLSL_CG_DATA_TYPES
    for(int i = 0; i < gl_MaxLights; i++)
    {
        s3d_ColPair result;
        s3d_calcPointLightTerm(
                result, posView.xyz, normalView, gl_FrontMaterial.shininess, 
                gl_LightSource[i], gl_FrontLightProduct[i]);
        diffuseOut.rgb += result.diffuse.rgb;
        specularOut.rgb += result.specular.rgb;
    }
#else
    s3d_ColPair result;
    s3d_calcPointLightTerm(
            result, posView.xyz, vec3(0.0, 0.0, 0.0), 
            gl_FrontMaterial.shininess, 
            gl_LightSource[0], gl_FrontLightProduct[0]);
    diffuseOut.rgb += result.diffuse.rgb;
    specularOut.rgb += result.specular.rgb;
    
    s3d_calcPointLightTerm(
            result, posView.xyz, vec3(0.0, 0.0, 0.0), 
            gl_FrontMaterial.shininess, 
            gl_LightSource[1], gl_FrontLightProduct[1]);
    diffuseOut.rgb += result.diffuse.rgb;
    specularOut.rgb += result.specular.rgb;
    
    s3d_calcPointLightTerm(
            result, posView.xyz, vec3(0.0, 0.0, 0.0), 
            gl_FrontMaterial.shininess, 
            gl_LightSource[2], gl_FrontLightProduct[2]);
    diffuseOut.rgb += result.diffuse.rgb;
    specularOut.rgb += result.specular.rgb;         
#endif
    gl_FrontColor = diffuseOut * colorAlpha * gl_Color;
    gl_FrontSecondaryColor = specularOut;
@else
    gl_FrontColor = colorAlpha * gl_Color;
    gl_FrontSecondaryColor = vec4(0.0);
@endif
}

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