Java TFloatList.size方法代码示例

import gnu.trove.list.TFloatList; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
public boolean equals( Object other ) {
    if ( other == this ) {
        return true;
    }
    if ( !( other instanceof TFloatList ) ) return false;

    TFloatList that = ( TFloatList )other;
    if ( size() != that.size() ) return false;

    for( int i = 0; i < size(); i++ ) {
        if ( get( i ) != that.get( i ) ) {
            return false;
        }
    }
    return true;
}
 

import gnu.trove.list.TFloatList; //导入方法依赖的package包/类
public void set(final TFloatList value) {
    final Command command = new Command(Command.SETALL, (short) value.size());
    commands.add(command);
    ++baselineCommandCount;

    //Is this the best way to do this?
    v.clear();
    v.addAll(value);

    for (int i = 0, size = value.size(); i < size; ++i) {
        final Command subCommand = new Command(Command.SET, (short) i, value.get(i));
        commands.add(subCommand);
        ++baselineCommandCount;
    }

    touch();
    onChanged();
}
 

import gnu.trove.list.TFloatList; //导入方法依赖的package包/类
private static FloatBuffer createVertexBuffer(TFloatList vertices, TFloatList texcoord0, TFloatList texcoord1, TFloatList normals, TFloatList colors, int vertexCount, boolean hasTexCoord0, boolean hasTexCoord1, boolean hasNormal, boolean hasColor, int vertSize) {
    FloatBuffer vertexBuffer;
    vertexBuffer = BufferUtils.createFloatBuffer(vertSize * vertexCount);
    int texCoord0Size = (hasTexCoord0) ? TEX_COORD_0_SIZE : 0;
    int texCoord1Size = (hasTexCoord1) ? TEX_COORD_1_SIZE : 0;
    int normalSize = (hasNormal) ? NORMAL_SIZE : 0;
    int colorSize = (hasColor) ? COLOR_SIZE : 0;
    int uv1 = 0, uv2 = 0, n = 0, c = 0;
    for (int v = 0; v < vertices.size(); v += 3) {
        vertexBuffer.put(vertices.get(v)).put(vertices.get(v + 1)).put(vertices.get(v + 2));
        for (int i = 0; i < texCoord0Size; ++i) {
            vertexBuffer.put(texcoord0.get(uv1 + i));
        }
        for (int i = 0; i < texCoord1Size; ++i) {
            vertexBuffer.put(texcoord1.get(uv2 + i));
        }
        for (int i = 0; i < normalSize; ++i) {
            vertexBuffer.put(normals.get(n + i));
        }
        for (int i = 0; i < colorSize; ++i) {
            vertexBuffer.put(colors.get(c + i));
        }
        uv1 += texCoord0Size;
        uv2 += texCoord1Size;
        n += normalSize;
        c += colorSize;
    }
    vertexBuffer.flip();
    return vertexBuffer;
}
 

import gnu.trove.list.TFloatList; //导入方法依赖的package包/类
@Override
public Mesh load(AssetUri uri, InputStream stream, List<URL> urls) throws IOException {
    BufferedReader reader = new BufferedReader(new InputStreamReader(stream));

    List<Vector3f> rawVertices = Lists.newArrayList();
    List<Vector3f> rawNormals = Lists.newArrayList();
    List<Vector2f> rawTexCoords = Lists.newArrayList();
    List<Tuple3i[]> rawIndices = Lists.newArrayList();

    // Gather data
    readMeshData(reader, rawVertices, rawNormals, rawTexCoords, rawIndices);

    // Process data
    TFloatList vertices = new TFloatArrayList();
    TFloatList texCoord0 = new TFloatArrayList();
    TFloatList normals = new TFloatArrayList();
    TIntList indices = new TIntArrayList();

    // Determine face format;
    if (rawIndices.size() == 0) {
        throw new IOException("No index data");
    }

    processData(rawVertices, rawNormals, rawTexCoords, rawIndices, vertices, texCoord0, normals, indices);

    if (normals.size() != vertices.size() || texCoord0.size() / 2 != vertices.size() / 3) {
        throw new IOException("Mixed face format");
    }

    return Mesh.buildMesh(uri, vertices, texCoord0, null, normals, null, indices);
}
 

import gnu.trove.list.TFloatList; //导入方法依赖的package包/类
private String[] returnAsString(TFloatList fs)
{
	int n = fs.size();
	String[] asString = new String[n];
	for(int i=0; i < n; ++i)
		asString[i] = String.valueOf(fs.get(i));
	return asString;
}
 

import gnu.trove.list.TFloatList; //导入方法依赖的package包/类
public static Mesh buildMesh(TFloatList vertices, TFloatList texCoord0, TFloatList texCoord1, TFloatList normals, TFloatList colors, TIntList indices) {

        int vertexCount = vertices.size() / VERTEX_SIZE;
        boolean hasTexCoord0 = texCoord0 != null && texCoord0.size() / TEX_COORD_0_SIZE == vertexCount;
        boolean hasTexCoord1 = texCoord1 != null && texCoord1.size() / TEX_COORD_1_SIZE == vertexCount;
        boolean hasNormals = normals != null && normals.size() / NORMAL_SIZE == vertexCount;
        boolean hasColors = colors != null && colors.size() / COLOR_SIZE == vertexCount;

        int vertSize = VERTEX_SIZE + (hasTexCoord0 ? TEX_COORD_0_SIZE : 0) + (hasTexCoord1 ? TEX_COORD_1_SIZE : 0) + (hasNormals ? NORMAL_SIZE : 0) + (hasColors ? COLOR_SIZE : 0);
        FloatBuffer vertexBuffer = createVertexBuffer(vertices, texCoord0, texCoord1, normals, colors, vertexCount, hasTexCoord0, hasTexCoord1, hasNormals, hasColors, vertSize);

        IntBuffer indexBuffer = BufferUtils.createIntBuffer(indices.size());
        TIntIterator iterator = indices.iterator();
        while (iterator.hasNext()) {
            indexBuffer.put(iterator.next());
        }
        indexBuffer.flip();

        Mesh mesh = new Mesh();
        mesh.vertices = vertices;
        mesh.texCoord0 = texCoord0;
        mesh.texCoord1 = texCoord1;
        mesh.normals = normals;
        mesh.colors = colors;
        mesh.indices = indices;
        mesh.indexCount = indices.size();
        mesh.aabb = calculateAABB(vertices, vertexCount);

        mesh.vboVertexBuffer = VertexBufferObjectManager.getInstance().getVboId();
        VertexBufferObjectManager.getInstance().bufferVboData(mesh.vboVertexBuffer, vertexBuffer, GL15.GL_STATIC_DRAW);
        mesh.vboIndexBuffer = VertexBufferObjectManager.getInstance().getVboId();
        VertexBufferObjectManager.getInstance().bufferVboElementData(mesh.vboIndexBuffer, indexBuffer, GL15.GL_STATIC_DRAW);

        mesh.stride = vertSize * 4;
        mesh.vertexOffset = 0;
        int offset = VERTEX_SIZE;

        if (hasTexCoord0) {
            mesh.hasTexCoord0 = hasTexCoord0;
            mesh.texCoord0Offset = 4 * offset;
            offset += TEX_COORD_0_SIZE;
        }
        if (hasTexCoord1) {
            mesh.hasTexCoord1 = hasTexCoord1;
            mesh.texCoord1Offset = 4 * offset;
            offset += TEX_COORD_1_SIZE;
        }
        if (hasNormals) {
            mesh.hasNormal = hasNormals;
            mesh.normalOffset = 4 * offset;
            offset += NORMAL_SIZE;
        }
        if (hasColors) {
            mesh.hasColor = hasColors;
            mesh.colorOffset = 4 * offset;
            offset += COLOR_SIZE;
        }

        indexBuffer.flip();
        return mesh;
    }
 

import gnu.trove.list.TFloatList; //导入方法依赖的package包/类
private void renderBatch(TFloatList vertexData, TIntList indexData) {
    if (vertexData.size() == 0 || indexData.size() == 0) return;

    PerformanceMonitor.startActivity("BatchRenderMesh");
    FloatBuffer vertexBuffer = BufferUtils.createFloatBuffer(vertexData.size());
    vertexBuffer.put(vertexData.toArray());
    vertexBuffer.flip();
    GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, batchVertexBuffer);
    GL15.glBufferData(GL15.GL_ARRAY_BUFFER, vertexBuffer, GL15.GL_DYNAMIC_DRAW);

    IntBuffer indexBuffer = BufferUtils.createIntBuffer(indexData.size());
    indexBuffer.put(indexData.toArray());
    indexBuffer.flip();
    GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, batchIndexBuffer);
    GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, indexBuffer, GL15.GL_DYNAMIC_DRAW);

    glPushMatrix();

    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_NORMAL_ARRAY);

    //GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, batchVertexBuffer);
    //GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, batchIndexBuffer);

    glVertexPointer(Mesh.VERTEX_SIZE, GL11.GL_FLOAT, 15 * 4, 0);
    GL13.glClientActiveTexture(GL13.GL_TEXTURE0);
    glTexCoordPointer(Mesh.TEX_COORD_0_SIZE, GL11.GL_FLOAT, 15 * 4, 4 * 3);
    GL13.glClientActiveTexture(GL13.GL_TEXTURE1);
    glTexCoordPointer(Mesh.TEX_COORD_1_SIZE, GL11.GL_FLOAT, 15 * 4, 4 * 5);
    glColorPointer(Mesh.COLOR_SIZE, GL11.GL_FLOAT, 15 * 4, 4 * 11);
    glNormalPointer(GL11.GL_FLOAT, 15 * 4, 4 * 8);

    GL12.glDrawRangeElements(GL11.GL_TRIANGLES, 0, indexData.size(), indexData.size(), GL_UNSIGNED_INT, 0);

    glDisableClientState(GL_NORMAL_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_VERTEX_ARRAY);

    GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
    GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
    glPopMatrix();
    PerformanceMonitor.endActivity();
}
 

import gnu.trove.list.TFloatList; //导入方法依赖的package包/类
public FloatStatistics(TFloatList list) {
    int n = list.size();

    float min = Float.MAX_VALUE, max = Float.MIN_VALUE;
    float total = 0;
    float totalSq = 0;

    TFloatIterator itr = list.iterator();
    for (; itr.hasNext();) {
        float f = itr.next();

        min = Math.min(min, f);
        max = Math.max(max, f);

        total += f;
        totalSq += f * f;
    }


    float rank10 = 10f / 100f * (n - 1);
    int rI10 = (int) rank10;
    float rF10 = rank10 - rI10;
    float percentile10;

    float rank90 = 90f / 100f * (n - 1);
    int rI90 = (int) rank90;
    float rF90 = rank90 - rI90;
    float percentile90;

    if (n > 1) {
        percentile10 =
                (1 - rF10) * list.get(rI10) + rF10 * list.get(rI10 + 1);
        percentile90 =
                (1 - rF90) * list.get(rI90) + rF90 * list.get(rI90 + 1);
    } else {
        percentile10 = total;
        percentile90 = total;
    }

    init(n,
         min, max,
         total, totalSq,
         percentile10,
         percentile90);
}