Revision 35268ac9
Added by Leszek Koltunski 4 days ago
| src/main/java/org/distorted/library/effect/PostprocessEffect.kt | ||
|---|---|---|
| 25 | 25 |
import org.distorted.library.main.DistortedLibrary |
| 26 | 26 |
import org.distorted.library.main.InternalMaster |
| 27 | 27 |
import org.distorted.library.main.InternalMaster.Slave |
| 28 |
import org.distorted.library.platform.NativeBuffer |
|
| 28 | 29 |
import org.distorted.library.program.DistortedProgram |
| 29 | 30 |
|
| 30 |
import java.nio.ByteBuffer |
|
| 31 |
import java.nio.ByteOrder |
|
| 32 |
import java.nio.FloatBuffer |
|
| 33 |
|
|
| 34 | 31 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 35 | 32 |
/** |
| 36 | 33 |
* Abstract class that represents an Effect that works by running a certain Shader Program(s) on a Framebuffer. |
| ... | ... | |
| 70 | 67 |
const val POS_DATA_SIZE: Int = 2 |
| 71 | 68 |
const val TEX_DATA_SIZE: Int = 2 |
| 72 | 69 |
|
| 73 |
val mQuadPositions: FloatBuffer
|
|
| 74 |
val mQuadTexture: FloatBuffer
|
|
| 70 |
val mQuadPositions: NativeBuffer
|
|
| 71 |
val mQuadTexture : NativeBuffer
|
|
| 75 | 72 |
|
| 76 | 73 |
init |
| 77 | 74 |
{
|
| 78 |
val dataLength = 4*4 |
|
| 79 |
|
|
| 80 | 75 |
val position = floatArrayOf(-0.5f,-0.5f,-0.5f, 0.5f, 0.5f,-0.5f, 0.5f, 0.5f) |
| 81 | 76 |
val textureNor = floatArrayOf( 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f) |
| 82 | 77 |
|
| 83 |
mQuadPositions = ByteBuffer.allocateDirect(POS_DATA_SIZE*dataLength).order(ByteOrder.nativeOrder()).asFloatBuffer() |
|
| 84 |
mQuadPositions.put(position).position(0) |
|
| 85 |
mQuadTexture = ByteBuffer.allocateDirect(TEX_DATA_SIZE*dataLength).order(ByteOrder.nativeOrder()).asFloatBuffer() |
|
| 86 |
mQuadTexture.put(textureNor).position(0) |
|
| 78 |
mQuadPositions = NativeBuffer(position) |
|
| 79 |
mQuadTexture = NativeBuffer(textureNor) |
|
| 87 | 80 |
} |
| 88 | 81 |
|
| 89 | 82 |
var mPrograms: ArrayList<DistortedProgram> = ArrayList() |
| src/main/java/org/distorted/library/main/DistortedLibrary.kt | ||
|---|---|---|
| 42 | 42 |
import org.distorted.library.mesh.MeshBase.Companion.maxEffComponents |
| 43 | 43 |
import org.distorted.library.mesh.MeshBase.Companion.useCenters |
| 44 | 44 |
import org.distorted.library.message.EffectMessageSender |
| 45 |
import org.distorted.library.platform.NativeBuffer |
|
| 45 | 46 |
import org.distorted.library.program.DistortedProgram |
| 46 | 47 |
import org.distorted.library.program.VertexCompilationException |
| 47 | 48 |
import org.distorted.library.type.Dynamic |
| 48 | 49 |
import org.distorted.library.shaders.* |
| 49 | 50 |
|
| 50 |
import java.nio.ByteBuffer |
|
| 51 |
import java.nio.ByteOrder |
|
| 52 |
import java.nio.FloatBuffer |
|
| 53 |
|
|
| 54 | 51 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 55 | 52 |
/** |
| 56 | 53 |
* A singleton class used to control various global settings. |
| ... | ... | |
| 195 | 192 |
private var mBlitProgram: DistortedProgram? = null |
| 196 | 193 |
private var mBlitTextureH = 0 |
| 197 | 194 |
private var mBlitDepthH = 0 |
| 198 |
private var mQuadPositions: FloatBuffer
|
|
| 195 |
private var mQuadPositions: NativeBuffer
|
|
| 199 | 196 |
|
| 200 | 197 |
/** FULL PROGRAM /// */ |
| 201 | 198 |
private var mFullProgram: DistortedProgram? = null |
| ... | ... | |
| 203 | 200 |
init |
| 204 | 201 |
{
|
| 205 | 202 |
val positionData = floatArrayOf(-0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f) |
| 206 |
mQuadPositions = ByteBuffer.allocateDirect(32).order(ByteOrder.nativeOrder()).asFloatBuffer() |
|
| 207 |
mQuadPositions.put(positionData).position(0) |
|
| 203 |
mQuadPositions = NativeBuffer(positionData) |
|
| 208 | 204 |
} |
| 209 | 205 |
|
| 210 | 206 |
/** BLIT DEPTH PROGRAM /// */ |
| ... | ... | |
| 708 | 704 |
} |
| 709 | 705 |
} |
| 710 | 706 |
|
| 711 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 712 |
// yes it is safe to be mixing 3.0 and 3.1 like that, senior members of the OpenGL discussions forum assert |
|
| 713 |
private fun printPreviousBuffer(): Int |
|
| 714 |
{
|
|
| 715 |
val atomicBuf = GLES.glMapBufferRange(GLES.GL_ATOMIC_COUNTER_BUFFER, 0, 4, GLES.GL_MAP_READ_BIT) |
|
| 716 |
val atomicIntBuf = atomicBuf.order(ByteOrder.nativeOrder()).asIntBuffer() |
|
| 717 |
val counter = atomicIntBuf[0] |
|
| 718 |
|
|
| 719 |
GLES.glUnmapBuffer(GLES.GL_ATOMIC_COUNTER_BUFFER) |
|
| 720 |
|
|
| 721 |
return counter |
|
| 722 |
} |
|
| 723 |
|
|
| 724 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 725 |
private fun zeroBuffer() |
|
| 726 |
{
|
|
| 727 |
val atomicBuf = GLES.glMapBufferRange(GLES.GL_ATOMIC_COUNTER_BUFFER, 0, 4, GLES.GL_MAP_WRITE_BIT or GLES.GL_MAP_INVALIDATE_BUFFER_BIT) |
|
| 728 |
val atomicIntBuf = atomicBuf.order(ByteOrder.nativeOrder()).asIntBuffer() |
|
| 729 |
atomicIntBuf.put(0, 0) |
|
| 730 |
|
|
| 731 |
GLES.glUnmapBuffer(GLES.GL_ATOMIC_COUNTER_BUFFER) |
|
| 732 |
} |
|
| 733 |
|
|
| 734 | 707 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 735 | 708 |
// reset atomic counter to 0 |
| 736 | 709 |
fun zeroOutAtomic(): Int |
| ... | ... | |
| 747 | 720 |
{
|
| 748 | 721 |
GLES.glBindBuffer(GLES.GL_ATOMIC_COUNTER_BUFFER, mAtomicCounter!![i]) |
| 749 | 722 |
GLES.glBufferData(GLES.GL_ATOMIC_COUNTER_BUFFER, 4, null, GLES.GL_DYNAMIC_DRAW) |
| 750 |
zeroBuffer() |
|
| 723 |
GLES.zeroBuffer()
|
|
| 751 | 724 |
} |
| 752 | 725 |
} |
| 753 | 726 |
|
| ... | ... | |
| 756 | 729 |
if (mCurrBuffer==0) |
| 757 | 730 |
{
|
| 758 | 731 |
GLES.glBindBufferBase(GLES.GL_ATOMIC_COUNTER_BUFFER, 0, mAtomicCounter!![mCurrBuffer]) |
| 759 |
counter = printPreviousBuffer() |
|
| 732 |
counter = GLES.printPreviousBuffer()
|
|
| 760 | 733 |
} |
| 761 | 734 |
|
| 762 | 735 |
if (++mCurrBuffer>=queueSize) mCurrBuffer = 0 |
| 763 | 736 |
|
| 764 | 737 |
GLES.glBindBufferBase(GLES.GL_ATOMIC_COUNTER_BUFFER, 0, mAtomicCounter!![mCurrBuffer]) |
| 765 |
zeroBuffer() |
|
| 738 |
GLES.zeroBuffer()
|
|
| 766 | 739 |
|
| 767 | 740 |
return counter |
| 768 | 741 |
} |
| src/main/java/org/distorted/library/main/InternalBuffer.kt | ||
|---|---|---|
| 20 | 20 |
package org.distorted.library.main |
| 21 | 21 |
|
| 22 | 22 |
import org.distorted.library.platform.GLES |
| 23 |
|
|
| 24 |
import java.nio.Buffer |
|
| 25 |
import java.nio.ByteBuffer |
|
| 26 |
import java.nio.ByteOrder |
|
| 27 |
import java.nio.FloatBuffer |
|
| 28 |
import java.nio.IntBuffer |
|
| 23 |
import org.distorted.library.platform.NativeBuffer |
|
| 29 | 24 |
|
| 30 | 25 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 31 | 26 |
/** |
| ... | ... | |
| 43 | 38 |
private val mIndex : IntArray |
| 44 | 39 |
private val mTarget: Int |
| 45 | 40 |
private val mUsage : Int |
| 46 |
private var mBuffer: Buffer? |
|
| 41 |
private var mBuffer: NativeBuffer?
|
|
| 47 | 42 |
|
| 48 | 43 |
companion object |
| 49 | 44 |
{
|
| ... | ... | |
| 80 | 75 |
if( (mStatus and RECREATE)!=0 ) |
| 81 | 76 |
{
|
| 82 | 77 |
mSize = size |
| 83 |
|
|
| 84 |
if (buffer!=null) |
|
| 85 |
{
|
|
| 86 |
val buf = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder()).asFloatBuffer() |
|
| 87 |
buf.put(buffer).position(0) |
|
| 88 |
mBuffer = buf |
|
| 89 |
} |
|
| 90 |
else |
|
| 91 |
{
|
|
| 92 |
mBuffer = null |
|
| 93 |
} |
|
| 78 |
mBuffer = buffer?.let { NativeBuffer(it) }
|
|
| 94 | 79 |
|
| 95 | 80 |
GLES.glGenBuffers(1, mIndex, 0) |
| 96 | 81 |
GLES.glBindBuffer(mTarget, mIndex[0]) |
| ... | ... | |
| 116 | 101 |
if ((mStatus and RECREATE)!=0) |
| 117 | 102 |
{
|
| 118 | 103 |
mSize = size |
| 119 |
|
|
| 120 |
if (buffer!=null) |
|
| 121 |
{
|
|
| 122 |
val buf = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder()).asIntBuffer() |
|
| 123 |
buf.put(buffer).position(0) |
|
| 124 |
mBuffer = buf |
|
| 125 |
} |
|
| 126 |
else |
|
| 127 |
{
|
|
| 128 |
mBuffer = null |
|
| 129 |
} |
|
| 104 |
mBuffer = buffer?.let { NativeBuffer(it) }
|
|
| 130 | 105 |
|
| 131 | 106 |
GLES.glGenBuffers(1, mIndex, 0) |
| 132 | 107 |
GLES.glBindBuffer(mTarget, mIndex[0]) |
| ... | ... | |
| 149 | 124 |
// buffer non-null!! |
| 150 | 125 |
fun updateFloat(buffer: FloatArray?) |
| 151 | 126 |
{
|
| 152 |
(mBuffer as FloatBuffer).put(buffer).position(0)
|
|
| 127 |
mBuffer?.update(buffer)
|
|
| 153 | 128 |
|
| 154 | 129 |
GLES.glBindBuffer(mTarget, mIndex[0]) |
| 155 | 130 |
GLES.glBufferData(mTarget, mSize, mBuffer, mUsage) |
| ... | ... | |
| 162 | 137 |
// buffer non-null!! |
| 163 | 138 |
fun updateInt(buffer: IntArray?) |
| 164 | 139 |
{
|
| 165 |
(mBuffer as IntBuffer).put(buffer).position(0)
|
|
| 140 |
mBuffer?.update(buffer)
|
|
| 166 | 141 |
|
| 167 | 142 |
GLES.glBindBuffer(mTarget, mIndex[0]) |
| 168 | 143 |
GLES.glBufferData(mTarget, mSize, mBuffer, mUsage) |
| src/main/java/org/distorted/library/mesh/MeshBase.kt | ||
|---|---|---|
| 33 | 33 |
import org.distorted.library.uniformblock.UniformBlockAssociation |
| 34 | 34 |
import org.distorted.library.uniformblock.UniformBlockCenter |
| 35 | 35 |
|
| 36 |
import java.nio.ByteOrder |
|
| 37 |
|
|
| 38 | 36 |
import kotlin.math.min |
| 39 | 37 |
import kotlin.math.sqrt |
| 40 | 38 |
|
| ... | ... | |
| 79 | 77 |
|
| 80 | 78 |
const val VERT1_ATTRIBS: Int = POS_DATA_SIZE+NOR_DATA_SIZE // number of attributes of a vertex (the part changed by preapply) |
| 81 | 79 |
const val VERT2_ATTRIBS: Int = TEX_DATA_SIZE+COM_DATA_SIZE // number of attributes of a vertex (the 'preapply invariant' part) |
| 82 |
const val TRAN_ATTRIBS: Int = POS_DATA_SIZE+NOR_DATA_SIZE // number of attributes of a transform feedback vertex |
|
| 80 |
const val TRAN_ATTRIBS : Int = POS_DATA_SIZE+NOR_DATA_SIZE // number of attributes of a transform feedback vertex
|
|
| 83 | 81 |
|
| 84 | 82 |
private const val BYTES_PER_FLOAT = 4 |
| 85 | 83 |
|
| ... | ... | |
| 639 | 637 |
*/ |
| 640 | 638 |
fun copyTransformToVertex() |
| 641 | 639 |
{
|
| 642 |
val buffer = GLES.glMapBufferRange(GLES.GL_TRANSFORM_FEEDBACK_BUFFER, 0, |
|
| 643 |
TRAN_SIZE*numVertices, GLES.GL_MAP_READ_BIT) |
|
| 644 |
|
|
| 645 |
val feedback = buffer.order(ByteOrder.nativeOrder()).asFloatBuffer() |
|
| 646 |
feedback[mVertAttribs1, 0, VERT1_ATTRIBS*numVertices] |
|
| 640 |
GLES.copyTransformToVertex(mVertAttribs1!!, VERT1_ATTRIBS*numVertices) |
|
| 647 | 641 |
mVBO1.updateFloat(mVertAttribs1) |
| 648 |
|
|
| 649 |
GLES.glUnmapBuffer(GLES.GL_TRANSFORM_FEEDBACK_BUFFER) |
|
| 650 | 642 |
} |
| 651 | 643 |
|
| 652 | 644 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/library/platform/GLES.kt | ||
|---|---|---|
| 25 | 25 |
|
| 26 | 26 |
import java.nio.Buffer |
| 27 | 27 |
import java.nio.ByteBuffer |
| 28 |
import java.nio.FloatBuffer
|
|
| 28 |
import java.nio.ByteOrder
|
|
| 29 | 29 |
|
| 30 | 30 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 31 | 31 |
|
| ... | ... | |
| 133 | 133 |
{
|
| 134 | 134 |
GLES31.glGetActiveUniformsiv(programH,uniformCount,uniformIndices,uIndex,pname,params,pIndex) |
| 135 | 135 |
} |
| 136 |
fun glMapBufferRange(target: Int, offset: Int, length: Int, access: Int) : ByteBuffer |
|
| 137 |
{
|
|
| 138 |
return GLES31.glMapBufferRange(target,offset,length,access) as ByteBuffer |
|
| 139 |
} |
|
| 140 |
fun glUnmapBuffer(target: Int) |
|
| 141 |
{
|
|
| 142 |
GLES31.glUnmapBuffer(target) |
|
| 143 |
} |
|
| 144 | 136 |
fun glBindBufferBase(target: Int, index: Int, buffer: Int) |
| 145 | 137 |
{
|
| 146 | 138 |
GLES31.glBindBufferBase(target, index, buffer) |
| ... | ... | |
| 153 | 145 |
{
|
| 154 | 146 |
GLES31.glBindBuffer(target, buffer) |
| 155 | 147 |
} |
| 156 |
fun glVertexAttribPointer(indx: Int, size: Int, type: Int, normalized: Boolean, stride: Int, ptr: FloatBuffer)
|
|
| 148 |
fun glVertexAttribPointer(indx: Int, size: Int, type: Int, normalized: Boolean, stride: Int, ptr: NativeBuffer)
|
|
| 157 | 149 |
{
|
| 158 |
GLES31.glVertexAttribPointer(indx, size, type, normalized, stride, ptr) |
|
| 150 |
GLES31.glVertexAttribPointer(indx, size, type, normalized, stride, ptr.fb )
|
|
| 159 | 151 |
} |
| 160 | 152 |
fun glVertexAttribPointer(indx: Int, size: Int, type: Int, normalized: Boolean, stride: Int, offset: Int) |
| 161 | 153 |
{
|
| ... | ... | |
| 241 | 233 |
{
|
| 242 | 234 |
GLES31.glGenBuffers(n, buffers, offset) |
| 243 | 235 |
} |
| 244 |
fun glBufferData(target: Int, size: Int, data: Buffer?, usage: Int) |
|
| 236 |
fun glBufferData(target: Int, size: Int, data: NativeBuffer?, usage: Int)
|
|
| 245 | 237 |
{
|
| 246 |
GLES31.glBufferData(target, size, data, usage) |
|
| 238 |
var buf: Buffer? = null |
|
| 239 |
|
|
| 240 |
if( data!=null ) |
|
| 241 |
{
|
|
| 242 |
if( data.ib!=null ) buf = data.ib |
|
| 243 |
else if( data.fb!=null ) buf = data.fb |
|
| 244 |
} |
|
| 245 |
|
|
| 246 |
GLES31.glBufferData(target, size, buf, usage) |
|
| 247 | 247 |
} |
| 248 | 248 |
fun glDeleteBuffers(n: Int, buffers: IntArray, offset: Int) |
| 249 | 249 |
{
|
| ... | ... | |
| 293 | 293 |
{
|
| 294 | 294 |
GLES31.glTexParameterf(target, pname, param) |
| 295 | 295 |
} |
| 296 |
fun glTexImage2D(target: Int, level: Int, internalformat: Int, width: Int, height: Int, border: Int, format: Int, type: Int, pixels: ByteBuffer?)
|
|
| 296 |
fun glTexImage2D(target: Int, level: Int, internalformat: Int, width: Int, height: Int, border: Int, format: Int, type: Int, pixels: NativeBuffer?)
|
|
| 297 | 297 |
{
|
| 298 |
GLES31.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels) |
|
| 298 |
GLES31.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels?.bb)
|
|
| 299 | 299 |
} |
| 300 | 300 |
fun glDisable(cap: Int) |
| 301 | 301 |
{
|
| ... | ... | |
| 353 | 353 |
fun glGetAttribLocation(program: Int, name: String): Int = GLES31.glGetAttribLocation(program,name) |
| 354 | 354 |
fun glCreateProgram(): Int = GLES31.glCreateProgram() |
| 355 | 355 |
|
| 356 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 357 |
fun printPreviousBuffer(): Int |
|
| 358 |
{
|
|
| 359 |
val atomicBuf = GLES31.glMapBufferRange(GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, 4, GLES31.GL_MAP_READ_BIT) |
|
| 360 |
val atomicIntBuf = (atomicBuf as ByteBuffer).order(ByteOrder.nativeOrder()).asIntBuffer() |
|
| 361 |
val counter = atomicIntBuf[0] |
|
| 362 |
|
|
| 363 |
GLES31.glUnmapBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER) |
|
| 364 |
|
|
| 365 |
return counter |
|
| 366 |
} |
|
| 367 |
|
|
| 368 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 369 |
fun zeroBuffer() |
|
| 370 |
{
|
|
| 371 |
val atomicBuf = GLES31.glMapBufferRange(GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, 4, GLES31.GL_MAP_WRITE_BIT or GLES31.GL_MAP_INVALIDATE_BUFFER_BIT) |
|
| 372 |
val atomicIntBuf = (atomicBuf as ByteBuffer).order(ByteOrder.nativeOrder()).asIntBuffer() |
|
| 373 |
atomicIntBuf.put(0, 0) |
|
| 374 |
|
|
| 375 |
GLES31.glUnmapBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER) |
|
| 376 |
} |
|
| 377 |
|
|
| 378 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 379 |
fun copyTransformToVertex(buf: FloatArray, size: Int) |
|
| 380 |
{
|
|
| 381 |
val buffer = GLES31.glMapBufferRange(GLES31.GL_TRANSFORM_FEEDBACK_BUFFER, 0, |
|
| 382 |
4*size, GLES31.GL_MAP_READ_BIT) |
|
| 383 |
|
|
| 384 |
val feedback = (buffer as ByteBuffer).order(ByteOrder.nativeOrder()).asFloatBuffer() |
|
| 385 |
feedback[buf, 0, size] |
|
| 386 |
|
|
| 387 |
GLES31.glUnmapBuffer(GLES31.GL_TRANSFORM_FEEDBACK_BUFFER) |
|
| 388 |
} |
|
| 389 |
|
|
| 356 | 390 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 357 | 391 |
// GLUtils |
| 358 | 392 |
|
| src/main/java/org/distorted/library/platform/NativeBuffer.kt | ||
|---|---|---|
| 1 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 2 |
// Copyright 2025 Leszek Koltunski leszek@koltunski.pl // |
|
| 3 |
// // |
|
| 4 |
// This file is part of Distorted. // |
|
| 5 |
// // |
|
| 6 |
// This library is free software; you can redistribute it and/or // |
|
| 7 |
// modify it under the terms of the GNU Lesser General Public // |
|
| 8 |
// License as published by the Free Software Foundation; either // |
|
| 9 |
// version 2.1 of the License, or (at your option) any later version. // |
|
| 10 |
// // |
|
| 11 |
// This library is distributed in the hope that it will be useful, // |
|
| 12 |
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
| 13 |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // |
|
| 14 |
// Lesser General Public License for more details. // |
|
| 15 |
// // |
|
| 16 |
// You should have received a copy of the GNU Lesser General Public // |
|
| 17 |
// License along with this library; if not, write to the Free Software // |
|
| 18 |
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // |
|
| 19 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 20 |
|
|
| 21 |
package org.distorted.library.platform |
|
| 22 |
|
|
| 23 |
import java.nio.ByteBuffer |
|
| 24 |
import java.nio.IntBuffer |
|
| 25 |
import java.nio.FloatBuffer |
|
| 26 |
import java.nio.ByteOrder |
|
| 27 |
|
|
| 28 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 29 |
|
|
| 30 |
class NativeBuffer() |
|
| 31 |
{
|
|
| 32 |
var bb: ByteBuffer? = null |
|
| 33 |
var ib: IntBuffer? = null |
|
| 34 |
var fb: FloatBuffer? = null |
|
| 35 |
|
|
| 36 |
constructor(b: IntArray): this() |
|
| 37 |
{
|
|
| 38 |
ib = ByteBuffer.allocateDirect(4*b.size).order(ByteOrder.nativeOrder()).asIntBuffer() |
|
| 39 |
ib!!.put(b).position(0) |
|
| 40 |
} |
|
| 41 |
|
|
| 42 |
constructor(b: FloatArray) : this() |
|
| 43 |
{
|
|
| 44 |
fb = ByteBuffer.allocateDirect(4*b.size).order(ByteOrder.nativeOrder()).asFloatBuffer() |
|
| 45 |
fb!!.put(b).position(0) |
|
| 46 |
} |
|
| 47 |
|
|
| 48 |
fun update(b: FloatArray?) |
|
| 49 |
{
|
|
| 50 |
fb?.put(b)?.position(0) |
|
| 51 |
} |
|
| 52 |
|
|
| 53 |
fun update(b: IntArray?) |
|
| 54 |
{
|
|
| 55 |
ib?.put(b)?.position(0) |
|
| 56 |
} |
|
| 57 |
} |
|
Also available in: Unified diff
remove the last instances of 'import java' from the library. Now only a single package - 'platform' - imports anything 'android' or 'java'