Magic Cube

import android.graphics.Bitmap;

      BandagedCreatorWorkerThread.create(this);

    public void iconCreationDone(Bitmap bmp)

      mScreen.iconCreationDone(bmp);

import android.view.View;

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void playObject()

    {

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void deleteObject()

    {

    }

    plaButton.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        playObject();

        }

      });

    delButton.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        deleteObject();

        }

      });

import android.opengl.GLES31;

import org.distorted.library.effect.PostprocessEffectBorder;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedFramebuffer;

import org.distorted.library.type.Static1D;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.ShapeHexahedron;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

   public static final float BRIGHTNESS = 0.333f;

   private int mSaveIcon;

   private DistortedFramebuffer mFramebuffer;

   private String mPath;

     mSaveIcon = -1;

     if( mSaveIcon>=0 ) mSaveIcon++;

     if( mSaveIcon>=2 ) { saveIcon(); mSaveIcon = -1; }

     setupIconCreation(obj,act);

   private void setupIconCreation(TwistyObject object, Activity act)

/*

     // create framebuffer, attach object's node to it

     ObjectControl control = getControl();

     DistortedEffects effects = object.getObjectEffects();

     Static4D defRot = ShapeHexahedron.DEFAULT_ROT;

     Static1D halo = new Static1D(5);

     control.rotateNow(defRot);

     float scale = 1.15f;

     control.scaleNow(scale);

     Static4D color = new Static4D(0,0,0,1);

     PostprocessEffectBorder border = new PostprocessEffectBorder(halo,color);

     border.setHaloDepth(false);

     effects.apply(border);

     final String name = object.getShortName()+".png";

     File file = new File(act.getFilesDir(), name);

     String filename = file.getAbsolutePath();

     mSaveIcon = 0;

     mPath = filename;

 */

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void saveIcon()

      {

      int fW = mFramebuffer.getWidth();

      int fH = mFramebuffer.getHeight();

      ByteBuffer buf = ByteBuffer.allocateDirect(fW*fH*4);

      buf.order(ByteOrder.LITTLE_ENDIAN);

      int textureID = mFramebuffer.getTextureID();

      if( textureID>=0 )

        {

        GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, textureID);

        GLES31.glReadPixels( 0, 0, fW, fH, GLES31.GL_RGBA, GLES31.GL_UNSIGNED_BYTE, buf);

        BandagedCreatorWorkerThread.newBuffer(buf,fW,fH,6,mPath);

        }

      else

        {

        android.util.Log.e("Save", "Error trying to read from offscreen FBO, textureID="+textureID);

        }

      mSaveIcon = -1;

      }

import android.graphics.Bitmap;

import android.widget.ImageView;

///////////////////////////////////////////////////////////////////////////////////////////////////

  void iconCreationDone(Bitmap bmp)

    {

    int numChildren = mObjectView.getChildCount();

    LinearLayout pane = (LinearLayout)mObjectView.getChildAt(numChildren-1);

    ImageView view = pane.findViewById(R.id.bandagedCreatorObjectIcon);

    if( view!=null )

      {

      view.setImageBitmap(bmp);

      }

    else

      {

      android.util.Log.e("D", "ImageView not found!");

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2022 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.bandaged;

import android.app.Activity;

import android.content.Intent;

import android.graphics.Bitmap;

import android.net.Uri;

import android.widget.Toast;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.lang.ref.WeakReference;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.util.Vector;

///////////////////////////////////////////////////////////////////////////////////////////////////

class BandagedCreatorWorkerThread extends Thread

  {

  private static Vector<WorkLoad> mBuffers;

  private static BandagedCreatorWorkerThread mThis=null;

  private static WeakReference<Activity> mWeakAct;

  private static class WorkLoad

    {

    ByteBuffer buffer;

    int width;

    int height;

    int numColors;

    String filename;

    WorkLoad(ByteBuffer buf, int w, int h, int n, String name)

      {

      buffer   = buf;

      width    = w;

      height   = h;

      numColors= n;

      filename = name;

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private BandagedCreatorWorkerThread()

    {

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  static void create(Activity act)

    {

    mWeakAct = new WeakReference<>(act);

    if( mThis==null )

      {

      mBuffers = new Vector<>();

      mThis = new BandagedCreatorWorkerThread();

      mThis.start();

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void run()

    {

    WorkLoad load;

    while(true)

      {

      synchronized(mThis)

        {

        while( mBuffers.size()>0 )

          {

          load = mBuffers.remove(0);

          process(load);

          }

        try  { mThis.wait(); }

        catch(InterruptedException ex) { }

        }

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  static void newBuffer(ByteBuffer buffer, int width, int height, int numColors, String filename)

    {

    synchronized(mThis)

      {

      WorkLoad load = new WorkLoad(buffer,width,height,numColors,filename);

      mBuffers.add(load);

      mThis.notify();

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private boolean containsBlackness(byte[] tmp, int width)

    {

    for(int i=0; i<width; i++)

      {

      if( tmp[4*i]==0 && tmp[4*i+3]==-1 ) return true;

      }

    return false;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int computeFirstRow(ByteBuffer buf, byte[] tmp, int width, int height)

    {

    int wBytes = 4*width;

    for(int i=0; i<height; i++)

      {

      buf.position(i*wBytes);

      buf.get(tmp);

      if( containsBlackness(tmp,width) ) return i;

      }

    return -1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int computeLastRow(ByteBuffer buf, byte[] tmp, int width, int height)

    {

    int wBytes = 4*width;

    for(int i=height-1; i>=0; i--)

      {

      buf.position(i*wBytes);

      buf.get(tmp);

      if( containsBlackness(tmp,width) ) return i;

      }

    return -1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// GL uses a coordinate system from mathematics; i.e. (0,0) is in the lower-left corner. 2D stuff

// has the origin on the upper-left corner; we have to flip our bitmap upside down!

//

// We also need to figure out the topmost and bottommost rows where the object starts and cut out

// a square section from the 'input' so that the object is vertically centralized.

  private ByteBuffer adjustBuffer(ByteBuffer input, byte[] tmp, int width, int height)

    {

    int wBytes = 4*width;

    ByteBuffer output = ByteBuffer.allocateDirect(wBytes*width);

    output.order(ByteOrder.LITTLE_ENDIAN);

    int firstRow = computeFirstRow(input,tmp,width,height);

    int lastRow  = computeLastRow(input,tmp,width,height);

    int startRow = (firstRow+lastRow+width)/2;

    for(int i=0; i<width; i++)

      {

      input.position((startRow-i)*wBytes);

      input.get(tmp);

      output.position(i*wBytes);

      output.put(tmp);

      }

    output.rewind();

    return output;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void replaceColor(byte[] tmp, int index, int numColors)

    {

    byte A = (byte)0xab;

    int CUTOFF = 100;

    switch(numColors)

      {

      case 4: if( tmp[index+1]==0 ) { tmp[index]=A; tmp[index+1]=0; tmp[index+2]=0; }

              else

                {

                if( tmp[index]==tmp[index+1] )

                  {

                  if( tmp[index]<0 || tmp[index]>CUTOFF )  { tmp[index]=A; tmp[index+1]=A; tmp[index+2]=0; }

                  }

                else { tmp[index]=0; tmp[index+1]=0; tmp[index+2]=A; }

                }

              break;

      case 6: if( tmp[index+2]!=0 )

                {

                if( tmp[index]==0 ) { tmp[index]=0; tmp[index+1]=0; tmp[index+2]=A; }

                }

              else

                {

                if( tmp[index]==tmp[index+1] ) { tmp[index]=A; tmp[index+1]=A; tmp[index+2]=0; }

                else { tmp[index]=A; tmp[index+1]=0; tmp[index+2]=0; }

                }

              break;

      case 8: if( tmp[index+2]!=0 )

                {

                if( tmp[index+1]==0 ) { tmp[index]=A; tmp[index+1]=0; tmp[index+2]=0; }

                }

              else

                {

                if( tmp[index+1]==0 ) { tmp[index]=0; tmp[index+1]=0; tmp[index+2]=A; }

                else

                  {

                  if( tmp[index]==tmp[index+1] ) { tmp[index]=A; tmp[index+1]=A; tmp[index+2]=0; }

                  else { tmp[index]=0; tmp[index+1]=A; tmp[index+2]=0; }

                  }

                }

              break;

      case 12:if( tmp[index+2]==0 )

                {

                if( tmp[index+1]==0 )  {tmp[index]=A; tmp[index+1]=0; tmp[index+2]=0;}

                else  {tmp[index]=0; tmp[index+1]=A; tmp[index+2]=0;}

                }

              else

                {

                if( tmp[index]==tmp[index+1] )

                  {

                  if( tmp[index]<0 || tmp[index]>CUTOFF ) {tmp[index]=A; tmp[index+1]=A; tmp[index+2]=0;}

                  }

                else  {tmp[index]=0; tmp[index+1]=0; tmp[index+2]=A;}

                }

              break;

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private ByteBuffer replaceColors(ByteBuffer input, byte[] tmp, int size, int numColors)

    {

    int marker = (int)(255*BandagedCreatorRenderer.BRIGHTNESS);

    int wBytes = 4*size;

    ByteBuffer output = ByteBuffer.allocateDirect(wBytes*size);

    output.order(ByteOrder.LITTLE_ENDIAN);

    for(int i=0; i<size; i++)

      {

      input.position(i*wBytes);

      input.get(tmp);

      for(int j=0; j<size; j++)

        {

        if( tmp[4*j]==marker && tmp[4*j+1]==marker && tmp[4*j+2]==marker )

          {

          tmp[4*j  ]=0;

          tmp[4*j+1]=0;

          tmp[4*j+2]=0;

          tmp[4*j+3]=0;

          }

        else if( tmp[4*j]!=0 || tmp[4*j+1]!=0 || tmp[4*j+2]!=0 ) replaceColor(tmp,4*j,numColors);

        }

      output.position(i*wBytes);

      output.put(tmp);

      }

    output.rewind();

    return output;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void process(WorkLoad load)

    {

    int width = load.width;

    int height= load.height;

    byte[] tmp = new byte[4*width];

    ByteBuffer bufSquare = adjustBuffer(load.buffer,tmp,width,height);

    ByteBuffer bufTransp = replaceColors(bufSquare,tmp,width,load.numColors);

    final String filename = load.filename;

    BufferedOutputStream bos =null;

    final Activity act = mWeakAct.get();

    try

      {

      bos = new BufferedOutputStream(new FileOutputStream(filename));

      Bitmap bmp = Bitmap.createBitmap( width, width, Bitmap.Config.ARGB_8888);

      bmp.copyPixelsFromBuffer(bufTransp);

      bmp.compress(Bitmap.CompressFormat.PNG, 90, bos);

      BandagedCreatorActivity cact = (BandagedCreatorActivity)act;

      cact.iconCreationDone(bmp);

      }

    catch(final Exception ex)

      {

      act.runOnUiThread(new Runnable()

        {

        public void run()

          {

          Toast.makeText(act,

              "Saving to \n\n"+filename+"\n\n failed: "+"\n\n"+ex.getMessage() ,

              Toast.LENGTH_LONG).show();

          }

        });

      }

    finally

      {

      if(bos!=null)

        {

        try { bos.close(); }

        catch(IOException io) {}

        }

      }

    Intent mediaScanIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);

    File f = new File(filename);

    Uri contentUri = Uri.fromFile(f);

    mediaScanIntent.setData(contentUri);

    act.sendBroadcast(mediaScanIntent);

    }

  }

      MeshBase mesh = factory.createMesh(mPosition,false);

      MeshBase mesh = factory.createMesh(mPosition,false);

      MeshBase mesh = factory.createMesh(mPosition,false);

import org.distorted.objectlib.main.TwistyObject;

        int iconMode           = TwistyObject.MODE_NORM;

        control.changeIfDifferent(ordinal,name,meshState,iconMode,jsonStream,meshStream);

import org.distorted.objectlib.main.TwistyObject;

        int iconMode           = TwistyObject.MODE_NORM;

        control.changeIfDifferent(ordinal,name,meshState,iconMode,jsonStream,meshStream);

        int iconMode           = TwistyObject.MODE_NORM;

        control.changeObject(ordinal,meshState,iconMode,jsonStream,meshStream);

      int iconMode  = TwistyObject.MODE_NORM;

      control.changeIfDifferent(ordinal,name,meshState,iconMode,jsonStream,meshStream);

import org.distorted.objectlib.main.TwistyObject;

      int iconMode  = TwistyObject.MODE_NORM;

      control.changeIfDifferent(ordinal,name,meshState,iconMode,jsonStream,meshStream);