Note that for practice codes like I’m doing right now, I’m following a strict rule:
No jumping around: Basically, you don’t create objects just for the sake of categorizing the code into objects and what objects they should be. Instead, the main focus is the order of code execution that the compiler runs when you’re stepping through (using breakpoints or hot-swapping), where all the codes are placed in one single function, and is ordered in a fixed pipeline without having the compiler calling methods/functions here and there and jumping all over the place in the source code.
TL;DR: It’s to cut down the numbers of function calling and just focus on the order of code execution.
Here’s the entire code that follows in that strict rule:
package core;
import static org.lwjgl.opengl.GL11.GL_FLOAT;
import static org.lwjgl.opengl.GL11.GL_LINEAR;
import static org.lwjgl.opengl.GL11.GL_LINEAR_MIPMAP_NEAREST;
import static org.lwjgl.opengl.GL11.GL_MODELVIEW;
import static org.lwjgl.opengl.GL11.GL_PROJECTION;
import static org.lwjgl.opengl.GL11.GL_RGBA;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_MAG_FILTER;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_MIN_FILTER;
import static org.lwjgl.opengl.GL11.glBindTexture;
import static org.lwjgl.opengl.GL11.glGenTextures;
import static org.lwjgl.opengl.GL11.glLoadIdentity;
import static org.lwjgl.opengl.GL11.glLoadMatrix;
import static org.lwjgl.opengl.GL11.glMatrixMode;
import static org.lwjgl.opengl.GL11.glTexImage2D;
import static org.lwjgl.opengl.GL11.glTexParameteri;
import static org.lwjgl.opengl.GL11.glViewport;
import game.Game;
import java.awt.image.BufferedImage;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import javax.imageio.ImageIO;
import org.lwjgl.opengl.GL30;
import org.lwjgl.util.vector.Vector3f;
public class Something {
private int texture;
public Something() {
init();
}
private void init() {
float[] pixels = null;
BufferedImage img = null;
try {
img = ImageIO.read(Something.class.getResource("/icon.png"));
pixels = img.getData().getPixels(0, 0, img.getWidth(), img.getHeight(), pixels);
}
catch (Exception e) {
e.printStackTrace();
return;
}
texture = glGenTextures();
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, img.getWidth(), img.getHeight(), 0, GL_RGBA, GL_FLOAT, ByteBuffer.allocateDirect(pixels.length * 4).order(ByteOrder.nativeOrder()).asFloatBuffer().put(pixels));
GL30.glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glViewport(0, 0, Game.WIDTH, Game.HEIGHT);
{
//Perspective Matrix creation
final float FOV = 45f;
float yFactor = (float) Math.tan(FOV * Math.PI / 360f);
float xFactor = yFactor / ((float) Game.WIDTH / (float) Game.HEIGHT);
float near = 1f;
float far = 1000f;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glLoadMatrix(ByteBuffer.allocateDirect(16 * 4).order(ByteOrder.nativeOrder()).asFloatBuffer().put(new float[] {
1f / xFactor, 0f, 0f, 0f,
0f, 1f / yFactor, 0f, 0f,
0f, 0f, -(far + near) / (far - near), -1f,
0f, 0f, -(2f * far * near) / (far - near), 0f
}));
}
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
{
//View Matrix creation
Vector3f eye = new Vector3f();
Vector3f center = new Vector3f();
Vector3f up = new Vector3f();
eye.x = 0f;
eye.y = 0f;
eye.z = 0f;
center.x = 0f;
center.y = 0f;
center.z = -1f;
up.x = 0f;
up.y = 1f;
up.z = 0f;
eye.normalise();
center.normalise();
up.normalise();
Vector3f zaxis = center.negate(eye);
zaxis.normalise();
Vector3f xaxis = new Vector3f();
Vector3f yaxis = new Vector3f();
Vector3f.cross(up, zaxis, xaxis);
xaxis.normalise();
Vector3f.cross(zaxis, xaxis, yaxis);
yaxis.normalise();
float[] viewMatrix = {
xaxis.x, yaxis.x, -zaxis.x, 0f,
xaxis.y, yaxis.y, -zaxis.y, 0f,
xaxis.z, yaxis.z, -zaxis.z, 0f,
0f, 0f, 0f, 1f
};
glLoadMatrix(ByteBuffer.allocateDirect(16 * 4).order(ByteOrder.nativeOrder()).asFloatBuffer().put(viewMatrix));
}
//TODO: No idea what to do next.
//As in:
// #1. Do I start work on texture and vertices binding?
// #2. Do I continue to make the model matrix? (And how, precisely? On Android, projection, view, and model matrices are separately calculated, so it's easier to say.)
// #3. Anything else like matrix multiplications within the MODELVIEW state?
// #4. Do I start working on what I should do when I'm drawing frames? (On Android, GLSurfaceView.Renderer's onDrawFrame() is equivalent to this.)
}
}
Basically, that covers it all. I don’t know what is the next step for me to take, since I’m porting my own Android OpenGL ES practice codes into LWJGL practice codes, and I’m a bit lost. Any hints are welcomed.
Thanks in advance. I’m going to sleep, as my brain is really foggy after all these calculations.