eessppeelllloo/processing4
1
0
Fork 0
mirror of https://github.com/processing/processing4.git synced 2026-06-16 04:26:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

Added PGL layer

Browse Source
This commit is contained in:
codeanticode
2012-01-17 03:26:32 +00:00
parent f11c16b941
commit a23acca863
6 changed files with 2598 additions and 992 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/libraries/opengl/src/processing/opengl/PFramebuffer.java
+111 -81
View File
@@ -23,9 +23,6 @@
package processing.opengl;
import java.nio.IntBuffer;
import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import javax.media.opengl.GL2GL3;
import processing.core.PApplet;
import processing.core.PConstants;
@@ -42,6 +39,7 @@ import processing.core.PConstants;
public class PFramebuffer implements PConstants {
protected PApplet parent;
protected PGraphicsOpenGL ogl;
protected PGLJava pgl;
public int glFboID;
public int glDepthBufferID;
@@ -59,7 +57,7 @@ public class PFramebuffer implements PConstants {
protected int nsamples;
protected int numColorBuffers;
protected int[] colorBufferAttchPoints;
//protected int[] colorBufferAttchPoints;
protected PTexture[] colorBufferTex;
protected boolean screenFb;
@@ -82,6 +80,7 @@ public class PFramebuffer implements PConstants {
boolean screen) {
this.parent = parent;
ogl = (PGraphicsOpenGL)parent.g;
pgl = ogl.pgl;
//gl.registerPGLObject(this);
glFboID = 0;
@@ -111,10 +110,10 @@ public class PFramebuffer implements PConstants {
}
numColorBuffers = colorBuffers;
colorBufferAttchPoints = new int[numColorBuffers];
//colorBufferAttchPoints = new int[numColorBuffers];
colorBufferTex = new PTexture[numColorBuffers];
for (int i = 0; i < numColorBuffers; i++) {
colorBufferAttchPoints[i] = GL.GL_COLOR_ATTACHMENT0 + i;
//colorBufferAttchPoints[i] = GL.GL_COLOR_ATTACHMENT0 + i;
colorBufferTex[i] = null;
}
@@ -178,25 +177,32 @@ public class PFramebuffer implements PConstants {
public void clear() {
ogl.pushFramebuffer();
ogl.setFramebuffer(this);
getGl().glClearColor(0f, 0f, 0f, 0.0f);
getGl().glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);
// getGl().glClearColor(0f, 0f, 0f, 0.0f);
// getGl().glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT);
pgl.setClearColor(0, 0, 0, 0);
pgl.clearAllBuffers();
ogl.popFramebuffer();
}
public void copy(PFramebuffer dest) {
getGl().glBindFramebuffer(GL2.GL_READ_FRAMEBUFFER, this.glFboID);
getGl().glBindFramebuffer(GL2.GL_DRAW_FRAMEBUFFER, dest.glFboID);
getGl2().glBlitFramebuffer(0, 0, this.width, this.height, 0, 0, dest.width, dest.height,
GL.GL_COLOR_BUFFER_BIT, GL.GL_NEAREST);
// getGl().glBindFramebuffer(GL2.GL_READ_FRAMEBUFFER, this.glFboID);
// getGl().glBindFramebuffer(GL2.GL_DRAW_FRAMEBUFFER, dest.glFboID);
pgl.bindReadFramebuffer(this.glFboID);
pgl.bindWriteFramebuffer(dest.glFboID);
// getGl2().glBlitFramebuffer(0, 0, this.width, this.height, 0, 0, dest.width, dest.height, GL.GL_COLOR_BUFFER_BIT, GL.GL_NEAREST);
pgl.copyFramebuffer(this.width, this.height, dest.width, dest.height);
}
public void bind() {
if (screenFb) {
if (PGraphicsOpenGL.fboSupported) {
getGl().glBindFramebuffer(GL.GL_FRAMEBUFFER, 0);
// getGl().glBindFramebuffer(GL.GL_FRAMEBUFFER, 0);
pgl.bindFramebuffer(0);
}
} else if (fboMode) {
getGl().glBindFramebuffer(GL.GL_FRAMEBUFFER, glFboID);
// getGl().glBindFramebuffer(GL.GL_FRAMEBUFFER, glFboID);
pgl.bindFramebuffer(glFboID);
} else {
backupScreen();
@@ -207,7 +213,8 @@ public class PFramebuffer implements PConstants {
}
if (noDepth) {
getGl().glDisable(GL.GL_DEPTH_TEST);
// getGl().glDisable(GL.GL_DEPTH_TEST);
pgl.disableDepthTest();
}
}
}
@@ -220,9 +227,11 @@ public class PFramebuffer implements PConstants {
if (noDepth) {
// No need to clear depth buffer because depth testing was disabled.
if (ogl.hintEnabled(DISABLE_DEPTH_TEST)) {
getGl().glDisable(GL.GL_DEPTH_TEST);
// getGl().glDisable(GL.GL_DEPTH_TEST);
pgl.disableDepthTest();
} else {
getGl().glEnable(GL.GL_DEPTH_TEST);
// getGl().glEnable(GL.GL_DEPTH_TEST);
pgl.enableDepthTest();
}
}
@@ -237,8 +246,10 @@ public class PFramebuffer implements PConstants {
// after this offscreen render.
// A consequence of this behavior is that all the offscreen rendering when
// no FBOs are available should be done before any onscreen drawing.
getGl().glClearColor(0, 0, 0, 0);
getGl().glClear(GL.GL_DEPTH_BUFFER_BIT);
pgl.setClearColor(0, 0, 0, 0);
pgl.clearDepthBuffer();
// getGl().glClearColor(0, 0, 0, 0);
// getGl().glClear(GL.GL_DEPTH_BUFFER_BIT);
}
}
}
@@ -247,7 +258,9 @@ public class PFramebuffer implements PConstants {
public void backupScreen() {
if (pixelBuffer == null) createPixelBuffer();
pixelBuffer.rewind();
getGl().glReadPixels(0, 0, width, height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, pixelBuffer);
//getGl().glReadPixels(0, 0, width, height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, pixelBuffer);
pgl.readPixels(pixelBuffer, 0, 0, width, height);
copyToTexture(pixelBuffer, backupTexture.glID, backupTexture.glTarget);
}
@@ -260,7 +273,8 @@ public class PFramebuffer implements PConstants {
public void copyToColorBuffers() {
if (pixelBuffer == null) createPixelBuffer();
pixelBuffer.rewind();
getGl().glReadPixels(0, 0, width, height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, pixelBuffer);
//getGl().glReadPixels(0, 0, width, height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, pixelBuffer);
pgl.readPixels(pixelBuffer, 0, 0, width, height);
for (int i = 0; i < numColorBuffers; i++) {
copyToTexture(pixelBuffer, colorBufferTex[i].glID, colorBufferTex[i].glTarget);
}
@@ -269,7 +283,8 @@ public class PFramebuffer implements PConstants {
public void readPixels() {
if (pixelBuffer == null) createPixelBuffer();
pixelBuffer.rewind();
getGl().glReadPixels(0, 0, width, height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, pixelBuffer);
// getGl().glReadPixels(0, 0, width, height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, pixelBuffer);
pgl.readPixels(pixelBuffer, 0, 0, width, height);
}
public void getPixels(int[] pixels) {
@@ -323,13 +338,13 @@ public class PFramebuffer implements PConstants {
// Making sure nothing is attached.
for (int i = 0; i < numColorBuffers; i++) {
getGl().glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0 + i,
GL.GL_TEXTURE_2D, 0, 0);
// getGl().glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0 + i, GL.GL_TEXTURE_2D, 0, 0);
pgl.cleanFramebufferTexture(i);
}
for (int i = 0; i < numColorBuffers; i++) {
getGl().glFramebufferTexture2D(GL.GL_FRAMEBUFFER, colorBufferAttchPoints[i],
colorBufferTex[i].glTarget, colorBufferTex[i].glID, 0);
pgl.setFramebufferTexture(i, colorBufferTex[i].glTarget, colorBufferTex[i].glID);
// getGl().glFramebufferTexture2D(GL.GL_FRAMEBUFFER, colorBufferAttchPoints[i], colorBufferTex[i].glTarget, colorBufferTex[i].glID, 0);
}
validateFbo();
@@ -403,15 +418,16 @@ public class PFramebuffer implements PConstants {
if (fboMode) {
ogl.pushFramebuffer();
ogl.setFramebuffer(this);
//glColorBufferMultisampleID = ogl.createGLResource(PGraphicsOpenGL.GL_RENDER_BUFFER);
ogl.setFramebuffer(this);
glColorBufferMultisampleID = ogl.createRenderBufferObject();
getGl().glBindRenderbuffer(GL.GL_RENDERBUFFER, glColorBufferMultisampleID);
getGl2().glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER, nsamples,
GL.GL_RGBA8, width, height);
getGl().glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0,
GL.GL_RENDERBUFFER, glColorBufferMultisampleID);
pgl.bindRenderbuffer(glColorBufferMultisampleID);
pgl.setRenderbufferNumSamples(nsamples, width, height);
pgl.setRenderbufferColorAttachment(glColorBufferMultisampleID);
// getGl().glBindRenderbuffer(GL.GL_RENDERBUFFER, glColorBufferMultisampleID);
// getGl2().glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER, nsamples, GL.GL_RGBA8, width, height);
// getGl().glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_RENDERBUFFER, glColorBufferMultisampleID);
ogl.popFramebuffer();
}
@@ -429,20 +445,22 @@ public class PFramebuffer implements PConstants {
ogl.pushFramebuffer();
ogl.setFramebuffer(this);
//glDepthStencilBufferID = ogl.createGLResource(PGraphicsOpenGL.GL_RENDER_BUFFER);
glDepthStencilBufferID = ogl.createRenderBufferObject();
getGl().glBindRenderbuffer(GL.GL_RENDERBUFFER, glDepthStencilBufferID);
pgl.bindRenderbuffer(glDepthStencilBufferID);
//getGl().glBindRenderbuffer(GL.GL_RENDERBUFFER, glDepthStencilBufferID);
if (multisample) {
getGl2().glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER, nsamples, GL.GL_DEPTH24_STENCIL8, width, height);
// getGl2().glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER, nsamples, GL.GL_DEPTH24_STENCIL8, width, height);
pgl.setRenderbufferNumSamples(nsamples, width, height);
} else {
getGl().glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH24_STENCIL8, width, height);
pgl.setRenderbufferStorage(PGLJava.DEPTH_24BIT_STENCIL_8BIT, width, height);
// getGl().glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH24_STENCIL8, width, height);
}
getGl().glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT,
GL.GL_RENDERBUFFER, glDepthStencilBufferID);
getGl().glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_STENCIL_ATTACHMENT,
GL.GL_RENDERBUFFER, glDepthStencilBufferID);
pgl.setRenderbufferDepthAttachment(glDepthStencilBufferID);
pgl.setRenderbufferStencilAttachment(glDepthStencilBufferID);
// getGl().glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, GL.GL_RENDERBUFFER, glDepthStencilBufferID);
// getGl().glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_STENCIL_ATTACHMENT, GL.GL_RENDERBUFFER, glDepthStencilBufferID);
ogl.popFramebuffer();
}
@@ -460,27 +478,29 @@ public class PFramebuffer implements PConstants {
ogl.pushFramebuffer();
ogl.setFramebuffer(this);
//glDepthBufferID = ogl.createGLResource(PGraphicsOpenGL.GL_RENDER_BUFFER);
glDepthBufferID = ogl.createRenderBufferObject();
getGl().glBindRenderbuffer(GL.GL_RENDERBUFFER, glDepthBufferID);
//getGl().glBindRenderbuffer(GL.GL_RENDERBUFFER, glDepthBufferID);
pgl.bindRenderbuffer(glDepthBufferID);
int glConst = GL.GL_DEPTH_COMPONENT16;
int glConst = PGLJava.DEPTH_16BIT;
if (depthBits == 16) {
glConst = GL.GL_DEPTH_COMPONENT16;
glConst = PGLJava.DEPTH_16BIT;
} else if (depthBits == 24) {
glConst = GL.GL_DEPTH_COMPONENT24;
glConst = PGLJava.DEPTH_24BIT;
} else if (depthBits == 32) {
glConst = GL.GL_DEPTH_COMPONENT32;
glConst = PGLJava.DEPTH_32BIT;
}
if (multisample) {
getGl2().glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER, nsamples, glConst, width, height);
//getGl2().glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER, nsamples, glConst, width, height);
pgl.setRenderbufferNumSamples(nsamples, width, height);
} else {
getGl().glRenderbufferStorage(GL.GL_RENDERBUFFER, glConst, width, height);
//getGl().glRenderbufferStorage(GL.GL_RENDERBUFFER, glConst, width, height);
pgl.setRenderbufferStorage(glConst, width, height);
}
getGl().glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT,
GL.GL_RENDERBUFFER, glDepthBufferID);
pgl.setRenderbufferDepthAttachment(glDepthBufferID);
//getGl().glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, GL.GL_RENDERBUFFER, glDepthBufferID);
ogl.popFramebuffer();
}
@@ -498,25 +518,28 @@ public class PFramebuffer implements PConstants {
ogl.pushFramebuffer();
ogl.setFramebuffer(this);
//glStencilBufferID = ogl.createGLResource(PGraphicsOpenGL.GL_RENDER_BUFFER);
glStencilBufferID = ogl.createRenderBufferObject();
getGl().glBindRenderbuffer(GL.GL_RENDERBUFFER, glStencilBufferID);
// getGl().glBindRenderbuffer(GL.GL_RENDERBUFFER, glStencilBufferID);
pgl.bindRenderbuffer(glStencilBufferID);
int glConst = GL.GL_STENCIL_INDEX1;
int glConst = PGLJava.STENCIL_1BIT;
if (stencilBits == 1) {
glConst = GL.GL_STENCIL_INDEX1;
glConst = PGLJava.STENCIL_1BIT;
} else if (stencilBits == 4) {
glConst = GL.GL_STENCIL_INDEX4;
glConst = PGLJava.STENCIL_4BIT;
} else if (stencilBits == 8) {
glConst = GL.GL_STENCIL_INDEX8;
glConst = PGLJava.STENCIL_8BIT;
}
if (multisample) {
getGl2().glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER, nsamples, glConst, width, height);
// getGl2().glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER, nsamples, glConst, width, height);
pgl.setRenderbufferNumSamples(nsamples, width, height);
} else {
getGl().glRenderbufferStorage(GL.GL_RENDERBUFFER, glConst, width, height);
// getGl().glRenderbufferStorage(GL.GL_RENDERBUFFER, glConst, width, height);
pgl.setRenderbufferStorage(glConst, width, height);
}
getGl().glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_STENCIL_ATTACHMENT,
GL.GL_RENDERBUFFER, glStencilBufferID);
pgl.setRenderbufferStencilAttachment(glStencilBufferID);
// getGl().glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_STENCIL_ATTACHMENT, GL.GL_RENDERBUFFER, glStencilBufferID);
ogl.popFramebuffer();
}
@@ -534,37 +557,44 @@ public class PFramebuffer implements PConstants {
// Internal copy to texture method.
protected void copyToTexture(IntBuffer buffer, int glid, int gltarget) {
getGl().glEnable(gltarget);
getGl().glBindTexture(gltarget, glid);
getGl().glTexSubImage2D(gltarget, 0, 0, 0, width, height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, buffer);
getGl().glBindTexture(gltarget, 0);
getGl().glDisable(gltarget);
pgl.enableTexturing(gltarget);
pgl.bindTexture(gltarget, glid);
pgl.copyTexSubImage(buffer, gltarget, 0, 0, width, height);
pgl.unbindTexture(gltarget);
pgl.disableTexturing(gltarget);
// getGl().glEnable(gltarget);
// getGl().glBindTexture(gltarget, glid);
// getGl().glTexSubImage2D(gltarget, 0, 0, 0, width, height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, buffer);
// getGl().glBindTexture(gltarget, 0);
// getGl().glDisable(gltarget);
}
public boolean validateFbo() {
int status = getGl().glCheckFramebufferStatus(GL.GL_FRAMEBUFFER);
if (status == GL.GL_FRAMEBUFFER_COMPLETE) {
// int status = getGl().glCheckFramebufferStatus(GL.GL_FRAMEBUFFER);
int status = pgl.getFramebufferStatus();
if (status == PGLJava.FRAMEBUFFER_COMPLETE) {
return true;
} else if (status == GL.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT) {
} else if (status == PGLJava.FRAMEBUFFER_INCOMPLETE_ATTACHMENT) {
throw new RuntimeException("PFramebuffer: GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT (" + Integer.toHexString(status) + ")");
} else if (status == GL.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT) {
} else if (status == PGLJava.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT) {
throw new RuntimeException("PFramebuffer: GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT (" + Integer.toHexString(status) + ")");
} else if (status == GL.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS) {
} else if (status == PGLJava.FRAMEBUFFER_INCOMPLETE_DIMENSIONS) {
throw new RuntimeException("PFramebuffer: GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS (" + Integer.toHexString(status) + ")");
} else if (status == GL.GL_FRAMEBUFFER_INCOMPLETE_FORMATS) {
} else if (status == PGLJava.FRAMEBUFFER_INCOMPLETE_FORMATS) {
throw new RuntimeException("PFramebuffer: GL_FRAMEBUFFER_INCOMPLETE_FORMATS (" + Integer.toHexString(status) + ")");
} else if (status == GL.GL_FRAMEBUFFER_UNSUPPORTED) {
} else if (status == PGLJava.FRAMEBUFFER_UNSUPPORTED) {
throw new RuntimeException("PFramebuffer: GL_FRAMEBUFFER_UNSUPPORTED" + Integer.toHexString(status));
} else {
throw new RuntimeException("PFramebuffer: unknown framebuffer error (" + Integer.toHexString(status) + ")");
}
}
protected GL getGl() {
return ogl.gl;
}
protected GL2GL3 getGl2() {
return ogl.gl2x;
}
// protected GL getGl() {
// return ogl.gl;
// }
//
// protected GL2GL3 getGl2() {
// return ogl.gl2x;
// }
}
java/libraries/opengl/src/processing/opengl/PGLJava.java
+1032
View File
File diff suppressed because it is too large Load Diff
java/libraries/opengl/src/processing/opengl/PGraphicsOpenGL.java
+871 -553
View File
File diff suppressed because it is too large Load Diff
java/libraries/opengl/src/processing/opengl/PShader.java
+83 -84
View File
@@ -24,12 +24,8 @@
package processing.opengl;
import processing.core.*;
import javax.media.opengl.*;
import java.io.IOException;
import java.net.URL;
import java.nio.*;
/**
* This class encapsulates a glsl shader. Based in the code by JohnG
@@ -38,7 +34,7 @@ import java.nio.*;
public class PShader {
protected PApplet parent;
protected PGraphicsOpenGL ogl;
protected GL2GL3 gl;
protected PGLJava pgl;
protected int programObject;
protected int vertexShader;
@@ -55,7 +51,7 @@ public class PShader {
public PShader(PApplet parent) {
this.parent = parent;
ogl = (PGraphicsOpenGL) parent.g;
gl = ogl.gl2x;
pgl = ogl.pgl;
programObject = ogl.createGLSLProgramObject();
@@ -163,8 +159,10 @@ public class PShader {
* Links the shader program and validates it.
*/
public void setup() {
gl.glLinkProgram(programObject);
gl.glValidateProgram(programObject);
// gl.glLinkProgram(programObject);
// gl.glValidateProgram(programObject);
pgl.linkProgram(programObject);
pgl.validateProgram(programObject);
checkLogInfo("GLSL program validation: ", programObject);
initialized = true;
}
@@ -189,14 +187,16 @@ public class PShader {
// textures.
// gl.glUniform1iARB(loc, unit);
ogl.gl.getGL2().glUseProgramObjectARB(programObject);
//ogl.gl.getGL2().glUseProgramObjectARB(programObject);
pgl.startProgram(programObject);
}
/**
* Stops the execution of the shader program.
*/
public void stop() {
ogl.gl.getGL2().glUseProgramObjectARB(0);
//ogl.gl.getGL2().glUseProgramObjectARB(0);
pgl.stopProgram();
}
/**
@@ -206,7 +206,8 @@ public class PShader {
* @return int
*/
public int getAttribLocation(String name) {
return (gl.glGetAttribLocation(programObject, name));
// return gl.glGetAttribLocation(programObject, name);
return pgl.getAttribLocation(programObject, name);
}
/**
@@ -216,7 +217,8 @@ public class PShader {
* @return int
*/
public int getUniformLocation(String name) {
return (gl.glGetUniformLocation(programObject, name));
// return gl.glGetUniformLocation(programObject, name);
return pgl.getUniformLocation(programObject, name);
}
/**
@@ -228,7 +230,10 @@ public class PShader {
*/
public void setTexUniform(String name, int unit) {
int loc = getUniformLocation(name);
if (-1 < loc) gl.glUniform1i(loc, unit);
if (-1 < loc) {
// gl.glUniform1i(loc, unit);
pgl.setIntUniform(loc, unit);
}
}
/**
@@ -261,7 +266,10 @@ public class PShader {
*/
public void setIntUniform(String name, int x) {
int loc = getUniformLocation(name);
if (-1 < loc) gl.glUniform1i(loc, x);
if (-1 < loc) {
// gl.glUniform1i(loc, x);
pgl.setIntUniform(loc, x);
}
}
/**
@@ -272,7 +280,10 @@ public class PShader {
*/
public void setFloatUniform(String name, float x) {
int loc = getUniformLocation(name);
if (-1 < loc) gl.glUniform1f(loc, x);
if (-1 < loc) {
//gl.glUniform1f(loc, x);
pgl.setFloatUniform(loc, x);
}
}
/**
@@ -284,7 +295,10 @@ public class PShader {
*/
public void setVecUniform(String name, float x, float y) {
int loc = getUniformLocation(name);
if (-1 < loc) gl.glUniform2f(loc, x, y);
if (-1 < loc) {
// gl.glUniform2f(loc, x, y);
pgl.setFloatUniform(loc, x, y);
}
}
/**
@@ -297,7 +311,10 @@ public class PShader {
*/
public void setVecUniform(String name, float x, float y, float z) {
int loc = getUniformLocation(name);
if (-1 < loc) gl.glUniform3f(loc, x, y, z);
if (-1 < loc) {
// gl.glUniform3f(loc, x, y, z);
pgl.setFloatUniform(loc, x, y, z);
}
}
/**
@@ -311,7 +328,10 @@ public class PShader {
*/
public void setVecUniform(String name, float x, float y, float z, float w) {
int loc = getUniformLocation(name);
if (-1 < loc) gl.glUniform4f(loc, x, y, z, w);
if (-1 < loc) {
// gl.glUniform4f(loc, x, y, z, w);
pgl.setFloatUniform(loc, x, y, z, w);
}
}
/**
@@ -325,12 +345,9 @@ public class PShader {
float m10, float m11) {
int loc = getUniformLocation(name);
if (-1 < loc) {
float[] mat = new float[4];
mat[0] = m00;
mat[1] = m10;
mat[4] = m01;
mat[5] = m11;
gl.glUniformMatrix2fv(loc, 1, false, mat, 0);
pgl.setMatUniform(loc, m00, m01,
m10, m11);
//gl.glUniformMatrix2fv(loc, 1, false, mat, 0);
}
}
@@ -346,17 +363,9 @@ public class PShader {
float m20, float m21, float m22) {
int loc = getUniformLocation(name);
if (-1 < loc) {
float[] mat = new float[9];
mat[0] = m00;
mat[1] = m10;
mat[2] = m20;
mat[4] = m01;
mat[5] = m11;
mat[6] = m21;
mat[8] = m02;
mat[9] = m12;
mat[10] =m22;
gl.glUniformMatrix3fv(loc, 1, false, mat, 0);
pgl.setMatUniform(loc, m00, m01, m02,
m10, m11, m12,
m20, m21, m22);
}
}
@@ -373,24 +382,10 @@ public class PShader {
float m30, float m31, float m32, float m33) {
int loc = getUniformLocation(name);
if (-1 < loc) {
float[] mat = new float[16];
mat[0] = m00;
mat[1] = m10;
mat[2] = m20;
mat[3] = m30;
mat[4] = m01;
mat[5] = m11;
mat[6] = m21;
mat[7] = m31;
mat[8] = m02;
mat[9] = m12;
mat[10] = m22;
mat[11] = m32;
mat[12] = m03;
mat[13] = m13;
mat[14] = m23;
mat[15] = m33;
gl.glUniformMatrix4fv(loc, 1, false, mat, 0);
pgl.setMatUniform(loc, m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23,
m30, m31, m32, m33);
}
}
@@ -402,7 +397,10 @@ public class PShader {
*/
public void setFloatAttribute(String name, float x) {
int loc = getAttribLocation(name);
if (-1 < loc) gl.glVertexAttrib1f(loc, x);
if (-1 < loc) {
// gl.glVertexAttrib1f(loc, x);
pgl.setFloatAttrib(loc, x);
}
}
/**
@@ -414,7 +412,10 @@ public class PShader {
*/
public void setVecAttribute(String name, float x, float y) {
int loc = getAttribLocation(name);
if (-1 < loc) gl.glVertexAttrib2f(loc, x, y);
if (-1 < loc) {
// gl.glVertexAttrib2f(loc, x, y);
pgl.setFloatAttrib(loc, x, y);
}
}
/**
@@ -427,7 +428,10 @@ public class PShader {
*/
public void setVecAttribute(String name, float x, float y, float z) {
int loc = getAttribLocation(name);
if (-1 < loc) gl.glVertexAttrib3f(loc, x, y, z);
if (-1 < loc) {
// gl.glVertexAttrib3f(loc, x, y, z);
pgl.setFloatAttrib(loc, x, y, z);
}
}
/**
@@ -441,7 +445,10 @@ public class PShader {
*/
public void setVecAttribute(String name, float x, float y, float z, float w) {
int loc = getAttribLocation(name);
if (-1 < loc) gl.glVertexAttrib4f(loc, x, y, z, w);
if (-1 < loc) {
// gl.glVertexAttrib4f(loc, x, y, z, w);
pgl.setFloatAttrib(loc, x, y, z, w);
}
}
/**
@@ -451,11 +458,14 @@ public class PShader {
private void attachVertexShader(String shaderSource, String file) {
vertexShader = ogl.createGLSLVertShaderObject();
gl.glShaderSource(vertexShader, 1, new String[] { shaderSource },
(int[]) null, 0);
gl.glCompileShader(vertexShader);
// gl.glShaderSource(vertexShader, 1, new String[] { shaderSource }, (int[]) null, 0);
// gl.glCompileShader(vertexShader);
pgl.setShaderSource(vertexShader, shaderSource);
pgl.compileShader(vertexShader);
checkLogInfo("Vertex shader " + file + " compilation: ", vertexShader);
ogl.gl.getGL2().glAttachObjectARB(programObject, vertexShader);
// ogl.gl.getGL2().glAttachObjectARB(programObject, vertexShader);
pgl.attachShader(programObject, vertexShader);
}
/**
@@ -465,37 +475,26 @@ public class PShader {
private void attachFragmentShader(String shaderSource, String file) {
fragmentShader = ogl.createGLSLFragShaderObject();
gl.glShaderSource(fragmentShader, 1, new String[] { shaderSource },
(int[]) null, 0);
gl.glCompileShader(fragmentShader);
// gl.glShaderSource(fragmentShader, 1, new String[] { shaderSource }, (int[]) null, 0);
// gl.glCompileShader(fragmentShader);
pgl.setShaderSource(fragmentShader, shaderSource);
pgl.compileShader(fragmentShader);
checkLogInfo("Fragment shader " + file + " compilation: ", fragmentShader);
ogl.gl.getGL2().glAttachObjectARB(programObject, fragmentShader);
// ogl.gl.getGL2().glAttachObjectARB(programObject, fragmentShader);
pgl.attachShader(programObject, fragmentShader);
}
/**
* @invisible Check the log error for the opengl object obj. Prints error
* message if needed.
*/
protected void checkLogInfo(String title, int obj) {
IntBuffer iVal = IntBuffer.allocate(1);
ogl.gl.getGL2().glGetObjectParameterivARB(obj, GL2.GL_OBJECT_INFO_LOG_LENGTH_ARB, iVal);
int length = iVal.get();
if (length <= 1) {
return;
protected void checkLogInfo(String title, int obj) {
String log = pgl.getShaderLog(obj);
if (!log.equals("")) {
System.out.println(title);
System.out.println(log);
}
// Some error occurred...
ByteBuffer infoLog = ByteBuffer.allocate(length);
iVal.flip();
ogl.gl.getGL2().glGetInfoLogARB(obj, length, iVal, infoLog);
byte[] infoBytes = new byte[length];
infoLog.get(infoBytes);
System.out.println(title);
System.out.println(new String(infoBytes));
}
protected void release() {
java/libraries/opengl/src/processing/opengl/PShape3D.java
+431 -220
View File
@@ -23,10 +23,6 @@
package processing.opengl;
import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import javax.media.opengl.GL2ES1;
import processing.core.PApplet;
import processing.core.PGraphics;
import processing.core.PImage;
@@ -34,16 +30,13 @@ import processing.core.PMatrix;
import processing.core.PMatrix2D;
import processing.core.PMatrix3D;
import processing.core.PShape;
import processing.core.PStyle;
import processing.core.PVector;
import processing.opengl.PGraphicsOpenGL.InGeometry;
import processing.opengl.PGraphicsOpenGL.TessGeometry;
import processing.opengl.PGraphicsOpenGL.Tessellator;
import java.io.BufferedReader;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Hashtable;
@@ -81,6 +74,7 @@ import java.util.Hashtable;
public class PShape3D extends PShape {
protected PGraphicsOpenGL ogl;
protected PGLJava pgl;
protected PShape3D root;
protected int glMode;
@@ -247,8 +241,9 @@ public class PShape3D extends PShape {
public PShape3D(PApplet parent, int family) {
ogl = (PGraphicsOpenGL)parent.g;
pgl = ogl.pgl;
glMode = GL.GL_STATIC_DRAW;
glMode = PGLJava.STATIC_DRAW;
glFillVertexBufferID = 0;
glFillColorBufferID = 0;
@@ -327,11 +322,11 @@ public class PShape3D extends PShape {
public void setMode(int mode) {
if (mode == STATIC) {
glMode = GL.GL_STATIC_DRAW;
glMode = PGLJava.STATIC_DRAW;
} else if (mode == DYNAMIC) {
glMode = GL.GL_DYNAMIC_DRAW;
glMode = PGLJava.DYNAMIC_DRAW;
} else if (mode == STREAM) {
glMode = GL2.GL_STREAM_COPY;
glMode = PGLJava.STREAM_DRAW;
}
}
@@ -1889,6 +1884,7 @@ public class PShape3D extends PShape {
public FloatBuffer mapFillVertices() {
/*
ByteBuffer bb;
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glFillVertexBufferID);
@@ -1898,16 +1894,21 @@ public class PShape3D extends PShape {
bb = ogl.gl2x.glMapBufferRange(GL.GL_ARRAY_BUFFER, 3 * tess.firstFillVertex, 3 * tess.fillVertexCount, GL2.GL_READ_WRITE);
}
return bb.asFloatBuffer();
*/
return null;
}
public void unmapFillVertices() {
/*
getGl().glUnmapBuffer(GL.GL_ARRAY_BUFFER);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
*/
}
public FloatBuffer mapLineVertices() {
/*
ByteBuffer bb;
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glLineVertexBufferID);
@@ -1917,16 +1918,21 @@ public class PShape3D extends PShape {
bb = ogl.gl2x.glMapBufferRange(GL.GL_ARRAY_BUFFER, 3 * tess.firstLineVertex, 3 * tess.lineVertexCount, GL2.GL_READ_WRITE);
}
return bb.asFloatBuffer();
*/
return null;
}
public void unmapLineVertices() {
/*
getGl().glUnmapBuffer(GL.GL_ARRAY_BUFFER);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
*/
}
public FloatBuffer mapLineAttributes() {
/*
ByteBuffer bb;
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glLineAttribBufferID);
@@ -1936,11 +1942,15 @@ public class PShape3D extends PShape {
bb = ogl.gl2x.glMapBufferRange(GL.GL_ARRAY_BUFFER, 3 * tess.firstLineVertex, 3 * tess.lineVertexCount, GL2.GL_READ_WRITE);
}
return bb.asFloatBuffer();
*/
return null;
}
public void unmapLineAttributes() {
/*
getGl().glUnmapBuffer(GL.GL_ARRAY_BUFFER);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
*/
}
@@ -2406,27 +2416,41 @@ public class PShape3D extends PShape {
protected void initFillBuffers(int nvert, int nind) {
glFillVertexBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillVertexBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glFillVertexBufferID = ogl.createVertexBufferObject();
pgl.bindVertexBuffer(glFillVertexBufferID);
pgl.initVertexBuffer(3 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillVertexBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glFillColorBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillColorBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 4 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.bindVertexBuffer(glFillColorBufferID);
pgl.initVertexBuffer(4 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillColorBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 4 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glFillNormalBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillNormalBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.bindVertexBuffer(glFillNormalBufferID);
pgl.initVertexBuffer(3 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillNormalBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glFillTexCoordBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillTexCoordBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 2 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.bindVertexBuffer(glFillTexCoordBufferID);
pgl.initVertexBuffer(2 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillTexCoordBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 2 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glFillIndexBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillIndexBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, nind * PGraphicsOpenGL.SIZEOF_INT, null, glMode);
pgl.unbindVertexBuffer();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
glFillIndexBufferID = ogl.createVertexBufferObject();
pgl.bindIndexBuffer(glFillIndexBufferID);
pgl.initIndexBuffer(nind, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillIndexBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, nind * PGraphicsOpenGL.SIZEOF_INT, null, glMode);
pgl.unbindIndexBuffer();
}
@@ -2608,88 +2632,131 @@ public class PShape3D extends PShape {
protected void copyFillGeometry(int offset, int size,
float[] vertices, float[] colors,
float[] normals, float[] texcoords) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillVertexBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
pgl.bindVertexBuffer(glFillVertexBufferID);
pgl.copyVertexBufferSubData(vertices, 3 * offset, 3 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillVertexBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillColorBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
pgl.bindVertexBuffer(glFillColorBufferID);
pgl.copyVertexBufferSubData(colors, 4 * offset, 4 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillColorBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillNormalBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
pgl.bindVertexBuffer(glFillNormalBufferID);
pgl.copyVertexBufferSubData(normals, 3 * offset, 3 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillNormalBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillTexCoordBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 2 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
2 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(texcoords));
pgl.bindVertexBuffer(glFillTexCoordBufferID);
pgl.copyVertexBufferSubData(texcoords, 2 * offset, 2 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillTexCoordBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 2 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 2 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(texcoords));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.unbindVertexBuffer();
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
}
protected void copyFillVertices(int offset, int size, float[] vertices) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillVertexBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillVertexBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glFillVertexBufferID);
pgl.copyVertexBufferSubData(vertices, 3 * offset, 3 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyFillColors(int offset, int size, float[] colors) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillColorBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillColorBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glFillColorBufferID);
pgl.copyVertexBufferSubData(colors, 4 * offset, 4 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyFillNormals(int offset, int size, float[] normals) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillNormalBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillNormalBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glFillNormalBufferID);
pgl.copyVertexBufferSubData(normals, 3 * offset, 3 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyFillTexCoords(int offset, int size, float[] texcoords) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillTexCoordBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 2 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
2 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(texcoords));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillTexCoordBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 2 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 2 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(texcoords));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glFillTexCoordBufferID);
pgl.copyVertexBufferSubData(texcoords, 2 * offset, 2 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyFillIndices(int offset, int size, int[] indices) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillIndexBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, offset * PGraphicsOpenGL.SIZEOF_INT,
size * PGraphicsOpenGL.SIZEOF_INT, IntBuffer.wrap(indices));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glFillIndexBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, offset * PGraphicsOpenGL.SIZEOF_INT,
// size * PGraphicsOpenGL.SIZEOF_INT, IntBuffer.wrap(indices));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindIndexBuffer(glFillTexCoordBufferID);
pgl.copyIndexBufferSubData(indices, offset, size, glMode);
pgl.unbindVertexBuffer();
}
protected void initLineBuffers(int nvert, int nind) {
glLineVertexBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineVertexBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.bindVertexBuffer(glLineVertexBufferID);
pgl.initVertexBuffer(3 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineVertexBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glLineColorBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineColorBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 4 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.bindVertexBuffer(glLineColorBufferID);
pgl.initVertexBuffer(4 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineColorBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 4 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glLineNormalBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineNormalBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.bindVertexBuffer(glLineNormalBufferID);
pgl.initVertexBuffer(3 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineNormalBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glLineAttribBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineAttribBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 4 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.bindVertexBuffer(glLineAttribBufferID);
pgl.initVertexBuffer(4 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineAttribBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 4 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.unbindVertexBuffer();
glLineIndexBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineIndexBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, nind * PGraphicsOpenGL.SIZEOF_INT, null, glMode);
pgl.bindIndexBuffer(glLineIndexBufferID);
pgl.initIndexBuffer(nind, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineIndexBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, nind * PGraphicsOpenGL.SIZEOF_INT, null, glMode);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.unbindIndexBuffer();
}
@@ -2714,88 +2781,130 @@ public class PShape3D extends PShape {
protected void copyLineGeometry(int offset, int size,
float[] vertices, float[] colors, float[] normals, float[] attribs) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineVertexBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
pgl.bindVertexBuffer(glLineVertexBufferID);
pgl.copyVertexBufferSubData(vertices, 3 * offset, 3 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineVertexBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineColorBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
pgl.bindVertexBuffer(glLineColorBufferID);
pgl.copyVertexBufferSubData(colors, 4 * offset, 4 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineColorBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineNormalBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
pgl.bindVertexBuffer(glLineNormalBufferID);
pgl.copyVertexBufferSubData(normals, 3 * offset, 3 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineNormalBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineAttribBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(attribs));
pgl.bindVertexBuffer(glLineAttribBufferID);
pgl.copyVertexBufferSubData(attribs, 4 * offset, 4 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineAttribBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(attribs));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.unbindVertexBuffer();
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
}
protected void copyLineVertices(int offset, int size, float[] vertices) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineVertexBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineVertexBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glLineVertexBufferID);
pgl.copyVertexBufferSubData(vertices, 3 * offset, 3 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyLineColors(int offset, int size, float[] colors) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineColorBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineColorBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glLineColorBufferID);
pgl.copyVertexBufferSubData(colors, 4 * offset, 4 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyLineNormals(int offset, int size, float[] normals) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineNormalBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineNormalBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glLineNormalBufferID);
pgl.copyVertexBufferSubData(normals, 3 * offset, 3 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyLineAttributes(int offset, int size, float[] attribs) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineAttribBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(attribs));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineAttribBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(attribs));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glLineAttribBufferID);
pgl.copyVertexBufferSubData(attribs, 4 * offset, 4 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyLineIndices(int offset, int size, int[] indices) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineIndexBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, offset * PGraphicsOpenGL.SIZEOF_INT,
size * PGraphicsOpenGL.SIZEOF_INT, IntBuffer.wrap(indices));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glLineIndexBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, offset * PGraphicsOpenGL.SIZEOF_INT,
// size * PGraphicsOpenGL.SIZEOF_INT, IntBuffer.wrap(indices));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindIndexBuffer(glLineIndexBufferID);
pgl.copyIndexBufferSubData(indices, offset, size, glMode);
pgl.unbindIndexBuffer();
}
protected void initPointBuffers(int nvert, int nind) {
glPointVertexBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointVertexBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glPointVertexBufferID = ogl.createVertexBufferObject();
pgl.bindVertexBuffer(glPointVertexBufferID);
pgl.initVertexBuffer(3 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointVertexBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glPointColorBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointColorBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 4 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.bindVertexBuffer(glPointColorBufferID);
pgl.initVertexBuffer(4 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointColorBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 4 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glPointNormalBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointNormalBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.bindVertexBuffer(glPointNormalBufferID);
pgl.initVertexBuffer(3 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointNormalBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 3 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
glPointAttribBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointAttribBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, 2 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.bindVertexBuffer(glPointAttribBufferID);
pgl.initVertexBuffer(2 * nvert, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointAttribBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, 2 * nvert * PGraphicsOpenGL.SIZEOF_FLOAT, null, glMode);
pgl.unbindVertexBuffer();
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
glPointIndexBufferID = ogl.createVertexBufferObject();
pgl.bindIndexBuffer(glPointIndexBufferID);
pgl.initIndexBuffer(nind, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointIndexBufferID);
// getGl().glBufferData(GL.GL_ARRAY_BUFFER, nind * PGraphicsOpenGL.SIZEOF_INT, null, glMode);
glPointIndexBufferID = ogl.createVertexBufferObject();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointIndexBufferID);
getGl().glBufferData(GL.GL_ARRAY_BUFFER, nind * PGraphicsOpenGL.SIZEOF_INT, null, glMode);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.unbindIndexBuffer();
}
@@ -2820,63 +2929,92 @@ public class PShape3D extends PShape {
protected void copyPointGeometry(int offset, int size,
float[] vertices, float[] colors, float[] normals, float[] attribs) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointVertexBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
pgl.bindVertexBuffer(glPointVertexBufferID);
pgl.copyVertexBufferSubData(vertices, 3 * offset, 3 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointVertexBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointColorBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
pgl.bindVertexBuffer(glPointColorBufferID);
pgl.copyVertexBufferSubData(colors, 4 * offset, 4 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointColorBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointNormalBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
pgl.bindVertexBuffer(glPointNormalBufferID);
pgl.copyVertexBufferSubData(normals, 3 * offset, 3 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointNormalBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointAttribBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 2 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
2 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(attribs));
pgl.bindVertexBuffer(glPointAttribBufferID);
pgl.copyVertexBufferSubData(attribs, 2 * offset, 2 * size, glMode);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointAttribBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 2 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 2 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(attribs));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.unbindVertexBuffer();
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
}
protected void copyPointVertices(int offset, int size, float[] vertices) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointVertexBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointVertexBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(vertices));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glPointVertexBufferID);
pgl.copyVertexBufferSubData(vertices, 3 * offset, 3 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyPointColors(int offset, int size, float[] colors) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointColorBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointColorBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 4 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 4 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(colors));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glPointColorBufferID);
pgl.copyVertexBufferSubData(colors, 4 * offset, 4 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyPointNormals(int offset, int size, float[] normals) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointNormalBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointNormalBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 3 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 3 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(normals));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glPointNormalBufferID);
pgl.copyVertexBufferSubData(normals, 3 * offset, 3 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyPointAttributes(int offset, int size, float[] attribs) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointAttribBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 2 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
2 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(attribs));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointAttribBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, 2 * offset * PGraphicsOpenGL.SIZEOF_FLOAT,
// 2 * size * PGraphicsOpenGL.SIZEOF_FLOAT, FloatBuffer.wrap(attribs));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindVertexBuffer(glPointAttribBufferID);
pgl.copyVertexBufferSubData(attribs, 2 * offset, 2 * size, glMode);
pgl.unbindVertexBuffer();
}
protected void copyPointIndices(int offset, int size, int[] indices) {
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointIndexBufferID);
getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, offset * PGraphicsOpenGL.SIZEOF_INT,
size * PGraphicsOpenGL.SIZEOF_INT, IntBuffer.wrap(indices));
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, glPointIndexBufferID);
// getGl().glBufferSubData(GL.GL_ARRAY_BUFFER, offset * PGraphicsOpenGL.SIZEOF_INT,
// size * PGraphicsOpenGL.SIZEOF_INT, IntBuffer.wrap(indices));
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.bindIndexBuffer(glPointIndexBufferID);
pgl.copyIndexBufferSubData(indices, offset, size, glMode);
pgl.unbindIndexBuffer();
}
@@ -3064,31 +3202,53 @@ public class PShape3D extends PShape {
protected void renderPoints() {
ogl.startPointShader();
getGl().glEnableClientState(GL2.GL_NORMAL_ARRAY);
getGl().glEnableClientState(GL2.GL_COLOR_ARRAY);
getGl().glEnableClientState(GL2.GL_VERTEX_ARRAY);
pgl.enableVertexArrays();
pgl.enableColorArrays();
pgl.enableNormalArrays();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glPointNormalBufferID);
getGl().glNormalPointer(GL.GL_FLOAT, 0, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glPointColorBufferID);
getGl().glColorPointer(4, GL.GL_FLOAT, 0, 0);
// getGl().glEnableClientState(GL2.GL_NORMAL_ARRAY);
// getGl().glEnableClientState(GL2.GL_COLOR_ARRAY);
// getGl().glEnableClientState(GL2.GL_VERTEX_ARRAY);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glPointVertexBufferID);
getGl().glVertexPointer(3, GL.GL_FLOAT, 0, 0);
pgl.bindVertexBuffer(root.glPointVertexBufferID);
pgl.setVertexFormat(3, 0, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glPointVertexBufferID);
// getGl().glVertexPointer(3, GL.GL_FLOAT, 0, 0);
pgl.bindVertexBuffer(root.glPointColorBufferID);
pgl.setColorFormat(4, 0, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glPointColorBufferID);
// getGl().glColorPointer(4, GL.GL_FLOAT, 0, 0);
pgl.bindVertexBuffer(root.glPointNormalBufferID);
pgl.setNormalFormat(3, 0, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glPointNormalBufferID);
// getGl().glNormalPointer(GL.GL_FLOAT, 0, 0);
ogl.setupPointShader(root.glPointAttribBufferID);
getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, root.glPointIndexBufferID);
getGl().glDrawElements(GL.GL_TRIANGLES, tess.lastPointIndex - tess.firstPointIndex + 1, GL.GL_UNSIGNED_INT,
tess.firstPointIndex * PGraphicsOpenGL.SIZEOF_INT);
getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
int offset = tess.firstPointIndex;
int size = tess.lastPointIndex - tess.firstPointIndex + 1;
pgl.bindIndexBuffer(root.glPointIndexBufferID);
pgl.renderIndexBuffer(offset, size);
getGl().glDisableClientState(GL2.GL_VERTEX_ARRAY);
getGl().glDisableClientState(GL2.GL_COLOR_ARRAY);
getGl().glDisableClientState(GL2.GL_NORMAL_ARRAY);
// getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, root.glPointIndexBufferID);
// getGl().glDrawElements(GL.GL_TRIANGLES, tess.lastPointIndex - tess.firstPointIndex + 1, GL.GL_UNSIGNED_INT,
// tess.firstPointIndex * PGraphicsOpenGL.SIZEOF_INT);
// getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.unbindIndexBuffer();
pgl.unbindVertexBuffer();
pgl.disableVertexArrays();
pgl.disableColorArrays();
pgl.disableNormalArrays();
// getGl().glDisableClientState(GL2.GL_VERTEX_ARRAY);
// getGl().glDisableClientState(GL2.GL_COLOR_ARRAY);
// getGl().glDisableClientState(GL2.GL_NORMAL_ARRAY);
ogl.stopPointShader();
}
@@ -3097,81 +3257,132 @@ public class PShape3D extends PShape {
protected void renderLines() {
ogl.startLineShader();
getGl().glEnableClientState(GL2.GL_NORMAL_ARRAY);
getGl().glEnableClientState(GL2.GL_COLOR_ARRAY);
getGl().glEnableClientState(GL2.GL_VERTEX_ARRAY);
// getGl().glEnableClientState(GL2.GL_NORMAL_ARRAY);
// getGl().glEnableClientState(GL2.GL_COLOR_ARRAY);
// getGl().glEnableClientState(GL2.GL_VERTEX_ARRAY);
pgl.enableVertexArrays();
pgl.enableColorArrays();
pgl.enableNormalArrays();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glLineNormalBufferID);
getGl().glNormalPointer(GL.GL_FLOAT, 0, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glLineColorBufferID);
getGl().glColorPointer(4, GL.GL_FLOAT, 0, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glLineVertexBufferID);
getGl().glVertexPointer(3, GL.GL_FLOAT, 0, 0);
pgl.bindVertexBuffer(root.glLineVertexBufferID);
pgl.setVertexFormat(3, 0, 0);
ogl.setupLineShader(root.glLineAttribBufferID);
pgl.bindVertexBuffer(root.glLineColorBufferID);
pgl.setColorFormat(4, 0, 0);
getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, root.glLineIndexBufferID);
getGl().glDrawElements(GL.GL_TRIANGLES, tess.lastLineIndex - tess.firstLineIndex + 1, GL.GL_UNSIGNED_INT,
tess.firstLineIndex * PGraphicsOpenGL.SIZEOF_INT);
pgl.bindVertexBuffer(root.glLineNormalBufferID);
pgl.setNormalFormat(3, 0, 0);
getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glLineNormalBufferID);
// getGl().glNormalPointer(GL.GL_FLOAT, 0, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glLineColorBufferID);
// getGl().glColorPointer(4, GL.GL_FLOAT, 0, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glLineVertexBufferID);
// getGl().glVertexPointer(3, GL.GL_FLOAT, 0, 0);
getGl().glDisableClientState(GL2.GL_VERTEX_ARRAY);
getGl().glDisableClientState(GL2.GL_COLOR_ARRAY);
getGl().glDisableClientState(GL2.GL_NORMAL_ARRAY);
ogl.setupLineShader(root.glLineAttribBufferID);
int offset = tess.firstLineIndex;
int size = tess.lastLineIndex - tess.firstLineIndex + 1;
pgl.bindIndexBuffer(root.glLineIndexBufferID);
pgl.renderIndexBuffer(offset, size);
// getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, root.glLineIndexBufferID);
// getGl().glDrawElements(GL.GL_TRIANGLES, tess.lastLineIndex - tess.firstLineIndex + 1, GL.GL_UNSIGNED_INT,
// tess.firstLineIndex * PGraphicsOpenGL.SIZEOF_INT);
// getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.unbindIndexBuffer();
pgl.unbindVertexBuffer();
// getGl().glDisableClientState(GL2.GL_VERTEX_ARRAY);
// getGl().glDisableClientState(GL2.GL_COLOR_ARRAY);
// getGl().glDisableClientState(GL2.GL_NORMAL_ARRAY);
pgl.disableVertexArrays();
pgl.disableColorArrays();
pgl.disableNormalArrays();
ogl.stopLineShader();
}
protected void renderFill(PImage textureImage) {
getGl().glEnableClientState(GL2.GL_NORMAL_ARRAY);
getGl().glEnableClientState(GL2.GL_COLOR_ARRAY);
getGl().glEnableClientState(GL2.GL_VERTEX_ARRAY);
getGl().glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
// getGl().glEnableClientState(GL2.GL_NORMAL_ARRAY);
// getGl().glEnableClientState(GL2.GL_COLOR_ARRAY);
// getGl().glEnableClientState(GL2.GL_VERTEX_ARRAY);
// getGl().glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
pgl.enableVertexArrays();
pgl.enableColorArrays();
pgl.enableNormalArrays();
pgl.enableTexCoordArrays();
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glFillNormalBufferID);
getGl().glNormalPointer(GL.GL_FLOAT, 0, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glFillColorBufferID);
getGl().glColorPointer(4, GL.GL_FLOAT, 0, 0);
pgl.bindVertexBuffer(root.glFillColorBufferID);
pgl.setVertexFormat(3, 0, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glFillColorBufferID);
// getGl().glVertexPointer(3, GL.GL_FLOAT, 0, 0);
pgl.bindVertexBuffer(root.glFillColorBufferID);
pgl.setColorFormat(4, 0, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glFillColorBufferID);
// getGl().glColorPointer(4, GL.GL_FLOAT, 0, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glFillVertexBufferID);
getGl().glVertexPointer(3, GL.GL_FLOAT, 0, 0);
pgl.bindVertexBuffer(root.glFillNormalBufferID);
pgl.setNormalFormat(3, 0, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glFillNormalBufferID);
// getGl().glNormalPointer(GL.GL_FLOAT, 0, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glFillTexCoordBufferID);
getGl().glTexCoordPointer(2, GL.GL_FLOAT, 0, 0);
pgl.bindVertexBuffer(root.glFillTexCoordBufferID);
pgl.setTexCoordFormat(2, 0, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, root.glFillTexCoordBufferID);
// getGl().glTexCoordPointer(2, GL.GL_FLOAT, 0, 0);
PTexture tex = null;
if (textureImage != null) {
tex = ogl.getTexture(textureImage);
if (tex != null) {
getGl().glEnable(tex.glTarget);
getGl().glActiveTexture(GL.GL_TEXTURE0);
getGl().glBindTexture(tex.glTarget, tex.glID);
pgl.enableTexturing(tex.glTarget);
pgl.setActiveTexUnit(0);
pgl.bindTexture(tex.glTarget, tex.glID);
// getGl().glEnable(tex.glTarget);
// getGl().glActiveTexture(GL.GL_TEXTURE0);
// getGl().glBindTexture(tex.glTarget, tex.glID);
}
}
getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, root.glFillIndexBufferID);
getGl().glDrawElements(GL.GL_TRIANGLES, tess.lastFillIndex - tess.firstFillIndex + 1, GL.GL_UNSIGNED_INT,
tess.firstFillIndex * PGraphicsOpenGL.SIZEOF_INT);
int offset = tess.firstFillIndex;
int size = tess.lastFillIndex - tess.firstFillIndex + 1;
pgl.bindIndexBuffer(root.glFillIndexBufferID);
pgl.renderIndexBuffer(offset, size);
// getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, root.glFillIndexBufferID);
// getGl().glDrawElements(GL.GL_TRIANGLES, tess.lastFillIndex - tess.firstFillIndex + 1, GL.GL_UNSIGNED_INT,
// tess.firstFillIndex * PGraphicsOpenGL.SIZEOF_INT);
if (tex != null) {
getGl().glActiveTexture(GL.GL_TEXTURE0);
getGl().glBindTexture(tex.glTarget, 0);
getGl().glDisable(tex.glTarget);
pgl.unbindTexture(tex.glTarget);
pgl.disableTexturing(tex.glTarget);
//
// getGl().glActiveTexture(GL.GL_TEXTURE0);
// getGl().glBindTexture(tex.glTarget, 0);
// getGl().glDisable(tex.glTarget);
}
getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
pgl.unbindIndexBuffer();
pgl.unbindVertexBuffer();
getGl().glDisableClientState(GL2.GL_VERTEX_ARRAY);
getGl().glDisableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
getGl().glDisableClientState(GL2.GL_COLOR_ARRAY);
getGl().glDisableClientState(GL2.GL_NORMAL_ARRAY);
// getGl().glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
// getGl().glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
// getGl().glDisableClientState(GL2.GL_VERTEX_ARRAY);
// getGl().glDisableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
// getGl().glDisableClientState(GL2.GL_COLOR_ARRAY);
// getGl().glDisableClientState(GL2.GL_NORMAL_ARRAY);
pgl.disableVertexArrays();
pgl.disableColorArrays();
pgl.disableNormalArrays();
pgl.disableTexCoordArrays();
}
///////////////////////////////////////////////////////////
@@ -3330,9 +3541,9 @@ public class PShape3D extends PShape {
// Utilities methods
protected GL2ES1 getGl() {
return ogl.gl2f;
}
// protected GL2ES1 getGl() {
// return ogl.gl2f;
// }
///////////////////////////////////////////////////////////////////////////
java/libraries/opengl/src/processing/opengl/PTexture.java
+70 -54
View File
@@ -22,11 +22,7 @@
package processing.opengl;
import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import javax.media.opengl.GLContext;
import java.nio.*;
import processing.core.PApplet;
import processing.core.PConstants;
import processing.core.PGraphics;
@@ -42,6 +38,7 @@ public class PTexture implements PConstants {
protected PApplet parent; // The Processing applet
protected PGraphicsOpenGL ogl; // The main renderer
protected PGLJava pgl; // The interface between Processing and OpenGL.
protected GLContext context; // The context that created this texture.
// These are public but use at your own risk!
@@ -94,6 +91,7 @@ public class PTexture implements PConstants {
this.parent = parent;
ogl = (PGraphicsOpenGL)parent.g;
pgl = ogl.pgl;
context = ogl.getContext();
glID = 0;
@@ -238,15 +236,17 @@ public class PTexture implements PConstants {
return;
}
getGl().glEnable(glTarget);
getGl().glBindTexture(glTarget, glID);
pgl.enableTexturing(glTarget);
pgl.bindTexture(glTarget, glID);
// getGl().glEnable(glTarget);
// getGl().glBindTexture(glTarget, glID);
if (usingMipmaps) {
if (PGraphicsOpenGL.mipmapGeneration) {
// Automatic mipmap generation.
int[] rgbaPixels = new int[w * h];
convertToRGBA(pixels, rgbaPixels, format, w, h);
getGl().glTexParameteri(GL.GL_TEXTURE_2D, GL2.GL_GENERATE_MIPMAP, GL.GL_TRUE);
convertToRGBA(pixels, rgbaPixels, format, w, h);
pgl.enableTexMipmapGen(glTarget);
setTexels(x, y, w, h, rgbaPixels);
rgbaPixels = null;
} else {
@@ -261,8 +261,10 @@ public class PTexture implements PConstants {
rgbaPixels = null;
}
getGl().glBindTexture(glTarget, 0);
getGl().glDisable(glTarget);
// getGl().glBindTexture(glTarget, 0);
// getGl().glDisable(glTarget);
pgl.bindTexture(glTarget, 0);
pgl.enableTexturing(glTarget);
}
@@ -403,13 +405,17 @@ public class PTexture implements PConstants {
// Bind/unbind
public void bind() {
getGl().glEnable(glTarget);
getGl().glBindTexture(glTarget, glID);
pgl.enableTexturing(glTarget);
pgl.bindTexture(glTarget, glID);
// getGl().glEnable(glTarget);
// getGl().glBindTexture(glTarget, glID);
}
public void unbind() {
getGl().glEnable(glTarget);
getGl().glBindTexture(glTarget, 0);
pgl.enableTexturing(glTarget);
pgl.unbindTexture(glTarget);
// getGl().glEnable(glTarget);
// getGl().glBindTexture(glTarget, 0);
}
////////////////////////////////////////////////////////////
@@ -698,20 +704,27 @@ public class PTexture implements PConstants {
protected void allocate() {
release(); // Just in the case this object is being re-allocated.
getGl().glEnable(glTarget);
// getGl().glEnable(glTarget);
pgl.enableTexturing(glTarget);
glID = ogl.createTextureObject();
getGl().glBindTexture(glTarget, glID);
getGl().glTexParameteri(glTarget, GL.GL_TEXTURE_MIN_FILTER, glMinFilter);
getGl().glTexParameteri(glTarget, GL.GL_TEXTURE_MAG_FILTER, glMagFilter);
getGl().glTexParameteri(glTarget, GL.GL_TEXTURE_WRAP_S, glWrapS);
getGl().glTexParameteri(glTarget, GL.GL_TEXTURE_WRAP_T, glWrapT);
//getGl().glBindTexture(glTarget, glID);
// getGl().glTexParameteri(glTarget, GL.GL_TEXTURE_MIN_FILTER, glMinFilter);
// getGl().glTexParameteri(glTarget, GL.GL_TEXTURE_MAG_FILTER, glMagFilter);
// getGl().glTexParameteri(glTarget, GL.GL_TEXTURE_WRAP_S, glWrapS);
// getGl().glTexParameteri(glTarget, GL.GL_TEXTURE_WRAP_T, glWrapT);
pgl.bindTexture(glTarget, glID);
pgl.setTexMinFilter(glTarget, glMinFilter);
pgl.setTexMagFilter(glTarget, glMagFilter);
pgl.setTexWrapS(glTarget, glWrapS);
pgl.setTexWrapT(glTarget, glWrapT);
// First, we use glTexImage2D to set the full size of the texture (glW/glH might be diff
// from w/h in the case that the GPU doesn't support NPOT textures)
getGl().glTexImage2D(glTarget, 0, glFormat, glWidth, glHeight, 0, GL.GL_RGBA,
GL.GL_UNSIGNED_BYTE, null);
//getGl().glTexImage2D(glTarget, 0, glFormat, glWidth, glHeight, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, null);
pgl.initTex(glFormat, glFormat, glWidth, glHeight);
// Once OpenGL knows the size of the new texture, we make sure it doesn't
// contain any garbage in the region of interest (0, 0, width, height):
@@ -719,8 +732,10 @@ public class PTexture implements PConstants {
setTexels(0, 0, width, height, texels);
texels = null;
getGl().glBindTexture(glTarget, 0);
getGl().glDisable(glTarget);
// getGl().glBindTexture(glTarget, 0);
// getGl().glDisable(glTarget);
pgl.unbindTexture(glTarget);
pgl.disableTexturing(glTarget);
}
@@ -775,7 +790,8 @@ public class PTexture implements PConstants {
}
protected void setTexels(int level, int x, int y, int w, int h, int[] pix) {
getGl().glTexSubImage2D(glTarget, 0, x, y, w, h, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, IntBuffer.wrap(pix));
//getGl().glTexSubImage2D(glTarget, 0, x, y, w, h, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, IntBuffer.wrap(pix));
pgl.copyTexSubPixels(pix, glTarget, x, y, w, h);
}
protected void copyObject(PTexture src) {
@@ -814,35 +830,35 @@ public class PTexture implements PConstants {
public Parameters getParameters() {
Parameters res = new Parameters();
if ( glTarget == GL.GL_TEXTURE_2D ) {
if (glTarget == PGLJava.TEXTURE_2D) {
res.target = TEXTURE2D;
}
if (glFormat == GL.GL_RGB) {
if (glFormat == PGLJava.RGB) {
res.format = RGB;
} else if (glFormat == GL.GL_RGBA) {
} else if (glFormat == PGLJava.RGBA) {
res.format = ARGB;
} else if (glFormat == GL.GL_ALPHA) {
} else if (glFormat == PGLJava.ALPHA) {
res.format = ALPHA;
}
if (glMinFilter == GL.GL_NEAREST) {
if (glMinFilter == PGLJava.NEAREST) {
res.sampling = POINT;
} else if (glMinFilter == GL.GL_LINEAR) {
} else if (glMinFilter == PGLJava.LINEAR) {
res.sampling = BILINEAR;
} else if (glMinFilter == GL.GL_LINEAR_MIPMAP_LINEAR) {
} else if (glMinFilter == PGLJava.LINEAR_MIPMAP_LINEAR) {
res.sampling = TRILINEAR;
}
if (glWrapS == GL.GL_CLAMP_TO_EDGE) {
if (glWrapS == PGLJava.CLAMP_TO_EDGE) {
res.wrapU = CLAMP;
} else if (glWrapS == GL.GL_REPEAT) {
} else if (glWrapS == PGLJava.REPEAT) {
res.wrapU = REPEAT;
}
if (glWrapT == GL.GL_CLAMP_TO_EDGE) {
if (glWrapT == PGLJava.CLAMP_TO_EDGE) {
res.wrapV = CLAMP;
} else if (glWrapT == GL.GL_REPEAT) {
} else if (glWrapT == PGLJava.REPEAT) {
res.wrapV = REPEAT;
}
@@ -857,51 +873,51 @@ public class PTexture implements PConstants {
*/
protected void setParameters(Parameters params) {
if (params.target == TEXTURE2D) {
glTarget = GL.GL_TEXTURE_2D;
glTarget = PGLJava.TEXTURE_2D;
} else {
throw new RuntimeException("OPENGL2: Unknown texture target");
}
if (params.format == RGB) {
glFormat = GL.GL_RGB;
glFormat = PGLJava.RGB;
} else if (params.format == ARGB) {
glFormat = GL.GL_RGBA;
glFormat = PGLJava.RGBA;
} else if (params.format == ALPHA) {
glFormat = GL.GL_ALPHA;
glFormat = PGLJava.ALPHA;
} else {
throw new RuntimeException("OPENGL2: Unknown texture format");
}
if (params.sampling == POINT) {
glMagFilter = GL.GL_NEAREST;
glMinFilter = GL.GL_NEAREST;
glMagFilter = PGLJava.NEAREST;
glMinFilter = PGLJava.NEAREST;
} else if (params.sampling == BILINEAR) {
glMagFilter = GL.GL_LINEAR;
glMinFilter = GL.GL_LINEAR;
glMagFilter = PGLJava.LINEAR;
glMinFilter = PGLJava.LINEAR;
} else if (params.sampling == TRILINEAR) {
glMagFilter = GL.GL_LINEAR;
glMinFilter = GL.GL_LINEAR_MIPMAP_LINEAR;
glMagFilter = PGLJava.LINEAR;
glMinFilter = PGLJava.LINEAR_MIPMAP_LINEAR;
} else {
throw new RuntimeException("OPENGL2: Unknown texture filtering mode");
}
if (params.wrapU == CLAMP) {
glWrapS = GL.GL_CLAMP_TO_EDGE;
glWrapS = PGLJava.CLAMP_TO_EDGE;
} else if (params.wrapU == REPEAT) {
glWrapS = GL.GL_REPEAT;
glWrapS = PGLJava.REPEAT;
} else {
throw new RuntimeException("OPENGL2: Unknown wrapping mode");
}
if (params.wrapV == CLAMP) {
glWrapT = GL.GL_CLAMP_TO_EDGE;
glWrapT = PGLJava.CLAMP_TO_EDGE;
} else if (params.wrapV == REPEAT) {
glWrapT = GL.GL_REPEAT;
glWrapT = PGLJava.REPEAT;
} else {
throw new RuntimeException("OPENGL2: Unknown wrapping mode");
}
usingMipmaps = glMinFilter == GL.GL_LINEAR_MIPMAP_LINEAR;
usingMipmaps = glMinFilter == PGLJava.LINEAR_MIPMAP_LINEAR;
flippedX = false;
flippedY = false;
@@ -911,9 +927,9 @@ public class PTexture implements PConstants {
// Utilities
protected GL getGl() {
return ogl.gl;
}
// protected GL getGl() {
// return ogl.pgl.gl;
// }
///////////////////////////////////////////////////////////////////////////