Magic Cube

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

// Copyright 2023 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.solverui;

import android.content.res.Resources;

import android.opengl.GLES30;

import android.opengl.GLSurfaceView;

import com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.VertexEffectQuaternion;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.InternalOutputSurface;

import org.distorted.library.mesh.MeshBase;

import org.distorted.main.BuildConfig;

import org.distorted.objectlib.effects.BaseEffect;

import org.distorted.objectlib.main.ObjectControl;

import java.io.InputStream;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

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

public class SolverRenderer implements GLSurfaceView.Renderer, DistortedLibrary.LibraryUser

{

   public static final float BRIGHTNESS = 0.30f;

   private final SolverSurfaceView mView;

   private final Resources mResources;

   private final DistortedScreen mScreen;

   private final ObjectControl mControl;

   private boolean mErrorShown;

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

   SolverRenderer(SolverSurfaceView v)

     {

     mView = v;

     mResources = v.getResources();

     mErrorShown = false;

     mControl = v.getObjectControl();

     mScreen = new DistortedScreen();

     mScreen.glClearColor(BRIGHTNESS, BRIGHTNESS, BRIGHTNESS, 1.0f);

     mScreen.enableDepthStencil(InternalOutputSurface.DEPTH_NO_STENCIL);

     }

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

   DistortedScreen getScreen()

     {

     return mScreen;

     }

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

// various things are done here delayed, 'after the next render' as not to be done mid-render and

// cause artifacts.

   @Override

   public void onDrawFrame(GL10 glUnused)

     {

     long time = System.currentTimeMillis();

     mControl.preRender();

     mScreen.render(time);

     }

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

   @Override

   public void onSurfaceChanged(GL10 glUnused, int width, int height)

      {

      mScreen.resize(width,height);

      mView.setScreenSize(width,height);

      }

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

   @Override

   public void onSurfaceCreated(GL10 glUnused, EGLConfig config)

      {

      DistortedLibrary.setMax(EffectType.VERTEX,ObjectControl.MAX_QUATS+1);

      MeshBase.setMaxEffComponents(ObjectControl.MAX_MOVING_PARTS);

      VertexEffectRotate.enable();

      VertexEffectQuaternion.enable();

      BaseEffect.Type.enableEffects();

      DistortedLibrary.onSurfaceCreated(this,1);

      DistortedLibrary.setCull(true);

      }

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

   public void distortedException(Exception ex)

     {

     String message = ex.getMessage();

     String shading = GLES30.glGetString(GLES30.GL_SHADING_LANGUAGE_VERSION);

     String version = GLES30.glGetString(GLES30.GL_VERSION);

     String vendor  = GLES30.glGetString(GLES30.GL_VENDOR);

     String renderer= GLES30.glGetString(GLES30.GL_RENDERER);

     if( message==null ) message = "exception NULL";

     if( BuildConfig.DEBUG )

       {

       android.util.Log.e("DISTORTED", message );

       android.util.Log.e("DISTORTED", "GLSL Version "+shading);

       android.util.Log.e("DISTORTED", "GL Version "  +version);

       android.util.Log.e("DISTORTED", "GL Vendor "   +vendor);

       android.util.Log.e("DISTORTED", "GL Renderer " +renderer);

       }

     else

       {

       FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

       crashlytics.setCustomKey("DistortedError", message );

       crashlytics.setCustomKey("GLSL Version"  , shading );

       crashlytics.setCustomKey("GLversion"     , version );

       crashlytics.setCustomKey("GL Vendor "    , vendor  );

       crashlytics.setCustomKey("GLSLrenderer"  , renderer);

       crashlytics.recordException(ex);

       }

     int glsl = DistortedLibrary.getGLSL();

     if( glsl< 300 && !mErrorShown )

       {

       mErrorShown = true;

       SolverActivity act = (SolverActivity)mView.getContext();

       act.OpenGLError();

       }

     }

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

   public InputStream localFile(int fileID)

     {

     return mResources.openRawResource(fileID);

     }

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

   public void logMessage(String message)

     {

     android.util.Log.e("Rubik", message );

     }

}