WIP: Flatten to surface feature; Fix rotating multiple axis

app/src/main/java/ru/ytkab0bp/slicebeam/components/bed_menu/BedMenuItem.java

@@ -85,6 +85,7 @@ public class BedMenuItem extends SimpleRecyclerItem<BedMenuItem.BedMenuItemHolde
 
         private Path path = new Path();
         private float checkedProgress;
+        private boolean enabled;
 
         public BedMenuItemHolderView(Context context) {
             super(context);
@@ -117,7 +118,7 @@ public class BedMenuItem extends SimpleRecyclerItem<BedMenuItem.BedMenuItemHolde
             int rad = ViewUtils.dp(16);
             canvas.drawRoundRect(0, 0, getWidth(), getHeight(), rad, rad, bgPaint);
 
-            if (checkedProgress != 0f) {
+            if (enabled && checkedProgress != 0f) {
                 if (checkedProgress == 1f) {
                     canvas.drawRoundRect(0, 0, getWidth(), getHeight(), rad, rad, accentPaint);
                 } else {
@@ -144,6 +145,7 @@ public class BedMenuItem extends SimpleRecyclerItem<BedMenuItem.BedMenuItemHolde
         }
 
         public void bind(BedMenuItem item) {
+            enabled = item.isEnabled;
             title.setMaxLines(item.isSingleLine ? 1 : 2);
             title.setText(item.titleRes);
             icon.setImageResource(item.iconRes);

app/src/main/java/ru/ytkab0bp/slicebeam/components/bed_menu/OrientationMenu.java

@@ -28,6 +28,7 @@ import ru.ytkab0bp.slicebeam.R;
 import ru.ytkab0bp.slicebeam.SliceBeam;
 import ru.ytkab0bp.slicebeam.components.BeamAlertDialogBuilder;
 import ru.ytkab0bp.slicebeam.components.UnfoldMenu;
+import ru.ytkab0bp.slicebeam.events.FlattenModeResetEvent;
 import ru.ytkab0bp.slicebeam.events.NeedSnackbarEvent;
 import ru.ytkab0bp.slicebeam.events.ObjectsListChangedEvent;
 import ru.ytkab0bp.slicebeam.events.SelectedObjectChangedEvent;
@@ -52,31 +53,68 @@ public class OrientationMenu extends ListBedMenu {
         return Arrays.asList(
                 new BedMenuItem(R.string.MenuOrientationArrange, R.drawable.grid_layout_outline_28).onClick(v -> {
                     fragment.getGlView().arrange();
+                    fragment.getGlView().queueEvent(() -> {
+                        if (fragment.getGlView().getRenderer().invalidateFlattenMode()) {
+                            fragment.getGlView().requestRender();
+                        }
+                    });
                     SliceBeam.EVENT_BUS.fireEvent(new NeedSnackbarEvent(R.string.MenuOrientationArrangeFinished));
                 }).setEnabled(fragment.getGlView().getRenderer().getModel() != null),
                 new SpaceItem(portrait ? ViewUtils.dp(8) : 0, portrait ? 0 : ViewUtils.dp(8)),
-                new BedMenuItem(R.string.MenuOrientationPosition, R.drawable.menu_orientation_position_28).setEnabled(hasSelection()).onClick(v -> fragment.showUnfoldMenu(new PositionMenu(), v)),
-                new BedMenuItem(R.string.MenuOrientationRotation, R.drawable.menu_orientation_rotation_28).setEnabled(hasSelection()).onClick(v -> fragment.showUnfoldMenu(new RotationMenu(), v))
+                new BedMenuItem(R.string.MenuOrientationFlatten, R.drawable.menu_orientation_position_28).setEnabled(hasSelection()).setCheckable((buttonView, isChecked) -> {
+                    fragment.getGlView().getRenderer().setInFlattenMode(isChecked);
+                    fragment.getGlView().requestRender();
+                }, false),
+                new BedMenuItem(R.string.MenuOrientationPosition, R.drawable.menu_orientation_position_28).setEnabled(hasSelection()).onClick(v -> {
+                    if (fragment.getGlView().getRenderer().resetFlattenMode()) {
+                        fragment.getGlView().requestRender();
+                        ((BedMenuItem) adapter.getItems().get(2)).isChecked = false;
+                        adapter.notifyItemChanged(2);
+                    }
+                    fragment.showUnfoldMenu(new PositionMenu(), v);
+                }),
+                new BedMenuItem(R.string.MenuOrientationRotation, R.drawable.menu_orientation_rotation_28).setEnabled(hasSelection()).onClick(v -> {
+                    if (fragment.getGlView().getRenderer().resetFlattenMode()) {
+                        fragment.getGlView().requestRender();
+                        ((BedMenuItem) adapter.getItems().get(2)).isChecked = false;
+                        adapter.notifyItemChanged(2);
+                    }
+                    fragment.showUnfoldMenu(new RotationMenu(), v);
+                })
         );
     }
 
+    @EventHandler(runOnMainThread = true)
+    public void onFlattenModeReset(FlattenModeResetEvent e) {
+        ((BedMenuItem) adapter.getItems().get(2)).isChecked = false;
+        adapter.notifyItemChanged(2);
+    }
+
     @EventHandler(runOnMainThread = true)
     public void onObjectsChanged(ObjectsListChangedEvent e) {
         ((BedMenuItem) adapter.getItems().get(0)).setEnabled(fragment.getGlView().getRenderer().getModel() != null);
         adapter.notifyItemChanged(0);
 
-        ((BedMenuItem) adapter.getItems().get(2)).setEnabled(hasSelection());
-        adapter.notifyItemChanged(2);
-        ((BedMenuItem) adapter.getItems().get(3)).setEnabled(hasSelection());
-        adapter.notifyItemChanged(3);
+        for (int i = 2; i <= 4; i++) {
+            BedMenuItem item = (BedMenuItem) adapter.getItems().get(i);
+            item.setEnabled(hasSelection());
+            if (item.isCheckable) {
+                item.isChecked = false;
+            }
+            adapter.notifyItemChanged(i);
+        }
     }
 
     @EventHandler(runOnMainThread = true)
     public void onSelectionChanged(SelectedObjectChangedEvent e) {
-        ((BedMenuItem) adapter.getItems().get(2)).setEnabled(hasSelection());
-        adapter.notifyItemChanged(2);
-        ((BedMenuItem) adapter.getItems().get(3)).setEnabled(hasSelection());
-        adapter.notifyItemChanged(3);
+        for (int i = 2; i <= 4; i++) {
+            BedMenuItem item = (BedMenuItem) adapter.getItems().get(i);
+            item.setEnabled(hasSelection());
+            if (item.isCheckable) {
+                item.isChecked = false;
+            }
+            adapter.notifyItemChanged(i);
+        }
     }
 
     public final class PositionMenu extends UnfoldMenu {

app/src/main/java/ru/ytkab0bp/slicebeam/events/FlattenModeResetEvent.java

@@ -0,0 +1,7 @@
+package ru.ytkab0bp.slicebeam.events;
+
+import ru.ytkab0bp.eventbus.Event;
+
+@Event
+public class FlattenModeResetEvent {
+}

app/src/main/java/ru/ytkab0bp/slicebeam/fragment/BedFragment.java

@@ -37,6 +37,7 @@ import ru.ytkab0bp.slicebeam.components.bed_menu.OrientationMenu;
 import ru.ytkab0bp.slicebeam.components.bed_menu.SliceMenu;
 import ru.ytkab0bp.slicebeam.components.bed_menu.TransformMenu;
 import ru.ytkab0bp.slicebeam.config.ConfigObject;
+import ru.ytkab0bp.slicebeam.events.FlattenModeResetEvent;
 import ru.ytkab0bp.slicebeam.events.NeedSnackbarEvent;
 import ru.ytkab0bp.slicebeam.events.SlicingProgressEvent;
 import ru.ytkab0bp.slicebeam.navigation.Fragment;
@@ -398,6 +399,10 @@ public class BedFragment extends Fragment {
     }
 
     private void selectMenu(Context ctx, boolean portrait, int slot) {
+        if (glView.getRenderer().resetFlattenMode()) {
+            glView.requestRender();
+            SliceBeam.EVENT_BUS.fireEvent(new FlattenModeResetEvent());
+        }
         isAnimatingMenu = true;
 
         BedMenu prevMenu = menuMap.get(currentMenuSlot);

app/src/main/java/ru/ytkab0bp/slicebeam/render/GLRenderer.java

@@ -3,6 +3,7 @@ package ru.ytkab0bp.slicebeam.render;
 import static android.opengl.GLES30.*;
 import static ru.ytkab0bp.slicebeam.utils.DebugUtils.assertTrue;
 
+import android.graphics.Color;
 import android.opengl.GLSurfaceView;
 import android.util.Log;
 
@@ -72,6 +73,10 @@ public class GLRenderer implements GLSurfaceView.Renderer {
     private Vec3d rotate = new Vec3d();
     private ArrayList<GLModel.HitResult> raycastHits = new ArrayList<>();
 
+    private Vec3d bbMin = new Vec3d(), bbMax = new Vec3d();
+    private boolean isInFlattenMode;
+    private ArrayList<GLModel> flattenPlanes = new ArrayList<>();
+
     public Camera getCamera() {
         return camera;
     }
@@ -165,6 +170,36 @@ public class GLRenderer implements GLSurfaceView.Renderer {
         }
     }
 
+    public boolean invalidateFlattenMode() {
+        if (isInFlattenMode) {
+            setInFlattenMode(true);
+            return true;
+        }
+        return false;
+    }
+
+    public boolean resetFlattenMode() {
+        if (isInFlattenMode) {
+            setInFlattenMode(false);
+            return true;
+        }
+        return false;
+    }
+
+    public void setInFlattenMode(boolean inFlattenMode) {
+        isInFlattenMode = inFlattenMode;
+
+        for (int i = 0, c = flattenPlanes.size(); i < c; i++) {
+            flattenPlanes.get(i).release();
+        }
+        flattenPlanes.clear();
+
+        if (isInFlattenMode) {
+            List<GLModel> planes = model.createFlattenPlanes(selectedObject);
+            flattenPlanes.addAll(planes);
+        }
+    }
+
     @Override
     public void onDrawFrame(GL10 gl) {
         if (backgroundModel == null) return; // Not initialized yet
@@ -266,12 +301,12 @@ public class GLRenderer implements GLSurfaceView.Renderer {
                 if (selected) {
                     shader.stopUsing();
 
-                    GLShaderProgram dash = GLShadersManager.get(GLShadersManager.SHADER_FLAT);
+                    GLShaderProgram flat = GLShadersManager.get(GLShadersManager.SHADER_FLAT);
                     glLineWidth(ViewUtils.dp(1.5f));
 
-                    dash.startUsing();
-                    dash.setUniformMatrix4fv("view_model_matrix", outModelMatrix);
-                    dash.setUniformMatrix4fv("projection_matrix", projectionMatrix);
+                    flat.startUsing();
+                    flat.setUniformMatrix4fv("view_model_matrix", outModelMatrix);
+                    flat.setUniformMatrix4fv("projection_matrix", projectionMatrix);
 
                     if (selectionModel == null) {
                         selectionModel = new GLModel();
@@ -280,7 +315,30 @@ public class GLRenderer implements GLSurfaceView.Renderer {
                     selectionModel.setColor(hoverColor);
                     selectionModel.render();
 
-                    dash.stopUsing();
+                    flat.stopUsing();
+
+                    shader.startUsing();
+                }
+
+                if (isInFlattenMode) {
+                    shader.stopUsing();
+
+                    GLShaderProgram flat = GLShadersManager.get(GLShadersManager.SHADER_FLAT);
+
+                    flat.startUsing();
+                    glEnable(GL_BLEND);
+                    flat.setUniformMatrix4fv("view_model_matrix", outModelMatrix);
+                    flat.setUniformMatrix4fv("projection_matrix", projectionMatrix);
+
+                    for (GLModel plane : flattenPlanes) {
+                        boolean hoveringPlane = plane.isHovering;
+                        int clr = ColorUtils.blendARGB(hoverColor, color, hoveringPlane ? 1 : 0);
+                        plane.setColor(ColorUtils.setAlphaComponent(clr, (int) (Color.alpha(clr) * 0.75f)));
+                        plane.render();
+                    }
+
+                    glDisable(GL_BLEND);
+                    flat.stopUsing();
 
                     shader.startUsing();
                 }
@@ -337,9 +395,55 @@ public class GLRenderer implements GLSurfaceView.Renderer {
             }
         }
 
+        if (isInFlattenMode && (j == selectedObject || j == -1)) {
+            int minPlane = -1;
+            double minDistancePlane = Double.MAX_VALUE;
+
+            for (int i = 0, c = flattenPlanes.size(); i < c; i++) {
+                GLModel glModel = flattenPlanes.get(i);
+                glModel.getRaycaster().raycast(this, raycastHits, x, y);
+
+                double minDistanceRay = Double.MAX_VALUE;
+                if (!raycastHits.isEmpty()) {
+                    for (GLModel.HitResult res : raycastHits) {
+                        double distance = res.position.distance(camera.position);
+                        if (distance < minDistanceRay) {
+                            minDistanceRay = distance;
+                        }
+                    }
+                }
+                if (minDistanceRay < minDistancePlane) {
+                    minDistancePlane = minDistanceRay;
+                    minPlane = i;
+                }
+            }
+
+            if (minPlane != -1) {
+                GLModel glModel = flattenPlanes.get(minPlane);
+                model.flattenRotate(selectedObject, glModel);
+                model.getBoundingBoxExact(j, bbMin, bbMax);
+                model.translate(j, 0, 0, -bbMin.z);
+
+                invalidateGlModel(selectedObject);
+                for (int k = 0, l = flattenPlanes.size(); k < l; k++) {
+                    flattenPlanes.get(k).release();
+                }
+                flattenPlanes.clear();
+
+                selectedObject = -1;
+                SliceBeam.EVENT_BUS.fireEvent(new SelectedObjectChangedEvent());
+                return true;
+            }
+
+            return false;
+        }
+
         boolean render = j != selectedObject || j != -1;
         selectedObject = j == selectedObject ? -1 : j;
         if (render) {
+            if (isInFlattenMode) {
+                setInFlattenMode(false);
+            }
             if (selectedObject == -1) {
                 selX = selY = selZ = 0;
                 selRotX = selRotY = selRotZ = 0;
@@ -386,6 +490,44 @@ public class GLRenderer implements GLSurfaceView.Renderer {
             }
         }
 
+        if (isInFlattenMode) {
+            int minPlane = -1;
+            double minDistancePlane = Double.MAX_VALUE;
+
+            for (int i = 0, c = flattenPlanes.size(); i < c; i++) {
+                GLModel glModel = flattenPlanes.get(i);
+                glModel.getRaycaster().raycast(this, raycastHits, x, y);
+
+                double minDistanceRay = Double.MAX_VALUE;
+                if (!raycastHits.isEmpty()) {
+                    for (GLModel.HitResult res : raycastHits) {
+                        double distance = res.position.distance(camera.position);
+                        if (distance < minDistanceRay) {
+                            minDistanceRay = distance;
+                        }
+                    }
+                }
+                if (minDistanceRay < minDistancePlane) {
+                    minDistancePlane = minDistanceRay;
+                    minPlane = i;
+                }
+            }
+
+            if (minPlane != -1) {
+                for (int i = 0; i < flattenPlanes.size(); i++) {
+                    flattenPlanes.get(i).isHovering = i == minPlane;
+                }
+                render = true;
+            } else {
+                for (int i = 0; i < flattenPlanes.size(); i++) {
+                    if (flattenPlanes.get(i).isHovering) {
+                        flattenPlanes.get(i).isHovering = false;
+                        render = true;
+                    }
+                }
+            }
+        }
+
         return render;
     }
 
@@ -499,5 +641,11 @@ public class GLRenderer implements GLSurfaceView.Renderer {
             glModels.get(i).release();
         }
         glModels.clear();
+
+        isInFlattenMode = false;
+        for (int i = 0; i < flattenPlanes.size(); i++) {
+            flattenPlanes.get(i).release();
+        }
+        flattenPlanes.clear();
     }
 }

app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Bed3D.java

@@ -156,11 +156,19 @@ public class Bed3D {
     }
 
     public void release() {
-        Native.bed_release(pointer);
-        axes.release();
+        if (pointer != 0) {
+            Native.bed_release(pointer);
+            axes.release();
+            pointer = 0;
 
 //        triangles.release();
 //        gridlines.release();
 //        contourlines.release();
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        release();
     }
 }

app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GCodeProcessorResult.java

@@ -3,7 +3,7 @@ package ru.ytkab0bp.slicebeam.slic3r;
 import java.io.File;
 
 public class GCodeProcessorResult {
-    final long pointer;
+    long pointer;
 
     public GCodeProcessorResult(File f) {
         pointer = Native.gcoderesult_load_file(f.getAbsolutePath(), f.getName());
@@ -26,6 +26,14 @@ public class GCodeProcessorResult {
     }
 
     public void release() {
-        Native.gcoderesult_release(pointer);
+        if (pointer != 0) {
+            Native.gcoderesult_release(pointer);
+            pointer = 0;
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        release();
     }
 }

app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GCodeViewer.java

@@ -65,7 +65,7 @@ public class GCodeViewer {
         }
     };
 
-    private final long pointer;
+    private long pointer;
 
     public GCodeViewer() {
         pointer = Native.vgcode_create();
@@ -156,6 +156,14 @@ public class GCodeViewer {
     }
 
     public void release() {
-        Native.vgcode_release(pointer);
+        if (pointer != 0) {
+            Native.vgcode_release(pointer);
+            pointer = 0;
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        release();
     }
 }

app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GLModel.java

@@ -5,7 +5,6 @@ import static ru.ytkab0bp.slicebeam.utils.DebugUtils.assertTrue;
 import android.graphics.Color;
 
 import java.util.ArrayList;
-import java.util.List;
 
 import ru.ytkab0bp.slicebeam.render.Camera;
 import ru.ytkab0bp.slicebeam.render.GLRenderer;
@@ -13,7 +12,7 @@ import ru.ytkab0bp.slicebeam.utils.Prefs;
 import ru.ytkab0bp.slicebeam.utils.Vec3d;
 
 public class GLModel {
-    private long pointer;
+    long pointer;
     private MeshRaycaster raycaster;
 
     public float hoverProgress;
@@ -74,7 +73,10 @@ public class GLModel {
     }
 
     public void release() {
-        Native.glmodel_release(pointer);
+        if (pointer != 0) {
+            Native.glmodel_release(pointer);
+            pointer = 0;
+        }
     }
 
     public MeshRaycaster getRaycaster() {
@@ -86,7 +88,7 @@ public class GLModel {
     }
 
     public final class MeshRaycaster {
-        public List<HitResult> raycast(GLRenderer renderer, ArrayList<HitResult> list, float x, float y) {
+        public void raycast(GLRenderer renderer, ArrayList<HitResult> list, float x, float y) {
             assertTrue(renderer != null);
             list.clear();
 
@@ -104,7 +106,6 @@ public class GLModel {
                         new Vec3d(v[i + 3], v[i + 4], v[i + 5])
                 ));
             }
-            return list;
         }
     }
 

app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/GLShaderProgram.java

@@ -17,7 +17,7 @@ import ru.ytkab0bp.slicebeam.SliceBeam;
 import ru.ytkab0bp.slicebeam.utils.IOUtils;
 
 public class GLShaderProgram {
-    final long pointer;
+    long pointer;
     private static ThreadLocal<FloatBuffer> matrixBuffer = new ThreadLocal<FloatBuffer>() {
         @Nullable
         @Override
@@ -140,6 +140,14 @@ public class GLShaderProgram {
     }
 
     public void release() {
-        Native.shader_release(pointer);
+        if (pointer != 0) {
+            Native.shader_release(pointer);
+            pointer = 0;
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        release();
     }
 }

app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Model.java

@@ -1,13 +1,15 @@
 package ru.ytkab0bp.slicebeam.slic3r;
 
 import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.UUID;
 
 import ru.ytkab0bp.slicebeam.utils.Vec3d;
 
 public class Model {
     public final String key = UUID.randomUUID().toString();
-    final long pointer;
+    long pointer;
 
     private double[] boundingExact;
     private double[] boundingApprox;
@@ -92,6 +94,10 @@ public class Model {
         Native.model_rotate(pointer, i, x, y, z);
     }
 
+    public void flattenRotate(int i, GLModel surface) {
+        Native.model_flatten_rotate(pointer, i, surface.pointer);
+    }
+
     public int getObjectsCount() {
         return Native.model_get_objects_count(pointer);
     }
@@ -128,12 +134,29 @@ public class Model {
         vec.set(tr[0], tr[1], tr[2]);
     }
 
+    public List<GLModel> createFlattenPlanes(int i) {
+        long[] ptr = Native.model_create_flatten_planes(pointer, i);
+        List<GLModel> list = new ArrayList<>(ptr.length);
+        for (long l : ptr) {
+            list.add(new GLModel(l));
+        }
+        return list;
+    }
+
     public GCodeProcessorResult slice(String configPath, String gcodePath, SliceListener listener) throws Slic3rRuntimeError {
         return new GCodeProcessorResult(Native.model_slice(pointer, configPath, gcodePath, listener));
     }
 
     public void release() {
-        Native.model_release(pointer);
+        if (pointer != 0) {
+            Native.model_release(pointer);
+            pointer = 0;
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        release();
     }
 
     public static Model merge(Model... models) {

app/src/main/java/ru/ytkab0bp/slicebeam/slic3r/Native.java

@@ -68,6 +68,8 @@ class Native {
     static native void model_translate_global(long ptr, double x, double y, double z);
     static native void model_scale(long ptr, int i, double x, double y, double z);
     static native void model_rotate(long ptr, int i, double x, double y, double z);
+    static native void model_flatten_rotate(long ptr, int i, long surfacePtr);
+    static native long[] model_create_flatten_planes(long ptr, int i);
     static native long model_slice(long ptr, String configPath, String path, SliceListener listener) throws Slic3rRuntimeError;
     static native void model_release(long ptr);