Distorted Android

     Component(int end)

       mEndIndex = end;

       mTextureMap    = new float[4];

       mTextureMap[0] = 0.0f;  // LowerLeft_X

       mTextureMap[1] = 0.0f;  // LowerLeft_Y

       mTextureMap[2] = 1.0f;  // Width

       mTextureMap[3] = 1.0f;  // Height

       mTextureMap = new float[4];

       System.arraycopy(original.mTextureMap,0,mTextureMap,0,4);

       }

     void setMap(float[] newMap)

       {

       mTextureMap = newMap;

     mComponent   = new ArrayList<>();

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

// change mVertAttribs from index 'begin' to index 'end' (inclusive) to the new Texture Map.

// x varies from -mBoundingX to +mBoundingX; y accordingly.

   private void changeTextureMap( float[] newMap, float[] oldMap, int begin, int end)

     {

     }

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

   int numComponents()

     {

     return mComponent.size();

     }

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

   void setBounding(float bx, float by, float bz)

     {

     mBoundingX = bx/2;

     mBoundingY = by/2;

     mBoundingZ = bz/2;

     }

     mComponent.add(new Component(mNumVertices));

// called from MeshJoined

   void join(MeshBase[] meshes)

     MeshBase mesh;

     Component comp;

     int com, num, len = meshes.length;

     int origVertices = mNumVertices;

     // compute new numVertices; take care of Components

     if( origVertices>0 )

       {

       com = mComponent.size();

       mNumVertices+= ( mNumVertices%2==1 ? 2:1 );

       mComponent.get(com-1).mEndIndex = mNumVertices;

       }

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

       {

       mesh = meshes[i];

       com = mesh.mComponent.size();

       for(int j=0; j<com; j++)

         {

         comp = new Component(mesh.mComponent.get(j));

         comp.mEndIndex += mNumVertices;

         mComponent.add(comp);

         }

       num = mesh.mNumVertices;

       mNumVertices+= (i<len-1 ? ( num%2==1 ? num+2 : num+1 ) : num);

       }

     // allocate new attrib array

     float[] newAttribs = new float[VERT_ATTRIBS*mNumVertices];

     num = origVertices;

     if( origVertices>0 )

       {

       System.arraycopy(mVertAttribs,                             0, newAttribs,                         0, VERT_ATTRIBS*num);

       System.arraycopy(mVertAttribs, VERT_ATTRIBS*(origVertices-1), newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS    );

       origVertices++;

       if( num%2==1 )

         {

         System.arraycopy(mVertAttribs, VERT_ATTRIBS*(origVertices-1), newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS);

         origVertices++;

         }

       }

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

       {

       mesh = meshes[i];

       num = mesh.mNumVertices;

       System.arraycopy(mesh.mVertAttribs, 0, newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS    );

       origVertices++;

       System.arraycopy(mesh.mVertAttribs, 0, newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS*num);

       origVertices+=num;

       if( i<len-1 )

         {

         System.arraycopy(mesh.mVertAttribs, VERT_ATTRIBS*(num-1), newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS);

         origVertices++;

         if( num%2==1 )

           {

           System.arraycopy(mesh.mVertAttribs, VERT_ATTRIBS*(num-1), newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS);

           origVertices++;

           }

         }

       }

     if( origVertices!=mNumVertices )

       {

       android.util.Log.e("mesh", "join: origVertices: "+origVertices+" numVertices: "+mNumVertices);

       }

     mVertAttribs = newAttribs;

     FloatBuffer attribs = ByteBuffer.allocateDirect(mNumVertices*VERT_SIZE).order(ByteOrder.nativeOrder()).asFloatBuffer();

     attribs.put(mVertAttribs).position(0);

     mVBO.setData(mNumVertices*VERT_SIZE, attribs);

     mTFO.setData(mNumVertices*TRAN_SIZE, null   );

 * 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 mNumVertices;

     float[] array = new float[7];

 * Sets texture maps for all components of this mesh.

 * Please note that calling this once with the complete list of Maps will be much faster than

 * calling it repeatedly with one Maps at a time, as we have to reallocate the array of vertices

 * 'maps' needs to be maps[NumComponentsInThisMesh][4]. [0] is the lower-left corner's X, [1]- its Y,

 * [2] - width, [3] - height of the map.

 * For example map[0] = new float { 0.0, 0.5, 0.5, 0.5 } sets the 0th component texture map to the

 * upper-left quadrant of the texture.

   public void setTextureMap(float[][] maps)

     int num_comp = mComponent.size();

     int num_maps = maps.length;

     int min = num_comp<num_maps ? num_comp : num_maps;

     int lastEnd = 0;

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

       if( maps[i]!=null )

         Component comp = mComponent.get(i);

         changeTextureMap(maps[i],comp.mTextureMap,lastEnd,comp.mEndIndex);

         comp.setMap(maps[i]);

         lastEnd = comp.mEndIndex;

 * Each mesh has its 'bounding box' - return half of its X-length.

 * In case of all 'simple' Meshes, the bounding box is always 1x1x1 (Sphere, Cubes) or 1x1x0

 * (Rectangles, Triangles, Quad - i.e. all 'flat' Meshes). But this can be something else in case of

 * MeshComponent.

   public float getBoundingX()

    {

    return mBoundingX*mStretchX;

    }

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

/**

 * Each mesh has its 'bounding box' - return half of its Y-length.

 */

   public float getBoundingY()

    {

    return mBoundingY*mStretchY;

    }

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

/**

 * Each mesh has its 'bounding box' - return half of its Z-length.

 */

   public float getBoundingZ()

    {

    return mBoundingZ*mStretchZ;

    }

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

/**

 * Sometimes we want to display a Mesh on a rectangular screen. Then we need to stretch it by

 * different factors in x and y (or z) directions. If we also wanted do display some vertex effects

 * done on this mesh, let's say a bulge done by a Distort effect, and wanted the bulge to be round,

 * (i.e the same in x and y directions) then doing so without this method would be impossible.

 *

 * This sets 'stretch' factors in each 3 dimensions. All vertices of this Mesh will be premultiplied

 * by those factors in the very first line of the Vertex Shader, before any Effects are done on it.

 * Using this we can thus pre-stretch the mesh to aspect ratio equal to the surface we eventually

 * want to display the Mesh on, and this way we can achieve a round Distort bulge!

 *

 * This could also be used to pre-stretch a Rectangles Mesh to a size equal (in pixels) to the bitmap

 * this mesh is textured with - and this lets us work with all Effects in natural, pixel units.

 *

 * @param sx stretch factor in x.

 * @param sy stretch factor in y.

 * @param sz stretch factor in z.

 */

   public void setStretch(float sx, float sy, float sz)

     mStretchX = sx;

     mStretchY = sy;

     mStretchZ = sz;

     }

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

/**

 * Returns the x-factor set by setStretch().

 */

   public float getStretchX()

     {

     return mStretchX;

     }

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

/**

 * Returns the y-factor set by setStretch().

 */

   public float getStretchY()

     {

     return mStretchY;

     }

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

/**

 * Returns the z-factor set by setStretch().

 */

   public float getStretchZ()

     {

     return mStretchZ;

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

// Copyright 2020 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;

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

public class MeshJoined extends MeshBase

  {

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

/**

 * Join a list of (probably already changed by Matrix Effects) Meshes into one.

 * <p>

 * Try to keep the origin (0,0,0) in the center of gravity of the whole thing.

 */

  public MeshJoined(MeshBase[] meshes)

    {

    super(1,1,1);

    join(meshes);

    }

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

/**

 * Sets the lengths of the bounding box.

 * <p>

 * The 'bounding box' is an imaginary rectanguloid of size (bx,by,bz) inside of which this Mesh

 * fits tightly.

 * 'Normal' 3D meshes (e.g. Sphere) have this equal to 1,1,1. 'Normal' flat meshes (e.g. Quad) -

 * to 1,1,0. Here however we are joining several, probably already changed by MatrixEffects,

 * Meshes together. If the result fits into the standard 1,1,1 (recommended!) - we don't need to

 * call this function at all.

 *

 * @param bx x-length of the bounding box

 * @param by y-length of the bounding box

 * @param bz z-length of the bounding box

 */

   public void setBounding(float bx, float by, float bz)

     {

     super.setBounding(bx,by,bz);

     }

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

/**

 * Return how many basic Meshes is this Mesh joined from.

 */

   public int getNumComponents()

     {

     return numComponents();

     }

  }