emh/helium
Archived
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

trying to add textures and still failing

Browse Source
This commit is contained in:
EvilMuffinHa 2020-05-25 12:55:20 -04:00
parent ebf26f18d8
commit 5fc63b6c73
17 changed files with 882 additions and 627 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
resources/textures/testimg.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.6 KiB

112
src/Test.java
View File

@ -7,70 +7,76 @@ import org.lwjgl.glfw.GLFW;
public class Test { public class Test {
public final static int WIDTH = 640, HEIGHT = 480; public final static int WIDTH = 640, HEIGHT = 480;
public final String windowName = "Game!"; public final String windowName = "Game!";
public Display display; public Display display;
public Input i; public Input i;
public Renderer renderer; public Renderer renderer;
public Shader shader; public Shader shader;
public Mesh mesh = new Mesh(new Vertex[] { public Mesh mesh = new Mesh(new Vertex[] {
new Vertex(new Vector3f(-0.5F, 0.5F, 0.0F), new Vector3f(0, 0, 1.0F), new Vector2f(0, 0)), new Vertex(new Vector3f(-0.5F, 0.5F, 0.0F), new Vector3f(0, 0, 1.0F), new Vector2f(0, 0)),
new Vertex(new Vector3f(-0.5F, -0.5F, 0.0F), new Vector3f(0, 0, 1.0F), new Vector2f(0, 1)), new Vertex(new Vector3f(-0.5F, -0.5F, 0.0F), new Vector3f(0, 0, 1.0F), new Vector2f(0, 1)),
new Vertex(new Vector3f(0.5F, -0.5F, 0.0F), new Vector3f(1.0F, 0, 1.0F), new Vector2f(1, 1)), new Vertex(new Vector3f(0.5F, -0.5F, 0.0F), new Vector3f(1.0F, 0, 1.0F), new Vector2f(1, 1)),
new Vertex(new Vector3f(0.5F, 0.5F, 0.0F), new Vector3f(1.0F, 0, 1.0F), new Vector2f(1, 0)), new Vertex(new Vector3f(0.5F, 0.5F, 0.0F), new Vector3f(1.0F, 0, 1.0F), new Vector2f(1, 0)),
}, new int[] { }, new int[] {
0, 1, 2, 0, 1, 2,
0, 2, 3 0, 2, 3
}, new Material("/resources/textures/testimg.png")); }, new Material(new Texture("resources/textures/testimg.png")));
public void run() { public void run() throws Exception {
init(); setup();
i = new Input(display); i = new Input(display);
while (!(display.shouldClose()) && !i.isKeyDown(GLFW.GLFW_KEY_ESCAPE)) { while (!(display.shouldClose()) && !i.isKeyDown(GLFW.GLFW_KEY_ESCAPE)) {
update(); loop();
render(); }
}
close(); close();
} }
public void init() {
// System.out.println("Initializing Game ");
display = new Display(WIDTH, HEIGHT, windowName);
shader = new Shader("/resources/shaders/mainVertex.glsl", "/resources/shaders/mainFragment.glsl");
renderer = new Renderer(shader);
display.setBackgroundColor(1F, 0, 0);
display.create();
mesh.create();
shader.create();
} public void loop() {
private void update() { update();
// System.out.println("Updating "); render();
int frames = display.update(); }
display.setWindowName(display.getWindowName().substring(0, 4) + " (Frames : " + frames + ")");
i.reset();
} public void setup() throws Exception {
// System.out.println("Initializing Game ");
display = new Display(WIDTH, HEIGHT, windowName);
display.create();
shader = new Shader("/resources/shaders/mainVertex.glsl", "/resources/shaders/mainFragment.glsl");
renderer = new Renderer(shader);
display.setBackgroundColor(1F, 0, 0);
mesh.create();
shader.create();
private void render() { }
// System.out.println("Rendering "); private void update() {
renderer.renderMesh(mesh); // System.out.println("Updating ");
display.swapBuffers(); int frames = display.update();
display.setWindowName(display.getWindowName().substring(0, 4) + " (Frames : " + frames + ")");
} i.reset();
private void close() { }
display.destroy();
mesh.destroy();
shader.destroy();
}
public static void main(String[] args) { private void render() {
new Test().run(); // System.out.println("Rendering ");
} renderer.renderMesh(mesh);
display.swapBuffers();
}
private void close() {
display.destroy();
mesh.destroy();
shader.destroy();
}
public static void main(String[] args) throws Exception {
new Test().run();
}
} }

121
src/org/hl/engine/graphics/Material.java
View File

@ -1,48 +1,107 @@
package org.hl.engine.graphics; package org.hl.engine.graphics;
import org.hl.engine.utils.TextureLoader; import org.hl.engine.math.lalg.Vector4f;
import org.lwjgl.opengl.GL11;
import org.lwjgl.openvr.Texture;
import java.awt.image.BufferedImage;
public class Material { public class Material {
private static final Vector4f DEFAULT_COLOR = new Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
private Texture texture; private Vector4f ambientColor;
private String path; private Vector4f diffuseColor;
private BufferedImage image; private Vector4f specularColor;
private int width, height; private float reflectance;
private int textureID;
public Material(String path) { private Texture texture;
this.path = path; private Texture normalMap;
} public Material() {
public void create() { this.ambientColor = DEFAULT_COLOR;
this.diffuseColor = DEFAULT_COLOR;
this.specularColor = DEFAULT_COLOR;
this.texture = null;
this.reflectance = 0;
}
this.image = TextureLoader.loadImage(path); //The path is inside the jar file public Material(Vector4f color, float reflectance) {
this.width = this.image.getWidth(); this(color, color, color, null, reflectance);
this.height = this.image.getHeight(); }
this.textureID = TextureLoader.loadTexture(image);
}
public int getWidth() { public Material(Texture texture) {
return width; this(DEFAULT_COLOR, DEFAULT_COLOR, DEFAULT_COLOR, texture, 0);
} }
public int getHeight() { public Material(Texture texture, float reflectance) {
return height; this(DEFAULT_COLOR, DEFAULT_COLOR, DEFAULT_COLOR, texture, reflectance);
} }
public int getTextureID() { public Material(Vector4f ambientColor, Vector4f diffuseColor, Vector4f specularColor, Texture texture, float reflectance) {
return textureID; this.ambientColor = ambientColor;
} this.diffuseColor = diffuseColor;
this.specularColor = specularColor;
this.texture = texture;
this.reflectance = reflectance;
}
public void destroy() { public Vector4f getAmbientColor() {
GL11.glDeleteTextures(textureID); return ambientColor;
} }
public void setAmbientColor(Vector4f ambientColor) {
this.ambientColor = ambientColor;
}
public Vector4f getDiffuseColor() {
return diffuseColor;
}
public void setDiffuseColor(Vector4f diffuseColor) {
this.diffuseColor = diffuseColor;
}
public Vector4f getSpecularColor() {
return specularColor;
}
public void setSpecularColor(Vector4f specularColor) {
this.specularColor = specularColor;
}
public float getReflectance() {
return reflectance;
}
public void setReflectance(float reflectance) {
this.reflectance = reflectance;
}
public boolean isTextured() {
return this.texture != null;
}
public Texture getTexture() {
return texture;
}
public void setTexture(Texture texture) {
this.texture = texture;
}
public boolean hasNormalMap() {
return this.normalMap != null;
}
public Texture getNormalMap() {
return normalMap;
}
public void setNormalMap(Texture normalMap) {
this.normalMap = normalMap;
}
public void create() {
texture.create();
}
} }

188
src/org/hl/engine/graphics/Mesh.java
View File

@ -10,130 +10,130 @@ import java.nio.FloatBuffer;
import java.nio.IntBuffer; import java.nio.IntBuffer;
public class Mesh { public class Mesh {
private Vertex[] vertices; private Vertex[] vertices;
private int[] indices; private int[] indices;
private int vertexArrayObject, positionBufferObject, indicesBufferObject, colorBufferObject, textureBufferObject; private int vertexArrayObject, positionBufferObject, indicesBufferObject, colorBufferObject, textureBufferObject;
private Material material; private Material material;
// A group of vertices combined based on the indexes // A group of vertices combined based on the indexes
public Mesh(Vertex[] vertices, int[] indices, Material material) { public Mesh(Vertex[] vertices, int[] indices, Material material) {
this.vertices = vertices; this.vertices = vertices;
this.indices = indices; this.indices = indices;
this.material = material; this.material = material;
} }
// Destroy the mesh // Destroy the mesh
public void destroy () { public void destroy () {
GL15.glDeleteBuffers(positionBufferObject); GL15.glDeleteBuffers(positionBufferObject);
GL15.glDeleteBuffers(indicesBufferObject); GL15.glDeleteBuffers(indicesBufferObject);
GL15.glDeleteBuffers(colorBufferObject); GL15.glDeleteBuffers(colorBufferObject);
GL30.glDeleteBuffers(textureBufferObject); GL30.glDeleteBuffers(textureBufferObject);
GL30.glDeleteVertexArrays(vertexArrayObject); GL30.glDeleteVertexArrays(vertexArrayObject);
material.destroy(); material.getTexture().destroy();
} }
// getters for the mesh // getters for the mesh
public Vertex[] getVertices() { public Vertex[] getVertices() {
return vertices; return vertices;
} }
public int[] getIndices() { public int[] getIndices() {
return indices; return indices;
} }
public int getVertexArrayObject() { public int getVertexArrayObject() {
return vertexArrayObject; return vertexArrayObject;
} }
public int getPositionBufferObject() { public int getPositionBufferObject() {
return positionBufferObject; return positionBufferObject;
} }
public int getIndicesBufferObject() { public int getIndicesBufferObject() {
return indicesBufferObject; return indicesBufferObject;
} }
public int getColorBufferObject() { public int getColorBufferObject() {
return colorBufferObject; return colorBufferObject;
} }
public int getTextureBufferObject() { public int getTextureBufferObject() {
return textureBufferObject; return textureBufferObject;
} }
public Material getMaterial() { public Material getMaterial() {
return material; return material;
} }
public void create() { public void create() {
material.create(); material.create();
// Creates the mesh by formatting the vertices and indices and inputting them to OpenGL // Creates the mesh by formatting the vertices and indices and inputting them to OpenGL
vertexArrayObject = GL30.glGenVertexArrays(); vertexArrayObject = GL30.glGenVertexArrays();
GL30.glBindVertexArray(vertexArrayObject); GL30.glBindVertexArray(vertexArrayObject);
// Putting the position of the vertex into the buffer so the renderer can read it // Putting the position of the vertex into the buffer so the renderer can read it
FloatBuffer positionBuffer = MemoryUtil.memAllocFloat(vertices.length * 3); FloatBuffer positionBuffer = MemoryUtil.memAllocFloat(vertices.length * 3);
float[] positionData = new float[vertices.length * 3]; float[] positionData = new float[vertices.length * 3];
for (int i = 0; i < vertices.length; i ++ ) { for (int i = 0; i < vertices.length; i ++ ) {
positionData[i * 3] = vertices[i].getPosition().getX(); positionData[i * 3] = vertices[i].getPosition().getX();
positionData[i * 3 + 1] = vertices[i].getPosition().getY(); positionData[i * 3 + 1] = vertices[i].getPosition().getY();
positionData[i * 3 + 2] = vertices[i].getPosition().getZ(); positionData[i * 3 + 2] = vertices[i].getPosition().getZ();
} }
positionBuffer.put(positionData).flip(); positionBuffer.put(positionData).flip();
positionBufferObject = storeData(positionBuffer, 0, 3); positionBufferObject = storeData(positionBuffer, 0, 3);
// Putting the color into the buffer so renderer and shader can read it // Putting the color into the buffer so renderer and shader can read it
FloatBuffer colorBuffer = MemoryUtil.memAllocFloat(vertices.length * 3); FloatBuffer colorBuffer = MemoryUtil.memAllocFloat(vertices.length * 3);
float[] colorData = new float[vertices.length * 3]; float[] colorData = new float[vertices.length * 3];
for (int i = 0; i < vertices.length; i ++ ) { for (int i = 0; i < vertices.length; i ++ ) {
colorData[i * 3] = vertices[i].getColor().getX(); colorData[i * 3] = vertices[i].getColor().getX();
colorData[i * 3 + 1] = vertices[i].getColor().getY(); colorData[i * 3 + 1] = vertices[i].getColor().getY();
colorData[i * 3 + 2] = vertices[i].getColor().getZ(); colorData[i * 3 + 2] = vertices[i].getColor().getZ();
} }
colorBuffer.put(colorData).flip(); colorBuffer.put(colorData).flip();
colorBufferObject = storeData(colorBuffer, 1, 3); colorBufferObject = storeData(colorBuffer, 1, 3);
// Putting the texture into the buffer so renderer and shader can read it // Putting the texture into the buffer so renderer and shader can read it
FloatBuffer textureBuffer = MemoryUtil.memAllocFloat(vertices.length * 2); FloatBuffer textureBuffer = MemoryUtil.memAllocFloat(vertices.length * 2);
float[] textureData = new float[vertices.length * 2]; float[] textureData = new float[vertices.length * 2];
for (int i = 0; i < vertices.length; i ++ ) { for (int i = 0; i < vertices.length; i ++ ) {
textureData[i * 2] = vertices[i].getTextureCoords().getX(); textureData[i * 2] = vertices[i].getTextureCoords().getX();
textureData[i * 2 + 1] = vertices[i].getTextureCoords().getY(); textureData[i * 2 + 1] = vertices[i].getTextureCoords().getY();
} }
textureBuffer.put(textureData).flip(); textureBuffer.put(textureData).flip();
textureBufferObject = storeData(textureBuffer, 2, 2); textureBufferObject = storeData(textureBuffer, 2, 2);
IntBuffer indicesBuffer = MemoryUtil.memAllocInt(indices.length); IntBuffer indicesBuffer = MemoryUtil.memAllocInt(indices.length);
indicesBuffer.put(indices).flip(); indicesBuffer.put(indices).flip();
indicesBufferObject = GL15.glGenBuffers(); indicesBufferObject = GL15.glGenBuffers();
GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, indicesBufferObject); GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, indicesBufferObject);
GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, indicesBuffer, GL15.GL_STATIC_DRAW); GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, indicesBuffer, GL15.GL_STATIC_DRAW);
GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0); GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
} }
// Storing data to the buffer at position index (helps with storing color / position) // Storing data to the buffer at position index (helps with storing color / position)
private int storeData(FloatBuffer buffer, int index, int size) { private int storeData(FloatBuffer buffer, int index, int size) {
int bufferID = GL15.glGenBuffers(); int bufferID = GL15.glGenBuffers();
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, bufferID); GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, bufferID);
GL15.glBufferData(GL15.GL_ARRAY_BUFFER, buffer, GL15.GL_STATIC_DRAW); GL15.glBufferData(GL15.GL_ARRAY_BUFFER, buffer, GL15.GL_STATIC_DRAW);
GL20.glVertexAttribPointer(index, size, GL11.GL_FLOAT, false, 0, 0); GL20.glVertexAttribPointer(index, size, GL11.GL_FLOAT, false, 0, 0);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
return bufferID; return bufferID;
} }
} }

42
src/org/hl/engine/graphics/Renderer.java
View File

@ -7,35 +7,35 @@ import org.lwjgl.opengl.GL30;
public class Renderer { public class Renderer {
private Shader shader; private Shader shader;
public Renderer(Shader shader) { public Renderer(Shader shader) {
this.shader = shader; this.shader = shader;
} }
public void renderMesh(Mesh mesh) { public void renderMesh(Mesh mesh) {
// Renders the mesh by drawing it using triangles (least complicated) // Renders the mesh by drawing it using triangles (least complicated)
GL30.glBindVertexArray(mesh.getVertexArrayObject()); GL30.glBindVertexArray(mesh.getVertexArrayObject());
GL30.glEnableVertexAttribArray(0); GL30.glEnableVertexAttribArray(0);
GL30.glEnableVertexAttribArray(1); GL30.glEnableVertexAttribArray(1);
GL30.glEnableVertexAttribArray(2); GL30.glEnableVertexAttribArray(2);
GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, mesh.getIndicesBufferObject()); GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, mesh.getIndicesBufferObject());
GL13.glActiveTexture(GL13.GL_TEXTURE0); GL13.glActiveTexture(GL13.GL_TEXTURE0);
GL13.glBindTexture(GL11.GL_TEXTURE_2D, mesh.getMaterial().getTextureID()); GL13.glBindTexture(GL11.GL_TEXTURE_2D, mesh.getMaterial().getTexture().getId());
shader.bind(); shader.bind();
GL11.glDrawElements(GL11.GL_TRIANGLES, mesh.getIndices().length, GL11.GL_UNSIGNED_INT, 0); GL11.glDrawElements(GL11.GL_TRIANGLES, mesh.getIndices().length, GL11.GL_UNSIGNED_INT, 0);
shader.unbind(); shader.unbind();
GL30.glDisableVertexAttribArray(0); GL30.glDisableVertexAttribArray(0);
GL30.glDisableVertexAttribArray(1); GL30.glDisableVertexAttribArray(1);
GL30.glDisableVertexAttribArray(2); GL30.glDisableVertexAttribArray(2);
GL30.glBindVertexArray(0); GL30.glBindVertexArray(0);
} }
} }

116
src/org/hl/engine/graphics/Shader.java
View File

@ -5,84 +5,84 @@ import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL20; import org.lwjgl.opengl.GL20;
public class Shader { public class Shader {
private String vertexFile; private String vertexFile;
private String fragmentFile; private String fragmentFile;
private int vertexID, fragmentID, programID; private int vertexID, fragmentID, programID;
public Shader(String vertexPath, String fragmentPath) { public Shader(String vertexPath, String fragmentPath) {
vertexFile = FileUtils.loadAsString(vertexPath); vertexFile = FileUtils.loadAsString(vertexPath);
fragmentFile = FileUtils.loadAsString(fragmentPath); fragmentFile = FileUtils.loadAsString(fragmentPath);
} }
public void create() { public void create() {
// Creates the program // Creates the program
programID = GL20.glCreateProgram(); programID = GL20.glCreateProgram();
// loads the vertex shader // loads the vertex shader
vertexID = GL20.glCreateShader(GL20.GL_VERTEX_SHADER); vertexID = GL20.glCreateShader(GL20.GL_VERTEX_SHADER);
GL20.glShaderSource(vertexID, vertexFile); GL20.glShaderSource(vertexID, vertexFile);
GL20.glCompileShader(vertexID); GL20.glCompileShader(vertexID);
if (GL20.glGetShaderi(vertexID, GL20.GL_COMPILE_STATUS) == GL11.GL_FALSE) { if (GL20.glGetShaderi(vertexID, GL20.GL_COMPILE_STATUS) == GL11.GL_FALSE) {
System.err.println("Vertex Shader: " + GL20.glGetShaderInfoLog(vertexID)); System.err.println("Vertex Shader: " + GL20.glGetShaderInfoLog(vertexID));
System.exit(1); System.exit(1);
} }
// loads the fragment shader // loads the fragment shader
fragmentID = GL20.glCreateShader(GL20.GL_FRAGMENT_SHADER); fragmentID = GL20.glCreateShader(GL20.GL_FRAGMENT_SHADER);
GL20.glShaderSource(fragmentID, fragmentFile); GL20.glShaderSource(fragmentID, fragmentFile);
GL20.glCompileShader(fragmentID); GL20.glCompileShader(fragmentID);
if (GL20.glGetShaderi(fragmentID, GL20.GL_COMPILE_STATUS) == GL11.GL_FALSE) { if (GL20.glGetShaderi(fragmentID, GL20.GL_COMPILE_STATUS) == GL11.GL_FALSE) {
System.err.println("Fragment Shader: " + GL20.glGetShaderInfoLog(fragmentID)); System.err.println("Fragment Shader: " + GL20.glGetShaderInfoLog(fragmentID));
System.exit(1); System.exit(1);
} }
// Attach shaders to program // Attach shaders to program
GL20.glAttachShader(programID, vertexID); GL20.glAttachShader(programID, vertexID);
GL20.glAttachShader(programID, fragmentID); GL20.glAttachShader(programID, fragmentID);
// Link the program // Link the program
GL20.glLinkProgram(programID); GL20.glLinkProgram(programID);
if (GL20.glGetProgrami(programID, GL20.GL_LINK_STATUS) == GL11.GL_FALSE) { if (GL20.glGetProgrami(programID, GL20.GL_LINK_STATUS) == GL11.GL_FALSE) {
System.err.println("Program Linking: " + GL20.glGetProgramInfoLog(programID)); System.err.println("Program Linking: " + GL20.glGetProgramInfoLog(programID));
System.exit(1); System.exit(1);
return; return;
} }
// Validate the program // Validate the program
GL20.glValidateProgram(programID); GL20.glValidateProgram(programID);
if (GL20.glGetProgrami(programID, GL20.GL_VALIDATE_STATUS) == GL11.GL_FALSE) { if (GL20.glGetProgrami(programID, GL20.GL_VALIDATE_STATUS) == GL11.GL_FALSE) {
System.err.println("Program Validation: " + GL20.glGetProgramInfoLog(programID)); System.err.println("Program Validation: " + GL20.glGetProgramInfoLog(programID));
System.exit(1); System.exit(1);
return; return;
} }
GL20.glDeleteShader(vertexID); GL20.glDeleteShader(vertexID);
GL20.glDeleteShader(fragmentID); GL20.glDeleteShader(fragmentID);
} }
// Bind so we can use the shader // Bind so we can use the shader
public void bind() { public void bind() {
GL20.glUseProgram(programID); GL20.glUseProgram(programID);
} }
// Unbind the shader after use // Unbind the shader after use
public void unbind() { public void unbind() {
GL20.glUseProgram(0); GL20.glUseProgram(0);
} }
// Destroy the program // Destroy the program
public void destroy() { public void destroy() {
GL20.glDeleteProgram(programID); GL20.glDeleteProgram(programID);
} }
} }

133
src/org/hl/engine/graphics/Texture.java Normal file
View File

@ -0,0 +1,133 @@
package org.hl.engine.graphics;
import static org.lwjgl.opengl.GL46.*;
import static org.lwjgl.stb.STBImage.*;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import org.lwjgl.system.MemoryStack;
public class Texture {
private int id;
private int width;
private int height;
private int type;
private String fileName;
private ByteBuffer imageBuffer;
private int pixelFormat;
public Texture(int width, int height, int pixelFormat) {
this.type = 0;
this.width = width;
this.height = height;
this.pixelFormat = pixelFormat;
}
public Texture(String fileName) {
this.type = 1;
this.fileName = fileName;
}
public Texture(ByteBuffer imageBuffer) {
type = 2;
this.imageBuffer = imageBuffer;
}
public void create() {
if (this.type == 0) {
this.id = glGenTextures();
glBindTexture(GL_TEXTURE_2D, this.id);
glTexImage2D(GL_TEXTURE_2D, 0, this.pixelFormat, this.width, this.height, 0, this.pixelFormat, GL_FLOAT, (ByteBuffer) null);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
} else if (this.type == 1) {
ByteBuffer buf;
try(MemoryStack stack = MemoryStack.stackPush()) {
IntBuffer w = stack.mallocInt(1);
IntBuffer h = stack.mallocInt(1);
IntBuffer channels = stack.mallocInt(1);
buf = stbi_load(this.fileName, w, h, channels, 4);
if(buf == null) {
System.err.println("Image file [" + this.fileName + "] not loaded: " + stbi_failure_reason());
System.exit(1);
}
this.width = w.get();
this.height = h.get();
}
this.id = createTexture(buf);
stbi_image_free(buf);
} else {
ByteBuffer buf;
try(MemoryStack stack = MemoryStack.stackPush()) {
IntBuffer w = stack.mallocInt(1);
IntBuffer h = stack.mallocInt(1);
IntBuffer channels = stack.mallocInt(1);
buf = stbi_load_from_memory(this.imageBuffer, w, h, channels, 4);
if(buf == null) {
System.err.println("Image file not loaded: " + stbi_failure_reason());
System.exit(1);
}
this.width = w.get();
this.height = h.get();
}
this.id = createTexture(buf);
stbi_image_free(buf);
}
}
private int createTexture(ByteBuffer buf) {
int textureID = glGenTextures();
glBindTexture(GL_TEXTURE_2D, textureID);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf);
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
return textureID;
}
public int getWidth() {
return width;
}
public int getHeight() {
return height;
}
public int getId() {
return id;
}
public void destroy() {
glDeleteTextures(id);
}
}

34
src/org/hl/engine/graphics/Vertex.java
View File

@ -4,26 +4,26 @@ import org.hl.engine.math.lalg.*;
public class Vertex { public class Vertex {
// Just a vertex // Just a vertex
private Vector3f position; private Vector3f position;
private Vector3f color; private Vector3f color;
private Vector2f textureCoords; private Vector2f textureCoords;
public Vertex (Vector3f position, Vector3f color, Vector2f texture) { public Vertex (Vector3f position, Vector3f color, Vector2f texture) {
this.position = position; this.position = position;
this.color = color; this.color = color;
} }
public Vector3f getPosition() { public Vector3f getPosition() {
return position; return position;
} }
public Vector3f getColor() { public Vector3f getColor() {
return color; return color;
} }
public Vector2f getTextureCoords() { public Vector2f getTextureCoords() {
return textureCoords; return textureCoords;
} }
} }

316
src/org/hl/engine/io/Display.java
View File

@ -8,205 +8,207 @@ import org.lwjgl.opengl.GL11;
import static org.lwjgl.glfw.GLFW.*; import static org.lwjgl.glfw.GLFW.*;
public class Display { public class Display {
private int width, height; private int width, height;
private String windowName; private String windowName;
private long window; private long window;
public int frames; public int frames;
public int previousFrames = frames; public int previousFrames = frames;
public long time; public long time;
public Input input; public Input input;
private Vector3f background = new Vector3f(0, 0, 0); private Vector3f background = new Vector3f(0, 0, 0);
private GLFWWindowSizeCallback resizeCallback; private GLFWWindowSizeCallback resizeCallback;
private boolean isResized; private boolean isResized;
private boolean isFullscreen; private boolean isFullscreen;
private int[] windowXPos = new int[1]; private int[] windowXPos = new int[1];
private int[] windowYPos = new int[1]; private int[] windowYPos = new int[1];
private GLFWVidMode videoMode; private GLFWVidMode videoMode;
private int savedPosX; private int savedPosX;
private int savedPosY; private int savedPosY;
private int savedWidth; private int savedWidth;
private int savedHeight; private int savedHeight;
// Constructor to create the display // Constructor to create the display
public Display (int width, int height, String windowName) { public Display (int width, int height, String windowName) {
this.width = width; this.width = width;
this.height = height; this.height = height;
this.windowName = windowName; this.windowName = windowName;
} }
// Change the window name // Change the window name
public void setWindowName(String windowName) { public void setWindowName(String windowName) {
this.windowName = windowName; this.windowName = windowName;
glfwSetWindowTitle(window, windowName); glfwSetWindowTitle(window, windowName);
} }
// Getters for size, name, window, time, and fullScreen // Getters for size, name, window, time, and fullScreen
public int getWidth() { public int getWidth() {
return width; return width;
} }
public int getHeight() { public int getHeight() {
return height; return height;
} }
public String getWindowName() { public String getWindowName() {
return windowName; return windowName;
} }
public long getWindow() { public long getWindow() {
return window; return window;
} }
public long getTime() { public long getTime() {
return time; return time;
} }
public boolean isFullscreen() { public boolean isFullscreen() {
return isFullscreen; return isFullscreen;
} }
// Makes the screen fullscreen or not based on the argument // Makes the screen fullscreen or not based on the argument
public void setFullscreen(boolean fullscreen) { public void setFullscreen(boolean fullscreen) {
isFullscreen = fullscreen; isFullscreen = fullscreen;
isResized = true; isResized = true;
GL11.glViewport(0, 0, width, height); GL11.glViewport(0, 0, width, height);
if (isFullscreen) { if (isFullscreen) {
int[] xpos = {0}; int[] xpos = {0};
int[] ypos = {0}; int[] ypos = {0};
glfwGetWindowPos(this.window, xpos, ypos); glfwGetWindowPos(this.window, xpos, ypos);
savedPosX = xpos[0]; savedPosX = xpos[0];
savedPosY = ypos[0]; savedPosY = ypos[0];
savedWidth = width; savedWidth = width;
savedHeight = height; savedHeight = height;
glfwGetWindowPos(window, windowXPos, windowYPos); glfwGetWindowPos(window, windowXPos, windowYPos);
glfwSetWindowMonitor(window, glfwGetPrimaryMonitor(), 0, 0, videoMode.width(), videoMode.height(), 0); glfwSetWindowMonitor(window, glfwGetPrimaryMonitor(), 0, 0, videoMode.width(), videoMode.height(), 0);
} else { } else {
glfwSetWindowMonitor(window, 0, savedPosX, savedPosY, savedWidth, savedHeight, 0); glfwSetWindowMonitor(window, 0, savedPosX, savedPosY, savedWidth, savedHeight, 0);
} }
} }
// resized getter // resized getter
public boolean isResized() { public boolean isResized() {
return isResized; return isResized;
} }
// Creates the window (should go in the init() function of your Main program) // Creates the window (should go in the init() function of your Main program)
public void create() { public void create() throws Exception {
// initializing glfw // initializing glfw
if (!glfwInit()) { if (!glfwInit()) {
System.err.println("Failed to initialize GLFW! "); //System.err.println("Failed to initialize GLFW! ");
System.exit(1); //System.exit(1);
} throw new Exception("Failed to initialize GLFW! ");
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL11.GL_TRUE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL11.GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
//Creating window //Creating window
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
window = glfwCreateWindow(this.width, this.height, this.windowName, isFullscreen ? glfwGetPrimaryMonitor():0, 0); window = glfwCreateWindow(this.width, this.height, this.windowName, isFullscreen ? glfwGetPrimaryMonitor():0, 0);
if (window == 0) { if (window == 0) {
System.err.println("Failed to create window! "); //System.err.println("Failed to create window! ");
System.exit(1); //System.exit(1);
} throw new Exception("Failed to create window! ");
}
// Setting size of window // Setting size of window
videoMode = glfwGetVideoMode(glfwGetPrimaryMonitor()); videoMode = glfwGetVideoMode(glfwGetPrimaryMonitor());
windowXPos[0] = (videoMode.width() - this.width) / 2; windowXPos[0] = (videoMode.width() - this.width) / 2;
windowYPos[0] = (videoMode.height() - this.height ) / 2; windowYPos[0] = (videoMode.height() - this.height ) / 2;
glfwSetWindowPos(window, windowXPos[0], windowYPos[0]); glfwSetWindowPos(window, windowXPos[0], windowYPos[0]);
// Graphics // Graphics
glfwMakeContextCurrent(window); glfwMakeContextCurrent(window);
GL.createCapabilities(); GL.createCapabilities();
GL11.glEnable(GL11.GL_DEPTH_TEST); GL11.glEnable(GL11.GL_DEPTH_TEST);
callBacks(); callBacks();
glfwShowWindow(window); glfwShowWindow(window);
glfwSwapInterval(1); glfwSwapInterval(1);
// setting time // setting time
time = System.currentTimeMillis(); time = System.currentTimeMillis();
} }
// Creating the resize callback (all other callbacks were removed and are now in Input class) // Creating the resize callback (all other callbacks were removed and are now in Input class)
private void callBacks() { private void callBacks() {
resizeCallback = new GLFWWindowSizeCallback() { resizeCallback = new GLFWWindowSizeCallback() {
@Override @Override
public void invoke(long window, int w, int h) { public void invoke(long window, int w, int h) {
width = w; width = w;
height = h; height = h;
isResized = true; isResized = true;
} }
}; };
glfwSetWindowSizeCallback(window, resizeCallback); glfwSetWindowSizeCallback(window, resizeCallback);
} }
// Refreshes the screen, resets frame count // Refreshes the screen, resets frame count
public int update() { public int update() {
if (isResized) { if (isResized) {
GL11.glViewport(0, 0, width, height); GL11.glViewport(0, 0, width, height);
isResized = false; isResized = false;
} }
GL11.glClearColor(background.getX(), background.getY(), background.getZ(), 1.0F); GL11.glClearColor(background.getX(), background.getY(), background.getZ(), 1.0F);
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT); GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
glfwPollEvents(); glfwPollEvents();
frames++; frames++;
if (System.currentTimeMillis() > time + 1000) { if (System.currentTimeMillis() > time + 1000) {
previousFrames = frames; previousFrames = frames;
time = System.currentTimeMillis(); time = System.currentTimeMillis();
frames = 0; frames = 0;
return frames; return frames;
} else { } else {
return previousFrames; return previousFrames;
} }
} }
// Terminates the program (making WindowShouldClose) // Terminates the program (making WindowShouldClose)
public void terminate() { public void terminate() {
glfwSetWindowShouldClose(window, true); glfwSetWindowShouldClose(window, true);
} }
// Completely DESTROYS the window // Completely DESTROYS the window
public void destroy() { public void destroy() {
resizeCallback.free(); resizeCallback.free();
glfwDestroyWindow(window); glfwDestroyWindow(window);
glfwTerminate(); glfwTerminate();
} }
// switches the buffers (for rendering) // switches the buffers (for rendering)
public void swapBuffers() { public void swapBuffers() {
glfwSwapBuffers(window); glfwSwapBuffers(window);
} }
// get whether the window should close // get whether the window should close
public boolean shouldClose() { public boolean shouldClose() {
return glfwWindowShouldClose(window); return glfwWindowShouldClose(window);
} }
// changes the background color // changes the background color
public void setBackgroundColor(float r, float g, float b) { public void setBackgroundColor(float r, float g, float b) {
background.setVector(r, g, b); background.setVector(r, g, b);
} }
} }

164
src/org/hl/engine/io/Input.java
View File

@ -7,115 +7,115 @@ import java.util.Arrays;
import static org.lwjgl.glfw.GLFW.*; import static org.lwjgl.glfw.GLFW.*;
public class Input { public class Input {
private boolean[] keys = new boolean[GLFW.GLFW_KEY_LAST]; private boolean[] keys = new boolean[GLFW.GLFW_KEY_LAST];
private boolean[] buttons = new boolean[GLFW.GLFW_MOUSE_BUTTON_LAST]; private boolean[] buttons = new boolean[GLFW.GLFW_MOUSE_BUTTON_LAST];
private int[] keyState = new int[GLFW.GLFW_KEY_LAST]; private int[] keyState = new int[GLFW.GLFW_KEY_LAST];
private int[] buttonState = new int[GLFW.GLFW_MOUSE_BUTTON_LAST]; private int[] buttonState = new int[GLFW.GLFW_MOUSE_BUTTON_LAST];
private long window; private long window;
private Display display; private Display display;
private boolean inWindow; private boolean inWindow;
private double mouseX, mouseY; private double mouseX, mouseY;
private double scrollX, scrollY; private double scrollX, scrollY;
// Sets up the callbacks based on the window // Sets up the callbacks based on the window
public Input(Display d) { public Input(Display d) {
this.display = d; this.display = d;
this.window = this.display.getWindow(); this.window = this.display.getWindow();
glfwSetKeyCallback(this.window, (window, key, scancode, action, mods) -> { glfwSetKeyCallback(this.window, (window, key, scancode, action, mods) -> {
keys[key] = action != GLFW.GLFW_RELEASE; keys[key] = action != GLFW.GLFW_RELEASE;
keyState[key] = action; keyState[key] = action;
}); });
glfwSetMouseButtonCallback(this.window, (window, button, action, mods) -> { glfwSetMouseButtonCallback(this.window, (window, button, action, mods) -> {
buttons[button] = action != GLFW.GLFW_RELEASE; buttons[button] = action != GLFW.GLFW_RELEASE;
buttonState[button] = action; buttonState[button] = action;
}); });
glfwSetCursorPosCallback(this.window, (window, xpos, ypos) -> { glfwSetCursorPosCallback(this.window, (window, xpos, ypos) -> {
mouseX = xpos; mouseX = xpos;
mouseY = ypos; mouseY = ypos;
}); });
glfwSetCursorEnterCallback(this.window, (window, entered) -> { glfwSetCursorEnterCallback(this.window, (window, entered) -> {
inWindow = entered; inWindow = entered;
}); });
glfwSetScrollCallback(this.window, (window, xoffset, yoffset) -> { glfwSetScrollCallback(this.window, (window, xoffset, yoffset) -> {
scrollX += xoffset; scrollX += xoffset;
scrollY += yoffset; scrollY += yoffset;
}); });
resetKeyboard(); resetKeyboard();
resetButtons(); resetButtons();
} }
// All states (is<name>Down will return whether it has been held down but <name>Press only returns a press) // All states (is<name>Down will return whether it has been held down but <name>Press only returns a press)
public boolean isKeyDown(int key) { public boolean isKeyDown(int key) {
return keys[key]; return keys[key];
} }
public boolean keyPress(int key) { public boolean keyPress(int key) {
return keyState[key] == GLFW.GLFW_PRESS; return keyState[key] == GLFW.GLFW_PRESS;
} }
public boolean keyReleased(int key) { public boolean keyReleased(int key) {
return keyState[key] == GLFW.GLFW_RELEASE; return keyState[key] == GLFW.GLFW_RELEASE;
} }
public boolean isButtonDown(int button) { public boolean isButtonDown(int button) {
return buttons[button]; return buttons[button];
} }
public boolean buttonPress(int button) { public boolean buttonPress(int button) {
return buttonState[button] == GLFW.GLFW_PRESS; return buttonState[button] == GLFW.GLFW_PRESS;
} }
public boolean buttonReleased(int button) { public boolean buttonReleased(int button) {
return buttonState[button] == GLFW.GLFW_RELEASE; return buttonState[button] == GLFW.GLFW_RELEASE;
} }
// Resets keyboard and buttons so the presses will only be registered once // Resets keyboard and buttons so the presses will only be registered once
private void resetKeyboard() { private void resetKeyboard() {
Arrays.fill(keyState, -1); Arrays.fill(keyState, -1);
} }
private void resetButtons() { private void resetButtons() {
Arrays.fill(buttonState, -1); Arrays.fill(buttonState, -1);
} }
// This function should only be called after all input has been taken inside the loop. It must be called if keyPress and buttonPress should work. // This function should only be called after all input has been taken inside the loop. It must be called if keyPress and buttonPress should work.
public void reset() { public void reset() {
resetKeyboard(); resetKeyboard();
resetButtons(); resetButtons();
} }
// Scroll, mouse, and window getters // Scroll, mouse, and window getters
public double getMouseX() { public double getMouseX() {
return mouseX; return mouseX;
} }
public double getMouseY() { public double getMouseY() {
return mouseY; return mouseY;
} }
public boolean inWindow() { public boolean inWindow() {
return inWindow; return inWindow;
} }
public double getScrollX() { public double getScrollX() {
return scrollX; return scrollX;
} }
public double getScrollY() { public double getScrollY() {
return scrollY; return scrollY;
} }
} }

46
src/org/hl/engine/math/lalg/Vector2f.java
View File

@ -1,33 +1,33 @@
package org.hl.engine.math.lalg; package org.hl.engine.math.lalg;
public class Vector2f { public class Vector2f {
private float x; private float x;
private float y; private float y;
// Just a vector if you know what I mean // Just a vector if you know what I mean
public Vector2f (float x, float y) { public Vector2f (float x, float y) {
this.x = x; this.x = x;
this.y = y; this.y = y;
} }
public void setVector(float x, float y) { public void setVector(float x, float y) {
this.x = x; this.x = x;
this.y = y; this.y = y;
} }
public float getX() { public float getX() {
return x; return x;
} }
public void setX(float x) { public void setX(float x) {
this.x = x; this.x = x;
} }
public float getY() { public float getY() {
return y; return y;
} }
public void setY(float y) { public void setY(float y) {
this.y = y; this.y = y;
} }
} }

64
src/org/hl/engine/math/lalg/Vector3f.java
View File

@ -1,44 +1,44 @@
package org.hl.engine.math.lalg; package org.hl.engine.math.lalg;
public class Vector3f { public class Vector3f {
private float x; private float x;
private float y; private float y;
private float z; private float z;
// Just a vector if you know what I mean // Just a vector if you know what I mean
public Vector3f (float x, float y, float z) { public Vector3f (float x, float y, float z) {
this.x = x; this.x = x;
this.y = y; this.y = y;
this.z = z; this.z = z;
} }
public void setVector(float x, float y, float z) { public void setVector(float x, float y, float z) {
this.x = x; this.x = x;
this.y = y; this.y = y;
this.z = z; this.z = z;
} }
public float getX() { public float getX() {
return x; return x;
} }
public void setX(float x) { public void setX(float x) {
this.x = x; this.x = x;
} }
public float getY() { public float getY() {
return y; return y;
} }
public void setY(float y) { public void setY(float y) {
this.y = y; this.y = y;
} }
public float getZ() { public float getZ() {
return z; return z;
} }
public void setZ(float z) { public void setZ(float z) {
this.z = z; this.z = z;
} }
} }

55
src/org/hl/engine/math/lalg/Vector4f.java Normal file
View File

@ -0,0 +1,55 @@
package org.hl.engine.math.lalg;
public class Vector4f {
private float x;
private float y;
private float z;
private float a;
// Just a vector if you know what I mean
public Vector4f (float x, float y, float z, float a) {
this.x = x;
this.y = y;
this.z = z;
this.a = a;
}
public void setVector(float x, float y, float z, float a) {
this.x = x;
this.y = y;
this.z = z;
this.a = a;
}
public float getX() {
return x;
}
public void setX(float x) {
this.x = x;
}
public float getY() {
return y;
}
public void setY(float y) {
this.y = y;
}
public float getZ() {
return z;
}
public void setZ(float z) {
this.z = z;
}
public float getA() {
return a;
}
public void setA(float a) {
this.a = a;
}
}

30
src/org/hl/engine/utils/FileUtils.java
View File

@ -7,22 +7,22 @@ import java.io.InputStreamReader;
public class FileUtils { public class FileUtils {
// Reads a filepath and returns that as a String // Reads a filepath and returns that as a String
public static String loadAsString(String filepath) { public static String loadAsString(String filepath) {
StringBuilder result = new StringBuilder(); StringBuilder result = new StringBuilder();
try (BufferedReader reader = new BufferedReader(new try (BufferedReader reader = new BufferedReader(new
InputStreamReader(FileUtils.class.getResourceAsStream(filepath)))) { InputStreamReader(FileUtils.class.getResourceAsStream(filepath)))) {
String line = ""; String line = "";
while ((line = reader.readLine()) != null) { while ((line = reader.readLine()) != null) {
result.append(line) .append("\n"); result.append(line) .append("\n");
} }
} catch (Exception e) { } catch (Exception e) {
System.err.println("Couldn't get the file at " + filepath); System.err.println("Couldn't get the file at " + filepath);
System.exit(1); System.exit(1);
} }
return result.toString(); return result.toString();
} }
} }

84
src/org/hl/engine/utils/TextureLoader.java
View File

@ -14,57 +14,57 @@ import org.lwjgl.opengl.GL12;
import static org.lwjgl.opengl.GL11.*; import static org.lwjgl.opengl.GL11.*;
public class TextureLoader { public class TextureLoader {
private static final int BYTES_PER_PIXEL = 4;//3 for RGB, 4 for RGBA private static final int BYTES_PER_PIXEL = 4;//3 for RGB, 4 for RGBA
public static int loadTexture(BufferedImage image){ public static int loadTexture(BufferedImage image){
int[] pixels = new int[image.getWidth() * image.getHeight()]; int[] pixels = new int[image.getWidth() * image.getHeight()];
image.getRGB(0, 0, image.getWidth(), image.getHeight(), pixels, 0, image.getWidth()); image.getRGB(0, 0, image.getWidth(), image.getHeight(), pixels, 0, image.getWidth());
ByteBuffer buffer = BufferUtils.createByteBuffer(image.getWidth() * image.getHeight() * BYTES_PER_PIXEL); //4 for RGBA, 3 for RGB ByteBuffer buffer = BufferUtils.createByteBuffer(image.getWidth() * image.getHeight() * BYTES_PER_PIXEL); //4 for RGBA, 3 for RGB
for(int y = 0; y < image.getHeight(); y++){ for(int y = 0; y < image.getHeight(); y++){
for(int x = 0; x < image.getWidth(); x++){ for(int x = 0; x < image.getWidth(); x++){
int pixel = pixels[y * image.getWidth() + x]; int pixel = pixels[y * image.getWidth() + x];
buffer.put((byte) ((pixel >> 16) & 0xFF)); // Red component buffer.put((byte) ((pixel >> 16) & 0xFF)); // Red component
buffer.put((byte) ((pixel >> 8) & 0xFF)); // Green component buffer.put((byte) ((pixel >> 8) & 0xFF)); // Green component
buffer.put((byte) (pixel & 0xFF)); // Blue component buffer.put((byte) (pixel & 0xFF)); // Blue component
buffer.put((byte) ((pixel >> 24) & 0xFF)); // Alpha component. Only for RGBA buffer.put((byte) ((pixel >> 24) & 0xFF)); // Alpha component. Only for RGBA
} }
} }
buffer.flip(); //FOR THE LOVE OF GOD DO NOT FORGET THIS buffer.flip(); //FOR THE LOVE OF GOD DO NOT FORGET THIS
// You now have a ByteBuffer filled with the color data of each pixel. // You now have a ByteBuffer filled with the color data of each pixel.
// Now just create a texture ID and bind it. Then you can load it using // Now just create a texture ID and bind it. Then you can load it using
// whatever OpenGL method you want, for example: // whatever OpenGL method you want, for example:
int textureID = glGenTextures(); //Generate texture ID int textureID = glGenTextures(); //Generate texture ID
glBindTexture(GL_TEXTURE_2D, textureID); //Bind texture ID glBindTexture(GL_TEXTURE_2D, textureID); //Bind texture ID
//Setup wrap mode //Setup wrap mode
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
//Setup texture scaling filtering //Setup texture scaling filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//Send texel data to OpenGL //Send texel data to OpenGL
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, image.getWidth(), image.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, image.getWidth(), image.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
//Return the texture ID so we can bind it later again //Return the texture ID so we can bind it later again
return textureID; return textureID;
} }
public static BufferedImage loadImage(String loc) public static BufferedImage loadImage(String loc)
{ {
try { try {
return ImageIO.read(TextureLoader.class.getResource(loc)); return ImageIO.read(TextureLoader.class.getResource(loc));
} catch (IOException e) { } catch (IOException e) {
//Error Handling Here //Error Handling Here
System.err.println("Error with loading texture. "); System.err.println("Error with loading texture. ");
System.exit(1); System.exit(1);
} }
return null; return null;
} }
} }

2
src/resources/shaders/mainFragment.glsl
View File

@ -1,4 +1,4 @@
#version 460 core #version 410 core
in vec3 passColor; in vec3 passColor;
in vec2 passTextureCoord; in vec2 passTextureCoord;

2
src/resources/shaders/mainVertex.glsl
View File

@ -1,4 +1,4 @@
#version 460 core #version 410 core
in vec3 position; in vec3 position;
in vec3 color; in vec3 color;