import com.sun.opengl.cg.*; 
import javax.media.opengl.*; 
import com.sun.opengl.util.*; 
import java.nio.*; 
import processing.opengl.*; 
 
/*class CG 
{ 
  GL gl; 
  boolean vertexShaderSupported;  
  boolean fragmentShaderSupported; 
  boolean vertexShaderEnabled; 
  boolean fragmentShaderEnabled; 
  CGcontext context; 
  CGprogram vertexProgram;  
  CGprogram fragmentProgram; 
  int vertexProfile; 
  int fragmentProfile; 
    
  CG() 
  { 
    gl = ((PGraphicsOpenGL)g).gl; 
    String extensions = gl.glGetString(GL.GL_EXTENSIONS); 
    vertexShaderSupported = extensions.indexOf("GL_ARB_vertex_shader") != -1; 
    fragmentShaderSupported = extensions.indexOf("GL_ARB_fragment_shader") != -1;     
     
    context = CgGL.cgCreateContext(); 
     
    vertexProfile = CgGL.cgGLGetLatestProfile(CgGL.CG_GL_VERTEX); 
    if (vertexProfile == CgGL.CG_PROFILE_UNKNOWN) println("Vertex profile could not be created"); 
    else CgGL.cgGLSetOptimalOptions(vertexProfile); 
 
    fragmentProfile = CgGL.cgGLGetLatestProfile(CgGL.CG_GL_FRAGMENT); 
    if (fragmentProfile == CgGL.CG_PROFILE_UNKNOWN) println("Fragment profile could not be created"); 
    else CgGL.cgGLSetOptimalOptions(fragmentProfile); 
 
    vertexProgram = null; 
    fragmentProgram = null; 
  } 
    
  void loadVertexShader(String file) 
  { 
    String shaderSource = join(loadStrings(file), "\n");    
    vertexProgram = CgGL.cgCreateProgram(context, CgGL.CG_SOURCE, shaderSource, vertexProfile, null, null); 
    checkErrorInfo(file, vertexProgram); 
    vertexShaderEnabled = (vertexProgram != null) && (vertexProfile != CgGL.CG_PROFILE_UNKNOWN); 
  } 
  
  void loadFragmentShader(String file) 
  { 
    String shaderSource = join(loadStrings(file), "\n"); 
    fragmentProgram = CgGL.cgCreateProgram(context, CgGL.CG_SOURCE, shaderSource, fragmentProfile, null, null); 
    checkErrorInfo(file, fragmentProgram); 
    fragmentShaderEnabled = (fragmentProgram != null) && (fragmentProfile != CgGL.CG_PROFILE_UNKNOWN); 
  } 
    
  CGparameter getVertParameter(String name) 
  { 
    return CgGL.cgGetNamedParameter(vertexProgram, name); 
  } 
   
  CGparameter getFragParameter(String name) 
  { 
    return CgGL.cgGetNamedParameter(fragmentProgram, name); 
  }    
   
  void useShaders() 
  { 
    if (vertexShaderEnabled) CgGL.cgGLLoadProgram(vertexProgram); 
    if (fragmentShaderEnabled) CgGL.cgGLLoadProgram(fragmentProgram);  
  }   
   
  void startShader() 
  { 
    if (vertexShaderEnabled) 
    { 
   CgGL.cgGLBindProgram(vertexProgram); 
   CgGL.cgGLEnableProfile(vertexProfile); 
    } 
    if (fragmentShaderEnabled) 
    { 
   CgGL.cgGLBindProgram(fragmentProgram); 
   CgGL.cgGLEnableProfile(fragmentProfile); 
    } 
  } 
    
  void endShader() 
  { 
    if (vertexShaderEnabled) CgGL.cgGLDisableProfile(vertexProfile); 
    if (fragmentShaderEnabled) CgGL.cgGLDisableProfile(fragmentProfile); 
  } 
   
  void checkErrorInfo(String fn, CGprogram program) 
  { 
    if (program == null) 
    { 
 int error = CgGL.cgGetError(); 
 println("Cg error(s) in " + fn); 
 println(CgGL.cgGetErrorString(error)); 
 println(CgGL.cgGetLastListing(context)); 
    } 
  } 
}  */

class CG 
{ 
  int programObject; 
  GL gl; 
  boolean vertexShaderEnabled; 
  boolean vertexShaderSupported;  
  int vs; 
  int fs; 
   
  CG() 
  { 
     
    gl=((PGraphicsOpenGL)g).beginGL(); 
    ((PGraphicsOpenGL)g).endGL(); 
    String extensions = gl.glGetString(GL.GL_EXTENSIONS); 
    vertexShaderSupported = extensions.indexOf("GL_ARB_vertex_shader") != -1; 
    vertexShaderEnabled = true;     
    programObject = gl.glCreateProgramObjectARB();  
    vs=-1; 
    fs=-1; 
  } 
   
  void loadVertexShader(String file) 
  { 
    println(" Load vertex shader" ); 
    gl=((PGraphicsOpenGL)g).beginGL(); 
    ((PGraphicsOpenGL)g).endGL(); 
    String shaderSource=join(loadStrings(file),"\n"); 
    vs = gl.glCreateShaderObjectARB(GL.GL_VERTEX_SHADER_ARB); 
    gl.glShaderSourceARB(vs, 1, new String[]{shaderSource},(int[]) null, 0); 
    gl.glCompileShaderARB(vs); 
    checkLogInfo(gl, vs); 
    gl.glAttachObjectARB(programObject, vs);  
  } 
 
  void loadFragmentShader(String file) 
  { 
    println(" Load pixel shader" ); 
    gl=((PGraphicsOpenGL)g).beginGL(); 
    ((PGraphicsOpenGL)g).endGL(); 
    String shaderSource=join(loadStrings(file),"\n"); 
    fs = gl.glCreateShaderObjectARB(GL.GL_FRAGMENT_SHADER_ARB); 
    gl.glShaderSourceARB(fs, 1, new String[]{shaderSource},(int[]) null, 0); 
    gl.glCompileShaderARB(fs); 
    checkLogInfo(gl, fs); 
    gl.glAttachObjectARB(programObject, fs);  
  } 
 
  int getAttribLocation(String name) 
  { 
    gl=((PGraphicsOpenGL)g).beginGL(); 
    ((PGraphicsOpenGL)g).endGL(); 
    return(gl.glGetAttribLocationARB(programObject,name)); 
  } 
   
  int getUniformLocation(String name) 
  { 
    gl=((PGraphicsOpenGL)g).beginGL(); 
    ((PGraphicsOpenGL)g).endGL(); 
    return(gl.glGetUniformLocationARB(programObject,name)); 
  } 
     
  void useShaders() 
  { 
    gl=((PGraphicsOpenGL)g).beginGL(); 
    ((PGraphicsOpenGL)g).endGL(); 
    gl.glLinkProgramARB(programObject); 
    gl.glValidateProgramARB(programObject); 
    checkLogInfo(gl, programObject); 
  } 
   
  void startShader() 
  { 
    gl=((PGraphicsOpenGL)g).beginGL(); 
    ((PGraphicsOpenGL)g).endGL(); 
    gl.glUseProgramObjectARB(programObject);  
  } 
   
  void endShader() 
  { 
    gl=((PGraphicsOpenGL)g).beginGL(); 
    ((PGraphicsOpenGL)g).endGL(); 
    gl.glUseProgramObjectARB(0);  
  } 
   
  void checkLogInfo(GL gl, int obj)   
  { 
    gl=((PGraphicsOpenGL)g).beginGL(); 
    ((PGraphicsOpenGL)g).endGL(); 
    IntBuffer iVal = BufferUtil.newIntBuffer(1); 
    gl.glGetObjectParameterivARB(obj, GL.GL_OBJECT_INFO_LOG_LENGTH_ARB, iVal); 
  
    int length = iVal.get(); 
    if (length <= 1)   
    { 
      return; 
    } 
    ByteBuffer infoLog = BufferUtil.newByteBuffer(length); 
    iVal.flip(); 
    gl.glGetInfoLogARB(obj, length, iVal, infoLog); 
    byte[] infoBytes = new byte[length]; 
    infoLog.get(infoBytes); 
    println("GLSL Validation >> " + new String(infoBytes)); 
  }  
}