Project

General

Profile

« Previous | Next » 

Revision 61c6baa4

Added by Leszek Koltunski 10 days ago

transition the 'uniformblock' package

View differences:

src/main/java/org/distorted/library/message/EffectListener.kt
21 21
package org.distorted.library.message
22 22

  
23 23
///////////////////////////////////////////////////////////////////////////////////////////////////
24

  
25 24
/**
26 25
 * This interface lets users of the DistortedLibrary library get notified when a given effect finishes.
27 26
 * To receive the notifications, we first have to register with a call to [Effect.notifyWhenFinished].
src/main/java/org/distorted/library/program/DistortedProgram.kt
78 78
            if (attributes != null)
79 79
            {
80 80
                val size = attributes.size
81

  
82
                for (i in 0..<size)
83
                    GLES30.glBindAttribLocation(programHandle, i, attributes[i])
81
                for (i in 0..<size) GLES30.glBindAttribLocation(programHandle, i, attributes[i])
84 82
            }
85 83

  
86 84
            GLES30.glLinkProgram(programHandle)
src/main/java/org/distorted/library/uniformblock/UniformBlockAssociation.kt
1
////////////////////////////////////////////////////////////////////////////////////////////////////
1
///////////////////////////////////////////////////////////////////////////////////////////////////
2 2
// Copyright 2020 Leszek Koltunski  leszek@koltunski.pl                                          //
3 3
//                                                                                               //
4 4
// This file is part of Distorted.                                                               //
......
18 18
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
19 19
///////////////////////////////////////////////////////////////////////////////////////////////////
20 20

  
21
package org.distorted.library.uniformblock;
22

  
23
import org.distorted.library.main.DistortedLibrary;
24
import org.distorted.library.main.InternalBuffer;
25
import org.distorted.library.mesh.MeshBase;
21
package org.distorted.library.uniformblock
26 22

  
27
///////////////////////////////////////////////////////////////////////////////////////////////////
28
/**
29
 * Not part of public API, do not document
30
 *
31
 * @y.exclude
32
 */
33
public class UniformBlockAssociation
34
  {
35
  private static final int DEFAULT_ASSOCIATION = 0x7fffffff; // all effects associated, all components affected
36
  private static final int DEFAULT_STRIDE = 4;
37
  private static final int LOC_AND = 0;
38
  private static final int LOC_EQU = 1;
39

  
40
  private final InternalBuffer mUBO;
41
  private final int mMax;
42
  private int[] mAssociations;
43
  private int mStride;
23
import org.distorted.library.main.DistortedLibrary
24
import org.distorted.library.main.InternalBuffer
25
import org.distorted.library.mesh.MeshBase
44 26

  
45 27
///////////////////////////////////////////////////////////////////////////////////////////////////
46

  
47
  public UniformBlockAssociation()
28
/** Not part of public API, do not document
29
*
30
* @y.exclude
31
*/
32
class UniformBlockAssociation
33
{
34
    private val mUBO: InternalBuffer
35
    private val mMax: Int
36
    private var mAssociations: IntArray
37
    private var mStride: Int
38
    val index: Int get() = mUBO.createImmediatelyInt(4*mStride*mMax, mAssociations)
39

  
40
    companion object
48 41
    {
49
    mMax = MeshBase.getMaxEffComponents();
50
    mStride = DEFAULT_STRIDE;
51
    mAssociations= new int[mStride*mMax];
52

  
53
    for(int i=0; i<mMax; i++)
54
      {
55
      mAssociations[mStride*i+LOC_AND] = DEFAULT_ASSOCIATION;
56
      mAssociations[mStride*i+LOC_EQU] = i;
57
      }
58

  
59
    mUBO = new InternalBuffer();
42
        private const val DEFAULT_ASSOCIATION = 0x7fffffff // all effects associated, all components affected
43
        private const val DEFAULT_STRIDE = 4
44
        private const val LOC_AND = 0
45
        private const val LOC_EQU = 1
60 46
    }
61 47

  
62
///////////////////////////////////////////////////////////////////////////////////////////////////
63

  
64
  public UniformBlockAssociation(UniformBlockAssociation original)
48
    ///////////////////////////////////////////////////////////////////////////////////////////////
49
    constructor()
65 50
    {
66
    mMax = original.mMax;
67
    mStride = original.mStride;
68
    int size = original.mAssociations.length;
69
    mAssociations= new int[size];
70
    System.arraycopy(original.mAssociations, 0, mAssociations, 0, size);
51
        mMax = MeshBase.getMaxEffComponents()
52
        mStride = DEFAULT_STRIDE
53
        mAssociations = IntArray(mStride*mMax)
71 54

  
72
    mUBO = new InternalBuffer();
73
    }
74

  
75
///////////////////////////////////////////////////////////////////////////////////////////////////
76
// stride can be 0, if we just tried compiling a vertex shader which has NUM_VERTEX=0.
77
// stride==1 we also don't like because then we have an exception ( stride*mMax-1 < stride*(mMax-1)+1 )
78

  
79
  public void correctStride(int stride)
80
    {
81
    if( mStride != stride && stride>1 )
82
      {
83
      int[] tmp = new int[stride*mMax];
84

  
85
      for(int i=0; i<mMax; i++)
55
        for (i in 0..<mMax)
86 56
        {
87
        tmp[stride*i+LOC_AND] = mAssociations[mStride*i+LOC_AND];
88
        tmp[stride*i+LOC_EQU] = mAssociations[mStride*i+LOC_EQU];
57
            mAssociations[mStride*i+LOC_AND] = DEFAULT_ASSOCIATION
58
            mAssociations[mStride*i+LOC_EQU] = i
89 59
        }
90 60

  
91
      mAssociations = tmp;
92
      mStride = stride;
93
      }
61
        mUBO = InternalBuffer()
94 62
    }
95 63

  
96
///////////////////////////////////////////////////////////////////////////////////////////////////
97

  
98
  public boolean matchesAssociation( int comp, int andAssoc, int equAssoc)
64
    ///////////////////////////////////////////////////////////////////////////////////////////////
65
    constructor(original: UniformBlockAssociation)
99 66
    {
100
    return (andAssoc & mAssociations[mStride*comp+LOC_AND]) != 0 || (equAssoc == mAssociations[mStride*comp+LOC_EQU]);
67
        mMax = original.mMax
68
        mStride = original.mStride
69
        val size = original.mAssociations.size
70
        mAssociations = IntArray(size)
71
        System.arraycopy(original.mAssociations, 0, mAssociations, 0, size)
72
        mUBO = InternalBuffer()
101 73
    }
102 74

  
103
///////////////////////////////////////////////////////////////////////////////////////////////////
104

  
105
  public void setEffectAssociationNow(int comp, int andAssociation, int equAssociation)
75
    ///////////////////////////////////////////////////////////////////////////////////////////////
76
    // stride can be 0, if we just tried compiling a vertex shader which has NUM_VERTEX=0.
77
    // stride==1 we also don't like because then we have an exception ( stride*mMax-1 < stride*(mMax-1)+1 )
78
    fun correctStride(stride: Int)
106 79
    {
107
    int index = mStride*comp;
108
    mAssociations[index+LOC_AND] &= (~DEFAULT_ASSOCIATION);
109
    mAssociations[index+LOC_AND] += (andAssociation & DEFAULT_ASSOCIATION);
110
    mAssociations[index+LOC_EQU] = equAssociation;
80
        if (mStride!=stride && stride>1)
81
        {
82
            val tmp = IntArray(stride*mMax)
83

  
84
            for (i in 0..<mMax)
85
            {
86
                tmp[stride*i+LOC_AND] = mAssociations[mStride*i+LOC_AND]
87
                tmp[stride*i+LOC_EQU] = mAssociations[mStride*i+LOC_EQU]
88
            }
111 89

  
112
    mUBO.invalidate();
90
            mAssociations = tmp
91
            mStride = stride
92
        }
113 93
    }
114 94

  
115
///////////////////////////////////////////////////////////////////////////////////////////////////
95
    ///////////////////////////////////////////////////////////////////////////////////////////////
96
    fun matchesAssociation(comp: Int, andAssoc: Int, equAssoc: Int): Boolean
97
    {
98
        return (andAssoc and mAssociations[mStride*comp+LOC_AND]) != 0 || (equAssoc == mAssociations[mStride*comp+LOC_EQU])
99
    }
116 100

  
117
  public void setNotAffectedComponentsNow(int[] components)
101
    ///////////////////////////////////////////////////////////////////////////////////////////////
102
    fun setEffectAssociationNow(comp: Int, andAssociation: Int, equAssociation: Int)
118 103
    {
119
    for(int c=0; c<mMax; c++) mAssociations[mStride*c+LOC_AND] &= DEFAULT_ASSOCIATION;
104
        val index = mStride*comp
120 105

  
121
    if( components!=null )
122
      {
123
      for(int c : components) mAssociations[mStride*c+LOC_AND] |= (~DEFAULT_ASSOCIATION);
124
      }
106
        mAssociations[index+LOC_AND] = mAssociations[index+LOC_AND] and (DEFAULT_ASSOCIATION.inv())
107
        mAssociations[index+LOC_AND] += (andAssociation and DEFAULT_ASSOCIATION)
108
        mAssociations[index+LOC_EQU] = equAssociation
125 109

  
126
    mUBO.invalidate();
110
        mUBO.invalidate()
127 111
    }
128 112

  
129
///////////////////////////////////////////////////////////////////////////////////////////////////
130

  
131
  public int getIndex()
113
    ///////////////////////////////////////////////////////////////////////////////////////////////
114
    fun setNotAffectedComponentsNow(components: IntArray?)
132 115
    {
133
    return mUBO.createImmediatelyInt( 4*mStride*mMax, mAssociations);
134
    }
116
        for (c in 0..<mMax)
117
            mAssociations[mStride*c+LOC_AND] = mAssociations[mStride*c+LOC_AND] and DEFAULT_ASSOCIATION
135 118

  
136
///////////////////////////////////////////////////////////////////////////////////////////////////
119
        if (components != null)
120
            for (c in components)
121
                mAssociations[mStride*c+LOC_AND] = mAssociations[mStride*c+LOC_AND] or (DEFAULT_ASSOCIATION.inv())
137 122

  
138
  public void copy(int compTo, UniformBlockAssociation assocFrom, int compFrom)
139
    {
140
    mAssociations[mStride*compTo+LOC_AND] = assocFrom.mAssociations[mStride*compFrom+LOC_AND];
141
    mAssociations[mStride*compTo+LOC_EQU] = assocFrom.mAssociations[mStride*compFrom+LOC_EQU];
123
        mUBO.invalidate()
142 124
    }
143 125

  
144
///////////////////////////////////////////////////////////////////////////////////////////////////
145

  
146
  public void markForDeletion()
126
    ///////////////////////////////////////////////////////////////////////////////////////////////
127
    fun copy(compTo: Int, assocFrom: UniformBlockAssociation, compFrom: Int)
147 128
    {
148
    mUBO.markForDeletion();
129
        mAssociations[mStride*compTo+LOC_AND] = assocFrom.mAssociations[mStride*compFrom+LOC_AND]
130
        mAssociations[mStride*compTo+LOC_EQU] = assocFrom.mAssociations[mStride*compFrom+LOC_EQU]
149 131
    }
150 132

  
151
///////////////////////////////////////////////////////////////////////////////////////////////////
133
    ///////////////////////////////////////////////////////////////////////////////////////////////
134
    fun markForDeletion() = mUBO.markForDeletion()
152 135

  
153
  public void print()
136
    ///////////////////////////////////////////////////////////////////////////////////////////////
137
    fun print()
154 138
    {
155
    StringBuilder builder = new StringBuilder();
139
        val builder = StringBuilder()
156 140

  
157
    builder.append(mUBO.getID());
158
    builder.append(' ');
141
        builder.append(mUBO.id)
142
        builder.append(' ')
159 143

  
160
    for(int i=0; i<8; i++)
161
      {
162
      builder.append(mAssociations[mStride*i+LOC_AND]);
163
      builder.append(' ');
164
      builder.append(mAssociations[mStride*i+LOC_EQU]);
165
      builder.append(' ');
166
      }
144
        for (i in 0..7)
145
        {
146
            builder.append(mAssociations[mStride*i+LOC_AND])
147
            builder.append(' ')
148
            builder.append(mAssociations[mStride*i+LOC_EQU])
149
            builder.append(' ')
150
        }
167 151

  
168
    String res = builder.toString();
152
        val res = builder.toString()
169 153

  
170
    DistortedLibrary.logMessage("UniformBlockAssociation: "+res);
154
        DistortedLibrary.logMessage("UniformBlockAssociation: $res")
171 155
    }
172
  }
156
}
src/main/java/org/distorted/library/uniformblock/UniformBlockCenter.kt
18 18
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
19 19
///////////////////////////////////////////////////////////////////////////////////////////////////
20 20

  
21
package org.distorted.library.uniformblock;
21
package org.distorted.library.uniformblock
22 22

  
23
import org.distorted.library.main.InternalBuffer;
24
import org.distorted.library.mesh.MeshBase;
23
import org.distorted.library.main.InternalBuffer
24
import org.distorted.library.mesh.MeshBase
25 25

  
26 26
///////////////////////////////////////////////////////////////////////////////////////////////////
27
/**
28
 * Not part of public API, do not document
29
 *
30
 * @y.exclude
31
 */
32
public class UniformBlockCenter
33
  {
34
  private final InternalBuffer mUBO;
35
  private final float[] mArray;
36
  private final int mMax;
37

  
38
///////////////////////////////////////////////////////////////////////////////////////////////////
39

  
40
  public UniformBlockCenter()
27
/** Not part of public API, do not document
28
*
29
* @y.exclude
30
*/
31
class UniformBlockCenter
32
{
33
    private val mUBO: InternalBuffer
34
    private val mMax: Int
35
    val backingArray: FloatArray
36
    val index: Int get() = mUBO.createImmediatelyFloat(16*mMax, backingArray)
37

  
38
    ///////////////////////////////////////////////////////////////////////////////////////////////
39
    constructor()
41 40
    {
42
    mMax  = MeshBase.getMaxEffComponents();
43
    mArray= new float[4*mMax];
44
    mUBO  = new InternalBuffer();
41
        mMax = MeshBase.getMaxEffComponents()
42
        backingArray = FloatArray(4*mMax)
43
        mUBO = InternalBuffer()
45 44
    }
46 45

  
47
///////////////////////////////////////////////////////////////////////////////////////////////////
48

  
49
  public UniformBlockCenter(UniformBlockCenter original)
46
    ///////////////////////////////////////////////////////////////////////////////////////////////
47
    constructor(original: UniformBlockCenter)
50 48
    {
51
    mMax = original.mMax;
52
    int size = original.mArray.length;
53
    mArray= new float[size];
54
    System.arraycopy(original.mArray, 0, mArray, 0, size);
55
    mUBO = new InternalBuffer();
49
        mMax = original.mMax
50
        val size = original.backingArray.size
51
        backingArray = FloatArray(size)
52
        System.arraycopy(original.backingArray, 0, backingArray, 0, size)
53
        mUBO = InternalBuffer()
56 54
    }
57 55

  
58
///////////////////////////////////////////////////////////////////////////////////////////////////
59

  
60
  public void setEffectCenterNow(int comp, float x, float y, float z)
56
    ///////////////////////////////////////////////////////////////////////////////////////////////
57
    fun setEffectCenterNow(comp: Int, x: Float, y: Float, z: Float)
61 58
    {
62
    if( comp>=0 )
63
      {
64
      mArray[4*comp  ] = x;
65
      mArray[4*comp+1] = y;
66
      mArray[4*comp+2] = z;
67
      }
68
    else
69
      {
70
      for(int i=0; i<mMax; i++)
59
        if (comp >= 0)
71 60
        {
72
        mArray[4*i  ] = x;
73
        mArray[4*i+1] = y;
74
        mArray[4*i+2] = z;
61
            backingArray[4*comp  ] = x
62
            backingArray[4*comp+1] = y
63
            backingArray[4*comp+2] = z
64
        }
65
        else
66
        {
67
            for (i in 0..<mMax)
68
            {
69
                backingArray[4*i  ] = x
70
                backingArray[4*i+1] = y
71
                backingArray[4*i+2] = z
72
            }
75 73
        }
76
      }
77

  
78
    mUBO.invalidate();
79
    }
80

  
81
///////////////////////////////////////////////////////////////////////////////////////////////////
82

  
83
  public int getIndex()
84
    {
85
    return mUBO.createImmediatelyFloat( 16*mMax, mArray);
86
    }
87

  
88
///////////////////////////////////////////////////////////////////////////////////////////////////
89 74

  
90
  public void copy(int compTo, UniformBlockCenter blockFrom, int compFrom)
91
    {
92
    mArray[4*compTo  ] = blockFrom.mArray[4*compFrom  ];
93
    mArray[4*compTo+1] = blockFrom.mArray[4*compFrom+1];
94
    mArray[4*compTo+2] = blockFrom.mArray[4*compFrom+2];
75
        mUBO.invalidate()
95 76
    }
96 77

  
97
///////////////////////////////////////////////////////////////////////////////////////////////////
98

  
99
  public void markForDeletion()
78
    ///////////////////////////////////////////////////////////////////////////////////////////////
79
    fun copy(compTo: Int, blockFrom: UniformBlockCenter, compFrom: Int)
100 80
    {
101
    mUBO.markForDeletion();
81
        backingArray[4*compTo  ] = blockFrom.backingArray[4*compFrom  ]
82
        backingArray[4*compTo+1] = blockFrom.backingArray[4*compFrom+1]
83
        backingArray[4*compTo+2] = blockFrom.backingArray[4*compFrom+2]
102 84
    }
103 85

  
104
///////////////////////////////////////////////////////////////////////////////////////////////////
105

  
106
  public float[] getBackingArray()
107
    {
108
    return mArray;
109
    }
110
  }
86
    ///////////////////////////////////////////////////////////////////////////////////////////////
87
    fun markForDeletion() = mUBO.markForDeletion()
88
}
src/main/java/org/distorted/library/uniformblock/UniformBlockFloatUniforms.kt
1 1
///////////////////////////////////////////////////////////////////////////////////////////////////
2
// Copyright 2021 Leszek Koltunski  leszek@koltunski.pl                                          //
2
// Copyright 2020 Leszek Koltunski  leszek@koltunski.pl                                          //
3 3
//                                                                                               //
4 4
// This file is part of Distorted.                                                               //
5 5
//                                                                                               //
......
18 18
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
19 19
///////////////////////////////////////////////////////////////////////////////////////////////////
20 20

  
21
package org.distorted.library.uniformblock;
21
package org.distorted.library.uniformblock
22 22

  
23
import org.distorted.library.main.DistortedLibrary;
24
import org.distorted.library.main.InternalBuffer;
23
import org.distorted.library.main.DistortedLibrary
24
import org.distorted.library.main.InternalBuffer
25 25

  
26 26
///////////////////////////////////////////////////////////////////////////////////////////////////
27

  
28
/**
29
 * Not part of public API, do not document
30
 *
31
 * @y.exclude
32
 */
33
public class UniformBlockFloatUniforms
34
  {
35
  private InternalBuffer mUBO;
36
  private final float[] mArray;
37
  private final int mNumUniforms, mSize;
38
  private final boolean mReallyUseUBO;
39

  
40
///////////////////////////////////////////////////////////////////////////////////////////////////
41

  
42
  public UniformBlockFloatUniforms(int numUniforms, int size, boolean reallyUse)
27
/** Not part of public API, do not document
28
*
29
* @y.exclude
30
*/
31
class UniformBlockFloatUniforms
32
{
33
    private var mUBO: InternalBuffer? = null
34
    val backingArray: FloatArray
35
    private val mNumUniforms: Int
36
    private val mSize: Int
37
    private val mReallyUseUBO: Boolean
38
    val index: Int get() = mUBO!!.createImmediatelyFloat(4*mNumUniforms*mSize, backingArray)
39

  
40
    ///////////////////////////////////////////////////////////////////////////////////////////////
41
    constructor(numUniforms: Int, size: Int, reallyUse: Boolean)
43 42
    {
44
    mNumUniforms = numUniforms;
45
    mSize        = size;
46
    mArray       = new float[mNumUniforms*mSize];
47
    mReallyUseUBO= reallyUse;
48

  
49
    if( mReallyUseUBO )
50
      {
51
      mUBO = new InternalBuffer();
52
      }
43
        mNumUniforms = numUniforms
44
        mSize = size
45
        backingArray = FloatArray(mNumUniforms*mSize)
46
        mReallyUseUBO = reallyUse
47
        if (mReallyUseUBO) mUBO = InternalBuffer()
53 48
    }
54 49

  
55
///////////////////////////////////////////////////////////////////////////////////////////////////
56

  
57
  public UniformBlockFloatUniforms(UniformBlockFloatUniforms original)
50
    ///////////////////////////////////////////////////////////////////////////////////////////////
51
    constructor(original: UniformBlockFloatUniforms)
58 52
    {
59
    mNumUniforms = original.mNumUniforms;
60
    mSize        = original.mSize;
61
    mArray       = new float[mNumUniforms*mSize];
62
    mReallyUseUBO= original.mReallyUseUBO;
63

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

  
66
    if( mReallyUseUBO )
67
      {
68
      mUBO = new InternalBuffer();
69
      }
53
        mNumUniforms = original.mNumUniforms
54
        mSize = original.mSize
55
        backingArray = FloatArray(mNumUniforms*mSize)
56
        mReallyUseUBO = original.mReallyUseUBO
57
        System.arraycopy(original.backingArray, 0, backingArray, 0, 3 * mSize)
58
        if (mReallyUseUBO) mUBO = InternalBuffer()
70 59
    }
71 60

  
72
///////////////////////////////////////////////////////////////////////////////////////////////////
73

  
74
  public int getIndex()
61
    ///////////////////////////////////////////////////////////////////////////////////////////////
62
    fun remove(pos: Int, numEffects: Int)
75 63
    {
76
    return mUBO.createImmediatelyFloat( 4*mNumUniforms*mSize, mArray);
64
        System.arraycopy( backingArray, mNumUniforms*(pos+1), backingArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) )
65
        if (mReallyUseUBO) mUBO!!.invalidate()
77 66
    }
78 67

  
79
///////////////////////////////////////////////////////////////////////////////////////////////////
80

  
81
  public void remove(int pos, int numEffects)
68
    ///////////////////////////////////////////////////////////////////////////////////////////////
69
    fun markForDeletion()
82 70
    {
83
    System.arraycopy(mArray, mNumUniforms*(pos+1), mArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) );
84

  
85
    if( mReallyUseUBO )
86
      {
87
      mUBO.invalidate();
88
      }
71
        if (mReallyUseUBO) mUBO!!.markForDeletion()
89 72
    }
90 73

  
91
///////////////////////////////////////////////////////////////////////////////////////////////////
92

  
93
  public void markForDeletion()
74
    ///////////////////////////////////////////////////////////////////////////////////////////////
75
    fun invalidate()
94 76
    {
95
    if( mReallyUseUBO )
96
      {
97
      mUBO.markForDeletion();
98
      }
77
        if (mReallyUseUBO) mUBO!!.invalidate()
99 78
    }
100 79

  
101
///////////////////////////////////////////////////////////////////////////////////////////////////
102

  
103
  public void invalidate()
104
    {
105
    if( mReallyUseUBO )
106
      {
107
      mUBO.invalidate();
108
      }
109
    }
110

  
111
///////////////////////////////////////////////////////////////////////////////////////////////////
112

  
113
  public float[] getBackingArray()
114
    {
115
    return mArray;
116
    }
117

  
118
///////////////////////////////////////////////////////////////////////////////////////////////////
119

  
120
  public void print(int num)
80
    ///////////////////////////////////////////////////////////////////////////////////////////////
81
    fun print(num: Int)
121 82
    {
122
    StringBuilder builder = new StringBuilder();
123

  
124
    builder.append( mReallyUseUBO ? mUBO.getID() : "NOT USED");
125
    builder.append(':');
126

  
127
    for(int i=0; i<6; i++)
128
      {
129
      builder.append(' ');
130
      builder.append(mArray[4*i  ]);
131
      builder.append(' ');
132
      builder.append(mArray[4*i+1]);
133
      builder.append(' ');
134
      builder.append(mArray[4*i+2]);
135
      builder.append(',');
136
      }
137

  
138
    builder.append(' ');
139
    builder.append('(');
140
    builder.append(num);
141
    builder.append(')');
142

  
143
    String res = builder.toString();
144

  
145
    DistortedLibrary.logMessage("UniformBlockFloatUniforms: "+res);
83
        val builder = StringBuilder()
84

  
85
        builder.append(if (mReallyUseUBO) mUBO!!.id else "NOT USED")
86
        builder.append(':')
87

  
88
        for (i in 0..5)
89
        {
90
            builder.append(' ')
91
            builder.append(backingArray[4*i])
92
            builder.append(' ')
93
            builder.append(backingArray[4*i+1])
94
            builder.append(' ')
95
            builder.append(backingArray[4*i+2])
96
            builder.append(',')
97
        }
98

  
99
        builder.append(' ')
100
        builder.append('(')
101
        builder.append(num)
102
        builder.append(')')
103

  
104
        val res = builder.toString()
105

  
106
        DistortedLibrary.logMessage("UniformBlockFloatUniforms: $res")
146 107
    }
147
  }
108
}
src/main/java/org/distorted/library/uniformblock/UniformBlockIntUniforms.kt
18 18
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //
19 19
///////////////////////////////////////////////////////////////////////////////////////////////////
20 20

  
21
package org.distorted.library.uniformblock;
21
package org.distorted.library.uniformblock
22 22

  
23
import org.distorted.library.effect.Effect;
24
import org.distorted.library.main.DistortedLibrary;
25
import org.distorted.library.main.InternalBuffer;
23
import org.distorted.library.effect.Effect
24
import org.distorted.library.main.DistortedLibrary
25
import org.distorted.library.main.InternalBuffer
26 26

  
27 27
///////////////////////////////////////////////////////////////////////////////////////////////////
28
/**
29
 * Not part of public API, do not document
30
 *
31
 * @y.exclude
32
 */
33
public class UniformBlockIntUniforms
34
  {
35
  private InternalBuffer mUBO;
36
  private final int[] mArray;
37
  private final int mNumUniforms, mSize;
38
  private final boolean mReallyUseUBO;
39

  
40
///////////////////////////////////////////////////////////////////////////////////////////////////
41

  
42
  public UniformBlockIntUniforms(int numUniforms, int size, boolean reallyUse)
28
/** Not part of public API, do not document
29
*
30
* @y.exclude
31
*/
32
class UniformBlockIntUniforms
33
{
34
    private var mUBO: InternalBuffer? = null
35
    val backingArray: IntArray
36
    private val mNumUniforms: Int
37
    private val mSize: Int
38
    private val mReallyUseUBO: Boolean
39
    val index: Int get() = mUBO!!.createImmediatelyInt(4*mNumUniforms*mSize, backingArray)
40

  
41
    ///////////////////////////////////////////////////////////////////////////////////////////////
42
    constructor(numUniforms: Int, size: Int, reallyUse: Boolean)
43 43
    {
44
    mNumUniforms = numUniforms;
45
    mSize        = size;
46
    mArray       = new int[mNumUniforms*mSize];
47
    mReallyUseUBO= reallyUse;
48

  
49
    if( mReallyUseUBO )
50
      {
51
      mUBO = new InternalBuffer();
52
      }
44
        mNumUniforms = numUniforms
45
        mSize = size
46
        backingArray = IntArray(mNumUniforms * mSize)
47
        mReallyUseUBO = reallyUse
48
        if (mReallyUseUBO) mUBO = InternalBuffer()
53 49
    }
54 50

  
55
///////////////////////////////////////////////////////////////////////////////////////////////////
56

  
57
  public UniformBlockIntUniforms(UniformBlockIntUniforms original)
51
    ///////////////////////////////////////////////////////////////////////////////////////////////
52
    constructor(original: UniformBlockIntUniforms)
58 53
    {
59
    mNumUniforms = original.mNumUniforms;
60
    mSize        = original.mSize;
61
    mArray       = new int[mNumUniforms*mSize];
62
    mReallyUseUBO= original.mReallyUseUBO;
63

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

  
66
    if( mReallyUseUBO )
67
      {
68
      mUBO = new InternalBuffer();
69
      }
54
        mNumUniforms = original.mNumUniforms
55
        mSize = original.mSize
56
        backingArray = IntArray(mNumUniforms * mSize)
57
        mReallyUseUBO = original.mReallyUseUBO
58
        System.arraycopy(original.backingArray, 0, backingArray, 0, mSize)
59
        if (mReallyUseUBO) mUBO = InternalBuffer()
70 60
    }
71 61

  
72
///////////////////////////////////////////////////////////////////////////////////////////////////
73

  
74
  public int getIndex()
62
    ///////////////////////////////////////////////////////////////////////////////////////////////
63
    fun remove(pos: Int, numEffects: Int)
75 64
    {
76
    return mUBO.createImmediatelyInt( 4*mNumUniforms*mSize, mArray);
65
        System.arraycopy(backingArray, mNumUniforms*(pos+1), backingArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) )
66
        if (mReallyUseUBO) mUBO!!.invalidate()
77 67
    }
78 68

  
79
///////////////////////////////////////////////////////////////////////////////////////////////////
80

  
81
  public void remove(int pos, int numEffects)
69
    ///////////////////////////////////////////////////////////////////////////////////////////////
70
    fun makeHole(pos: Int, numEffects: Int)
82 71
    {
83
    System.arraycopy(mArray, mNumUniforms*(pos+1), mArray, mNumUniforms*pos, mNumUniforms*(numEffects-pos) );
84

  
85
    if( mReallyUseUBO )
86
      {
87
      mUBO.invalidate();
88
      }
72
        System.arraycopy( backingArray, mNumUniforms*pos, backingArray, mNumUniforms*(pos+1), mNumUniforms*(numEffects-pos) )
73
        if (mReallyUseUBO) mUBO!!.invalidate()
89 74
    }
90 75

  
91
///////////////////////////////////////////////////////////////////////////////////////////////////
92

  
93
  public void makeHole(int pos, int numEffects)
76
    ///////////////////////////////////////////////////////////////////////////////////////////////
77
    fun addOrdinal(pos: Int, ordinal: Int)
94 78
    {
95
    System.arraycopy(mArray, mNumUniforms*pos, mArray, mNumUniforms*(pos+1), mNumUniforms*(numEffects-pos) );
96

  
97
    if( mReallyUseUBO )
98
      {
99
      mUBO.invalidate();
100
      }
79
        backingArray[mNumUniforms*pos] = ordinal
80
        if (mReallyUseUBO) mUBO!!.invalidate()
101 81
    }
102 82

  
103
///////////////////////////////////////////////////////////////////////////////////////////////////
104

  
105
  public void addOrdinal(int pos, int ordinal)
83
    ///////////////////////////////////////////////////////////////////////////////////////////////
84
    fun addAssociations(pos: Int, effect: Effect)
106 85
    {
107
    mArray[mNumUniforms*pos] = ordinal;
108

  
109
    if( mReallyUseUBO )
110
      {
111
      mUBO.invalidate();
112
      }
113
    }
114

  
115
///////////////////////////////////////////////////////////////////////////////////////////////////
116

  
117
  public void addAssociations(int pos, Effect effect)
118
    {
119
    effect.writeAssociations(mArray, mNumUniforms*pos+1, mNumUniforms*pos+3);
120

  
121
    if( mReallyUseUBO )
122
      {
123
      mUBO.invalidate();
124
      }
125
    }
126

  
127
///////////////////////////////////////////////////////////////////////////////////////////////////
128

  
129
  public void markForDeletion()
130
    {
131
    if( mReallyUseUBO )
132
      {
133
      mUBO.markForDeletion();
134
      }
86
        effect.writeAssociations(backingArray, mNumUniforms*pos+1, mNumUniforms*pos+3)
87
        if (mReallyUseUBO) mUBO!!.invalidate()
135 88
    }
136 89

  
137
///////////////////////////////////////////////////////////////////////////////////////////////////
138

  
139
  public int[] getBackingArray()
90
    ///////////////////////////////////////////////////////////////////////////////////////////////
91
    fun markForDeletion()
140 92
    {
141
    return mArray;
93
        if (mReallyUseUBO) mUBO!!.markForDeletion()
142 94
    }
143 95

  
144
///////////////////////////////////////////////////////////////////////////////////////////////////
145

  
146
  public void print(int num)
96
    ///////////////////////////////////////////////////////////////////////////////////////////////
97
    fun print(num: Int)
147 98
    {
148
    StringBuilder builder = new StringBuilder();
149

  
150
    builder.append( mReallyUseUBO ? mUBO.getID() : "NOT USED");
151
    builder.append(':');
152

  
153
    for(int i=0; i<6; i++)
154
      {
155
      builder.append(' ');
156
      builder.append(mArray[4*i  ]);
157
      builder.append(' ');
158
      builder.append(mArray[4*i+1]);
159
      builder.append(' ');
160
      builder.append(mArray[4*i+2]);
161
      builder.append(',');
162
      }
163

  
164
    builder.append(' ');
165
    builder.append('(');
166
    builder.append(num);
167
    builder.append(')');
168

  
169
    String res = builder.toString();
170

  
171
    DistortedLibrary.logMessage("UniformBlockIntUniforms: "+res);
99
        val builder = StringBuilder()
100

  
101
        builder.append(if (mReallyUseUBO) mUBO!!.id else "NOT USED")
102
        builder.append(':')
103

  
104
        for (i in 0..5)
105
        {
106
            builder.append(' ')
107
            builder.append(backingArray[4*i])
108
            builder.append(' ')
109
            builder.append(backingArray[4*i+1])
110
            builder.append(' ')
111
            builder.append(backingArray[4*i+2])
112
            builder.append(',')
113
        }
114

  
115
        builder.append(' ')
116
        builder.append('(')
117
        builder.append(num)
118
        builder.append(')')
119

  
120
        val res = builder.toString()
121

  
122
        DistortedLibrary.logMessage("UniformBlockIntUniforms: $res")
172 123
    }
173
  }
124
}

Also available in: Unified diff