// Initialization code
void init()
{
	// Initializes the glew library
	glewInit();
	glEnable(GL_DEPTH_TEST);

	//Create shader program
	std::string vertShader = readShader("VertexShader.glsl");
	std::string fragShader = readShader("FragmentShader.glsl");

	vertex_shader = createShader(vertShader, GL_VERTEX_SHADER);
	fragment_shader = createShader(fragShader, GL_FRAGMENT_SHADER);

	program = glCreateProgram();
	glAttachShader(program, vertex_shader);
	glAttachShader(program, fragment_shader);
	glLinkProgram(program);

	//Generate the View Projection matrix
	glm::mat4 view = glm::lookAt(glm::vec3(0.0f, 0.0f, 2.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
	glm::mat4 proj = glm::perspective(45.0f, 800.0f / 800.0f, 0.1f, 100.0f);
	VP = proj * view;

	//Get uniforms
	uniMVP = glGetUniformLocation(program, "MVP");
	uniHue = glGetUniformLocation(program, "hue");

	//Set options
	glFrontFace(GL_CCW);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

//------------------------------------------------------------------------------
GLuint loadProgram( const std::string &name ){
    GLuint program{0};

    std::vector<GLuint> shaders;
    std::list<std::string> available = {"1.20","3.30"};

    std::string glslv;

    const GLubyte * glslVersion = glGetString( GL_SHADING_LANGUAGE_VERSION );
    std::string sv(reinterpret_cast<const char*>(glslVersion));

    for( auto i = available.begin(); i != available.end() ; ++i ){
        if( 0 == sv.find(*i) ){
            glslv = *i;
            break;
        }
    }

    if( "" == glslv ){
        printf( "Invalid shader version: %s\n", sv.c_str());
        exit(EXIT_FAILURE);
    }

    std::string strVertexShader = name+"."+glslv+".vert";
    std::string strFragmentShader = name+"."+glslv+".frag";

    shaders.push_back( createShader( GL_VERTEX_SHADER, strVertexShader ) );
    shaders.push_back( createShader( GL_FRAGMENT_SHADER, strFragmentShader ) );

    program = createProgram( shaders );

    std::for_each( shaders.begin(), shaders.end(), glDeleteShader );

    return program;
}

	bool COGLES2SLMaterialRenderer::init(s32& outMaterialTypeNr,
			const c8* vertexShaderProgram,
			const c8* pixelShaderProgram,
			bool registerMaterial )
	{
		outMaterialTypeNr = -1;

		if ( Program == 0 && !createProgram() )
			return false;

		if ( vertexShaderProgram )
			if ( !createShader( GL_VERTEX_SHADER, vertexShaderProgram, "" ) )
				return false;

		if ( pixelShaderProgram )
			if ( !createShader( GL_FRAGMENT_SHADER, pixelShaderProgram, "" ) )
				return false;

		for ( size_t i = 0; i < EVA_COUNT; ++i )
			glBindAttribLocation( Program, i, sBuiltInVertexAttributeNames[i] );

		if ( !linkProgram() )
			return false;

		// register myself as new material
		if ( registerMaterial )
			outMaterialTypeNr = Driver->addMaterialRenderer( this );
		return true;
	}

// bind shaders by vertex shader file and fragment shader fie
void CShader::createShaderProgram() {
    GLint vs = -1;
    GLint gs = -1;
    GLint ts = -1;
    GLint fs = -1;

    vs = createShader( _vs.c_str(), GL_VERTEX_SHADER );
    fs = createShader( _fs.c_str(), GL_FRAGMENT_SHADER );
    assert(  vs >= 0 );
    assert(  fs >= 0 );

    if( _gs!= "" ) {
        gs = createShader( _gs.c_str(), GL_GEOMETRY_SHADER );
        assert( gs >= 0 );
    }

    // bypass tessellation shader for now
    if( _ts != "" ) {
        // ts = createShader( _ts.c_str(), gl_tessshader)
    }

    _sp = createShaderProgram( vs, gs, ts, fs );  
    
    _inited = true;
}

static GLuint createShaderProgram(const char *vertexShaderSrc, const char *fragmentShaderSrc) {
    GLuint program = glCreateProgram();
    glAttachShader(program, createShader(vertexShaderSrc, GL_VERTEX_SHADER));
    glAttachShader(program, createShader(fragmentShaderSrc, GL_FRAGMENT_SHADER));
    glLinkProgram(program);
    return program;
}

static void gl_init(void) {
    GLuint program = glCreateProgram();
    glAttachShader(program, createShader(vertex_shader  , GL_VERTEX_SHADER));
    glAttachShader(program, createShader(fragment_shader, GL_FRAGMENT_SHADER));
    glLinkProgram(program);
    char msg[512];
    glGetProgramInfoLog(program, sizeof msg, NULL, msg);
    std::cout << "info: " <<  msg << std::endl;
    glUseProgram(program);
    std::vector<float> elements(nbNodes);
    int count = 0;
    for (float x=0; x < nbNodes; ++x ) {
        elements[count] = count;
        ++count;
    }
    /*Create one texture to store all the needed information */
    glGenTextures(1, &nodeTexture);
    /* Store the vertices in a vertex buffer object (VBO) */
    glGenBuffers(1, &indicesVBO);
    glBindBuffer(GL_ARRAY_BUFFER, indicesVBO);
    glBufferData(GL_ARRAY_BUFFER, elements.size() * sizeof(float), &elements[0], GL_STATIC_DRAW);
    /* Get the locations of the uniforms so we can access them */
    nodeSamplerLocation      = glGetUniformLocation(program, "nodeInfo");
    glBindAttribLocation(program, 0, "indices");
#ifndef __EMSCRIPTEN__ // GLES2 & WebGL do not have these, only pre 3.0 desktop GL and compatibility mode GL3.0+ GL do.
    //Enable glPoint size in shader, always enable in Open Gl ES 2.
    glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
    glEnable(GL_POINT_SPRITE);
#endif
}

//------------------------------------------------------------------------------
// setupGenericShaders - This function is totally not needed on PC because there
// is fixed-function support in D3D9
//------------------------------------------------------------------------------
inline void GFXD3D9Device::setupGenericShaders( GenericShaderType type /* = GSColor */ )
{
#ifdef WANT_TO_SIMULATE_UI_ON_360
   if( mGenericShader[GSColor] == NULL )
   {
      mGenericShader[GSColor] =           createShader( "shaders/common/genericColorV.hlsl", 
         "shaders/common/genericColorP.hlsl", 
         2.f );

      mGenericShader[GSModColorTexture] = createShader( "shaders/common/genericModColorTextureV.hlsl", 
         "shaders/common/genericModColorTextureP.hlsl", 
         2.f );

      mGenericShader[GSAddColorTexture] = createShader( "shaders/common/genericAddColorTextureV.hlsl", 
         "shaders/common/genericAddColorTextureP.hlsl", 
         2.f );
   }

   mGenericShader[type]->process();

   MatrixF world, view, proj;
   mWorldMatrix[mWorldStackSize].transposeTo( world );
   mViewMatrix.transposeTo( view );
   mProjectionMatrix.transposeTo( proj );

   mTempMatrix = world * view * proj;

   setVertexShaderConstF( VC_WORLD_PROJ, (F32 *)&mTempMatrix, 4 );
#else
   disableShaders();
#endif
}

void COpenGLSLMaterialRenderer::init(s32& outMaterialTypeNr,
	const c8* vertexShaderProgram,
	const c8* pixelShaderProgram)
{
	outMaterialTypeNr = -1;

	if (!createProgram())
		return;

#if defined(GL_ARB_vertex_shader) && defined (GL_ARB_fragment_shader)
	if (vertexShaderProgram)
		if (!createShader(GL_VERTEX_SHADER_ARB, vertexShaderProgram))
			return;


	if (pixelShaderProgram)
		if (!createShader(GL_FRAGMENT_SHADER_ARB, pixelShaderProgram))
			return;
#endif

	if (!linkProgram())
		return;

	// register myself as new material
	outMaterialTypeNr = Driver->addMaterialRenderer(this);
}

	bool COGLES2SLMaterialRenderer::init(s32& outMaterialTypeNr,
			const c8* vertexShaderProgram,
			const c8* pixelShaderProgram,
			bool registerMaterial )
	{
		outMaterialTypeNr = -1;

		if ( Program == 0 && !createProgram() )
			return false;

		if ( vertexShaderProgram )
			if ( !createShader( GL_VERTEX_SHADER, vertexShaderProgram, "" ) )
				return false;

		if ( pixelShaderProgram )
			if ( !createShader( GL_FRAGMENT_SHADER, pixelShaderProgram, "" ) )
				return false;

		if ( !linkProgram() )
			return false;

		// register myself as new material
		if ( registerMaterial )
			outMaterialTypeNr = Driver->addMaterialRenderer( this );
		return true;
	}

void QEglFSCursor::createShaderPrograms()
{
    static const char *textureVertexProgram =
        "attribute highp vec2 vertexCoordEntry;\n"
        "attribute highp vec2 textureCoordEntry;\n"
        "varying highp vec2 textureCoord;\n"
        "void main() {\n"
        "   textureCoord = textureCoordEntry;\n"
        "   gl_Position = vec4(vertexCoordEntry, 1.0, 1.0);\n"
        "}\n";

    static const char *textureFragmentProgram =
        "uniform sampler2D texture;\n"
        "varying highp vec2 textureCoord;\n"
        "void main() {\n"
        "   gl_FragColor = texture2D(texture, textureCoord).bgra;\n"
        "}\n";

    GLuint vertexShader = createShader(GL_VERTEX_SHADER, textureVertexProgram);
    GLuint fragmentShader = createShader(GL_FRAGMENT_SHADER, textureFragmentProgram);
    m_program = createProgram(vertexShader, fragmentShader);
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    m_vertexCoordEntry = glGetAttribLocation(m_program, "vertexCoordEntry");
    m_textureCoordEntry = glGetAttribLocation(m_program, "textureCoordEntry");
    m_textureEntry = glGetUniformLocation(m_program, "texture");
}

/**
 * Compile the shader from file 'filename', with error handling
 */
int Shader::loadShader(string fileName){
	GLint link_ok = GL_FALSE;
	GLuint vs, fs;

	string vsName = fileName+".v.glsl";
	string fsName = fileName+".f.glsl";

	if ((vs = createShader(vsName.c_str(), GL_VERTEX_SHADER))   == 0) return 0;
	if ((fs = createShader(fsName.c_str(), GL_FRAGMENT_SHADER)) == 0) return 0;
	program = glCreateProgram();
	glAttachShader(program, vs);
	glAttachShader(program, fs);
	glLinkProgram(program);

	glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
	if (!link_ok) {
		logWar("glLinkProgram:");
		printShaderLog(program);
        glDeleteShader(vs);
        glDeleteShader(fs);
		return -1;
	}
    glDeleteShader(vs);
    glDeleteShader(fs);
	loadVars();
    return 0;
}

bool Cc3dProgram::initWithFile(const string&vertShaderFilePath,const string&fragShaderFilePath){
    m_vertShaderFilePath=vertShaderFilePath;
    m_fragShaderFilePath=fragShaderFilePath;
    //create shader
    vector<string> _vertShaderFileName=splitStrInTwoByLastDot(vertShaderFilePath);
    vector<string> _fragShaderFileName=splitStrInTwoByLastDot(fragShaderFilePath);
    //创建Program
    GLuint vertShader=createShader(_vertShaderFileName[0].c_str(), _vertShaderFileName[1].c_str());
    GLuint fragShader=createShader(_fragShaderFileName[0].c_str(), _fragShaderFileName[1].c_str());
    //Calls glCreateProgram, glAttachShader, and glLinkProgram to link the vertex and fragment shaders into a complete program.
    GLuint programHandle = glCreateProgram();
    glAttachShader(programHandle, vertShader);
    glAttachShader(programHandle, fragShader);
    
    //needs to be done prior to linking
    {
        glBindAttribLocation(programHandle, ATTRIB_LOC_position_local, "position_local");
        glBindAttribLocation(programHandle, ATTRIB_LOC_texCoord, "texCoordIn");
        glBindAttribLocation(programHandle, ATTRIB_LOC_normal_local, "normal_local");
    }
    glLinkProgram(programHandle);//link过以后，通过glGet**Location得到的索引就是固定的了
    //check and see if there were any link errors
    GLint linkSuccess;
    glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
    if (linkSuccess == GL_FALSE) {
        GLchar messages[1024];
        glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
        C3DASSERT(false,messages);
    }
    m_program=programHandle;
    return true;
}

	GLuint Shader::reload(void)
	{
		// Loesche den Shader Code aus dem Grafikspeicher und weise allen IDs den Wert 0 zu:
		deleteShader();
		m_VertexShader   = 0;
		m_FragmentShader = 0;
		m_ShaderProgram  = 0;

		// Create vertex shader
		m_VertexShader = createShader( GL_VERTEX_SHADER, m_VertexShaderFilename.c_str() );
		if(m_VertexShader == 0)
		{
			return 0;
		}
		
		// Create fragment shader
		m_FragmentShader = createShader( GL_FRAGMENT_SHADER, m_FragmentShaderFilename.c_str() );
		if(m_FragmentShader == 0)
		{
			return 0;
		}

		// Generate shader program
		m_ShaderProgram = createShaderProgram( m_VertexShader, m_FragmentShader );
		if(m_ShaderProgram == 0)
		{
			return 0;
		}

		// No errors
		return 1;
	}

	GLuint Shader::compile(void)
	{
		// Generate vertex shader
		m_VertexShader = createShader( GL_VERTEX_SHADER, m_VertexShaderFilename.c_str() );
		if(m_VertexShader == 0)
		{
			return 0;
		}
		
		// Generate fragment shader
		m_FragmentShader = createShader( GL_FRAGMENT_SHADER, m_FragmentShaderFilename.c_str() );
		if(m_FragmentShader == 0)
		{
			return 0;
		}

		// Generate shader program
		m_ShaderProgram = createShaderProgram( m_VertexShader, m_FragmentShader );
		if(m_ShaderProgram == 0)
		{
			return 0;
		}

		// No errors
		return 1;
	}

void Render::initialize(const std::string &frag, const std::string &vert, int numOfRects)
{
   initialized = true;
   GLenum err = glewInit();

      if (GLEW_OK != err)
      {
         std::cout<<boost::format("Glew error: %s\n") % glewGetErrorString(err);
         exit(1);
      }

      std::cout<<boost::format("Status: Using GLEW %s\n") % glewGetString(GLEW_VERSION);
   
      GLuint vertShader = createShader(vert, GL_VERTEX_SHADER);
   GLuint fragShader = createShader(frag, GL_FRAGMENT_SHADER);
   program = createProgram(vertShader,fragShader);

   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
   glEnable(GL_BLEND);


   createAndBindBuffers(numOfRects);
   activateProgram(program);
   bindTexture();
}

static void gl_init(void) {
    GLuint program = glCreateProgram();
    glAttachShader(program, createShader(vertex_shader  , GL_VERTEX_SHADER));
    glAttachShader(program, createShader(fragment_shader, GL_FRAGMENT_SHADER));
    glLinkProgram(program);
    char msg[512];
    glGetProgramInfoLog(program, sizeof msg, NULL, msg);
    std::cout << "info: " <<  msg << std::endl;
    glUseProgram(program);
    std::vector<float> elements(nbNodes);
    int count = 0;
    for (float x=0; x < nbNodes; ++x ) {
        elements[count] = count;
        ++count;
    }
    /*Create one texture to store all the needed information */
    glGenTextures(1, &nodeTexture);
    /* Store the vertices in a vertex buffer object (VBO) */
    glGenBuffers(1, &indicesVBO);
    glBindBuffer(GL_ARRAY_BUFFER, indicesVBO);
    float zeroes[nbNodes];
    memset(zeroes, 0, sizeof(zeroes));
    glBufferData(GL_ARRAY_BUFFER, elements.size() * sizeof(float), zeroes, GL_STATIC_DRAW);
    for (int x = 0; x < nbNodes; x++) {
      glBufferSubData(GL_ARRAY_BUFFER, x * sizeof(float), elements.size() * sizeof(float), &elements[x]);
    }
    /* Get the locations of the uniforms so we can access them */
    nodeSamplerLocation      = glGetUniformLocation(program, "nodeInfo");
    glBindAttribLocation(program, 0, "indices");
    //Enable glPoint size in shader, always enable in Open Gl ES 2.
    glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
    glEnable(GL_POINT_SPRITE);
}

//====================================================================================================================================
bool GPUProgram::createFromFiles( const std::string& _rstrVertexShaderPath, const std::string& _rstrGeometryShaderPath , const std::string& _rstrFragmentShaderPath )
{

    // required to have the OpenGL functions working - this is because of our use of OpenGL with Qt
    initializeOpenGLFunctions();


    const bool bUseGeometryShader = "" != _rstrGeometryShaderPath;

    // Creates the requested Shaders - or assert on error !
    m_iGPUVertexShaderID        = createShader( _rstrVertexShaderPath, GL_VERTEX_SHADER );
    m_iGPUFragmentShaderID      = createShader( _rstrFragmentShaderPath, GL_FRAGMENT_SHADER );



    if( bUseGeometryShader )
    {
        m_iGPUGeometryShaderID    = createShader( _rstrGeometryShaderPath, GL_GEOMETRY_SHADER );
    }

    // Creates the GPU Program
    m_iGPUProgramID = glCreateProgram();

    // Attaches a Vertex and a Fragmen Shader
    glAttachShader( m_iGPUProgramID, m_iGPUVertexShaderID );
    glAttachShader( m_iGPUProgramID, m_iGPUFragmentShaderID );

    if( bUseGeometryShader )
    {
        glAttachShader( m_iGPUProgramID, m_iGPUGeometryShaderID );
    }

    // Links the GPU Program to finally make it effective
    // NB : this will "copy" the attached Shaders into the Program, kinda like static C library linking
    glLinkProgram( m_iGPUProgramID );

    // Now you can detach the Shaders !
    // NB : You can even delete the Shaders
    //      if you don't want to use them for other GPU Programs
    //      => they are not needed, since linking "copied" them into the Program !
    // NB2: on some mobile device, the driver may not behave properly,
    // and won't like to have the Shaders to be detached !... But this is out of scope.
    glDetachShader( m_iGPUProgramID, m_iGPUVertexShaderID );
    glDetachShader( m_iGPUProgramID, m_iGPUFragmentShaderID );

    if( bUseGeometryShader )
    {
        glDetachShader( m_iGPUProgramID, m_iGPUGeometryShaderID );
    }

    destroyShader( m_iGPUVertexShaderID );
    destroyShader( m_iGPUFragmentShaderID );

    if( bUseGeometryShader )
    {
        destroyShader( m_iGPUGeometryShaderID );
    }

}

GPUuint Shader::fromFile(const std::string &vert, const std::string &frag)
{
	Array<GPUuint> shaderList;
	shaderList.push_back(createShader(vert));
	shaderList.push_back(createShader(frag));

	return createProgram(shaderList);
}

//GLSL shader program creation
GLuint createShaderProgram(const char *fileNameVS, const char *fileNameGS, const char *fileNameFS, GLuint programID)
{
	//Create a new GLSL program
	bool reload = (programID != 0);
	if(!reload){
		programID = glCreateProgram();
	}

	GLsizei count;
	GLuint shaders[3];
	glGetAttachedShaders(programID, 3, &count, shaders);
	GLuint vertexShaderID = 0;
	GLuint geometryShaderID = 0;
	GLuint fragmentShaderID = 0;

	for(GLsizei i=0; i<count; i++){
		GLint shadertype;
		glGetShaderiv(shaders[i], GL_SHADER_TYPE, &shadertype);
		if(shadertype == GL_VERTEX_SHADER){
			vertexShaderID = shaders[i];
		}else if(shadertype == GL_GEOMETRY_SHADER){
			geometryShaderID = shaders[i];
		}else if(shadertype == GL_FRAGMENT_SHADER){
			fragmentShaderID = shaders[i];
		}
	}

	if(fileNameVS){
		// Create vertex shader
		vertexShaderID=createShader(fileNameVS, GL_VERTEX_SHADER, vertexShaderID);
		if(!reload){
			// Attach vertex shader to program object
			glAttachShader(programID, vertexShaderID);
		}
	}

	if(fileNameGS){
		// Create geometry shader
		geometryShaderID=createShader(fileNameGS, GL_GEOMETRY_SHADER, geometryShaderID);
		if(!reload){
			// Attach vertex shader to program object
			glAttachShader(programID, geometryShaderID);
		}
	}
	
	if(fileNameFS){
		// Create fragment shader
		fragmentShaderID = createShader(fileNameFS, GL_FRAGMENT_SHADER, fragmentShaderID);
		if(!reload){
			// Attach fragment shader to program object
			glAttachShader(programID, fragmentShaderID);
		}
	}

	return programID;
}

void compileAndLinkGLProgram(ShaderProgram *program, std::string vertexShaderFileName, std::string fragmentShaderFileName) {
    LOGV("Creating shader program from %s and %s", vertexShaderFileName.c_str(), fragmentShaderFileName.c_str());

    GLuint vertexHandle = createShader(vertexShaderFileName, GL_VERTEX_SHADER);
    GLuint fragmentHandle = createShader(fragmentShaderFileName, GL_FRAGMENT_SHADER);
    GLuint programHandle = createProgram(vertexHandle, fragmentHandle);
    program->setHandles(programHandle, vertexHandle, fragmentHandle);

    //TODO: glErrors?
}