Distorted Android

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

// Copyright 2017 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.library.effect;

import android.opengl.Matrix;

import org.distorted.library.type.Data3D;

import org.distorted.library.type.Data4D;

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

public class MatrixEffectQuaternion extends MatrixEffect

  {

  private Data4D mQuaternion;

  private Data3D mCenter;

  private static float[] mTmpMatrix1 = new float[16];

  private static float[] mTmpMatrix2 = new float[16];

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

/**

 * Rotates the Object by quaternion.

 *

 * @param quaternion Quaternion describing the rotation.

 * @param center     Coordinates of the Point we are rotating around.

 */

  public MatrixEffectQuaternion(Data4D quaternion, Data3D center )

    {

    super(EffectName.QUATERNION);

    mQuaternion = quaternion;

    mCenter = center;

    }

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

  public boolean compute(float[] uniforms, int index, long currentDuration, long step )

    {

    mCenter.get(uniforms,index+4,currentDuration,step);

    return mQuaternion.get(uniforms,index,currentDuration,step);

    }

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

  public void apply(float[] matrix, float[] uniforms, int index)

    {

    float qX = uniforms[NUM_UNIFORMS*index  ];

    float qY = uniforms[NUM_UNIFORMS*index+1];

    float qZ = uniforms[NUM_UNIFORMS*index+2];

    float qW = uniforms[NUM_UNIFORMS*index+3];

    float x = uniforms[NUM_UNIFORMS*index+4];

    float y = uniforms[NUM_UNIFORMS*index+5];

    float z = uniforms[NUM_UNIFORMS*index+6];

    Matrix.translateM(matrix, 0, x,-y, z);

    multiplyByQuat( matrix, qX, qY, qZ, qW);

    Matrix.translateM(matrix, 0,-x, y,-z);

    }

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

  private static void multiplyByQuat(float[] matrix, float X, float Y, float Z, float W)

    {

    float xx= X * X;

    float xy= X * Y;

    float xz= X * Z;

    float xw= X * W;

    float yy= Y * Y;

    float yz= Y * Z;

    float yw= Y * W;

    float zz= Z * Z;

    float zw= Z * W;

    mTmpMatrix1[0]  = 1 - 2 * ( yy + zz );

    mTmpMatrix1[1]  =     2 * ( xy - zw );

    mTmpMatrix1[2]  =     2 * ( xz + yw );

    mTmpMatrix1[4]  =     2 * ( xy + zw );

    mTmpMatrix1[5]  = 1 - 2 * ( xx + zz );

    mTmpMatrix1[6]  =     2 * ( yz - xw );

    mTmpMatrix1[8]  =     2 * ( xz - yw );

    mTmpMatrix1[9]  =     2 * ( yz + xw );

    mTmpMatrix1[10] = 1 - 2 * ( xx + yy );

    mTmpMatrix1[3]  = mTmpMatrix1[7] = mTmpMatrix1[11] = mTmpMatrix1[12] = mTmpMatrix1[13] = mTmpMatrix1[14] = 0;

    mTmpMatrix1[15] = 1;

    Matrix.multiplyMM(mTmpMatrix2, 0, matrix, 0, mTmpMatrix1, 0);

    matrix[ 0] = mTmpMatrix2[ 0];

    matrix[ 1] = mTmpMatrix2[ 1];

    matrix[ 2] = mTmpMatrix2[ 2];

    matrix[ 3] = mTmpMatrix2[ 3];

    matrix[ 4] = mTmpMatrix2[ 4];

    matrix[ 5] = mTmpMatrix2[ 5];

    matrix[ 6] = mTmpMatrix2[ 6];

    matrix[ 7] = mTmpMatrix2[ 7];

    matrix[ 8] = mTmpMatrix2[ 8];

    matrix[ 9] = mTmpMatrix2[ 9];

    matrix[10] = mTmpMatrix2[10];

    matrix[11] = mTmpMatrix2[11];

    matrix[12] = mTmpMatrix2[12];

    matrix[13] = mTmpMatrix2[13];

    matrix[14] = mTmpMatrix2[14];

    matrix[15] = mTmpMatrix2[15];

    }

  }