package org.yourorghere;

import com.sun.opengl.util.Animator;
import com.sun.opengl.util.GLUT;
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;
import com.sun.opengl.util.GLUT;
import javax.media.opengl.glu.GLUnurbs;
//import javax.media.opengl.glu.gl2.GLUgl2;
//import javax.media.opengl.glu.gl2es1.GLUgl2es1;

/**
 * Test.java <BR> author: Brian Paul (converted to Java by Ron Cemer and Sven
 * Goethel) <P>
 *
 * This version is equal to Brian Paul's version 1.2 1999/10/21
 */
public class Test implements GLEventListener {

    public static float[][][] controlPoints = new float[20][15][6]; // КОнтрольные точки.
    public static double Xangle = 30.0, Yangle = 10.0, Zangle = 40.0; // углы поворота поверхности.
    public static int rowCount = 0, columnCount = 0; // Индексы для выбора котроьных точек.
    public static GLUnurbs nurbsObject; //указатель на НУРБС объект
    // Standard knot vector along the u-parameter.
    public static float uknots[] = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7,
        8, 9, 10, 11, 12, 12, 12, 12};
// Standard knot vector along the v-parameter.
    public static float vknots[] = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6,
        7, 7, 7, 7};
//Сброс контрольных точек
/*
     * reser control points for new obj
     */
    
    private void resetControlPoints() {
        for (int i = 0; i < 15; i++) {
            for (int j = 0; j < 10; j++) {
                controlPoints[i][j][0] = (float) (-2.5 + j * 0.5);
                controlPoints[i][j][1] = 0;
                controlPoints[i][j][2] = 6 - i;
            }
        }
    }
    
    public static void main(String[] args) {
        Frame frame = new Frame("Simple JOGL Application");
        GLCanvas canvas = new GLCanvas();
            
        
        canvas.addGLEventListener(new Test());
        frame.add(canvas);
        frame.setSize(640, 640);
        final Animator animator = new Animator(canvas);
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                // Run this on another thread than the AWT event queue to
                // make sure the call to Animator.stop() completes before
                // exiting
                new Thread(new Runnable() {
                    public void run() {
                        animator.stop();
                        System.exit(0);
                    }
                }).start();
            }
        });
        // Center frame
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        animator.start();
    }
    
    public void init(GLAutoDrawable drawable) {
        // Use debug pipeline
        // drawable.setGL(new DebugGL(drawable.getGL()));

        GL gl = drawable.getGL();
        GLU glu = new GLU();
        System.err.println("INIT GL IS: " + gl.getClass().getName());

        // Enable VSync
        gl.setSwapInterval(1);

        // Setup the drawing area and shading mode
        gl.glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
        //Создаем НУРБС объект
        nurbsObject = glu.gluNewNurbsRenderer();
        //public static final int GLU_SAMPLING_METHOD = 100205;
        //public static final int GLU_PATH_LENGTH = 100215;
        glu.gluNurbsProperty(nurbsObject, 100205, 100215);
        //public static final int GLU_SAMPLING_TOLERANCE = 100203;
        glu.gluNurbsProperty(nurbsObject, 100203, 100);
        //public static final int GLU_DISPLAY_MODE = 100204;
         //public static final int GLU_OUTLINE_POLYG
        glu.gluNurbsProperty(nurbsObject, 100204, 100240);
        resetControlPoints();
        gl.glShadeModel(GL.GL_SMOOTH); // try setting this to GL_FLAT and see what happens.
    }
    
    public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
        GL gl = drawable.getGL();
        GLU glu = new GLU();
        
        if (height <= 0) { // avoid a divide by zero error!

            height = 1;
        }
        final float h = (float) width / (float) height;
        gl.glViewport(0, 0, width, height);
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();
        glu.gluPerspective(45.0f, h, 1.0, 20.0);
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadIdentity();
    }
    
    public void display(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();
        GLU glu = new GLU();
        GLUT glut = new GLUT();
        // Clear the drawing area
        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
        // Reset the current matrix to the "identity"
        gl.glLoadIdentity();
        
        glu.gluLookAt(0.0, 0.0, 12.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

        // Rotate scene.
        gl.glRotated(Zangle, 0.0d, 0.0d, 0.0d);
        gl.glRotated(Yangle, 0.0d, 1.0d, 0.0d);
        gl.glRotated(Xangle, 1.0d, 0.0d, 0.0d);
        // Draw the spline surface.
        gl.glColor3f(0.0f, 0.0f, 0.0f);
        glu.gluBeginSurface(nurbsObject);
         glu.gluNurbsSurface(nurbsObject, 19, uknots, 14, vknots, 30, 3, controlPoints[0][0], 4, 4, GL.GL_MAP2_VERTEX_3);
        glu.gluEndSurface(nurbsObject);
        gl.glPointSize(5);

        //Рисуем зеленые контрольные точки
        gl.glColor3f(0.0f, 1.0f, 0.0f);
        gl.glBegin(GL.GL_POINTS);
        for (int i = 0; i < 15; i++) {
            for (int j = 0; j < 10; j++) {
                gl.glVertex3fv(controlPoints[i][j], 0);
            }
        }
        gl.glEnd();
        
        gl.glColor3f(1.0F, 0.0F, 0.0f);
        gl.glBegin(GL.GL_POINTS);
        gl.glVertex3fv(controlPoints[10][columnCount], 0);
        gl.glEnd();
        
        //рисуем координатную сетку
        gl.glColor3f(0.0f, 0.0f, 1.0f);
        gl.glLineWidth(2);
        gl.glBegin(GL.GL_LINES);
        gl.glVertex3f(-6.0f, 0.0f, 0.0f);
        gl.glVertex3f(6.0f, 0.0f, 0.0f);
        gl.glVertex3f(5.75f, 0.0f, 0.25f);        
               gl.glVertex3f(6.0f, 0.0f, 0.0f);
       gl.glVertex3f(5.75f, 0.0f, -0.25f);
       gl.glVertex3f(6.0f, 0.0f, 0.0f);

    gl.glVertex3f(0.0f, -6.0f, 0.0f);
       gl.glVertex3f(0.0f, 6.0f, 0.0f);
       gl.glVertex3f(0.25f, 5.75f, 0.0f);
       gl.glVertex3f(0.0f, 6.0f, 0.0f);
       gl.glVertex3f(-0.25f, 5.75f, 0.0f);
       gl.glVertex3f(0.0f, 6.0f, 0.0f);

    gl.glVertex3f(0.0f, 0.0f, -9.0f);
       gl.glVertex3f(0.0f, 0.0f, 6.5f);
    gl.glVertex3f(0.25f, 0.0f, 6.25f);
    gl.glVertex3f(0.0f, 0.0f, 6.5f);
    gl.glVertex3f(-0.25f, 0.0f, 6.25f);
    gl.glVertex3f(0.0f, 0.0f, 6.5f);
       
        gl.glEnd();
        gl.glLineWidth(1);
        
           // Label the co-ordinate axes.
   gl.glPushMatrix();
   gl.glTranslatef(6.1f, 0.0f, 0.0f);
   gl.glScalef(0.005f, 0.005f, 0.005f);
  // writeStrokeString(GLUT_STROKE_ROMAN, "X");
   glut.glutBitmapString(GLUT.BITMAP_HELVETICA_12, "X");
   gl.glPopMatrix();

   gl.glPushMatrix();
   gl.glTranslatef(0.0f, 6.1f, 0.0f);
   gl.glScalef(0.005f, 0.005f, 0.005f);
   glut.glutBitmapString(GLUT.BITMAP_HELVETICA_12, "Y");
   gl.glPopMatrix();

   gl.glPushMatrix();
   gl.glTranslatef(0.0f, 0.0f, 6.6f);
   gl.glScalef(0.005f, 0.005f, 0.005f);
   //writeStrokeString(GLUT_STROKE_ROMAN, "Z");
   gl.glPopMatrix();
   
 //  glut.glutSwapBuffers();
        // Flush all drawing operations to the graphics card
      //  gl.glFlush();
    }
    
    public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {
    }
}