Distorted Android

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

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

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.InternalBuffer;

import org.distorted.library.mesh.MeshBase;

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

/**

 * Not part of public API, do not document

 *

 * @y.exclude

 */

public class UniformBlockAssociation

  {

  private static final int DEFAULT_ASSOCIATION = 0x7fffffff; // all effects associated, all components affected

  private static final int DEFAULT_STRIDE = 4;

  private static final int LOC_AND = 0;

  private static final int LOC_EQU = 1;

  private final InternalBuffer mUBO;

  private final int mMax;

  private int[] mAssociations;

  private int mStride;

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

  public UniformBlockAssociation()

    {

    mMax = MeshBase.getMaxEffComponents();

    mStride = DEFAULT_STRIDE;

    mAssociations= new int[mStride*mMax];

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

      {

      mAssociations[mStride*i+LOC_AND] = DEFAULT_ASSOCIATION;

      mAssociations[mStride*i+LOC_EQU] = i;

      }

    mUBO = new InternalBuffer();

    }

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

  public UniformBlockAssociation(UniformBlockAssociation original)

    {

    mMax = original.mMax;

    mStride = original.mStride;

    int size = original.mAssociations.length;

    mAssociations= new int[size];

    System.arraycopy(original.mAssociations, 0, mAssociations, 0, size);

    mUBO = new InternalBuffer();

    }

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

// stride can be 0, if we just tried compiling a vertex shader which has NUM_VERTEX=0.

// stride==1 we also don't like because then we have an exception ( stride*mMax-1 < stride*(mMax-1)+1 )

  public void correctStride(int stride)

    {

    if( mStride != stride && stride>1 )

      {

      int[] tmp = new int[stride*mMax];

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

        {

        tmp[stride*i+LOC_AND] = mAssociations[mStride*i+LOC_AND];

        tmp[stride*i+LOC_EQU] = mAssociations[mStride*i+LOC_EQU];

        }

      mAssociations = tmp;

      mStride = stride;

      }

    }

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

  public boolean matchesAssociation( int comp, int andAssoc, int equAssoc)

    {

    return (andAssoc & mAssociations[mStride*comp+LOC_AND]) != 0 || (equAssoc == mAssociations[mStride*comp+LOC_EQU]);

    }

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

  public void setEffectAssociationNow(int comp, int andAssociation, int equAssociation)

    {

    int index = mStride*comp;

    mAssociations[index+LOC_AND] &= (~DEFAULT_ASSOCIATION);

    mAssociations[index+LOC_AND] += (andAssociation & DEFAULT_ASSOCIATION);

    mAssociations[index+LOC_EQU] = equAssociation;

    mUBO.invalidate();

    }

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

  public void setNotAffectedComponentsNow(int[] components)

    {

    for(int c=0; c<mMax; c++) mAssociations[mStride*c+LOC_AND] &= DEFAULT_ASSOCIATION;

    if( components!=null )

      {

      for(int c : components) mAssociations[mStride*c+LOC_AND] |= (~DEFAULT_ASSOCIATION);

      }

    mUBO.invalidate();

    }

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

  public int getIndex()

    {

    return mUBO.createImmediatelyInt( 4*mStride*mMax, mAssociations);

    }

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

  public void copy(int compTo, UniformBlockAssociation assocFrom, int compFrom)

    {

    mAssociations[mStride*compTo+LOC_AND] = assocFrom.mAssociations[mStride*compFrom+LOC_AND];

    mAssociations[mStride*compTo+LOC_EQU] = assocFrom.mAssociations[mStride*compFrom+LOC_EQU];

    }

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

  public void markForDeletion()

    {

    mUBO.markForDeletion();

    }

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

  public void print()

    {

    StringBuilder builder = new StringBuilder();

    builder.append(mUBO.getID());

    builder.append(' ');

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

      {

      builder.append(mAssociations[mStride*i+LOC_AND]);

      builder.append(' ');

      builder.append(mAssociations[mStride*i+LOC_EQU]);

      builder.append(' ');

      }

    String res = builder.toString();

    DistortedLibrary.logMessage("UniformBlockAssociation: "+res);

    }

  }

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

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

import org.distorted.library.main.InternalBuffer;

import org.distorted.library.mesh.MeshBase;

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

/**

 * Not part of public API, do not document

 *

 * @y.exclude

 */

public class UniformBlockCenter

  {

  private final InternalBuffer mUBO;

  private final float[] mArray;

  private final int mMax;

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

  public UniformBlockCenter()

    {

    mMax  = MeshBase.getMaxEffComponents();

    mArray= new float[4*mMax];

    mUBO  = new InternalBuffer();

    }

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

  public UniformBlockCenter(UniformBlockCenter original)

    {

    mMax = original.mMax;

    int size = original.mArray.length;

    mArray= new float[size];

    System.arraycopy(original.mArray, 0, mArray, 0, size);

    mUBO = new InternalBuffer();

    }

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

  public void setEffectCenterNow(int comp, float x, float y, float z)

    {

    if( comp>=0 )

      {

      mArray[4*comp  ] = x;

      mArray[4*comp+1] = y;

      mArray[4*comp+2] = z;

      }

    else

      {

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

        {

        mArray[4*i  ] = x;

        mArray[4*i+1] = y;

        mArray[4*i+2] = z;

        }

      }

    mUBO.invalidate();

    }

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

  public int getIndex()

    {

    return mUBO.createImmediatelyFloat( 16*mMax, mArray);

    }

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

  public void copy(int compTo, UniformBlockCenter blockFrom, int compFrom)

    {

    mArray[4*compTo  ] = blockFrom.mArray[4*compFrom  ];

    mArray[4*compTo+1] = blockFrom.mArray[4*compFrom+1];

    mArray[4*compTo+2] = blockFrom.mArray[4*compFrom+2];

    }

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

  public void markForDeletion()

    {

    mUBO.markForDeletion();

    }

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

  public float[] getBackingArray()

    {

    return mArray;

    }

  }

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

// Copyright 2021 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.uniformblock;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.InternalBuffer;

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

/**

 * Not part of public API, do not document

 *

 * @y.exclude

 */

public class UniformBlockFloatUniforms

  {

  private InternalBuffer mUBO;

  private final float[] mArray;

  private final int mNumUniforms, mSize;

  private final boolean mReallyUseUBO;

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

  public UniformBlockFloatUniforms(int numUniforms, int size, boolean reallyUse)

    {

    mNumUniforms = numUniforms;

    mSize        = size;

    mArray       = new float[mNumUniforms*mSize];

    mReallyUseUBO= reallyUse;

    if( mReallyUseUBO )

      {

      mUBO = new InternalBuffer();

      }

    }

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

  public UniformBlockFloatUniforms(UniformBlockFloatUniforms original)

    {

    mNumUniforms = original.mNumUniforms;

    mSize        = original.mSize;

    mArray       = new float[mNumUniforms*mSize];

    mReallyUseUBO= original.mReallyUseUBO;

    System.arraycopy(original.mArray, 0, mArray, 0, 3*mSize);

    if( mReallyUseUBO )

      {

      mUBO = new InternalBuffer();

      }

    }

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

  public int getIndex()

    {

    return mUBO.createImmediatelyFloat( 4*mNumUniforms*mSize, mArray);

    }

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

  public void remove(int pos, int numEffects)

    {

    System.arraycopy(mArray, mNumUniforms*(pos+1), mArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) );

    if( mReallyUseUBO )

      {

      mUBO.invalidate();

      }

    }

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

  public void markForDeletion()

    {

    if( mReallyUseUBO )

      {

      mUBO.markForDeletion();

      }

    }

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

  public void invalidate()

    {

    if( mReallyUseUBO )

      {

      mUBO.invalidate();

      }

    }

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

  public float[] getBackingArray()

    {

    return mArray;

    }

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

  public void print(int num)

    {

    StringBuilder builder = new StringBuilder();

    builder.append( mReallyUseUBO ? mUBO.getID() : "NOT USED");

    builder.append(':');

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

      {

      builder.append(' ');

      builder.append(mArray[4*i  ]);

      builder.append(' ');

      builder.append(mArray[4*i+1]);

      builder.append(' ');

      builder.append(mArray[4*i+2]);

      builder.append(',');

      }

    builder.append(' ');

    builder.append('(');

    builder.append(num);

    builder.append(')');

    String res = builder.toString();

    DistortedLibrary.logMessage("UniformBlockFloatUniforms: "+res);

    }

  }

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

// Copyright 2021 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.uniformblock;

import org.distorted.library.effect.Effect;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.InternalBuffer;

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

/**

 * Not part of public API, do not document

 *

 * @y.exclude

 */

public class UniformBlockIntUniforms

  {

  private InternalBuffer mUBO;

  private final int[] mArray;

  private final int mNumUniforms, mSize;

  private final boolean mReallyUseUBO;

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

  public UniformBlockIntUniforms(int numUniforms, int size, boolean reallyUse)

    {

    mNumUniforms = numUniforms;

    mSize        = size;

    mArray       = new int[mNumUniforms*mSize];

    mReallyUseUBO= reallyUse;

    if( mReallyUseUBO )

      {

      mUBO = new InternalBuffer();

      }

    }

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

  public UniformBlockIntUniforms(UniformBlockIntUniforms original)

    {

    mNumUniforms = original.mNumUniforms;

    mSize        = original.mSize;

    mArray       = new int[mNumUniforms*mSize];

    mReallyUseUBO= original.mReallyUseUBO;

    System.arraycopy(original.mArray, 0, mArray, 0, mSize);

    if( mReallyUseUBO )

      {

      mUBO = new InternalBuffer();

      }

    }

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

  public int getIndex()

    {

    return mUBO.createImmediatelyInt( 4*mNumUniforms*mSize, mArray);

    }

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

  public void remove(int pos, int numEffects)

    {

    System.arraycopy(mArray, mNumUniforms*(pos+1), mArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) );

    if( mReallyUseUBO )

      {

      mUBO.invalidate();

      }

    }

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

  public void makeHole(int pos, int numEffects)

    {

    System.arraycopy(mArray, mNumUniforms*pos, mArray, mNumUniforms*(pos+1), mNumUniforms*(numEffects-pos) );

    if( mReallyUseUBO )

      {

      mUBO.invalidate();

      }

    }

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

  public void addOrdinal(int pos, int ordinal)

    {

    mArray[mNumUniforms*pos] = ordinal;

    if( mReallyUseUBO )

      {

      mUBO.invalidate();

      }

    }

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

  public void addAssociations(int pos, Effect effect)

    {

    effect.writeAssociations(mArray, mNumUniforms*pos+1, mNumUniforms*pos+3);

    if( mReallyUseUBO )

      {

      mUBO.invalidate();

      }

    }

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

  public void markForDeletion()

    {

    if( mReallyUseUBO )

      {

      mUBO.markForDeletion();

      }

    }

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

  public int[] getBackingArray()

    {

    return mArray;

    }

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

  public void print(int num)

    {

    StringBuilder builder = new StringBuilder();

    builder.append( mReallyUseUBO ? mUBO.getID() : "NOT USED");

    builder.append(':');

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

      {

      builder.append(' ');

      builder.append(mArray[4*i  ]);

      builder.append(' ');

      builder.append(mArray[4*i+1]);

      builder.append(' ');

      builder.append(mArray[4*i+2]);

      builder.append(',');

      }

    builder.append(' ');

    builder.append('(');

    builder.append(num);

    builder.append(')');

    String res = builder.toString();

    DistortedLibrary.logMessage("UniformBlockIntUniforms: "+res);

    }

  }