Plug rubberbox function :
[scilab.git] / scilab / modules / renderer / src / java / org / scilab / modules / renderer / JoGLView / interaction / util / HelpersGeometry.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2009-2012 - DIGITEO - Pierre Lando
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  */
11
12 package org.scilab.modules.renderer.JoGLView.interaction.util;
13
14 import org.scilab.forge.scirenderer.DrawingTools;
15 import org.scilab.forge.scirenderer.buffers.BuffersManager;
16 import org.scilab.forge.scirenderer.buffers.ElementsBuffer;
17 import org.scilab.forge.scirenderer.shapes.geometry.DefaultGeometry;
18 import org.scilab.forge.scirenderer.shapes.geometry.Geometry;
19 import org.scilab.forge.scirenderer.tranformations.Vector3d;
20 import org.scilab.modules.graphic_objects.axes.Axes;
21 import org.scilab.modules.renderer.JoGLView.interaction.RubberBox;
22
23 import java.nio.FloatBuffer;
24
25 /**
26  * @author Pierre Lando
27  */
28 public class HelpersGeometry extends DefaultGeometry {
29     
30     /** The helper size */
31     private static final double HELPERS_SIZE = .05;
32
33     /**
34      * There are:
35      *  - 4 marks per axis.
36      *  - 2 segments per marks.
37      *  - 2 vertex per segments.
38      *  - 4 coordinate per vertex.
39      */
40     private static final int VERTEX_BUFFER_SIZE = 64;
41
42     private final BuffersManager bufferManager;
43     private final ElementsBuffer vertexBuffer;
44
45     public HelpersGeometry(DrawingTools drawingTools) {
46         bufferManager = drawingTools.getCanvas().getBuffersManager();
47         vertexBuffer = bufferManager.createElementsBuffer();
48
49         setLineDrawingMode(Geometry.LineDrawingMode.SEGMENTS);
50         setFillDrawingMode(Geometry.FillDrawingMode.NONE);
51         setVertices(vertexBuffer);
52     }
53
54     @Override
55     public void finalize() throws Throwable {
56         super.finalize();
57         bufferManager.dispose(vertexBuffer);
58     }
59
60     public void updateVertex(Axes axes, PointComputer pointAComputer, Vector3d secondPoint, RubberBox.Status status) {
61         if ((pointAComputer != null) && (pointAComputer.getFirstAxisIndex() != -1)) {
62             FloatBuffer data;
63             boolean oneAxis;
64             if ((status == RubberBox.Status.WAIT_POINT_A) || (status == RubberBox.Status.WAIT_POINT_B)) {
65                 oneAxis = false;
66                 data = FloatBuffer.allocate(VERTEX_BUFFER_SIZE * 2);
67             } else {
68                 oneAxis = true;
69                 data = FloatBuffer.allocate(VERTEX_BUFFER_SIZE);
70             }
71
72             Double[] bounds = axes.getDisplayedBounds();
73             int mainAxisIndex = (pointAComputer.getFirstAxisIndex() + 1) % 3;
74             for (int axisIndex = 0; axisIndex < 3; axisIndex++) {
75                 if ((mainAxisIndex != axisIndex) ^ oneAxis) {
76                     for (int u = 0; u < 2; u++) {
77                         for (int v = 0; v < 2; v++) {
78                             double base[] = secondPoint.getData();
79                             base[axisIndex] = bounds[axisIndex * 2 + u];
80                             int nextAxisIndex = (axisIndex + 1) % 3;
81                             base[nextAxisIndex] = bounds[nextAxisIndex * 2 + v];
82                             float[] buffer = asFloatArray(base);
83                             data.put(buffer);
84
85                             buffer[axisIndex] = buffer[axisIndex] + (float) (HELPERS_SIZE * (bounds[axisIndex * 2 + (1 - u)] - bounds[axisIndex * 2 + u]));
86                             data.put(buffer);
87
88                             buffer[axisIndex] = bounds[axisIndex * 2 + u].floatValue();
89                             data.put(buffer);
90
91                             buffer[nextAxisIndex] = buffer[nextAxisIndex] + (float) (HELPERS_SIZE * (bounds[nextAxisIndex * 2 + (1 - v)] - bounds[nextAxisIndex * 2 + v]));
92                             data.put(buffer);
93                         }
94                     }
95                 }
96             }
97
98             data.rewind();
99             getVertices().setData(data, 3);
100         } else {
101             getVertices().setData(new Float[0], 4);
102         }
103     }
104
105     private float[] asFloatArray(double[] base) {
106         float data[] = new float[base.length];
107         for (int i = 0; i < base.length; i++) {
108             data[i] = (float) base[i];
109         }
110         return data;
111     }
112 }