//Create the textures and obtain the handles
foreach instance
	glGenTextures(1, &this->gpuTextureId);
	glBindTexture(GL_TEXTURE_2D, this->gpuTextureId);
 
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ResX, ResY, 0, GL_RGBA, GL_UNSIGNED_BYTE, info); 
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);	// Linear Filtering
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);	// Linear Filtering
 
	// Get a handle for the texture.
	this->gpuTextureHandlerId = glGetTextureHandleNV(this->gpuTextureId);
 
	// Make the handle resident before using it.
	glMakeTextureHandleResidentNV(this->gpuTextureHandlerId);
endfor
//Pass the handle to the buffer
	#define INSTANCE_TEXTURE_LOCATION 6
 
	glGenBuffers(1, &this->instanceTextureHandlerVboId);
	glBindBuffer(this->instanceTextureHandlerVboId);
 
	glEnableVertexAttribArray(INSTANCE_TEXTURE_LOCATION);
	glVertexAttribPointer(INSTANCE_TEXTURE_LOCATION, 1, GL_UNSIGNED_INT64_NV, GL_FALSE, sizeof(GLuint64), 0); 
	glVertexAttribDivisor(INSTANCE_TEXTURE_LOCATION, 1);
 
	glBufferData(GL_ARRAY_BUFFER, sizeof(GLuint64) * this->numElements, instanceTextureHandle, GL_DYNAMIC_DRAW); //instanceTextureHandle contains the texture handles for all the instances.

#version 430
#extension GL_NV_bindless_texture : require
#extension GL_NV_gpu_shader5 : require 
 
in vec2 ex_textCoord;
layout(location = 6) in  uint64_t in_textHandler;
 
out vec4 out_Color;
 
void main(void)
{
	sampler2D s = sampler2D(in_textHandler);
	out_Color = texture(s, ex_textCoord);
}

 
#version 330
uniform sampler2D colorMap;  //color
uniform sampler2D normalMap; //eye space normal & linear depth
uniform sampler2D positionMap; //eye space positions
 
uniform vec4 ratio; //ratio.x - inverse resolution
 
//matrices from main view
uniform mat4 inverseProjectionMatrix;
uniform mat4 projectionMatrix;
 
layout(location = 0) out vec4 outColor;
in vec2 texCoord0;
 
const int numSamples = 128;
 
void main(void)
{
    vec4 color = vec4(0.0);
    vec4 surfaceData = texture(normalMap, texCoord0);
    float depth = surfaceData.w;
 
    vec3 eyeSpaceNormal = normalize(surfaceData.xyz);
    vec3 eyeSpacePosition = normalize(texture(positionMap, texCoord0).xyz);
 
    vec4 viewDir = inverseProjectionMatrix * vec4(0.0, 0.0, 1.0, 1.0);
    viewDir /= viewDir.w;
 
    vec4 reflectionVector = normalize(projectionMatrix * vec4(reflect(viewDir.xyz, eyeSpaceNormal), 1.0));
    float refLength = length(reflectionVector.xy);
    reflectionVector = normalize(reflectionVector)/refLength * ratio.x;
    reflectionVector.z *= depth;
 
    vec3 currentPosition = vec3(reflectionVector.x, reflectionVector.y, depth + reflectionVector.z);
 
    int currentSamples = 0;
    while(currentSamples < numSamples) {
        float sampledDepth = texture(normalMap, texCoord0 + currentPosition.xy).w;
        float difference = currentPosition.z - sampledDepth;
        if(difference > 0.0025) {
            color = texture(colorMap, texCoord0 + currentPosition.xy);
            break;
        }
        currentPosition += reflectionVector.xyz;
        currentSamples++;
    }
    outColor = vec4(color.rgb, 1.0);
}

void updateHeightMap() {
    fboManager.bind(heightEditBufferIDs[Counter % 2]);
    glPushMatrix();
 
    glViewport(0, 0, 1024, 1024);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0f, 1024.0f, 0.0f, 1024.0f, 0.1f, 10.0f);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
 
    glDepthMask(0);
    SShader[3].applyProgram(10);
 
    glPushMatrix();
    glTranslatef(512.0f, 512.0f, -1.0f);
    glScalef(512.0f, 512.0f, 1.0f);
 
  //heightmap
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, fboManager[heightEditBufferIDs[Counter % 2 == 0]].rtList[0].textureObject);
    glUniform1i(SShader[shaderId].shaderSet[programId].uniform_colorMap, 0);
 
    glBindVertexArray(quadVertexArrayObjectId);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
    glPopMatrix();
 
  //brush
    if(terrainEditorMode && lmDown) {
        //irrelevant, currently drawing\not drawing onto heightmap doesn't affect problem
    }
 
    glBindVertexArray(0);
 
    glPopMatrix();
    glDepthMask(1);
    fboManager.unbind();
}

#version 120
uniform sampler2D colorMap;
void main(void)
{
    vec4 Color = texture2D(colorMap, gl_TexCoord[0].st);
    gl_FragColor = Color;
}

	//Transform feedback output buffer
	glGenBuffers(1, &TransformFeedbackBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, TransformFeedbackBuffer);
	glBufferData(GL_ARRAY_BUFFER, 4096*3*4, 0, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
 
	//transform feedback object
	glGenTransformFeedbacks(1, &TransformFeedbackObject);
	glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, TransformFeedbackObject);	
	glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, TransformFeedbackBuffer);
	glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);

		// enable / disable wireframe
		glPolygonMode( GL_FRONT_AND_BACK, wireframe ? GL_LINE : GL_FILL);printGLError();
 
		glEnable(GL_RASTERIZER_DISCARD);printGLError(); 
		//set up the program
		glUseProgram(program);printGLError();
 
		glBindBufferBase( GL_UNIFORM_BUFFER , 1, ubo);printGLError();
		glBufferData(GL_UNIFORM_BUFFER, sizeof(TessellationParams), &tessellationParameters, GL_STREAM_DRAW);printGLError();
 
		GLint numfeedbackwritten;
 
		glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, TransformFeedbackObject);printGLError();
		glBeginTransformFeedback(GL_TRIANGLES);printGLError();
		{
			glBindBuffer(GL_ARRAY_BUFFER, vbo);
			glEnableVertexAttribArray(0);
			glPatchParameteri( GL_PATCH_VERTICES, 1);
 
			//draw a single patch
			GLuint queryObject;
			glGenQueries(1, &queryObject);printGLError();
 
			glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, queryObject);printGLError();
				glDrawArrays( GL_PATCHES, 0, 1);printGLError();
			glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);printGLError();
 
 
			glGetQueryObjectiv(queryObject, GL_QUERY_RESULT, &numfeedbackwritten);
			printf("Tris drawn to feedback buffer: %d\n", numfeedbackwritten);
 
			glDisableVertexAttribArray(0);
			glBindBuffer(GL_ARRAY_BUFFER, 0);
		}
		glEndTransformFeedback();printGLError();
		glDisable(GL_RASTERIZER_DISCARD);printGLError();

		glUseProgram(0);
		glBindBuffer(GL_ARRAY_BUFFER, TransformFeedbackBuffer);printGLError();
		glEnableVertexAttribArray(0);
 
		GLuint queryObject2;
		glGenQueries(1, &queryObject2);printGLError();
 
		glBeginQuery(GL_PRIMITIVES_GENERATED, queryObject2);
			glDrawArrays( GL_TRIANGLES, 0, numfeedbackwritten);printGLError();
		glEndQuery(GL_PRIMITIVES_GENERATED);
 
		glGetQueryObjectiv(queryObject2, GL_QUERY_RESULT, &numfeedbackwritten);
		printf("Tris drawn to display: %d\n", numfeedbackwritten);

private void RenderPass2(int tex_coordBuffer, Vector2 wh, Vector3 eyePos)
{
   GL.BindFramebuffer(FramebufferTarget.Framebuffer, p2_fboID);
   GL.DrawBuffer(DrawBufferMode.ColorAttachment0);
 
   GL.DepthFunc(DepthFunction.Greater);
   GL.Enable(EnableCap.DepthTest);
 
   GL.ClearDepth(0.0f);
 
   GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
 
   GL.ClearColor(0.0f, 1.0f, 0.0f, 1.0f);
 
   GL.Enable(EnableCap.CullFace);
   GL.CullFace(Front);
 
 
   _manager.ActivateShader(p2_shaderID);
   GL.MatrixMode(MatrixMode.Modelview);
   GL.PushMatrix();
   GL.MultMatrix(_volume.transform[0]);
 
   // setup texture for depth buffer
   GL.Enable(EnableCap.Texture2D);
   GL.ActiveTexture(TextureUnit.Texture0);
   GL.BindTexture(TextureTarget.Texture2D, tex_coordBuffer);
   GL.Uniform1(p2_coordBuffer, 0);
 
   // create transform matrix for volume cs
   Vector3 x_dir = new KTC_Geometrie_Source.Vectors.Vector3(_volume.x_dir.X, _volume.x_dir.Y, _volume.x_dir.Z);
   Vector3 y_dir = new KTC_Geometrie_Source.Vectors.Vector3(_volume.y_dir.X, _volume.y_dir.Y, _volume.y_dir.Z);
   Vector3 z_dir = new KTC_Geometrie_Source.Vectors.Vector3(_volume.z_dir.X, _volume.z_dir.Y, _volume.z_dir.Z);
   Vector3 origin = new KTC_Geometrie_Source.Vectors.Vector3(_volume.origin.X, _volume.origin.Y, _volume.origin.Z);
 
   Matrix4X4 m = Matrix4X4.ChangeKS(x_dir, y_dir, z_dir, origin);
 
   Matrix4 transform = new Matrix4(1.0f / m.A11, m.A12, m.A13, m.A14,
                                              m.A21, 1.0f / m.A22, m.A23, m.A24,
                                              m.A31, m.A32, 1.0f / m.A33, m.A34,
                                              m.A41, m.A42, m.A43, m.A44);
 
    Vector4 eye = Vector4.Transform(new Vector4(eyePos), transform);
 
    GL.Uniform4(p2_camPos, eye);
    GL.Uniform2(p2_wh, wh);
    GL.UniformMatrix4(p2_changeCS, false, ref transform);
 
    GL.BindBuffer(BufferTarget.ArrayBuffer, DEBUG_verticeID);
    GL.BindBuffer(BufferTarget.ElementArrayBuffer, DEBUG_indiceID);
 
    GL.EnableVertexAttribArray(p2_inVertex);
    GL.VertexAttribPointer(p2_inVertex, 3, VertexAttribPointerType.Float, false, 0, IntPtr.Zero);
    GL.DrawElements(BeginMode.Quads, DEBUG_COUNT, DrawElementsType.UnsignedInt, IntPtr.Zero);
 
    GL.DisableVertexAttribArray(p2_inVertex);
    GL.PopMatrix();
    _manager.DeactivateShader();
 
    GL.Disable(EnableCap.Texture2D);
    GL.Disable(EnableCap.DepthTest);
    GL.Disable(EnableCap.CullFace);
 
    GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
}

private static int[] index;
        private static int width;
        private static int height;
 
        /// <summary>
        ///  TEXTURE CODE
        /// </summary>
 
 
        [EnvironmentPermissionAttribute(SecurityAction.LinkDemand, Unrestricted = true)]//For codeanalyst
        public static void Texture()
        {
            index = new int[1];
            Gl.glGenTextures(1, index);
            //LoadTexture(path);
        }
 
        [EnvironmentPermissionAttribute(SecurityAction.LinkDemand, Unrestricted = true)]//For codeanalyst
        public static  void LoadTexture(string path)
        {
            Bitmap image;
 
            try
            {
                image = new Bitmap(path);
 
                image.RotateFlip(RotateFlipType.RotateNoneFlipY);
                Rectangle rect = new Rectangle(0, 0, image.Width, image.Height);
                height = image.Height;
                width = image.Width;
                BitmapData bitmapdata = image.LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
 
                Gl.glEnable(Gl.GL_TEXTURE_2D);									// Enable 2D Texture Mapping
               // Gl.glDisable(Gl.GL_DEPTH_TEST);									// Disable Depth Testing
                Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE);							// Set Blending Mode
                Gl.glEnable(Gl.GL_BLEND);	
                Gl.glEnable(Gl.GL_TEXTURE_GEN_S); //enable texture coordinate generation
                Gl.glEnable(Gl.GL_TEXTURE_GEN_T);
 
                Gl.glBindTexture(Gl.GL_TEXTURE_2D, index[0]);
                Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA, image.Width, image.Height,
                                0, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, bitmapdata.Scan0);
                Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
                Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
                Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_CLAMP);
                Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_CLAMP);
                image.UnlockBits(bitmapdata);
                image.Dispose();
            }
            catch (ArgumentException)
            {
                Environment.Exit(0);
            }
        }
 
        public static void Activate()
        {
            Gl.glBindTexture(Gl.GL_TEXTURE_2D, index[0]);
        }
 
        public int GetWidth
        {
            get { return width; }
        }
 
        public int GetHeight
        {
            get { return height; }
        }
 
        /////END OF TEXTURE CODE
 
 
        public static void DisplayRainSystem()
        {
 
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
            Texture();
            LoadTexture("particle.bmp");
            Activate();
 
            float spost = 0.0f;											// Starting Texture Coordinate Offset
            float alphainc = 0.9f / 2;								// Fade Speed For Alpha Blending
            float alpha = 0.2f;											// Starting Alpha Value
 
            Gl.glPointSize(2.5f);
 
            int RandomColour = R.Next(4) + 1;
            if (RandomColour == 1) Gl.glColor3f(0.0f, 0.0f, 1.0f);
            if (RandomColour == 2) Gl.glColor3f(0.0f, 0.1f, 1.0f);
            if (RandomColour == 3) Gl.glColor3f(0.0f, 0.2f, 1.0f);
            if (RandomColour == 4) Gl.glColor3f(0.0f, 0.5f, 1.0f);
            if (RandomColour == 5) Gl.glColor3f(0.0f, 0.8f, 1.0f);
 
            Gl.glBegin(Gl.GL_POINTS);
 
            for (int i = 0; i <= RS.RainParticles.Count - 1; i++)
            {
                RainParticle RP = (RainParticle)RS.RainParticles[i];
                Gl.glVertex2d(RP.xpos, RP.ypos);
            }
 
            Gl.glFlush();
            Gl.glEnd();    
 
        }

// Returns true iif v1 can be considered equal to v2 
bool is_near(float v1, float v2){ 
    return fabs( v1-v2 ) < 0.01f; 
} 
 
// Searches through all already-exported vertices 
// for a similar one. 
// Similar = same position + same UVs + same normal 
bool getSimilarVertexIndex(  
    glm::vec3 & in_vertex,  
    glm::vec2 & in_uv,  
    glm::vec3 & in_normal,  
    std::vector<glm::vec3> & out_vertices, 
    std::vector<glm::vec2> & out_uvs, 
    std::vector<glm::vec3> & out_normals, 
    unsigned short & result 
){ 
    // Lame linear search 
    for ( unsigned int i=0; i<out_vertices.size(); i++ ){ 
        if ( 
            is_near( in_vertex.x , out_vertices[i].x ) && 
            is_near( in_vertex.y , out_vertices[i].y ) && 
            is_near( in_vertex.z , out_vertices[i].z ) && 
            is_near( in_uv.x     , out_uvs     [i].x ) && 
            is_near( in_uv.y     , out_uvs     [i].y ) && 
            is_near( in_normal.x , out_normals [i].x ) && 
            is_near( in_normal.y , out_normals [i].y ) && 
            is_near( in_normal.z , out_normals [i].z ) 
        ){ 
            result = i; 
            return true; 
        } 
    } 
    // No other vertex could be used instead. 
    // Looks like we'll have to add it to the VBO. 
    return false; 
} 
 
void indexVBO_slow( 
    std::vector<glm::vec3> & in_vertices, 
    std::vector<glm::vec2> & in_uvs, 
    std::vector<glm::vec3> & in_normals, 
 
    std::vector<unsigned short> & out_indices, 
    std::vector<glm::vec3> & out_vertices, 
    std::vector<glm::vec2> & out_uvs, 
    std::vector<glm::vec3> & out_normals 
){ 
    // For each input vertex 
    for ( unsigned int i=0; i<in_vertices.size(); i++ ){ 
 
        // Try to find a similar vertex in out_XXXX 
        unsigned short index; 
        bool found = getSimilarVertexIndex(in_vertices[i], in_uvs[i], in_normals[i],     out_vertices, out_uvs, out_normals, index); 
 
        if ( found ){ // A similar vertex is already in the VBO, use it instead ! 
            out_indices.push_back( index ); 
        }else{ // If not, it needs to be added in the output data. 
            out_vertices.push_back( in_vertices[i]); 
            out_uvs     .push_back( in_uvs[i]); 
            out_normals .push_back( in_normals[i]); 
            out_indices .push_back( (unsigned short)out_vertices.size() - 1 ); 
        } 
    } 
}