/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
import javax.media.opengl.GL;
import java.util.Hashtable;

/**
 *
 * @author nbriere
 */
public class PointFlow extends Object3D
{
    static final long serialVersionUID = 0;
    
    cList<cVector> points = new cList();
    
    transient Hashtable<cVector, cVector> ht;
    
    PointFlow()
    {
        super("Flow");
        
        CreateMaterial();
        
        live = true;
    }
    
    void CreateHT()
    {
        if (ht == null)
        {
            ht = new Hashtable();
            
            cList<cVector> newpoints = new cList();
    
            for (int i=0; i<points.size(); i++)
            {
                cVector w = points.get(i);
                
                if (ht.get(w) != null)
                    continue;
                
                newpoints.add(w);
                ht.put(w, w);
            }
            
            points = newpoints;
        }
    }
    
    void add(cVector v)
    {
        if (!live)
            return;
        
        CreateHT();
        
        if (ht.get(v) != null)
            return;
        
//        if (points.size() > 0 && points.get(points.size()-1).equals(v))
//            return;
        
        System.err.println("new point = " + v);
        points.add(v);
        ht.put(v,v);
    }
    
//    void add(double x, double y, double z)
//    {
//        points.add(new cVector(x,y,z));
//    }
    
    void Reset()
    {
        if (points.size() > 0)
        {
            cVector v = points.get(0);
            
            CameraPane.selectedpoint.toParent[3][0] = v.x;
            CameraPane.selectedpoint.toParent[3][1] = v.y;
            CameraPane.selectedpoint.toParent[3][2] = v.z;
        }
        
        points.clear();
        ht.clear();
    }
    
    static Sphere geo = new Sphere();
    
    static
    {
        geo.material = null;
        geo.bRep.Stripify();
        geo.bRep.colors = null;
    }
    
    float[] texmat = { 1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1 };
    
    double minimumSize = 0, maximumSize = 0.01;
    double resizefactor = 1;
    
    static cVector tmp = new cVector();
    
    void CallList(CameraPane display, Object3D /*Composite*/ root, boolean selected, boolean blocked)
    {
        CreateHT();
        
        float r = display.modelParams0[0];
        float g = display.modelParams0[1];
        float b = display.modelParams0[2];
        float opacity = display.modelParams5[1];        
        
        //final GL gl = GLU.getCurrentGL();
        GL gl = display.GetGL(); // getGL();

        int s = points.size();

        boolean cf = gl.glIsEnabled(gl.GL_CULL_FACE);
        gl.glEnable(gl.GL_CULL_FACE);
        
        for (int i=s; --i>=0;)
        //for (int i=0; i<s; i++)
        {
            cVector v = points.get(i);
            
            double mindist = Double.MAX_VALUE;
            
            double size = minimumSize;
            
            double distancenext = 0;
            
            if (i > 0)
            {
                cVector w = points.get(i-1);
                
                double dist = w.distance(v);
                
                distancenext = dist;
        
                if (mindist > dist)
                {
                    mindist = dist;
                    size = mindist*resizefactor;
                }
            }
            
            if (i < s-1)
            {
                cVector w = points.get(i+1);
                
                double dist = w.distance(v);
                
                if (mindist > dist)
                {
                    mindist = dist;
                    size = mindist*resizefactor;
                }
            }
            
            if (size < minimumSize)
                size = minimumSize;
            if (size > maximumSize)
                size = maximumSize;
            
            double tx = v.x;
            double ty = v.y;
            double tz = v.z;
            
        //    if (tx == 0 && ty == 0 && tz == 0)
        //        continue;
            
        gl.glMatrixMode(gl.GL_TEXTURE);
        gl.glPushMatrix();
        texmat[12] = texmat[13] = texmat[14] = i;
        
        gl.glMultMatrixf(texmat, 0);
        
            gl.glMatrixMode(gl.GL_MODELVIEW);
            gl.glPushMatrix();
            
            gl.glTranslated(tx,ty,tz);

            gl.glScaled(size,size,size);
            
//            float cr = colorBuf.get(index4);
//            float cg = colorBuf.get(index4+1);
//            float cb = colorBuf.get(index4+2);
//            float ca = colorBuf.get(index4+3);
//            
//            display.modelParams0[0] = r * cr;
//            display.modelParams0[1] = g * cg;
//            display.modelParams0[2] = b * cb;
//            
//            display.modelParams5[1] = opacity * ca;
//            
//        gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 0, display.modelParams0, 0);
//        gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 5, display.modelParams5, 0);
//        
//        RandomNode.globalseed = (int)sizeBuf.get(index3+2); // i;
//        RandomNode.globalseed2 = RandomNode.globalseed;
//        
////            gl.glColor4f(cr,cg,cb,ca);
//   //         gl.glScalef(1024/16,1024/16,1024/16);
            geo.Draw/*Node*/(display,null,selected, blocked);
            
            gl.glPopMatrix();

            double step = size/4; //
            
            if (i == 0 || size == 0 || distancenext > 8*size || distancenext < step)
                continue;
            
            int nbsteps = (int)(distancenext/step);
            
            step = distancenext/nbsteps;
            
            cVector next = points.get(i-1);
            
            tmp.set(next);
            tmp.sub(v);
            tmp.normalize();
            tmp.mul(step);
            
            // calculate next size
            mindist = Double.MAX_VALUE;
            
            double nextsize = minimumSize;
            
            if (i > 1)
            {
                cVector w = points.get(i-2);
                
                double dist = w.distance(next);
                
                if (mindist > dist)
                {
                    mindist = dist;
                    nextsize = mindist*resizefactor;
                }
            }
            
            double dist = v.distance(next);

            if (mindist > dist)
            {
                mindist = dist;
                nextsize = mindist*resizefactor;
            }
            
            if (nextsize < minimumSize)
                nextsize = minimumSize;
            if (nextsize > maximumSize)
                nextsize = maximumSize;
            //
            
            double count = 0;
            
            while (distancenext > 0.000000001) // step
            {
                gl.glPushMatrix();

                gl.glTranslated(tx + tmp.x*count, ty + tmp.y*count, tz + tmp.z*count);

                double K = count/nbsteps;
                
                double intersize = K*nextsize + (1-K)*size;
                
                gl.glScaled(intersize,intersize,intersize);

                geo.Draw/*Node*/(display,null,selected,blocked);
            
                count++;
                
                distancenext -= step;
                
                gl.glPopMatrix();
            }
            
            if (count != nbsteps)
                assert(count == nbsteps);
            
   //         gl.glScalef(16.0f/1024,16.0f/1024,16.0f/1024);
            //gl.glTranslatef(-tx,-ty,-tz);
            
        gl.glMatrixMode(gl.GL_TEXTURE);
        gl.glPopMatrix();
        }

        if (!cf)
            gl.glDisable(gl.GL_CULL_FACE);
        
//        display.modelParams0[0] = r;
//        display.modelParams0[1] = g;
//        display.modelParams0[2] = b;
//            
//        display.modelParams5[1] = opacity;
//            
//        gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 0, display.modelParams0, 0);
//        gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 5, display.modelParams5, 0);
        
        gl.glMatrixMode(gl.GL_MODELVIEW);
    }
    
    
    void createEditWindow(GroupEditor callee, boolean newWindow)
    {
        //editWindow = (new SphereEditor(this, deepCopy(), callee)).GetEditor();
        if (newWindow)
        {
            objectUI = new PointFlowEditor(this, deepCopy(), callee);
        } else
        {
            objectUI = new PointFlowEditor(this, callee);
        }
        editWindow = objectUI.GetEditor();
    }
}