Magic Cube

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

// Copyright 2022 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.overlays;

import android.content.res.Resources;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Paint;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectScale;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.message.EffectListener;

public class OverlayStars extends OverlayGeneric implements EffectListener

{

   private static final int DUR_MOV =  3500;

   private static final int DUR_GLO =   600;

   private Bitmap mCountBitmap, mStarBitmap;

   private Paint mPaint;

   private int mBmpW, mBmpH;

   private Random mRandom;

   private Dynamic1D mAlphaStrength;

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

      Dynamic3D move = new Dynamic3D();

      move.setCount(0.5f);

      float heighM = (mRandom.nextFloat()-0.5f)*mHeight*0.2f;

      Static3D pointM = new Static3D(widthM,mHeight*0.25f+heighM,0);

      Static3D pointE = new Static3D(0,0,0);

         {

         move.add(pointS);

         move.add(pointM);

         move.add(pointE);

         move.add(pointF);

         }

      else

         {

         move.add(pointF);

         move.add(pointE);

         move.add(pointM);

         move.add(pointS);

         }

      return move;

      }

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

      {

      if( mAlpha==null )

         {

         mAlphaStrength = new Dynamic1D();

         mAlphaStrength.setMode(Dynamic.MODE_PATH);

         mAlphaStrength.setDuration(DUR_APP);

         mAlphaStrength.setCount(0.5f);

         equipAlpha(mAlphaStrength,appear);

         mAlpha = new FragmentEffectAlpha(mAlphaStrength);

         }

      else

         {

         mAlphaStrength.resetToBeginning();

         equipAlpha(mAlphaStrength,appear);

         }

      }

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

   private void equipAlpha(Dynamic1D alpha, boolean appear)

      {

      Static1D point0 = new Static1D(0.0f);

      Static1D point1 = new Static1D(1.0f);

      alpha.removeAll();

      if( appear )

        {

        alpha.add(point0);

        alpha.add(point1);

        }

      else

        {

        alpha.add(point1);

        alpha.add(point0);

        }

      }

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

      {

      if( total>=10000 )

         {

         mTextHeight = 0.610f;

         return 0.16f;

         }

      if( total>= 1000 )

         {

         mTextHeight = 0.625f;

         return 0.20f;

         }

      if( total>=  100 )

         {

         mTextHeight = 0.640f;

         return 0.26f;

         }

      mTextHeight = 0.655f;

      return 0.28f;

      }

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

   private void createBitmap(Resources res, int total)

      mBmpW = mStarBitmap.getWidth();

      mBmpH = mStarBitmap.getHeight();

      mCountBitmap = Bitmap.createBitmap(mBmpW,mBmpH,Bitmap.Config.ARGB_8888);

      mCountCanvas = new Canvas(mCountBitmap);

      float quotient = computeQuotientAndTextHeight(total);

      mPaint.setColor(0xff000000);

      mPaint.setTextAlign(Paint.Align.CENTER);

      }

      {

      DistortedTexture texture = new DistortedTexture();

      texture.setTexture(mStarBitmap);

         mesh[i] = new MeshQuad();

      DistortedEffects effects = new DistortedEffects();

      effects.apply(scaleE);

        if( i==0 )

           {

           mMoveID = moveE.getID();

           moveE.notifyWhenFinished(this);

           }

      }

   private DistortedNode createNodeCentral(int numStars)

      {

      mTexture = new DistortedTexture();

      renderStars(numStars);

      MeshQuad mesh = new MeshQuad();

      DistortedEffects effects = new DistortedEffects();

      float scaleM  = mWidth*0.40f;

      Static3D moveM= new Static3D(0,0,1);

      MatrixEffectMove move  = new MatrixEffectMove(moveM);

      MatrixEffectScale scale= new MatrixEffectScale(scaleM);

      effects.apply(move);

      effects.apply(scale);

      effects.apply(mAlpha);

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

   private void renderStars(int numStars)

      {

      String txt = ""+numStars;

      mCountCanvas.drawBitmap(mStarBitmap,0,0,null);

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

   public long startOverlay(DistortedScreen screen, ListenerOverlay listener, DataGeneric data)

      {

      mListener= listener;

      DataStars stars = (DataStars)data;

      mHeight= mScreen.getHeight();

      if( !mIncrease ) mNewStars = -mNewStars;

      mNodeFalling.enableDepthStencil(InternalOutputSurface.NO_DEPTH_NO_STENCIL);

      mScreen.attach(mNodeFalling);

      mNodeCentral = createNodeCentral(mTotalStars);

      mNodeCentral.glDepthMask(false);

      mScreen.attach(mNodeCentral);

      return 0;

      }

   private PostprocessEffectGlow constructGlow(boolean firstPhase)

      {

      Dynamic2D haloRadius = new Dynamic2D(DUR_GLO,0.5f);

      Static2D point21 = new Static2D(15,50);

      Dynamic4D color = new Dynamic4D(DUR_GLO, 0.5f);

      Static4D point40 = new Static4D(1,1,1,0.0f);

      Static4D point41 = new Static4D(1,1,1,0.8f);

      if( firstPhase )

         {

         haloRadius.add(point21);

         color.add(point40);

         color.add(point41);

      else

         {

         haloRadius.add(point20);

         color.add(point41);

         color.add(point40);

      PostprocessEffectGlow glow = new PostprocessEffectGlow(haloRadius,color);

      glow.setQuality(EffectQuality.MEDIUM);

      glow.notifyWhenFinished(this);

      return glow;

      }

   public void effectFinished(long id)

      {

         {

         mGlow1ID = glow.getID();

      if( id==mGlow1ID )

         {

         mGlow2ID = glow.getID();

         DistortedEffects effects = mNodeCentral.getEffects();

         effects.abortById(mGlow1ID);

         effects.apply(glow);

         effects.abortById(mGlow2ID);

         mAlphaID = mAlpha.getID();

         mAlpha.notifyWhenFinished(this);

      if( id==mAlphaID )

         {

         mNodeCentral.markForDeletion();

         mNodeCentral=null;

         mScreen.detach(mNodeFalling);

         mNodeFalling.markForDeletion();

         mNodeFalling=null;

         }

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

  @SuppressWarnings("unused")

  public static void enableEffects()

     {

     VertexEffectScale.enable();