public void init(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
glut = new GLUT();
//
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
makeStripeImage();
gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1);
gl.glGenTextures(1, texName, 0);
gl.glBindTexture(GL2.GL_TEXTURE_1D, texName[0]);
gl.glTexParameterf(GL2.GL_TEXTURE_1D, GL2.GL_TEXTURE_WRAP_S, GL2.GL_REPEAT);
gl.glTexParameterf(
GL2.GL_TEXTURE_1D, //
GL2.GL_TEXTURE_MAG_FILTER,
GL.GL_LINEAR);
gl.glTexParameterf(
GL2.GL_TEXTURE_1D, //
GL2.GL_TEXTURE_MIN_FILTER,
GL.GL_LINEAR);
gl.glTexImage1D(
GL2.GL_TEXTURE_1D,
0,
GL2.GL_RGBA,
stripeImageWidth, //
0,
GL2.GL_RGB,
GL.GL_UNSIGNED_BYTE,
stripeImageBuf);
gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_MODULATE);
currentCoeff = xequalzero;
currentGenMode = GL2.GL_OBJECT_LINEAR;
currentPlane = GL2.GL_OBJECT_PLANE;
gl.glTexGeni(GL2.GL_S, GL2.GL_TEXTURE_GEN_MODE, GL2.GL_OBJECT_LINEAR);
gl.glTexGendv(GL2.GL_S, GL2.GL_OBJECT_PLANE, currentCoeff, 0);
// gl.glEnable(GL.GL_DEPTH_TEST);
gl.glDepthFunc(GL.GL_LESS);
gl.glEnable(GL2.GL_TEXTURE_GEN_S);
gl.glEnable(GL2.GL_TEXTURE_1D);
gl.glEnable(GL.GL_CULL_FACE);
gl.glEnable(GL2.GL_LIGHTING);
gl.glEnable(GL2.GL_LIGHT0);
gl.glEnable(GL2.GL_AUTO_NORMAL);
gl.glEnable(GL2.GL_NORMALIZE);
gl.glFrontFace(GL.GL_CW);
gl.glCullFace(GL.GL_BACK);
gl.glMaterialf(GL.GL_FRONT, GL2.GL_SHININESS, 64.0f);
}
public void drawTextureToOffScreenTexture(int texId, int attachment)
// public void drawTextureToOffScreenTextureUsingShader(Texture tex, int attachment, Program
// program)
{
GL2 gl = getGL();
// program.bind(gl);
gl.glBindTexture(GL_TEXTURE_2D, texId);
// gl.glBindTexture(GL_TEXTURE_2D, tex.getTextureObject());
// gl.glDrawBuffer(attachment);
gl.glBindFramebuffer(GL_FRAMEBUFFER, attachment); // think this is the new way...
gl.glEnable(GL_TEXTURE_2D);
// gl.glActiveTexture(GL_TEXTURE0);
gl.glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
gl.glViewport(0, 0, fboWidth, fboHeight);
// gl.glUniform1i(program.uniform("theTexture"), 0);
// set projection to ortho
gl.glMatrixMode(GL_PROJECTION);
gl.glTranslatef(1f, 1f, 1f);
gl.glPushMatrix();
{
gl.glLoadIdentity();
RenderUtils.getGLU().gluOrtho2D(0, fboWidth, fboHeight, 0);
gl.glMatrixMode(gl.GL_MODELVIEW);
gl.glPushMatrix();
{
gl.glLoadIdentity();
gl.glColor4f(1f, 1f, 1f, 1f);
drawSquare(gl, 0, 0, fboWidth, fboHeight);
}
gl.glPopMatrix();
gl.glMatrixMode(gl.GL_PROJECTION);
}
gl.glPopMatrix();
gl.glMatrixMode(gl.GL_MODELVIEW);
gl.glDisable(GL_TEXTURE_2D);
// program.unbind(gl);
}
public void display(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
//
gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
gl.glPushMatrix();
gl.glRotatef(45.0f, 0.0f, 0.0f, 1.0f);
gl.glTexGeni(GL2.GL_S, GL2.GL_TEXTURE_GEN_MODE, currentGenMode);
gl.glTexGendv(GL2.GL_S, currentPlane, currentCoeff, 0);
gl.glBindTexture(GL2.GL_TEXTURE_1D, texName[0]);
glut.glutSolidTeapot(2.0f);
gl.glPopMatrix();
gl.glFlush();
}
protected void endDrawIcons(DrawContext dc) {
if (dc.isPickingMode()) this.pickSupport.endPicking(dc);
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
if (dc.isPickingMode()) {
gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, OGLUtil.DEFAULT_TEX_ENV_MODE);
gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_SRC0_RGB, OGLUtil.DEFAULT_SRC0_RGB);
gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_COMBINE_RGB, OGLUtil.DEFAULT_COMBINE_RGB);
}
gl.glBindTexture(GL.GL_TEXTURE_2D, 0);
this.oglStackHandler.pop(gl);
}
/**
* initSimplexTexture(GLuinttexID) - create and load a 1D texture for a simplex traversal order
* lookup table. This is used for simplex noise only, and only for 3D and 4D noise where there are
* more than 2 simplices. (3D simplex noise has 6 cases to sort out, 4D simplex noise has 24
* cases.)
*/
private void initSimplexTexture(GL2 gl, int[] texID) {
gl.glGenTextures(1, texID, 0); // Generate a unique texture ID
gl.glBindTexture(GL2.GL_TEXTURE_1D, texID[0]); // Bind the texture to texture unit 1
ByteBuffer simplexBuffer = ByteBuffer.allocate(64 * 4);
for (int[] myBytes : simplex4) {
for (int myByte : myBytes) {
simplexBuffer.put((byte) myByte);
}
}
simplexBuffer.rewind();
// GLFW texture loading functions won't work here - we need
// GL.GL_NEAREST lookup.
gl.glTexImage1D(
GL2.GL_TEXTURE_1D, 0, GL.GL_RGBA, 64, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, simplexBuffer);
gl.glTexParameteri(GL2.GL_TEXTURE_1D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
gl.glTexParameteri(GL2.GL_TEXTURE_1D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
}
public void init(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
textures[0] = new TextureImage();
try {
// Load The Font Texture
loadTGA(gl, textures[0], "demos/data/images/Font.tga");
} catch (IOException e) {
throw new RuntimeException(e);
}
buildFont(gl); // Build The Font
gl.glShadeModel(GL2.GL_SMOOTH); // Enable Smooth Shading
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
gl.glClearDepth(1.0f); // Depth Buffer Setup
gl.glBindTexture(GL.GL_TEXTURE_2D, textures[0].texID[0]); // Select Our
// Font
// Texture
}
public void display(GLAutoDrawable drawable) {
update();
GL2 gl = drawable.getGL().getGL2();
// Clear Color Buffer, Depth Buffer
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
Matrix TmpMatrix = new Matrix(); // Temporary MATRIX Structure ( NEW )
Vector TmpVector = new Vector(), TmpNormal = new Vector(); // Temporary
// VECTOR
// Structures
// ( NEW )
gl.glLoadIdentity(); // Reset The Matrix
if (outlineSmooth) { // Check To See If We Want Anti-Aliased Lines ( NEW
// )
gl.glHint(GL2.GL_LINE_SMOOTH_HINT, GL2.GL_NICEST); // Use The Good
// Calculations
// ( NEW )
gl.glEnable(GL2.GL_LINE_SMOOTH); // Enable Anti-Aliasing ( NEW )
} else
// We Don't Want Smooth Lines ( NEW )
gl.glDisable(GL2.GL_LINE_SMOOTH); // Disable Anti-Aliasing ( NEW )
gl.glTranslatef(0.0f, 0.0f, -2.0f); // Move 2 Units Away From The Screen
// ( NEW )
gl.glRotatef(modelAngle, 0.0f, 1.0f, 0.0f); // Rotate The Model On It's
// Y-Axis ( NEW )
gl.glGetFloatv(GLMatrixFunc.GL_MODELVIEW_MATRIX, TmpMatrix.Data, 0); // Get
// The
// Generated
// Matrix
// (
// NEW
// )
// Cel-Shading Code //
gl.glEnable(GL2.GL_TEXTURE_1D); // Enable 1D Texturing ( NEW )
gl.glBindTexture(GL2.GL_TEXTURE_1D, shaderTexture[0]); // Bind Our
// Texture ( NEW
// )
gl.glColor3f(1.0f, 1.0f, 1.0f); // Set The Color Of The Model ( NEW )
gl.glBegin(GL2.GL_TRIANGLES); // Tell OpenGL That We're Drawing
// Triangles
// Loop Through Each Polygon
for (int i = 0; i < polyNum; i++)
// Loop Through Each Vertex
for (int j = 0; j < 3; j++) {
// Fill Up The TmpNormal Structure With
TmpNormal.X = polyData[i].Verts[j].Nor.X;
// The Current Vertices' Normal Values
TmpNormal.Y = polyData[i].Verts[j].Nor.Y;
TmpNormal.Z = polyData[i].Verts[j].Nor.Z;
// Rotate This By The Matrix
TmpMatrix.rotateVector(TmpNormal, TmpVector);
// Normalize The New Normal
TmpVector.normalize();
// Calculate The Shade Value
float TmpShade = Vector.dotProduct(TmpVector, lightAngle);
// Clamp The Value to 0 If Negative ( NEW )
if (TmpShade < 0.0f) {
TmpShade = 0.0f;
}
// Set The Texture Co-ordinate As The Shade Value
gl.glTexCoord1f(TmpShade);
// Send The Vertex Position
gl.glVertex3f(
polyData[i].Verts[j].Pos.X, polyData[i].Verts[j].Pos.Y, polyData[i].Verts[j].Pos.Z);
}
gl.glEnd(); // Tell OpenGL To Finish Drawing
gl.glDisable(GL2.GL_TEXTURE_1D); // Disable 1D Textures ( NEW )
// Outline Code
// Check To See If We Want To Draw The Outline
if (outlineDraw) {
// Enable Blending
gl.glEnable(GL2.GL_BLEND);
// Set The Blend Mode
gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA);
// Draw Backfacing Polygons As Wireframes
gl.glPolygonMode(GL2.GL_BACK, GL2.GL_LINE);
// Set The Line Width
gl.glLineWidth(outlineWidth);
// Don't Draw Any Front-Facing Polygons
gl.glCullFace(GL2.GL_FRONT);
// Change The Depth Mode
gl.glDepthFunc(GL2.GL_LEQUAL);
// Set The Outline Color
gl.glColor3fv(outlineColor, 0);
// Tell OpenGL What We Want To Draw
gl.glBegin(GL2.GL_TRIANGLES);
// Loop Through Each Polygon
for (int i = 0; i < polyNum; i++) {
// Loop Through Each Vertex
for (int j = 0; j < 3; j++) {
// Send The Vertex Position
gl.glVertex3f(
polyData[i].Verts[j].Pos.X, polyData[i].Verts[j].Pos.Y, polyData[i].Verts[j].Pos.Z);
}
}
gl.glEnd(); // Tell OpenGL We've Finished
// Reset The Depth-Testing Mode
gl.glDepthFunc(GL2.GL_LESS);
// Reset The Face To Be Culled
gl.glCullFace(GL2.GL_BACK);
// Reset Back-Facing Polygon Drawing Mode
gl.glPolygonMode(GL2.GL_BACK, GL2.GL_FILL);
// Disable Blending
gl.glDisable(GL2.GL_BLEND);
}
// Check To See If Rotation Is Enabled
if (modelRotate) {
// Update Angle Based On The Clock
modelAngle += .2f;
}
}
public void init(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
// Storage for the 96 Shader Values ( NEW )
FloatBuffer shaderData = GLBuffers.newDirectFloatBuffer(96);
// Start Of User Initialization
// Really Nice perspective calculations Light Grey Background
gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST);
gl.glClearColor(0.7f, 0.7f, 0.7f, 0.0f);
// Depth Buffer Setup
gl.glClearDepth(1.0f);
// Enable Depth Testing
gl.glEnable(GL2.GL_DEPTH_TEST);
// The Type Of Depth Test To Do
gl.glDepthFunc(GL2.GL_LESS);
// Enables Smooth Color Shading ( NEW )
gl.glShadeModel(GL2.GL_SMOOTH);
// Initially Disable Line Smoothing ( NEW )
gl.glDisable(GL2.GL_LINE_SMOOTH);
// Enable OpenGL Face Culling ( NEW )
gl.glEnable(GL2.GL_CULL_FACE);
// Disable OpenGL Lighting ( NEW )
gl.glDisable(GL2.GL_LIGHTING);
StringBuffer readShaderData = new StringBuffer();
try {
InputStream inputStream =
ResourceRetriever.getResourceAsStream("demos/data/models/Shader.txt");
int info;
while ((info = inputStream.read()) != -1) readShaderData.append((char) info);
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
StringTokenizer tokenizer = new StringTokenizer(readShaderData.toString());
// Loop Though The 32 Greyscale Values
while (tokenizer.hasMoreTokens()) {
float value = Float.parseFloat(tokenizer.nextToken());
shaderData.put(value);
shaderData.put(value);
shaderData.put(value);
}
shaderData.flip();
gl.glGenTextures(1, shaderTexture, 0); // Get A Free Texture ID ( NEW )
gl.glBindTexture(GL2.GL_TEXTURE_1D, shaderTexture[0]); // Bind This
// Texture. From
// Now On It
// Will Be 1D
// For Crying Out Loud Don't Let OpenGL Use Bi/Trilinear Filtering!
gl.glTexParameteri(GL2.GL_TEXTURE_1D, GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_NEAREST);
gl.glTexParameteri(GL2.GL_TEXTURE_1D, GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_NEAREST);
gl.glTexImage1D(
GL2.GL_TEXTURE_1D, 0, GL2.GL_RGB, 32, 0, GL2.GL_RGB, GL2.GL_FLOAT, shaderData); // Upload
// Set The X Direction
lightAngle.X = 0.0f;
// Set The Y Direction
lightAngle.Y = 0.0f;
// Set The Z Direction
lightAngle.Z = 1.0f;
lightAngle.normalize();
try {
// Return The Value Of ReadMesh
readMesh();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public void draw(IDelegateView view, DrawContext dc, DrawableSceneController sc) {
GL2 gl = dc.getGL().getGL2();
init(gl);
if (distortionShader.isCreationFailed()) {
view.draw(dc, sc);
return;
}
Rectangle oldViewport = view.getViewport();
hmd.beginFrameTiming(++frameCount);
{
Posef[] eyePoses = hmd.getEyePoses(frameCount, eyeOffsets);
// RiftLogger.logPose(eyePoses);
renderEyes = true;
frameBuffer.bind(gl);
{
sc.clearFrame(dc);
for (int i = 0; i < ovrEye_Count; i++) {
int eye = hmd.EyeRenderOrder[i];
Posef pose = eyePoses[eye];
this.eyePoses[eye].Orientation = pose.Orientation;
this.eyePoses[eye].Position = pose.Position;
this.eye = eye;
gl.glViewport(
eyeRenderViewport[eye].Pos.x,
eyeRenderViewport[eye].Pos.y,
eyeRenderViewport[eye].Size.w,
eyeRenderViewport[eye].Size.h);
sc.applyView(dc);
sc.draw(dc);
}
}
frameBuffer.unbind(gl);
renderEyes = false;
OGLStackHandler oglsh = new OGLStackHandler();
oglsh.pushAttrib(gl, GL2.GL_ENABLE_BIT);
oglsh.pushClientAttrib(gl, GL2.GL_CLIENT_VERTEX_ARRAY_BIT);
try {
gl.glViewport(0, 0, hmd.Resolution.w, hmd.Resolution.h);
gl.glDisable(GL2.GL_DEPTH_TEST);
gl.glEnable(GL2.GL_TEXTURE_2D);
gl.glActiveTexture(GL2.GL_TEXTURE0);
gl.glBindTexture(GL2.GL_TEXTURE_2D, frameBuffer.getTexture().getId());
for (int eyeNum = 0; eyeNum < ovrEye_Count; eyeNum++) {
OvrMatrix4f[] timeWarpMatricesRowMajor = new OvrMatrix4f[2];
hmd.getEyeTimewarpMatrices(eyeNum, eyePoses[eyeNum], timeWarpMatricesRowMajor);
distortionShader.use(
gl,
uvScaleOffset[eyeNum][0].x,
-uvScaleOffset[eyeNum][0].y,
uvScaleOffset[eyeNum][1].x,
1 - uvScaleOffset[eyeNum][1].y,
timeWarpMatricesRowMajor[0].M,
timeWarpMatricesRowMajor[1].M);
gl.glClientActiveTexture(GL2.GL_TEXTURE0);
gl.glEnableClientState(GL2.GL_VERTEX_ARRAY);
gl.glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
gl.glEnableClientState(GL2.GL_COLOR_ARRAY);
gl.glBindBuffer(
GL2.GL_ARRAY_BUFFER, distortionObjects[eyeNum][DistortionObjects.vbo.ordinal()]);
{
int stride = 10 * 4;
gl.glVertexPointer(4, GL2.GL_FLOAT, stride, 0);
gl.glTexCoordPointer(2, GL2.GL_FLOAT, stride, 4 * 4);
gl.glColorPointer(4, GL2.GL_FLOAT, stride, 6 * 4);
gl.glBindBuffer(
GL2.GL_ELEMENT_ARRAY_BUFFER,
distortionObjects[eyeNum][DistortionObjects.ibo.ordinal()]);
{
gl.glDrawElements(GL2.GL_TRIANGLES, indicesCount, GL2.GL_UNSIGNED_INT, 0);
}
gl.glBindBuffer(GL2.GL_ELEMENT_ARRAY_BUFFER, 0);
}
gl.glBindBuffer(GL2.GL_ARRAY_BUFFER, 0);
distortionShader.unuse(gl);
}
} finally {
oglsh.pop(gl);
}
}
hmd.endFrameTiming();
// apply the old viewport, and ensure that the view is updated for the next picking round
gl.glViewport(oldViewport.x, oldViewport.y, oldViewport.width, oldViewport.height);
sc.applyView(dc);
view.firePropertyChange(
AVKey.VIEW, null, view); // make the view draw repeatedly for oculus rotation
}
public void draw(GL2 gl) {
if (particles.size() == 0) return;
switch (blendMode) {
case 0: // '\0'
gl.glDisable(3042);
gl.glDisable(3008);
break;
case 1: // '\001'
gl.glEnable(3042);
gl.glDisable(3008);
gl.glBlendFunc(768, 1);
break;
case 2: // '\002'
gl.glEnable(3042);
gl.glDisable(3008);
gl.glBlendFunc(770, 1);
break;
case 3: // '\003'
gl.glDisable(3042);
gl.glEnable(3008);
break;
case 4: // '\004'
gl.glEnable(3042);
gl.glDisable(3008);
gl.glBlendFunc(770, 1);
break;
}
gl.glBindTexture(3553, model.mMaterials[texture].mTextureId);
gl.glPushMatrix();
if (particleType == 0 || particleType == 2) {
if ((flags & 0x1000) == 0) {
Vec3 view = new Vec3(viewer.getCamera().getPosition());
view.normalize();
Vec3 right = Vec3.cross(view, new Vec3(0.0F, 0.0F, 1.0F)).normalize();
Vec3 up = Vec3.cross(right, view).normalize();
int tcStart = 0;
if (flags == 0x40019) tcStart++;
gl.glBegin(7);
int count = particles.size();
Vec3 pos = new Vec3();
Vec3 cPos = new Vec3();
Vec3 ofs = new Vec3();
for (int i = 0; i < count; i++) {
Particle p = (Particle) particles.get(i);
if (p.tile < texCoords.size()) {
gl.glColor4f(p.color.x, p.color.y, p.color.z, p.color.w);
Point2f tc[] = (Point2f[]) texCoords.get(p.tile);
Vec3.add(right, up, ofs);
cPos.set(p.pos);
Vec3.sub(cPos, ofs.scale(p.size), pos);
gl.glTexCoord2f(tc[tcStart % 4].x, tc[tcStart % 4].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.sub(right, up, ofs);
Vec3.add(cPos, ofs.scale(p.size), pos);
gl.glTexCoord2f(tc[(tcStart + 1) % 4].x, tc[(tcStart + 1) % 4].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(right, up, ofs);
Vec3.add(cPos, ofs.scale(p.size), pos);
gl.glTexCoord2f(tc[(tcStart + 2) % 4].x, tc[(tcStart + 2) % 4].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.sub(right, up, ofs);
Vec3.sub(cPos, ofs.scale(p.size), pos);
gl.glTexCoord2f(tc[(tcStart + 3) % 4].x, tc[(tcStart + 3) % 4].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
}
}
gl.glEnd();
} else {
gl.glBegin(7);
int count = particles.size();
Vec3 pos = new Vec3();
Vec3 ofs = new Vec3();
for (int i = 0; i < count; i++) {
Particle p = (Particle) particles.get(i);
if (p.tile < texCoords.size()) {
gl.glColor4f(p.color.x, p.color.y, p.color.z, p.color.w);
Point2f tc[] = (Point2f[]) texCoords.get(p.tile);
Vec3.add(p.pos, Vec3.scale(p.corners[0], p.size, ofs), pos);
gl.glTexCoord2f(tc[0].x, tc[0].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.pos, Vec3.scale(p.corners[1], p.size, ofs), pos);
gl.glTexCoord2f(tc[1].x, tc[1].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.pos, Vec3.scale(p.corners[2], p.size, ofs), pos);
gl.glTexCoord2f(tc[2].x, tc[2].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.pos, Vec3.scale(p.corners[3], p.size, ofs), pos);
gl.glTexCoord2f(tc[3].x, tc[3].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
}
}
gl.glEnd();
}
} else if (particleType == 1) {
gl.glBegin(7);
int count = particles.size();
Vec3 pos = new Vec3();
Vec3 ofs = new Vec3();
float f = 1.0F;
Vec3 bv0 = new Vec3(-f, f, 0.0F);
Vec3 bv1 = new Vec3(f, f, 0.0F);
for (int i = 0; i < count; i++) {
Particle p = (Particle) particles.get(i);
if (p.tile >= texCoords.size() - 1) break;
gl.glColor4f(p.color.x, p.color.y, p.color.z, p.color.w);
Point2f tc[] = (Point2f[]) texCoords.get(p.tile);
Vec3.add(p.pos, Vec3.scale(bv0, p.size, ofs), pos);
gl.glTexCoord2f(tc[0].x, tc[0].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.pos, Vec3.scale(bv1, p.size, ofs), pos);
gl.glTexCoord2f(tc[1].x, tc[1].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.origin, Vec3.scale(bv1, p.size, ofs), pos);
gl.glTexCoord2f(tc[2].x, tc[2].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.origin, Vec3.scale(bv0, p.size, ofs), pos);
gl.glTexCoord2f(tc[3].x, tc[3].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
}
gl.glEnd();
}
gl.glPopMatrix();
}
public boolean generateFBO(GL2 gl) {
if (fboWidth < 0 || fboHeight < 0) {
fboWidth = inputTexture.getWidth();
fboHeight = inputTexture.getHeight();
}
System.err.println("(********* in generateFBO...");
boolean fboUsed;
this.texture1 = TextureIO.newTexture(GL_TEXTURE_2D);
this.texture1.bind();
gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
// gl.glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); // automatic mipmap
// gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
// gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
gl.glTexImage2D(
GL_TEXTURE_2D, 0, GL_RGBA, fboWidth, fboHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, null);
// gl.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, fboWidth, fboHeight, 0, GL_RGB, GL_UNSIGNED_BYTE,
// null);
gl.glBindTexture(GL_TEXTURE_2D, 0);
this.texture2 = TextureIO.newTexture(GL_TEXTURE_2D);
this.texture2.bind();
gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
// gl.glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); // automatic mipmap
// gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
// gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
gl.glTexImage2D(
GL_TEXTURE_2D, 0, GL_RGBA, fboWidth, fboHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, null);
// gl.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, fboWidth, fboHeight, 0, GL_RGB, GL_UNSIGNED_BYTE,
// null);
gl.glBindTexture(GL_TEXTURE_2D, 0);
// create a renderbuffer object to store depth info
// int[] rboBindId = new int[1];
// gl.glGenRenderbuffersEXT(1, rboBindId, 0);
// this.rboId = rboBindId[0];
// gl.glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, this.rboId);
// gl.glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, fboWidth, fboHeight);
// gl.glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
// create a framebuffer object and attach the color texture and depth renderbuffer
int[] fboBindId = new int[1];
gl.glGenFramebuffers(1, fboBindId, 0);
this.fboId = fboBindId[0];
gl.glBindFramebuffer(GL_FRAMEBUFFER, this.fboId);
int textureLevel = 0; // not using mipmaps so only first level is available
// attach the texture to FBO color attachment point
gl.glFramebufferTexture2D(
GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D,
this.texture1.getTextureObject(),
textureLevel);
// attach the renderbuffer to depth attachment point
// gl.glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
// GL_RENDERBUFFER_EXT, this.rboId);
// attach the texture to FBO color attachment point
gl.glFramebufferTexture2D(
GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT1,
GL_TEXTURE_2D,
this.texture2.getTextureObject(),
textureLevel);
// attach the renderbuffer to depth attachment point
// gl.glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
// GL_RENDERBUFFER_EXT, this.rboId);
// check FBO status
int status = gl.glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE) {
fboUsed = false;
System.out.println("GL_FRAMEBUFFER_COMPLETE_EXT failed, CANNOT use FBO\n");
} else {
fboUsed = true;
System.out.printf("GL_FRAMEBUFFER_COMPLETE_EXT OK, using FBO\n");
System.out.printf("fbo offScreenWidth =%d\n", fboWidth);
System.out.printf("fbo offScreenHeight =%d\n", fboHeight);
System.out.printf("fbo texture1 id=%d\n", this.texture1.getTextureObject());
System.out.printf("fbo texture2 id=%d\n", this.texture2.getTextureObject());
System.out.printf("fbo id=%d\n", fboId);
System.out.printf("fbo's rbo id=%d\n", rboId);
}
// switch back to window-system-provided framebuffer
gl.glBindFramebuffer(GL_FRAMEBUFFER, 0);
return fboUsed;
}
public void bindTexture(GL2 gl, int target, String texname, int texid, int texunit) {
gl.glActiveTexture(GL2.GL_TEXTURE0 + texunit);
gl.glBindTexture(target, texid);
setTextureUnit(gl, texname, texunit);
gl.glActiveTexture(GL2.GL_TEXTURE0);
}
