TwistyPuzzleLib

public abstract class TwistyObject extends TwistyObjectWithStickers

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

  protected void setReader(JsonReader reader) { }

  public String getInventor()                 { return mMetadata.getAuthor(); }

  public int getYearOfInvention()             { return mMetadata.getYearOfInvention(); }

  public float getComplexity()                { return mMetadata.getDifficulty(); }

  public String getObjectName()               { return mMetadata.getObjectName(); }

  public ObjectSignature getSignature()       { return mMetadata.getSignature(); }

  public int getCategory()                    { return mMetadata!=null ? mMetadata.getCategory() : 0; }

    super.initialize(iconMode,asset,fromJSON);

    mNode = new DistortedNode(mNodeTexture,mEffects,mMesh);

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

// Copyright 2024 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.objectlib.main;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.FactorySticker;

import org.distorted.objectlib.helpers.ObjectSticker;

import org.distorted.objectlib.helpers.ObjectStickerOverride;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

import java.io.InputStream;

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

// The fourth layer of the PUzzle implementation: stickers.

public abstract class TwistyObjectWithStickers extends TwistyObjectSolved

{

  public static final int COLOR_STROKE   = 0xff000000;

  public static final int COLOR_INTERNAL = 0xff000000;

  private static final int DEFAULT_TEXTURE_HEIGHT = 256;

  private static final int DEFAULT_TEXTURE_ROWS   = 8;

  protected float[][][][] mStickerCoords;

  protected DistortedTexture mNodeTexture;

  private int[][] mStickerVariants;

  private float[] mStickerScales;

  private int mNumTextures, mNumOverrides;

  private int mNumStickerTypes;

  private int mNumTexRows, mNumTexCols, mTexHeight;

  private Bitmap mBitmap;

  private ObjectSticker[] mStickers;

  private ObjectStickerOverride[] mStickerOverrides;

  private float mTextureBorderMultiplier, mTextureCornerMultiplier;

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

  public abstract float getStickerRadius();

  public abstract float getStickerStroke();

  public abstract float[][][] getStickerAngles();

  public abstract String getShortName();

  public abstract int getFOV();

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

  public void adjustStickerCoords()                    { } // some objects (currently Kilominx,Ivy,Rex) want to change the stickers.

  public int getInternalColor()                        { return COLOR_INTERNAL; }

  public ObjectStickerOverride[] getStickerOverrides() { return null; }

  public Bitmap getStickerBitmap()                     { return mBitmap; }

  public int getNumStickerTypes()                      { return mNumStickerTypes; }

  public boolean isSubmittable()                       { return mCurrentColorSchemeSubmittable; }

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

  void initialize(int iconMode, InitAssets asset, boolean fromJSON)

    {

    super.initialize(iconMode,asset,fromJSON);

    mTextureBorderMultiplier = 1.0f;

    mTextureCornerMultiplier = 1.0f;

    mNodeTexture= new DistortedTexture();

    InputStream meshStream = asset!=null ? asset.getMeshStream(): null;

    boolean fromDMESH = (meshStream!=null);

    setUpTextures(fromDMESH,fromJSON);

    }

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

// in degrees so that everything can be treated modulo 360

  private void figureOutBitmapDimensions(int numTextures)

    {

    int maxSize = DistortedLibrary.getMaxTextureSize();

    mTexHeight  = DEFAULT_TEXTURE_HEIGHT;

    while(true)

      {

      mNumTexCols = DEFAULT_TEXTURE_ROWS;

      mNumTexRows = numTextures/mNumTexCols + 1;

      if( mNumTexRows*mTexHeight <= maxSize &&

          mNumTexCols*mTexHeight <= maxSize  ) break;

      mTexHeight/=2;

      }

    }

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

  private void setUpTextures(boolean fromDMESH, boolean fromJSON)

    {

    if( fromJSON )

      {

      mNumStickerTypes = getNumStickerTypes();

      }

    else

      {

      FactoryCubit factory = FactoryCubit.getInstance();

      mStickerCoords   = factory.getStickerCoords();

      mStickerVariants = factory.getStickerVariants();

      mStickerScales   = factory.getStickerScales();

      adjustStickerCoords();

      mNumStickerTypes = (mStickerCoords==null ? 0 : mStickerCoords.length);

      }

    mStickerOverrides = getStickerOverrides();

    mNumOverrides = mStickerOverrides==null ? 0 : mStickerOverrides.length;

    mNumTextures= mNumFaceColors*mNumStickerTypes + mNumOverrides;

    figureOutBitmapDimensions(mNumTextures);

    if( mNumTexCols*mNumTexRows < mNumTextures+1 ) mNumTexRows++;

    if( !fromDMESH || shouldResetTextureMaps() ) resetAllTextureMaps();

    else overrideCubitFaceColor();

    setTexture();

    }

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

  public int getVariantStickerShape(int variant, int face)

    {

    if( variant <mStickerVariants.length )

      {

      int[] var = mStickerVariants[variant];

      return face>=var.length ? -1 : var[face];

      }

    return -1;

    }

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

  public boolean shouldResetTextureMaps()

    {

    return false;

    }

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

  void setTextureMap(int cubit, int face, int color)

    {

    int variant  = getCubitVariant(cubit);

    int shape    = getVariantStickerShape(variant,face);

    int texIndex = color<0 || shape<0 ? mNumTextures-mNumOverrides : shape*mNumFaceColors + color;

    int row      = (mNumTexRows-1) - texIndex/mNumTexCols;

    int col      = texIndex%mNumTexCols;

    final float ratioW = 1.0f/mNumTexCols;

    final float ratioH = 1.0f/mNumTexRows;

    final Static4D[] maps = new Static4D[1];

    maps[0] = new Static4D(col*ratioW, row*ratioH, ratioW, ratioH);

    mMesh.setTextureMap(maps, mMaxNumCubitFaces*cubit+face);

    }

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

// figure out the puzzle face to which (cubit,face) belongs, repaint all (cubit,face) pairs to

// the new color.

  void repaintPuzzleFace(int cubit, int face, int newColor)

    {

    int oldColorIndex = getDefaultCubitFaceColor(cubit,face);

    if( oldColorIndex<0 || oldColorIndex>=mNumFaceColors )

      {

      System.out.println("TwistyObject.repaintPuzzleFace: index="+oldColorIndex);

      return;

      }

    int oldColor = mColorTable[oldColorIndex];

    if( oldColor!=newColor )

      {

      oldColor = mOriginalColorTable[oldColorIndex];

      changeColorInTexture(oldColor,newColor);

      mColorTable[oldColorIndex] = newColor;

      setTexture();

      int numOrig = numberOfDifferentColors(mOriginalColorTable);

      int numNow  = numberOfDifferentColors(mColorTable);

      mCurrentColorSchemeSubmittable = (numOrig==numNow);

      }

    }

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

// this doesn't have to return the real, displayed color - but the default one (from Shape classes).

// The real displayed color can be different because of the sticker color overrides.

  int getDefaultCubitFaceColor(int cubit, int face)

    {

    int puzzleFace = getPuzzleFace(cubit,face);

    if( puzzleFace>=0 ) puzzleFace %= mNumFaceColors;

    return puzzleFace;

    }

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

  void resetAllTextureMaps()

    {

    final float ratioW = 1.0f/mNumTexCols;

    final float ratioH = 1.0f/mNumTexRows;

    int cubColor, stiShape, texIndex, variant, row, col;

    for(int cubit=0; cubit<mNumCubits; cubit++)

      {

      final Static4D[] maps = new Static4D[mMaxNumCubitFaces];

      variant = getCubitVariant(cubit);

      for( int face=0; face<mMaxNumCubitFaces; face++)

        {

        cubColor = getDefaultCubitFaceColor(cubit,face);

        stiShape = getVariantStickerShape(variant,face);

        texIndex = cubColor<0 || stiShape<0 ? mNumTextures-mNumOverrides : stiShape*mNumFaceColors + cubColor;

        row      = (mNumTexRows-1) - texIndex/mNumTexCols;

        col      = texIndex%mNumTexCols;

        maps[face] = new Static4D( col*ratioW, row*ratioH, ratioW, ratioH);

        }

      mMesh.setTextureMap(maps, mMaxNumCubitFaces*cubit);

      }

    overrideCubitFaceColor();

    }

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

  private void overrideCubitFaceColor()

    {

    final float ratioW = 1.0f/mNumTexCols;

    final float ratioH = 1.0f/mNumTexRows;

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

      {

      int[] cubitFaces = mStickerOverrides[i].getCubitFaces();

      int length = cubitFaces.length/2;

      int color = mNumTextures-mNumOverrides+1+i;

      int row   = (mNumTexRows-1) - color/mNumTexCols;

      int col   = color%mNumTexCols;

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

        {

        final Static4D[] maps = new Static4D[1];

        maps[0] = new Static4D(col*ratioW, row*ratioH, ratioW, ratioH);

        int cubit = cubitFaces[2*j];

        int face  = cubitFaces[2*j+1];

        mMesh.setTextureMap(maps, mMaxNumCubitFaces*cubit+face);

        }

      }

    }

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

  private int numberOfDifferentColors(int[] table)

    {

    int ret=0;

    int len = table.length;

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

      {

      boolean increase = true;

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

        if( table[j]==table[i] )

          {

          increase = false;

          break;

          }

      if( increase ) ret++;

      }

    return ret;

    }

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

  private void restoreSti(String key, OperatingSystemInterface os)

    {

    mTextureBorderMultiplier = os.getFloat(key+"_border", 1.0f);

    mTextureCornerMultiplier = os.getFloat(key+"_corner", 1.0f);

    String colors = os.getString(key+"_colors", null);

    boolean different = false;

    if( colors!=null ) different = restoreColors(colors,mColorTable);

    if( different || mTextureBorderMultiplier!=1.0f || mTextureCornerMultiplier!=1.0f )

      {

      createTexture(mTextureBorderMultiplier,mTextureCornerMultiplier);

      setTexture();

      int numOrig = numberOfDifferentColors(mOriginalColorTable);

      int numNow  = numberOfDifferentColors(mColorTable);

      mCurrentColorSchemeSubmittable = (numOrig==numNow);

      }

    }

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

  synchronized void restorePreferences(OperatingSystemInterface os)

    {

    String key = getShortName();

    super.restorePreferences(key,os);

    restoreSti(key,os);

    }

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

  synchronized void restoreStickers(OperatingSystemInterface os)

    {

    String key = getShortName();

    restoreSti(key,os);

    }

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

  void savePreferences(OperatingSystemInterface os)

    {

    String key = getShortName();

    super.savePreferences(key,os);

    os.putFloat(key+"_border", mTextureBorderMultiplier);

    os.putFloat(key+"_corner", mTextureCornerMultiplier);

    os.putString(key+"_colors", createColors(mColorTable) );

    }

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

  public void removePreferences(OperatingSystemInterface os)

    {

    String key = getShortName();

    super.removePreferences(key,os);

    os.remove(key+"_border");

    os.remove(key+"_corner");

    os.remove(key+"_colors");

    }

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

  private String createColors(int[] table)

    {

    StringBuilder sb = new StringBuilder();

    int len = table!=null ? table.length : 0;

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

      {

      sb.append(table[i]);

      sb.append(',');

      }

    return sb.toString();

    }

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

  private boolean restoreColors(String colors, int[] table)

    {

    String[] parts = colors.split(",");

    int len = parts.length;

    boolean ret = false;

    try

      {

      for(int s=0; s<len; s++)

        {

        table[s] = Integer.parseInt(parts[s]);

        if( table[s]!=mOriginalColorTable[s] ) ret = true;

        }

      }

    catch(NumberFormatException nfe)

      {

      for(int s=0; s<len; s++) table[s] = mOriginalColorTable[s];

      return false;

      }

    return ret;

    }

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

  private float computeRadiusCorrection(float[][] sticker, int curr, int len)

    {

    final float A = 0.8f;  // 0<A<1

    int prev = curr>0 ? curr-1 : len-1;

    int next = curr<len-1 ? curr+1 : 0;

    float v1x = sticker[prev][0]-sticker[curr][0];

    float v1y = sticker[prev][1]-sticker[curr][1];

    float v2x = sticker[next][0]-sticker[curr][0];

    float v2y = sticker[next][1]-sticker[curr][1];

    float len1= v1x*v1x+v1y*v1y;

    float len2= v2x*v2x+v2y*v2y;

    float cos = (v1x*v2x+v1y*v2y) / ( (float)Math.sqrt(len1*len2) );

    return 1-A*cos;

    }

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

// might be overridden in subclasses which want per-edge radii

  protected float[][][] getStickerRadii()

    {

    float radius = getStickerRadius();

    int numStickers = mStickerCoords.length;

    float[][][] ret = new float[numStickers][][];

    for(int s=0; s<numStickers; s++)

      {

      int numLoops = mStickerCoords[s].length;

      ret[s] = new float[numLoops][];

      for(int l=0; l<numLoops; l++)

        {

        int numVertices = mStickerCoords[s][l].length;

        ret[s][l] = new float[numVertices];

        for(int v=0; v<numVertices; v++) ret[s][l][v] = radius;

        }

      }

    return ret;

    }

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

// might be overridden in subclasses which want per-edge strokes

  protected float[][][] getStickerStrokes()

    {

    float stroke = getStickerStroke();

    int numStickers = mStickerCoords.length;

    float[][][] ret = new float[numStickers][][];

    for(int s=0; s<numStickers; s++)

      {

      int numLoops = mStickerCoords[s].length;

      ret[s] = new float[numLoops][];

      for(int l=0; l<numLoops; l++)

        {

        int numVertices = mStickerCoords[s][l].length;

        ret[s][l] = new float[numVertices];

        for(int v=0; v<numVertices; v++) ret[s][l][v] = stroke;

        }

      }

    return ret;

    }

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

  public ObjectSticker retSticker(int sticker)

    {

    if( mStickers==null )

      {

      float[][][] radii   = getStickerRadii();

      float[][][] strokes = getStickerStrokes();

      float[][][] angles  = getStickerAngles();

      int numStickers = mStickerCoords.length;

      mStickers = new ObjectSticker[numStickers];

      for(int s=0; s<numStickers; s++)

        {

        float scale = mStickerScales.length>s ? mStickerScales[s] : 1.0f;

        int numLoops = mStickerCoords[s].length;

        float[][] rad = new float[numLoops][];

        float[][] str = new float[numLoops][];

        for(int l=0; l<numLoops; l++)

          {

          int numVerts = mStickerCoords[s][l].length;

          rad[l] = new float[numVerts];

          str[l] = new float[numVerts];

          float[] st = strokes[s][l];

          float[] ra = radii[s][l];

          for(int v=0; v<numVerts; v++)

            {

            rad[l][v] = ra[v] * computeRadiusCorrection(mStickerCoords[s][l],v,numVerts) / scale;

            str[l][v] = st[v] / scale;

            }

          }

        mStickers[s] = new ObjectSticker(mStickerCoords[s], (angles==null ? null : angles[s]) ,rad, str);

        }

      }

    return mStickers[sticker];

    }

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

// the getFaceColors + final INTERNAL_COLOR in a grid (so that we do not exceed the maximum texture size)

  void createTexture(float border, float corner)

    {

    Paint paint = new Paint();

    Canvas canvas = new Canvas(mBitmap);

    paint.setAntiAlias(true);

    paint.setTextAlign(Paint.Align.CENTER);

    paint.setStyle(Paint.Style.FILL);

    paint.setColor(getInternalColor());

    canvas.drawRect(0, 0, mNumTexCols*mTexHeight, mNumTexRows*mTexHeight, paint);

    mTextureBorderMultiplier = border;

    mTextureCornerMultiplier = corner;

    int texture = 0;

    FactorySticker factory = FactorySticker.getInstance();

    for(int row=0; row<mNumTexRows; row++)

      for(int col=0; col<mNumTexCols; col++)

        {

        if( texture<mNumTextures-mNumOverrides )

          {

          ObjectSticker sticker = retSticker(texture/mNumFaceColors);

          int color = mColorTable[texture%mNumFaceColors];

          factory.drawRoundedPolygons( canvas, paint, col*mTexHeight, (mNumTexRows-row)*mTexHeight, color,

                                       mTexHeight, sticker,mTextureBorderMultiplier,mTextureCornerMultiplier);

          }

        else if( texture>mNumTextures-mNumOverrides && texture<=mNumTextures )

          {

          int color = mStickerOverrides[mNumTextures-texture].getColor();

          factory.drawSolidColor(canvas, paint, col*mTexHeight, (mNumTexRows-row)*mTexHeight, color, mTexHeight);

          }

        texture++;

        }

    }

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

  private void changeColorInTexture(int oldColor, int newColor)

    {

    Paint paint = new Paint();

    Canvas canvas = new Canvas(mBitmap);

    paint.setAntiAlias(true);

    int texture = 0;

    FactorySticker factory = FactorySticker.getInstance();

    for(int row=0; row<mNumTexRows; row++)

      for(int col=0; col<mNumTexCols; col++)

        {

        if( texture<mNumTextures-mNumOverrides )

          {

          int color = mOriginalColorTable[texture%mNumFaceColors];

          if( color==oldColor )

            {

            ObjectSticker sticker = retSticker(texture/mNumFaceColors);

            factory.drawRoundedPolygons( canvas, paint, col*mTexHeight, (mNumTexRows-row)*mTexHeight,

                                         newColor, mTexHeight, sticker,mTextureBorderMultiplier,mTextureCornerMultiplier);

            }

          }

        texture++;

        }

    }

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

  void setTexture()

    {

    if( mBitmap==null )

      {

      mBitmap = Bitmap.createBitmap( mNumTexCols*mTexHeight, mNumTexRows*mTexHeight, Bitmap.Config.ARGB_4444);

      createTexture(mTextureBorderMultiplier,mTextureCornerMultiplier);

      }

    if( !mNodeTexture.setTextureAlreadyInverted(mBitmap) )

      {

      int max = DistortedLibrary.getMaxTextureSize();

      System.out.println("failed to set texture of size "+mBitmap.getWidth()+"x"+mBitmap.getHeight()+" max is "+max);

      }

    }

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

  public int getCubitFaceStickerIndex(int cubit, int face)

    {

    Static4D texMap = mMesh.getTextureMap(mMaxNumCubitFaces*cubit + face);

    int x = (int)(texMap.get0()/texMap.get2());

    int y = (int)(texMap.get1()/texMap.get3());

    return (mNumTexRows-1-y)*mNumTexCols + x;

    }

}