-----------------------GoldSrc version-----------------------
//=======================================
// CGLSLShader :: CompileShader
// Purpose:
//=======================================
bool CGLSLShader :: CompileShader( int index, glsl_shader_t* pshader, csdshaderdata_t* pshaderdata )
{
    int iStatus;
    const GLchar *vp = (GLchar*)((byte*)m_pCSDHeader + pshaderdata->vertexdataoffs);
    pshader->vertex_id = gImports.glCreateShader(GL_VERTEX_SHADER);
    gImports.glShaderSource(pshader->vertex_id, 1, &vp, &pshaderdata->vertexdatasize);
    gImports.glCompileShader(pshader->vertex_id);

    char szBasename[64];
    Sh_FilenameFromPath(m_szShaderFile, szBasename);

    static char szvsout[MAX_PATH];
    sprintf(szvsout, "logs/%s_%d_vs", szBasename, index);

    gImports.glGetShaderiv(pshader->vertex_id, GL_COMPILE_STATUS, &iStatus);
    if(iStatus != TRUE)
    {
        Shader_PrintLog(pshader->vertex_id, (char*)vp, pshaderdata->vertexdatasize, szvsout);
        sprintf(m_szErrorString, "Vertex shader %s failed to compile.\nLog file was written.\n", m_szShaderFile);
        return false;
    }

    const GLchar *fp = (GLchar*)((byte*)m_pCSDHeader + pshaderdata->fragmentdataoffs);
    pshader->fragment_id = gImports.glCreateShader(GL_FRAGMENT_SHADER);
    gImports.glShaderSource(pshader->fragment_id, 1, &fp, &pshaderdata->fragmentdatasize);
    gImports.glCompileShader(pshader->fragment_id);

    static char szfsout[MAX_PATH];
    sprintf(szfsout, "logs/%s_%d_fs", szBasename, index);

    gImports.glGetShaderiv(pshader->fragment_id, GL_COMPILE_STATUS, &iStatus);
    if(iStatus != TRUE)
    {
        Shader_PrintLog(pshader->fragment_id, (char*)fp, pshaderdata->fragmentdatasize, szfsout);
        sprintf(m_szErrorString, "Fragment shader %s failed to compile.\nLog file was written.\n", m_szShaderFile);
        return false;
    }

    pshader->program_id = gImports.glCreateProgram();
    gImports.glAttachShader(pshader->program_id, pshader->vertex_id);
    gImports.glAttachShader(pshader->program_id, pshader->fragment_id);
    gImports.glLinkProgram(pshader->program_id);

    static char szprogout[MAX_PATH];
    sprintf(szprogout, "logs/%s_%d_prog", szBasename, index);

    gImports.glGetProgramiv(pshader->program_id, GL_LINK_STATUS, &iStatus);
    if(iStatus != TRUE)
    {
        Shader_PrintLog(pshader->vertex_id, (char*)vp, pshaderdata->vertexdatasize, szvsout);
        Shader_PrintLog(pshader->fragment_id, (char*)fp, pshaderdata->fragmentdatasize, szfsout);
        Program_PrintLog(pshader->program_id, szprogout);

        sprintf(m_szErrorString, "Program %s failed to compile.\nLog file was written.\n", m_szShaderFile);
        return false;
    }

    // Flag it as compiled
    pshader->compiled = true;

    return true;
}


-----------------------Custom engine version-----------------------
//=============================================
// @brief Compiles a single unique shader
//
// @param index Index of the shader to compile
// @param pshader Shader information object
// @param pshaderdata Pointer to compiled shader data
// @return TRUE if the compile was successful, FALSE otherwise
//=============================================
bool CGLSLShader::CompileShader( Uint32 index, glsl_shader_t* pshader, csdshaderdata_t* pshaderdata )
{
    // Try to compile the vertex shader
    const Char *vp = (Char*)((byte*)m_pCSDHeader + pshaderdata->vertexdataoffs);
    pshader->vertex_id = m_glExtF.glCreateShader(GL_VERTEX_SHADER);
    m_glExtF.glShaderSource(pshader->vertex_id, 1, &vp, &pshaderdata->vertexdatasize);
    m_glExtF.glCompileShader(pshader->vertex_id);

    CString basename;
    COM_Basename(m_shaderFile.c_str(), basename);

    CString vsOut;
    vsOut << "logs/" << basename << "_" << (Int32)index << "_vs";

    Int32 iStatus = FALSE;
    m_glExtF.glGetShaderiv(pshader->vertex_id, GL_COMPILE_STATUS, &iStatus);
    if(iStatus != TRUE)
    {
        Shader_PrintLog(pshader->vertex_id, (Char*)vp, vsOut.c_str());
        m_errorString = "Vertex shader " + m_shaderFile + " failed to compile. Log file was written.";
        return false;
    }

    // Compile the fragment shader now
    const Char *fp = (Char*)((byte*)m_pCSDHeader + pshaderdata->fragmentdataoffs);
    pshader->fragment_id = m_glExtF.glCreateShader(GL_FRAGMENT_SHADER);
    m_glExtF.glShaderSource(pshader->fragment_id, 1, &fp, &pshaderdata->fragmentdatasize);
    m_glExtF.glCompileShader(pshader->fragment_id);

    CString fsOut;
    fsOut << "logs/" << basename << "_" << (Int32)index << "_fs";

    m_glExtF.glGetShaderiv(pshader->fragment_id, GL_COMPILE_STATUS, &iStatus);
    if(iStatus != TRUE)
    {
        Shader_PrintLog(pshader->fragment_id, (Char*)fp, fsOut.c_str());
        m_errorString = "Fragment shader " + m_shaderFile + " failed to compile. Log file was written.";
        return false;
    }

    // Link the two into one program
    pshader->program_id = m_glExtF.glCreateProgram();
    m_glExtF.glAttachShader(pshader->program_id, pshader->vertex_id);
    m_glExtF.glAttachShader(pshader->program_id, pshader->fragment_id);
    m_glExtF.glLinkProgram(pshader->program_id);

    CString progOut;
    progOut << "logs/" << basename << "_" << (Int32)index << "_prog";

    m_glExtF.glGetProgramiv(pshader->program_id, GL_LINK_STATUS, &iStatus);
    if(iStatus != TRUE)
    {
        Shader_PrintLog(pshader->vertex_id, (Char*)vp, vsOut.c_str());
        Shader_PrintLog(pshader->fragment_id, (Char*)fp, fsOut.c_str());
        Program_PrintLog(pshader->program_id, progOut.c_str());

        m_errorString = "Program " + m_shaderFile + " failed to compile. Log file was written.";
        return false;
    }

    // Flag it as compiled
    pshader->compiled = true;

    return true;
}


-----------------------Vertex shader-----------------------
#version 140

uniform mat4 projection;
uniform mat4 modelview;

in vec4 in_position;
in vec2 in_texcoord;

out vec2 ps_texcoord;

void main()
{
    ps_texcoord = in_texcoord;
    vec4 position = in_position*modelview;;
    gl_Position = position*projection;
}


-----------------------Fragment shader-----------------------
#version 140

uniform sampler2DRect texture0;
uniform vec4 color;
uniform float screenwidth;
uniform float screenheight;

in vec2 ps_texcoord;
out vec4 oColor;

uniform float timer;

const float permTexUnit = 1.0/256.0;        // Perm texture texel-size
const float permTexUnitHalf = 0.5/256.0;    // Half perm texture texel-size

const float grainamount = 0.05; //grain amount
float grainsize = 1.6; //grain particle size (1.5 - 2.5)
float lumamount = 1.0; //
float coloramount = 0.6;

//a random texture generator, but you can also use a pre-computed perturbation texture
vec4 rnm(in vec2 tc)
{
    float noise =  sin(dot(tc + vec2(timer,timer),vec2(12.9898,78.233))) * 43758.5453;

    float noiseR =  fract(noise)*2.0-1.0;
    float noiseG =  fract(noise*1.2154)*2.0-1.0;
    float noiseB =  fract(noise*1.3453)*2.0-1.0;
    float noiseA =  fract(noise*1.3647)*2.0-1.0;

    return vec4(noiseR,noiseG,noiseB,noiseA);
}

float fade(in float t) {
    return t*t*t*(t*(t*6.0-15.0)+10.0);
}

float pnoise3D(in vec3 p)
{
    vec3 pi = permTexUnit*floor(p)+permTexUnitHalf; // Integer part, scaled so +1 moves permTexUnit texel
    // and offset 1/2 texel to sample texel centers
    vec3 pf = fract(p);     // Fractional part for interpolation

    // Noise contributions from (x=0, y=0), z=0 and z=1
    float perm00 = rnm(pi.xy).a ;
    vec3  grad000 = rnm(vec2(perm00, pi.z)).rgb * 4.0 - 1.0;
    float n000 = dot(grad000, pf);
    vec3  grad001 = rnm(vec2(perm00, pi.z + permTexUnit)).rgb * 4.0 - 1.0;
    float n001 = dot(grad001, pf - vec3(0.0, 0.0, 1.0));

    // Noise contributions from (x=0, y=1), z=0 and z=1
    float perm01 = rnm(pi.xy + vec2(0.0, permTexUnit)).a ;
    vec3  grad010 = rnm(vec2(perm01, pi.z)).rgb * 4.0 - 1.0;
    float n010 = dot(grad010, pf - vec3(0.0, 1.0, 0.0));
    vec3  grad011 = rnm(vec2(perm01, pi.z + permTexUnit)).rgb * 4.0 - 1.0;
    float n011 = dot(grad011, pf - vec3(0.0, 1.0, 1.0));

    // Noise contributions from (x=1, y=0), z=0 and z=1
    float perm10 = rnm(pi.xy + vec2(permTexUnit, 0.0)).a ;
    vec3  grad100 = rnm(vec2(perm10, pi.z)).rgb * 4.0 - 1.0;
    float n100 = dot(grad100, pf - vec3(1.0, 0.0, 0.0));
    vec3  grad101 = rnm(vec2(perm10, pi.z + permTexUnit)).rgb * 4.0 - 1.0;
    float n101 = dot(grad101, pf - vec3(1.0, 0.0, 1.0));

    // Noise contributions from (x=1, y=1), z=0 and z=1
    float perm11 = rnm(pi.xy + vec2(permTexUnit, permTexUnit)).a ;
    vec3  grad110 = rnm(vec2(perm11, pi.z)).rgb * 4.0 - 1.0;
    float n110 = dot(grad110, pf - vec3(1.0, 1.0, 0.0));
    vec3  grad111 = rnm(vec2(perm11, pi.z + permTexUnit)).rgb * 4.0 - 1.0;
    float n111 = dot(grad111, pf - vec3(1.0, 1.0, 1.0));

    // Blend contributions along x
    vec4 n_x = mix(vec4(n000, n001, n010, n011), vec4(n100, n101, n110, n111), fade(pf.x));

    // Blend contributions along y
    vec2 n_xy = mix(n_x.xy, n_x.zw, fade(pf.y));

    // Blend contributions along z
    float n_xyz = mix(n_xy.x, n_xy.y, fade(pf.z));

    // We're done, return the final noise value.
    return n_xyz;
}

//2d coordinate orientation thing
vec2 coordRot(in vec2 tc, in float angle)
{
    float aspect = screenwidth/screenheight;
    float rotX = ((tc.x*2.0-1.0)*aspect*cos(angle)) - ((tc.y*2.0-1.0)*sin(angle));
    float rotY = ((tc.y*2.0-1.0)*cos(angle)) + ((tc.x*2.0-1.0)*aspect*sin(angle));
    rotX = ((rotX/aspect)*0.5+0.5);
    rotY = rotY*0.5+0.5;
    return vec2(rotX,rotY);
}

void main()
{
    vec2 norm_texcoords = vec2(ps_texcoord.x/screenwidth, ps_texcoord.y/screenheight);

    vec3 rotOffset = vec3(1.425,3.892,5.835); //rotation offset values
    vec2 rotCoordsR = coordRot(norm_texcoords, timer*0.25 + rotOffset.x);
    vec2 rotCoordsG = coordRot(norm_texcoords, timer*0.25 + rotOffset.y);
    vec2 rotCoordsB = coordRot(norm_texcoords, timer*0.25 + rotOffset.z);

    vec3 noise;
    noise.r = vec3(pnoise3D(vec3(rotCoordsR*vec2(screenwidth/grainsize,screenheight/grainsize),0.0))).r;
    noise.g = mix(noise.r,pnoise3D(vec3(rotCoordsG*vec2(screenwidth/grainsize,screenheight/grainsize),1.0)), coloramount);
    noise.b = mix(noise.r,pnoise3D(vec3(rotCoordsB*vec2(screenwidth/grainsize,screenheight/grainsize),2.0)), coloramount);

    vec3 col = texture(texture0, ps_texcoord).rgb;

    //noisiness response curve based on scene luminance
    vec3 lumcoeff = vec3(0.299,0.587,0.114);
    float luminance = mix(0.0,dot(col, lumcoeff),lumamount);
    luminance = clamp(luminance, 0.25, 0.75);
    float lum = smoothstep(0.2,0.0,luminance);
    lum += luminance;

    noise = mix(noise,vec3(0.0),pow(lum,4.0));
    col = col+noise*grainamount;

    oColor =  vec4(col,1.0);
}