eessppeelllloo/processing4
1
0
Fork 0
mirror of https://github.com/processing/processing4.git synced 2026-01-30 11:51:54 +01:00
Code Issues Packages Projects Releases Wiki Activity

update aggregation for line and point geometry

Browse Source
This commit is contained in:
codeanticode
2012-05-03 03:03:30 +00:00
parent 77af634033
commit be853161be
2 changed files with 76 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
java/libraries/opengl/src/processing/opengl/PGraphicsOpenGL.java
View File

@@ -8324,66 +8324,33 @@ public class PGraphicsOpenGL extends PGraphics {
}
}
void updateLineFromCache() {
firstLineVertex = lineIndexCache.vertexOffset[0];
lastLineVertex = firstLineVertex + lineVertexCount - 1;
firstLineIndex = lineIndexCache.indexOffset[0];
lastLineIndex = firstLineIndex + lineIndexCount - 1;
}
void incLineIndices(int i0, int i1, int inc) {
for (int i = i0; i <= i1; i++) {
lineIndices[i] += inc;
}
}
int setLineVertex(int offset) {
firstLineVertex = 0;
if (0 < offset) {
firstLineVertex = offset + 1;
}
lastLineVertex = firstLineVertex + lineVertexCount - 1;
return lastLineVertex;
void updatePointFromCache() {
firstPointVertex = pointIndexCache.vertexOffset[0];
lastPointVertex = firstPointVertex + pointVertexCount - 1;
firstPointIndex = pointIndexCache.indexOffset[0];
lastPointIndex = firstPointIndex + pointIndexCount - 1;
}
int setLineIndex(int voffset, int ioffset) {
firstLineIndex = 0;
if (0 < ioffset) {
firstLineIndex = ioffset + 1;
}
if (0 < voffset) {
// The indices are update to take into account all the previous
// shapes in the hierarchy, as the entire geometry will be stored
// contiguously in a single VBO in the root node.
for (int i = 0; i < lineIndexCount; i++) {
lineIndices[i] += voffset;
}
}
lastLineIndex = firstLineIndex + lineIndexCount - 1;
return lastLineIndex;
}
int setPointVertex(int offset) {
firstPointVertex = 0;
if (0 < offset) {
firstPointVertex = offset + 1;
}
lastPointVertex = firstPointVertex + pointVertexCount - 1;
return lastPointVertex;
}
int setPointIndex(int voffset, int ioffset) {
firstPointIndex = 0;
if (0 < ioffset) {
firstPointIndex = ioffset + 1;
}
if (0 < voffset) {
// The indices are update to take into account all the previous
// shapes in the hierarchy, as the entire geometry will be stored
// contiguously in a single VBO in the root node.
for (int i = 0; i < pointIndexCount; i++) {
pointIndices[i] += voffset;
}
}
lastPointIndex = firstPointIndex + pointIndexCount - 1;
return lastPointIndex;
}
void incPointIndices(int i0, int i1, int inc) {
for (int i = i0; i <= i1; i++) {
pointIndices[i] += inc;
}
}
// -----------------------------------------------------------------
//

88
java/libraries/opengl/src/processing/opengl/PShape3D.java
View File

@@ -132,15 +132,15 @@ public class PShape3D extends PShape {
protected int fillVertexAbs;
protected int fillVertexRel;
protected int lastLineVertexOffset;
protected int lastLineIndexOffset;
protected int firstLineVertexRel;
protected int firstLineVertexAbs;
protected int lineIndexOffset;
protected int lineVertexOffset;
protected int lineVertexAbs;
protected int lineVertexRel;
protected int lastPointVertexOffset;
protected int lastPointIndexOffset;
protected int firstPointVertexRel;
protected int firstPointVertexAbs;
protected int pointIndexOffset;
protected int pointVertexOffset;
protected int pointVertexAbs;
protected int pointVertexRel;
// ........................................................
@@ -3070,22 +3070,22 @@ public class PShape3D extends PShape {
protected void aggregate() {
if (root == this && parent == null) {
// We recursively calculate the total number of vertices and indices.
fillIndexOffset = 0;
fillVertexOffset = 0;
fillVertexAbs = 0;
fillVertexRel = 0;
lastLineVertexOffset = 0;
lastLineIndexOffset = 0;
firstLineVertexRel = 0;
firstLineVertexAbs = 0;
lineIndexOffset = 0;
lineVertexOffset = 0;
lineVertexAbs = 0;
lineVertexRel = 0;
lastPointVertexOffset = 0;
lastPointIndexOffset = 0;
firstPointVertexRel = 0;
firstPointVertexAbs = 0;
pointIndexOffset = 0;
pointVertexOffset = 0;
pointVertexAbs = 0;
pointVertexRel = 0;
// We recursively calculate the total number of vertices and indices.
aggregateImpl();
needBufferInit = true;
@@ -3196,27 +3196,45 @@ public class PShape3D extends PShape {
}
if (0 < tess.lineVertexCount && 0 < tess.lineIndexCount) {
if (PGL.MAX_VERTEX_INDEX1 < root.firstLineVertexRel + tess.lineVertexCount) {
root.firstLineVertexRel = 0;
root.firstLineVertexAbs = root.lastLineVertexOffset + 1;
}
root.lastLineVertexOffset = tess.setLineVertex(root.lastLineVertexOffset);
root.lastLineIndexOffset = tess.setLineIndex(root.firstLineVertexRel, root.lastLineIndexOffset);
root.firstLineVertexRel += tess.lineVertexCount;
//addLineIndexBlock(tess.lastLineIndex - tess.firstLineIndex + 1, tess.firstLineIndex, root.firstLineVertexAbs);
IndexCache cache = tess.lineIndexCache;
for (int n = 0; n < cache.count; n++) {
int ioffset = cache.indexOffset[n];
int icount = cache.indexCount[n];
int vcount = cache.vertexCount[n];
if (PGL.MAX_VERTEX_INDEX1 <= root.lineVertexRel + vcount) {
root.lineVertexRel = 0;
root.lineVertexOffset = root.lineVertexAbs;
cache.indexOffset[n] = root.lineIndexOffset;
} else tess.incLineIndices(ioffset, ioffset + icount - 1, root.lineVertexRel);
cache.vertexOffset[n] = root.lineVertexOffset;
root.lineIndexOffset += icount;
root.lineVertexAbs += vcount;
root.lineVertexRel += vcount;
}
tess.updateLineFromCache();
}
if (0 < tess.pointVertexCount && 0 < tess.pointIndexCount) {
if (PGL.MAX_VERTEX_INDEX1 < root.firstPointVertexRel + tess.pointVertexCount) {
root.firstPointVertexRel = 0;
root.firstPointVertexAbs = root.lastPointVertexOffset + 1;
}
root.lastPointVertexOffset = tess.setPointVertex(root.lastPointVertexOffset);
root.lastPointIndexOffset = tess.setPointIndex(root.firstPointVertexRel, root.lastPointIndexOffset);
root.firstPointVertexRel += tess.pointVertexCount;
//addPointIndexBlock(tess.lastPointIndex - tess.firstPointIndex + 1, tess.firstPointIndex, root.firstPointVertexAbs);
IndexCache cache = tess.pointIndexCache;
for (int n = 0; n < cache.count; n++) {
int ioffset = cache.indexOffset[n];
int icount = cache.indexCount[n];
int vcount = cache.vertexCount[n];
if (PGL.MAX_VERTEX_INDEX1 <= root.pointVertexRel + vcount) {
root.pointVertexRel = 0;
root.pointVertexOffset = root.pointVertexAbs;
cache.indexOffset[n] = root.pointIndexOffset;
} else tess.incPointIndices(ioffset, ioffset + icount - 1, root.pointVertexRel);
cache.vertexOffset[n] = root.pointVertexOffset;
root.pointIndexOffset += icount;
root.pointVertexAbs += vcount;
root.pointVertexRel += vcount;
}
tess.updatePointFromCache();
}
}