commit 2aeb75aaed1edc631c4e65f4b4fbe681aeecc007
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Wed Jun 3 21:25:21 2020 +0100

    Update Myanmar flag.

diff --git a/src/main/java/org/distorted/library/effect/Effect.java b/src/main/java/org/distorted/library/effect/Effect.java
index 52376e7..f1e1642 100644
--- a/src/main/java/org/distorted/library/effect/Effect.java
+++ b/src/main/java/org/distorted/library/effect/Effect.java
@@ -48,8 +48,8 @@ public abstract class Effect
   private final static float[] mUnity= new float[MAX_UNITY_DIM*NUM_EFFECTS];
   private final static int[]   mUnityDim = new int[NUM_EFFECTS];
 
-  int mAssociation;
-  int mComponent;
+  int mAndAssociation;
+  int mEquAssociation;
 
   static boolean[] mEnabled = new boolean[NUM_EFFECTS];
 
@@ -68,8 +68,8 @@ public abstract class Effect
     mCenterDim = name.getCenterDimension();
     mRegionDim = name.getRegionDimension();
 
-    mAssociation = 0xffffffff;
-    mComponent   = 0;
+    mAndAssociation = 0xffffffff;
+    mEquAssociation = 0;
 
     int n = name.ordinal();
     float[] u = name.getUnity();
@@ -142,9 +142,9 @@ public abstract class Effect
  *
  * @y.exclude
  */
-  public int getAssociation()
+  public int getAndAssociation()
     {
-    return mAssociation;
+    return mAndAssociation;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -153,9 +153,9 @@ public abstract class Effect
  *
  * @y.exclude
  */
-  public int getComponent()
+  public int getEquAssociation()
     {
-    return mComponent;
+    return mEquAssociation;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/library/effect/VertexEffect.java b/src/main/java/org/distorted/library/effect/VertexEffect.java
index c08a981..363c577 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffect.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffect.java
@@ -192,20 +192,20 @@ public abstract class VertexEffect extends Effect
 /**
  * Set Mesh association.
  *
- * This creates an association between this Vertex Effect and a Component of a Mesh.
- * One can set the association of an Effect and of a Component, and the Effect will only be active on
- * vertices of Components such that
+ * This creates an association between a Component of a Mesh and this Vertex Effect.
+ * One can set two types of associations - an 'logical and' and a 'equal' associations and the Effect
+ * will only be active on vertices of Components such that
  *
- * (effect assoc) & (component assoc) != 0 || (effect component) == (mesh component)
+ * (effect andAssoc) & (component andAssoc) != 0 || (effect equAssoc) == (mesh equAssoc)
  *
  * (see main_vertex_shader)
  *
  * The point: this way we can configure the system so that each Vertex Effect acts only on a certain
  * subset of a Mesh, thus potentially significantly reducing the number of render calls.
  */
-  public void setMeshAssociation(int component, int association)
+  public void setMeshAssociation(int andAssociation, int equAssociation)
     {
-    mComponent   = component;
-    mAssociation = association;
+    mAndAssociation = andAssociation;
+    mEquAssociation = equAssociation;
     }
   }
\ No newline at end of file
diff --git a/src/main/java/org/distorted/library/effectqueue/EffectQueue.java b/src/main/java/org/distorted/library/effectqueue/EffectQueue.java
index 608fca6..2c5e4b7 100644
--- a/src/main/java/org/distorted/library/effectqueue/EffectQueue.java
+++ b/src/main/java/org/distorted/library/effectqueue/EffectQueue.java
@@ -51,8 +51,8 @@ public abstract class EffectQueue implements InternalMaster.Slave
   long[] mCurrentDuration;
   Effect[] mEffects;
   int[] mName;
-  int[] mAssociation;
-  int[] mComponent;
+  int[] mAndAssociation;
+  int[] mEquAssociation;
   long mTime;
 
   private static int[] mMax = new int[EffectType.LENGTH];
@@ -143,8 +143,8 @@ public abstract class EffectQueue implements InternalMaster.Slave
         mCurrentDuration = new long[max];
         mEffects         = new Effect[max];
         mName            = new int[max];
-        mAssociation     = new int[max];
-        mComponent       = new int[max];
+        mAndAssociation  = new int[max];
+        mEquAssociation  = new int[max];
         }
 
       for(int i=0; i<mNumEffects; i++ )
@@ -152,8 +152,8 @@ public abstract class EffectQueue implements InternalMaster.Slave
         mEffects[i]         = source.mEffects[i];
         mCurrentDuration[i] = source.mCurrentDuration[i];
         mName[i]            = source.mName[i];
-        mAssociation[i]     = source.mAssociation[i];
-        mComponent[i]       = source.mComponent[i];
+        mAndAssociation[i]  = source.mAndAssociation[i];
+        mEquAssociation[i]  = source.mEquAssociation[i];
         }
       }
     }
@@ -282,8 +282,8 @@ public abstract class EffectQueue implements InternalMaster.Slave
       mEffects[j]         = mEffects[j+1];
       mCurrentDuration[j] = mCurrentDuration[j+1];
       mName[j]            = mName[j+1];
-      mAssociation[j]     = mAssociation[j+1];
-      mComponent[j]       = mComponent[j+1];
+      mAndAssociation[j]  = mAndAssociation[j+1];
+      mEquAssociation[j]  = mEquAssociation[j+1];
       }
 
     mEffects[mNumEffects] = null;
@@ -441,8 +441,8 @@ public abstract class EffectQueue implements InternalMaster.Slave
                        mCurrentDuration = new long[max];
                        mEffects         = new Effect[max];
                        mName            = new int[max];
-                       mAssociation     = new int[max];
-                       mComponent       = new int[max];
+                       mAndAssociation  = new int[max];
+                       mEquAssociation  = new int[max];
                        }
                      mCreated = true;
 
@@ -453,11 +453,11 @@ public abstract class EffectQueue implements InternalMaster.Slave
 
                        if( position==-1 )
                          {
-                         mCurrentDuration[mNumEffects] = 0;
-                         mEffects[mNumEffects]    = job.effect;
-                         mName[mNumEffects]       = job.effect.getName().ordinal();
-                         mAssociation[mNumEffects]= job.effect.getAssociation();
-                         mComponent[mNumEffects]  = job.effect.getComponent();
+                         mCurrentDuration[mNumEffects]= 0;
+                         mEffects[mNumEffects]        = job.effect;
+                         mName[mNumEffects]           = job.effect.getName().ordinal();
+                         mAndAssociation[mNumEffects] = job.effect.getAndAssociation();
+                         mEquAssociation[mNumEffects] = job.effect.getEquAssociation();
 
                          mNumEffects++;
                          changed = true;
@@ -469,15 +469,15 @@ public abstract class EffectQueue implements InternalMaster.Slave
                            mCurrentDuration[j] = mCurrentDuration[j-1];
                            mEffects[j]         = mEffects[j-1];
                            mName[j]            = mName[j-1];
-                           mAssociation[j]     = mAssociation[j-1];
-                           mComponent[j]       = mComponent[j-1];
+                           mAndAssociation[j]  = mAndAssociation[j-1];
+                           mEquAssociation[j]  = mEquAssociation[j-1];
                            }
 
-                         mCurrentDuration[position] = 0;
-                         mEffects[position]    = job.effect;
-                         mName[position]       = job.effect.getName().ordinal();
-                         mAssociation[position]= job.effect.getAssociation();
-                         mComponent[position]  = job.effect.getComponent();
+                         mCurrentDuration[position]= 0;
+                         mEffects[position]        = job.effect;
+                         mName[position]           = job.effect.getName().ordinal();
+                         mAndAssociation[position] = job.effect.getAndAssociation();
+                         mEquAssociation[position] = job.effect.getEquAssociation();
 
                          mNumEffects++;
                          changed = true;
diff --git a/src/main/java/org/distorted/library/effectqueue/EffectQueueVertex.java b/src/main/java/org/distorted/library/effectqueue/EffectQueueVertex.java
index 358bcdf..de7244b 100644
--- a/src/main/java/org/distorted/library/effectqueue/EffectQueueVertex.java
+++ b/src/main/java/org/distorted/library/effectqueue/EffectQueueVertex.java
@@ -36,12 +36,12 @@ public class EffectQueueVertex extends EffectQueue
   private static final int NUM_UNIFORMS = VertexEffect.NUM_UNIFORMS;
   private static final int INDEX = EffectType.VERTEX.ordinal();
 
-  private static int[] mNumEffectsH = new int[MAIN_VARIANTS];
-  private static int[] mNameH       = new int[MAIN_VARIANTS];
-  private static int[] mUniformsH   = new int[MAIN_VARIANTS];
-  private static int[] mAssociationH= new int[MAIN_VARIANTS];
-  private static int[] mComponentH  = new int[MAIN_VARIANTS];
-  private static int[] mInflateH    = new int[MAIN_VARIANTS];
+  private static int[] mNumEffectsH    = new int[MAIN_VARIANTS];
+  private static int[] mNameH          = new int[MAIN_VARIANTS];
+  private static int[] mUniformsH      = new int[MAIN_VARIANTS];
+  private static int[] mAndAssociationH= new int[MAIN_VARIANTS];
+  private static int[] mEquAssociationH= new int[MAIN_VARIANTS];
+  private static int[] mInflateH       = new int[MAIN_VARIANTS];
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
    
@@ -61,12 +61,12 @@ public class EffectQueueVertex extends EffectQueue
 
   static void uniforms(int mProgramH, int variant)
     {
-    mNumEffectsH[variant] = GLES30.glGetUniformLocation( mProgramH, "vNumEffects");
-    mNameH[variant]       = GLES30.glGetUniformLocation( mProgramH, "vName");
-    mUniformsH[variant]   = GLES30.glGetUniformLocation( mProgramH, "vUniforms");
-    mAssociationH[variant]= GLES30.glGetUniformLocation( mProgramH, "vEffectAssoc");
-    mComponentH[variant]  = GLES30.glGetUniformLocation( mProgramH, "vEffectCompo");
-    mInflateH[variant]    = GLES30.glGetUniformLocation( mProgramH, "u_Inflate");
+    mNumEffectsH[variant]    = GLES30.glGetUniformLocation( mProgramH, "vNumEffects");
+    mNameH[variant]          = GLES30.glGetUniformLocation( mProgramH, "vName");
+    mUniformsH[variant]      = GLES30.glGetUniformLocation( mProgramH, "vUniforms");
+    mAndAssociationH[variant]= GLES30.glGetUniformLocation( mProgramH, "vEffAndAssoc");
+    mEquAssociationH[variant]= GLES30.glGetUniformLocation( mProgramH, "vEffEquAssoc");
+    mInflateH[variant]       = GLES30.glGetUniformLocation( mProgramH, "u_Inflate");
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -84,8 +84,8 @@ public class EffectQueueVertex extends EffectQueue
     for(int i=0; i<mNumEffects; i++)
       {
       mCurrentDuration[i] += step;
-      mAssociation[i] = mEffects[i].getAssociation();
-      mComponent[i] = mEffects[i].getComponent();
+      mAndAssociation[i] = mEffects[i].getAndAssociation();
+      mEquAssociation[i] = mEffects[i].getEquAssociation();
 
       if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )
         {
@@ -109,10 +109,10 @@ public class EffectQueueVertex extends EffectQueue
 
     if( mNumEffects>0 )
       {
-      GLES30.glUniform1iv( mNameH[variant]       ,                 mNumEffects, mName       , 0);
-      GLES30.glUniform1iv( mAssociationH[variant],                 mNumEffects, mAssociation, 0);
-      GLES30.glUniform1iv( mComponentH[variant]  ,                 mNumEffects, mComponent  , 0);
-      GLES30.glUniform4fv( mUniformsH[variant]   ,(NUM_UNIFORMS/4)*mNumEffects, mUniforms   , 0);
+      GLES30.glUniform1iv( mNameH[variant]          ,                 mNumEffects, mName          , 0);
+      GLES30.glUniform1iv( mAndAssociationH[variant],                 mNumEffects, mAndAssociation, 0);
+      GLES30.glUniform1iv( mEquAssociationH[variant],                 mNumEffects, mEquAssociation, 0);
+      GLES30.glUniform4fv( mUniformsH[variant]      ,(NUM_UNIFORMS/4)*mNumEffects, mUniforms      , 0);
       }
     }
   }
diff --git a/src/main/java/org/distorted/library/mesh/MeshBase.java b/src/main/java/org/distorted/library/mesh/MeshBase.java
index 3fd55a4..8e8c85f 100644
--- a/src/main/java/org/distorted/library/mesh/MeshBase.java
+++ b/src/main/java/org/distorted/library/mesh/MeshBase.java
@@ -80,11 +80,13 @@ public abstract class MeshBase
    private float[] mVertAttribs1;             // packed: PosX,PosY,PosZ, NorX,NorY,NorZ, InfX,InfY,InfZ
    private float[] mVertAttribs2;             // packed: TexS,TexT, Component
    private float mInflate;
-   private int[] mAssociation;
+   private int[] mEquAssociation;
+   private int[] mAndAssociation;
 
    DeferredJobs.JobNode[] mJobNode;
 
-   private static int[] mComponentAssociationH = new int[EffectQueue.MAIN_VARIANTS];
+   private static int[] mEquAssociationH = new int[EffectQueue.MAIN_VARIANTS];
+   private static int[] mAndAssociationH = new int[EffectQueue.MAIN_VARIANTS];
 
    private static class Component
      {
@@ -122,11 +124,16 @@ public abstract class MeshBase
      mShowNormals= false;
      mInflate    = 0.0f;
      mComponent  = new ArrayList<>();
-     mAssociation= new int[MAX_COMPONENTS];
+     mEquAssociation= new int[MAX_COMPONENTS];
+     mAndAssociation= new int[MAX_COMPONENTS];
 
      mJobNode = new DeferredJobs.JobNode[1];
 
-     for(int i=0; i<MAX_COMPONENTS; i++) mAssociation[i] = DEFAULT_ASSOCIATION;
+     for(int i=0; i<MAX_COMPONENTS; i++)
+       {
+       mAndAssociation[i] = DEFAULT_ASSOCIATION;
+       mEquAssociation[i] = i;
+       }
 
      mVBO1= new InternalBuffer(GLES30.GL_ARRAY_BUFFER             , GLES30.GL_STATIC_READ);
      mVBO2= new InternalBuffer(GLES30.GL_ARRAY_BUFFER             , GLES30.GL_STATIC_READ);
@@ -142,8 +149,10 @@ public abstract class MeshBase
      mInflate    = original.mInflate;
      mNumVertices= original.mNumVertices;
 
-     mAssociation= new int[MAX_COMPONENTS];
-     System.arraycopy(original.mAssociation, 0, mAssociation, 0, MAX_COMPONENTS);
+     mAndAssociation= new int[MAX_COMPONENTS];
+     System.arraycopy(original.mAndAssociation, 0, mAndAssociation, 0, MAX_COMPONENTS);
+     mEquAssociation= new int[MAX_COMPONENTS];
+     System.arraycopy(original.mEquAssociation, 0, mEquAssociation, 0, MAX_COMPONENTS);
 
      if( deep )
        {
@@ -270,7 +279,8 @@ public abstract class MeshBase
 
          if( origComponents<MAX_COMPONENTS )
            {
-           mAssociation[origComponents] = mesh.mAssociation[j];
+           mAndAssociation[origComponents] = mesh.mAndAssociation[j];
+           mEquAssociation[origComponents] = mesh.mEquAssociation[j];
            origComponents++;
            }
          }
@@ -424,7 +434,8 @@ public abstract class MeshBase
 
    public static void getUniforms(int mProgramH, int variant)
      {
-     mComponentAssociationH[variant] = GLES30.glGetUniformLocation( mProgramH, "vComponAssoc");
+     mEquAssociationH[variant] = GLES30.glGetUniformLocation( mProgramH, "vComEquAssoc");
+     mAndAssociationH[variant] = GLES30.glGetUniformLocation( mProgramH, "vComAndAssoc");
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -532,7 +543,8 @@ public abstract class MeshBase
  */
    public void send(int variant)
      {
-     GLES30.glUniform1iv( mComponentAssociationH[variant], MAX_COMPONENTS, mAssociation, 0);
+     GLES30.glUniform1iv( mEquAssociationH[variant], MAX_COMPONENTS, mEquAssociation, 0);
+     GLES30.glUniform1iv( mAndAssociationH[variant], MAX_COMPONENTS, mAndAssociation, 0);
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -721,21 +733,22 @@ public abstract class MeshBase
  * Set Effect association.
  *
  * This creates an association between a Component of this Mesh and a Vertex Effect.
- * One can set the association of an Effect and of a Component, and the Effect will only be active on
- * vertices of Components such that
+ * One can set two types of associations - an 'logical and' and a 'equal' associations and the Effect
+ * will only be active on vertices of Components such that
  *
- * (effect assoc) & (component assoc) != 0 || (effect component) == (mesh component)
+ * (effect andAssoc) & (component andAssoc) != 0 || (effect equAssoc) == (mesh equAssoc)
  *
  * (see main_vertex_shader)
  *
  * The point: this way we can configure the system so that each Vertex Effect acts only on a certain
  * subset of a Mesh, thus potentially significantly reducing the number of render calls.
  */
-  public void setEffectAssociation(int component, int association)
+  public void setEffectAssociation(int component, int andAssociation, int equAssociation)
     {
     if( component>=0 && component<MAX_COMPONENTS )
       {
-      mAssociation[component] = association;
+      mAndAssociation[component] = andAssociation;
+      mEquAssociation[component] = equAssociation;
       }
     }
 
diff --git a/src/main/res/raw/main_vertex_shader.glsl b/src/main/res/raw/main_vertex_shader.glsl
index 830a7e8..88fa565 100644
--- a/src/main/res/raw/main_vertex_shader.glsl
+++ b/src/main/res/raw/main_vertex_shader.glsl
@@ -49,9 +49,10 @@ uniform int vName[NUM_VERTEX];       // their names.
 uniform vec4 vUniforms[3*NUM_VERTEX];// i-th effect is 3 consecutive vec4's: [3*i], [3*i+1], [3*i+2].
                                      // The first vec4 is the Interpolated values,
                                      // second vec4: first float - cache, next 3: Center, the third -  the Region.
-uniform int vEffectAssoc[NUM_VERTEX];// Associations of the vertex effects. Those are used to connect an effect to a Mesh component.
-uniform int vEffectCompo[NUM_VERTEX];// Components the vertex effects work on. Likewise used to conneect an effect to a Mesh component.
-uniform int vComponAssoc[MAX_COMPON];// Associations of the component.
+uniform int vEffAndAssoc[NUM_VERTEX];// Associations of the vertex effects. Those are used to connect an effect to a Mesh component.
+uniform int vEffEquAssoc[NUM_VERTEX];// Components the vertex effects work on. Likewise used to connect an effect to a Mesh component.
+uniform int vComAndAssoc[MAX_COMPON];// 'logical AND' association of the component.
+uniform int vComEquAssoc[MAX_COMPON];// 'equal' association of the component.
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 // HELPER FUNCTIONS
@@ -110,7 +111,7 @@ void main()
 
   for(int i=0; i<vNumEffects; i++)
     {
-    if( ((vComponAssoc[component] & vEffectAssoc[i]) != 0) || (component == vEffectCompo[i]) )
+    if( ((vComAndAssoc[component] & vEffAndAssoc[i]) != 0) || (vComEquAssoc[component] == vEffEquAssoc[i]) )
       {
       // ENABLED EFFECTS WILL BE INSERTED HERE
 
