Distorted Android

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

// Copyright 2017 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

// This library 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                             //

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

package org.distorted.library.effect;

import org.distorted.library.helpers.MatrixHelper;

import org.distorted.library.type.Data3D;

import org.distorted.library.type.Data4D;

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

/**

 * Rotate the Mesh by a quaternion.

 */

public class MatrixEffectQuaternion extends MatrixEffect

  {

  private final Data4D mQuaternion;

  private final Data3D mCenter;

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

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

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

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

    {

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

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

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

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

    {

    float qX = uniforms[NUM_FLOAT_UNIFORMS*index  ];

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

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

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

    float x = uniforms[NUM_FLOAT_UNIFORMS*index+CENTER_OFFSET  ];

    float y = uniforms[NUM_FLOAT_UNIFORMS*index+CENTER_OFFSET+1];

    float z = uniforms[NUM_FLOAT_UNIFORMS*index+CENTER_OFFSET+2];

    MatrixHelper.translate(matrixP, x, y, z);

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

    MatrixHelper.translate(matrixP,-x,-y,-z);

    MatrixHelper.translate(matrixV, x, y, z);

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

    MatrixHelper.translate(matrixV,-x,-y,-z);

    }

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

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

    MatrixHelper.multiply(mTmpMatrix2, matrix, mTmpMatrix1);

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

    }

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

// PUBLIC API

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

/**

 * Rotate the Mesh by a 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;

    }

  }