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.Canvas;

import android.graphics.Paint;

import org.distorted.library.effect.EffectQuality;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.PostprocessEffectGlow;

import org.distorted.library.effect.VertexEffectMove;

import org.distorted.library.effect.VertexEffectScale;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.main.InternalOutputSurface;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.mesh.MeshQuad;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Dynamic;

import org.distorted.library.type.Dynamic2D;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Dynamic4D;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.main.R;

import java.util.Random;

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

public class OverlayStars extends OverlayGeneric implements EffectListener

{

   private static final int DUR_MOV =  4000;

   private static final int DUR_GLO =  2000;

   private static final int[] colors = new int[] {0,0,1,  1,0,1,  1,0,0,  1,1,0,  0,1,0,  1,1,1}; // blue, pink, red, yellow, green, white

   private static final int INDEX = 5;

   private ListenerOverlay mListener;

   private DistortedNode mStarsNode, mCountNode;

   private DistortedScreen mScreen;

   private DistortedTexture mStarsTexture, mCountTexture;

   private Bitmap mCountBitmap;

   private Canvas mCountCanvas;

   private Paint mPaint;

   private int mBmpW, mBmpH;

   private float mWidth, mHeight;

   private Random mRandom;

   private long mMoveID, mGlowID;

   private int mTotalStars, mNewStars;

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

   private Dynamic3D createRandomMove()

      {

      Dynamic3D move = new Dynamic3D();

      move.setMode(Dynamic.MODE_PATH);

      move.setDuration(DUR_MOV);

      move.setCount(0.5f);

      float widthS = (mRandom.nextFloat()-0.5f)*mWidth*1.10f;

      float widthM = widthS + (mRandom.nextFloat()-0.5f)*mWidth*0.2f;

      float heighS = mRandom.nextFloat()*mHeight*0.2f;

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

      Static3D pointS = new Static3D(widthS,mHeight*0.55f+heighS,0);

      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);

      return move;

      }

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

   private DistortedNode createStarsNode(Resources res)

      {

      // texture /////////////////////////////////////////////////////

      if( mStarsTexture==null )

         {

         mStarsTexture = new DistortedTexture();

         Bitmap star = BitmapFactory.decodeResource(res, R.drawable.star);

         mBmpW = star.getWidth();

         mBmpH = star.getHeight();

         mStarsTexture.setTexture(star);

         }

      // mesh ////////////////////////////////////////////////////////

      MeshQuad[] mesh = new MeshQuad[mNewStars+1];

      for(int i=0; i<mNewStars+1; i++)

         {

         mesh[i] = new MeshQuad();

         mesh[i].setEffectAssociation(0,(i>=mNewStars?2:1),i);

         }

      MeshJoined wholeMesh = new MeshJoined(mesh);

      // effects: main ///////////////////////////////////////////////

      DistortedEffects effects = new DistortedEffects();

      float scaleM  = mWidth*0.40f;

      float scaleP  = mWidth*0.15f;

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

      VertexEffectMove mainMove     = new VertexEffectMove(moveM);

      VertexEffectScale mainScale   = new VertexEffectScale(scaleM);

      mainMove.setMeshAssociation(2,-1);

      mainScale.setMeshAssociation(2,-1);

      // effects: moving stars ///////////////////////////////////////

      VertexEffectScale scaleE = new VertexEffectScale(scaleP);

      scaleE.setMeshAssociation(1,-1);

      effects.apply(scaleE);

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

        {

        Dynamic3D moveP = createRandomMove();

        VertexEffectMove moveE= new VertexEffectMove(moveP);

        moveE.setMeshAssociation(0,i);

        effects.apply(moveE);

        if( i==0 )

           {

           mMoveID = moveE.getID();

           moveE.notifyWhenFinished(this);

           }

        }

      // main effect queue ///////////////////////////////////////////

      effects.apply(mainMove);

      effects.apply(mainScale);

      return new DistortedNode(mStarsTexture,effects,wholeMesh);

      }

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

   private void renderStars(int numStars)

      {

      String txt = ""+numStars;

      mCountCanvas.drawText(txt,mBmpW*0.5f,mBmpH*0.64f,mPaint);

      mCountTexture.setTexture(mCountBitmap);

      }

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

   private DistortedNode createCountNode()

      {

      // texture /////////////////////////////////////////////////////

      if( mCountTexture==null )

         {

         mCountTexture = new DistortedTexture();

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

         mCountCanvas = new Canvas(mCountBitmap);

         mPaint = new Paint();

         mPaint.setColor(0xff000000);

         mPaint.setTextSize(mBmpH*0.28f);

         mPaint.setAntiAlias(true);

         mPaint.setTextAlign(Paint.Align.CENTER);

         renderStars(mTotalStars);

         }

      // mesh ////////////////////////////////////////////////////////

      MeshQuad mesh = new MeshQuad();

      // effects: main ///////////////////////////////////////////////

      DistortedEffects effects = new DistortedEffects();

      float scaleM  = mWidth*0.40f;

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

      MatrixEffectMove mainMove  = new MatrixEffectMove(moveM);

      MatrixEffectScale mainScale= new MatrixEffectScale(scaleM);

      // main effect queue ///////////////////////////////////////////

      effects.apply(mainMove);

      effects.apply(mainScale);

      return new DistortedNode(mCountTexture,effects,mesh);

      }

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

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

      {

      if( mRandom==null ) mRandom = new Random();

      mScreen = screen;

      mListener= listener;

      DataStars stars = (DataStars)data;

      mTotalStars = stars.getTotal();

      mNewStars   = stars.getNew();

      Resources res = stars.getResources();

      mWidth = mScreen.getWidth();

      mHeight= mScreen.getHeight();

      mStarsNode = createStarsNode(res);

      mStarsNode.glDepthMask(false);

      mStarsNode.glStencilMask(0);

      mStarsNode.enableDepthStencil(InternalOutputSurface.NO_DEPTH_NO_STENCIL);

      mScreen.attach(mStarsNode);

      mCountNode = createCountNode();

      mCountNode.glDepthMask(false);

      mCountNode.glStencilMask(0);

      mCountNode.enableDepthStencil(InternalOutputSurface.NO_DEPTH_NO_STENCIL);

      mScreen.attach(mCountNode);

      return 0;

      }

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

   public void effectFinished(long id)

      {

      if( id==mMoveID )

         {

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

         haloRadius.add(new Static2D( 0, 0));

         haloRadius.add(new Static2D(15,50));

         haloRadius.add(new Static2D( 0, 0));

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

         Static4D P1    = new Static4D(colors[3*INDEX],colors[3*INDEX+1], colors[3*INDEX+2], 0.0f);

         Static4D P2    = new Static4D(colors[3*INDEX],colors[3*INDEX+1], colors[3*INDEX+2], 0.5f);

         color.add(P1);

         color.add(P2);

         color.add(P1);

         PostprocessEffectGlow glow = new PostprocessEffectGlow(haloRadius,color);

         glow.setQuality(EffectQuality.MEDIUM);

         mGlowID = glow.getID();

         glow.notifyWhenFinished(this);

         DistortedEffects effects = mStarsNode.getEffects();

         effects.apply(glow);

         renderStars(mTotalStars+mNewStars);

         }

      if( id==mGlowID )

         {

         mScreen.detach(mStarsNode);

         mStarsNode.markForDeletion();

         mStarsNode=null;

         mScreen.detach(mCountNode);

         mCountNode.markForDeletion();

         mCountNode=null;

         mListener.overlayFinished(id);

         }

      }

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

  @SuppressWarnings("unused")

  public static void enableEffects()

     {

     VertexEffectMove.enable();

     VertexEffectScale.enable();

     PostprocessEffectGlow.enable();

     }

}