//testShader.use();
      gl.glColor3f(1,1,1);
      gl.glBegin(GL.GL_QUADS);
      gl.glVertex3f(10f, 10f, -50f);
      gl.glColor3f(0,0,1);
      gl.glVertex3f(10f, 0f, -50f);
      gl.glColor3f(1,0,0);
      gl.glVertex3f(0f, 0f, -50f);
      gl.glColor3f(0,1,0);
      gl.glVertex3f(0f, 10f, -50f);
      gl.glEnd();

// vertexshader:
void main() {
   gl_Position     = gl_ModelViewProjectionMatrix * gl_Vertex;
}

//fragmentshader:
void main() {
    gl_FragColor = gl_Color;
}

void main()
{
   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
   gl_FrontColor = gl_Color;
}

public class Shader extends Resource {

   private static GL gl;
   
   private String vertexSource;
   private String fragmentSource;
   
   private int vertexShaderObject;
   private int fragmentShaderObject;
   
   private int shaderProgram;
   
   private int idxModelViewProjection = -1;
   private int idxModelView = -1;
   private int idxNormalMatrix = -1;
   
   
   public Shader(String resourceID, String vertexShaderSource, String fragmentShader) {
      super(resourceID);
      
      gl = Renderer.getInstance().getGL();
   
      vertexSource = vertexShaderSource;
      fragmentSource = fragmentShader;
      
      vertexShaderObject = loadShader(gl.GL_VERTEX_SHADER, vertexSource);
      fragmentShaderObject = loadShader(gl.GL_FRAGMENT_SHADER, fragmentSource);
      
      shaderProgram = attachToProgram(vertexShaderObject, fragmentShaderObject);
   
   }
   
   private static int loadShader(int shaderType, String shaderSource) {
      int result = Renderer.getInstance().getGL().glCreateShader(shaderType);
      
          // Vertex Shader
      BufferedInputStream vert_reader;
        try {
            //vert_reader = new BufferedReader(new FileReader(shaderSource));
           vert_reader = new BufferedInputStream(ResourceManager.getResourceAsStream(shaderSource));
        } catch (FileNotFoundException e) {
            System.out.println(e);
            return -1;
        }
      catch (IOException e)
      {
            System.out.println(e);
            return -1;
      }
        String[] vshader = new String[1];
        vshader[0] = "";
        String line;
        byte[] buffer = new byte[1024];
       
        int bytesRead = 0;
        try
      {
         while ((bytesRead = vert_reader.read(buffer)) != -1) {
            vshader[0] += new String(buffer, 0, bytesRead);
         }
         System.out.println(vshader[0]);
      }
      catch (IOException e)
      {
         
         e.printStackTrace();
         System.out.println("error");
         return -1;
      }
       
        int[] vlen = new int[1];
        vlen[0] = vshader[0].length();
    //    System.out.println(vshader[0]);

        gl.glShaderSource(result, 1, vshader, vlen, 0);
        gl.glCompileShader(result);
       
        String infoLog = getShaderInfoLog(result);
        if (infoLog != null)
           throw new RuntimeException("Shader incorrect");
       
       return result;
   }
   
   public static String getShaderInfoLog(int shaderObject) {
   //   gl.glGetShaderInfoLog(arg0, arg1, arg2, arg3)
      return null;
      
   }

   
   public static int attachToProgram(int vertexShaderObject, int fragmentShaderObject) {
        // Shaderprogram
        int shaderProgram = gl.glCreateProgram();
        gl.glAttachShader(shaderProgram, vertexShaderObject);
        gl.glAttachShader(shaderProgram, fragmentShaderObject);
        gl.glLinkProgram(shaderProgram);
        gl.glValidateProgram(shaderProgram);
        // Freigeben
        gl.glDeleteShader(vertexShaderObject);
        gl.glDeleteShader(fragmentShaderObject);
        return shaderProgram;
   }
   
   public void link() {
      gl.glLinkProgram(shaderProgram);
   }
   
   public void use() {
      gl.glUseProgram(shaderProgram);
   }

      gl.glUniform4fv(testShader.getUniformLocation("myColor"), 4, new float[]{0.5f,1f,0.5f,1.0f}, 0);

// erklärung von testShader.getUniformLocation
   public int getUniformLocation(String identifier) {
      return gl.glGetUniformLocation(shaderProgram, identifier);
   }

// vertexshader:
uniform vec4 myColor;
void main() {
   gl_Position  = gl_ModelViewProjectionMatrix * gl_Vertex;

}

//fragmentshader:
uniform vec4 myColor;
void main() {
    gl_FragColor = myColor;
}

const int TERRAIN_LEAFSIZE = 64;
GLuint m_vboLeaf;
GLuint m_iboLeaf;

// create vertex buffer object
{
   glGenBuffers(1, &m_vboLeaf);
   glBindBuffer(GL_ARRAY_BUFFER, m_vboLeaf);
   int verts = TERRAIN_LEAFSIZE+1;
   int data_size = verts*verts*2*sizeof(float);
   glBufferData(GL_ARRAY_BUFFER, data_size, NULL, GL_STATIC_DRAW);
   float* data = (float*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
   int pos = 0;
   for (int y=0; y<verts; ++y) {
      for (int x=0; x<verts; ++x) {
         data[pos++] = x;
         data[pos++] = y;
      }
   }
   glUnmapBuffer(GL_ARRAY_BUFFER);
}


// create index buffer object
{
   glGenBuffers(1, &m_iboLeaf);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iboLeaf);
   int verts = TERRAIN_LEAFSIZE+1;
   int data_size = TERRAIN_LEAFSIZE*TERRAIN_LEAFSIZE*2*3*sizeof(GLushort);
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, data_size, NULL, GL_STATIC_DRAW);
   GLushort* data = (GLushort*)glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
   int pos = 0;
   for (int y=0; y<TERRAIN_LEAFSIZE; ++y) {
      for (int x=0; x<TERRAIN_LEAFSIZE; ++x) {
         data[pos++] = (x+0) + (y+0) * verts;
         data[pos++] = (x+0) + (y+1) * verts;
         data[pos++] = (x+1) + (y+1) * verts;
         data[pos++] = (x+1) + (y+1) * verts;
         data[pos++] = (x+1) + (y+0) * verts;
         data[pos++] = (x+0) + (y+0) * verts;
      }
   }
   glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
}