Distorted Android

import org.distorted.library.mesh.MeshObject;

 * The queues hold actual effects to be applied to a given (InputSurface,MeshObject) combo.

  private void displayNormals(MeshObject mesh)

    GLES31.glVertexAttribPointer(mNormalProgram.mAttribute[0], MeshObject.POS_DATA_SIZE, GLES31.GL_FLOAT, false, 0, 0);

  void drawPrivOIT(float halfW, float halfH, MeshObject mesh, DistortedOutputSurface surface, long currTime)

    GLES31.glVertexAttribPointer(mMainOITProgram.mAttribute[0], MeshObject.POS_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET0);

    GLES31.glVertexAttribPointer(mMainOITProgram.mAttribute[1], MeshObject.NOR_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET1);

    GLES31.glVertexAttribPointer(mMainOITProgram.mAttribute[2], MeshObject.TEX_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET2);

  void drawPriv(float halfW, float halfH, MeshObject mesh, DistortedOutputSurface surface, long currTime)

    GLES31.glVertexAttribPointer(mMainProgram.mAttribute[0], MeshObject.POS_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET0);

    GLES31.glVertexAttribPointer(mMainProgram.mAttribute[1], MeshObject.NOR_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET1);

    GLES31.glVertexAttribPointer(mMainProgram.mAttribute[2], MeshObject.TEX_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET2);

 * single (InputSurface,MeshObject) combo.

import org.distorted.library.mesh.MeshObject;

  private MeshObject mMesh;

 * @param mesh MeshObject to put into the new Node.

  public DistortedNode(DistortedSurface surface, DistortedEffects effects, MeshObject mesh)

 * @param mesh MeshObject to initialize our child Node with.

  public DistortedNode attach(DistortedSurface surface, DistortedEffects effects, MeshObject mesh)

  public MeshObject getMesh()

import org.distorted.library.mesh.MeshObject;

 * @param mesh MeshObject to initialize our child Node with.

  public DistortedNode attach(DistortedSurface surface, DistortedEffects effects, MeshObject mesh)

import org.distorted.library.mesh.MeshObject;

  private MeshObject fpsMesh;

import org.distorted.library.mesh.MeshObject;

  public int getDepth(MeshObject mesh)

import org.distorted.library.mesh.MeshObject;

      MeshObject mesh = node.getMesh();

      GLES31.glVertexAttribPointer(mPreProgram.mAttribute[0], MeshObject.POS_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET0);

      GLES31.glVertexAttribPointer(mPreProgram.mAttribute[1], MeshObject.NOR_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET1);

      GLES31.glVertexAttribPointer(mPreProgram.mAttribute[2], MeshObject.TEX_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET2);

public class MeshCubes extends MeshObject

public class MeshFlat extends MeshObject

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

// Copyright 2016 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.mesh;

import android.opengl.GLES31;

import org.distorted.library.main.Distorted;

import org.distorted.library.main.DistortedBuffer;

import java.nio.FloatBuffer;

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

/**

 * Abstract class which represents a Mesh, ie 3 arrays of Vertex attributes: 1) positions

 * 2) normals 3) texture coordinates.

 * <p>

 * If you want to render to a particular shape, extend from here, construct the attrib FloatBuffer

 * and provide correct numVertices.

 */

public abstract class MeshObject

   {

   private static final int BYTES_PER_FLOAT = 4;

   public static final int POS_DATA_SIZE= 3;

   public static final int NOR_DATA_SIZE= 3;

   public static final int TEX_DATA_SIZE= 2;

   public static final int OFFSET0 =                                                           0;

   public static final int OFFSET1 = (POS_DATA_SIZE                            )*BYTES_PER_FLOAT;

   public static final int OFFSET2 = (POS_DATA_SIZE+NOR_DATA_SIZE              )*BYTES_PER_FLOAT;

   public static final int TFSIZE  = (POS_DATA_SIZE+POS_DATA_SIZE              )*BYTES_PER_FLOAT;

   public static final int VERTSIZE= (POS_DATA_SIZE+NOR_DATA_SIZE+TEX_DATA_SIZE)*BYTES_PER_FLOAT;

   private boolean mShowNormals;       // when rendering this mesh, draw normal vectors?

   private DistortedBuffer mVBO, mTFO; // main vertex buffer and transform feedback buffer

   private final float zFactor;        // strange workaround for the fact that we need to somehow store the 'depth'

                                       // of the Mesh. Used in DistortedEffects. See DistortedTexture.getDepth().

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

   // derived classes need to compute and fill up those 2 variables with data

   // describing a particular shape. Having done so, call setData()

   int numVertices;

   FloatBuffer mVertAttribs;   // packed: PosX,PosY,PosZ, NorX,NorY,NorZ, TexS,TexT

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

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

   MeshObject(float factor)

     {

     zFactor      = factor;

     mShowNormals = false;

     mVBO = new DistortedBuffer(GLES31.GL_ARRAY_BUFFER             , GLES31.GL_STATIC_READ);

     mTFO = new DistortedBuffer(GLES31.GL_TRANSFORM_FEEDBACK_BUFFER, GLES31.GL_STATIC_READ);

     }

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

// when a derived class is done computing its mesh, it has to call this method.

   void setData(int size, FloatBuffer buffer)

     {

     mVBO.setData(size*VERTSIZE, buffer);

     mTFO.setData(size*TFSIZE  , null  );

     }

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

/**

 * Not part of public API, do not document (public only because has to be used from the main package)

 *

 * @y.exclude

 */

   public int getVBO()

     {

     return mVBO.mIndex[0];

     }

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

/**

 * Not part of public API, do not document (public only because has to be used from the main package)

 *

 * @y.exclude

 */

   public int getTFO()

     {

     return mTFO.mIndex[0];

     }

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

/**

 * Not part of public API, do not document (public only because has to be used from the main package)

 *

 * @y.exclude

 */

   public int getNumVertices()

     {

     return numVertices;

     }

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

/**

 * Not part of public API, do not document (public only because has to be used from the main package)

 *

 * @y.exclude

 */

   public float getZFactor()

     {

     return zFactor;

     }

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

// PUBLIC API

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

/**

 * When rendering this Mesh, do we want to render the Normal vectors as well?

 * <p>

 * Will work only on OpenGL ES >= 3.0 devices.

 *

 * @param show Controls if we render the Normal vectors or not.

 */

   public void setShowNormals(boolean show)

     {

     mShowNormals = (Distorted.GLSL >= 300 && show);

     }

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

/**

 * When rendering this mesh, should we also draw the normal vectors?

 *

 * @return <i>true</i> if we do render normal vectors

 */

   public boolean getShowNormals()

     {

     return mShowNormals;

     }

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

/**

 * Release all internal resources.

 */

   public void markForDeletion()

     {

     mVertAttribs.clear();

     mVBO.markForDeletion();

     mTFO.markForDeletion();

     }

   }