Voomra/lwjgl-tools
Archived
0
Fork 0
Code Activity

Update LWJGL -> 3.0.0b

Browse Source
This commit is contained in:
DmitriyMX
2016-03-08 19:11:09 +03:00
parent acc146d06a
commit 93f9270695
2 changed files with 157 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
build.gradle
View File

@@ -6,11 +6,10 @@ repositories {
mavenCentral() mavenCentral()
} }
def lwjgl_ver = '2.9.3'
dependencies { dependencies {
compile (['org.lwjgl.lwjgl:lwjgl:'+lwjgl_ver], def lwjgl_version = '3.0.0b';
['org.lwjgl.lwjgl:lwjgl_util:'+lwjgl_ver]) compile (['org.lwjgl:lwjgl:' + lwjgl_version],
['org.lwjgl:lwjgl-platform:' + lwjgl_version + ':natives-linux'])
} }
sourceSets { sourceSets {

297
src/java/ru/dmitriymx/lwjgl/tools/Tessellator.java
View File

@@ -1,37 +1,47 @@
package ru.dmitriymx.lwjgl.tools; package ru.dmitriymx.lwjgl.tools;
import org.lwjgl.BufferUtils;
import java.nio.FloatBuffer;
import static org.lwjgl.opengl.GL11.*; import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL15.*; import static org.lwjgl.opengl.GL15.*;
import java.nio.FloatBuffer; /**
* Инструмент, облегчающий рисование объектов в OpenGL
import org.lwjgl.BufferUtils; *
* @author DmitriyMX <mail@dmitriymx.ru>
* 2015
*/
public class Tessellator { public class Tessellator {
private static Tessellator instance = new Tessellator(); private static final Tessellator instance = new Tessellator();
private int draw_mode; private int draw_mode = 0;
private float[] float_buffer; private boolean use_dl = false;
private int float_buffer_position; private boolean use_vbo = false;
private boolean use_dl, use_vbo, use_va; private boolean use_va = false;
private int vertex_count; private int display_list_id = 0;
private boolean use_color, use_texture; private float[] float_buffer = new float[0x200000];
private int display_list_id; private int float_buffer_index = 0;
private int vertex_count = 0;
private Tessellator() { private boolean has_color = false;
float_buffer = new float[0x200000]; private boolean has_texture = false;
}
public static Tessellator getInstance() { public static Tessellator getInstance() {
return instance; return instance;
} }
public void reset() { private Tessellator() {
}
private void reset() {
use_dl = false;
display_list_id = 0;
use_vbo = false; use_vbo = false;
draw_mode = 0; draw_mode = 0;
vertex_count = 0; vertex_count = 0;
float_buffer_position = 0; float_buffer_index = 0;
use_color = false; has_color = false;
use_texture = false; has_texture = false;
} }
public void addVertex(float x, float y, float z) { public void addVertex(float x, float y, float z) {
@@ -71,13 +81,108 @@ public class Tessellator {
public Tessellator setColor(float red, float green, float blue) { public Tessellator setColor(float red, float green, float blue) {
return setColor(red, green, blue, 1f); return setColor(red, green, blue, 1f);
} }
public Tessellator setColor(float[] colorf) {
if (colorf.length == 3)
return setColor(colorf[0], colorf[1], colorf[2]);
else
return setColor(colorf[0], colorf[1], colorf[2], colorf[3]);
}
public Tessellator setColor(Color4f color4f) { public Tessellator setColor(Color4f color4f) {
return setColor(color4f.getRed(), color4f.getGreen(), color4f.getBlue(), color4f.getAlpha()); return setColor(color4f.getRed(), color4f.getGreen(), color4f.getBlue(), color4f.getAlpha());
} }
// DISPLAY LIST (DL) ====================================================== // VERTEX BUFFER OBJECT (VBO) ======================================================================================
public void startDrawingUseVBO(int drawMode) {
draw_mode = drawMode;
use_vbo = true;
}
private void vbo_add_vertex(float x, float y, float z) {
float_buffer[float_buffer_index] = x;
float_buffer[float_buffer_index + 1] = y;
float_buffer[float_buffer_index + 2] = z;
float_buffer_index += 9;
vertex_count++;
}
private void vbo_set_color(float red, float green, float blue, float alpha) {
float_buffer[float_buffer_index + 5] = red;
float_buffer[float_buffer_index + 6] = green;
float_buffer[float_buffer_index + 7] = blue;
float_buffer[float_buffer_index + 8] = alpha;
has_color = true;
}
private void vbo_set_texture(float u, float v) {
float_buffer[float_buffer_index + 3] = u;
float_buffer[float_buffer_index + 4] = v;
has_texture = true;
}
public int createVBO() {
if (use_vbo) {
if (vertex_count > 0) {
FloatBuffer vbo_buffer = BufferUtils.createFloatBuffer(float_buffer_index);
vbo_buffer.put(float_buffer, 0, float_buffer_index);
vbo_buffer.flip();
int vboId = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, vboId);
glBufferData(GL_ARRAY_BUFFER, vbo_buffer, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
int r2 = vboId | (draw_mode << 8) | (vertex_count << 16) | ((has_color ? 1 : 0) << 24) | ((has_texture ? 1 : 0) << 32);
reset();
return r2;
} else {
throw new IllegalAccessError("Vertex count < 1");
}
} else {
throw new IllegalAccessError("Drawing with vertex buffer object not started");
}
}
public void drawVBO(long vboData) {
glBindBuffer(GL_ARRAY_BUFFER, (int) (0b11111111 & vboData));
boolean has_color = (0b11111111 & vboData >>> 24) == 1;
boolean has_texture = (0b11111111 & vboData >>> 32) == 1;
if (has_color) {
glEnableClientState(GL_COLOR_ARRAY);
// 12L -> 3 << 2
glColorPointer(4, GL_FLOAT, 9 << 2, 5 << 2);
}
if (has_texture) {
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// X << 3 -> (X * 2) << 2
glTexCoordPointer(2, GL_FLOAT, 9 << 2, 3 << 2);
}
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 9 << 2, 0);
glDrawArrays((int) (0b11111111 & vboData >>> 8), 0, (int) (0b11111111 & vboData >>> 16));
if (has_texture) {
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
if (has_color) {
glDisableClientState(GL_COLOR_ARRAY);
}
glDisableClientState(GL_VERTEX_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
public void removeVBO(long vboData) {
glDeleteBuffers((int) (0b11111111 & vboData));
}
// =================================================================================================================
// DISPLAY LIST (DL) ===============================================================================================
public void startDrawingUseDL(int drawMode) { public void startDrawingUseDL(int drawMode) {
use_dl = true; use_dl = true;
display_list_id = glGenLists(1); display_list_id = glGenLists(1);
@@ -109,167 +214,73 @@ public class Tessellator {
} }
} }
public void removeDL(int displayListId) {
glDeleteLists(displayListId, 1);
}
public void drawDL(int displayListId) { public void drawDL(int displayListId) {
glCallList(displayListId); glCallList(displayListId);
} }
// VERTEX BUFFER OBJECT (VBO) ============================================= public void removeDL(int displayListId) {
glDeleteLists(displayListId, 1);
public void startDrawingUseVBO(int drawMode) {
draw_mode = drawMode;
use_vbo = true;
} }
// =================================================================================================================
private void vbo_add_vertex(float x, float y, float z) { // VERTEX ARRAY (VA) ===============================================================================================
float_buffer[float_buffer_position] = x;
float_buffer[float_buffer_position + 1] = y;
float_buffer[float_buffer_position + 2] = z;
float_buffer_position += 9;
vertex_count++;
}
private void vbo_set_color(float red, float green, float blue, float alpha) {
float_buffer[float_buffer_position + 5] = red;
float_buffer[float_buffer_position + 6] = green;
float_buffer[float_buffer_position + 7] = blue;
float_buffer[float_buffer_position + 8] = alpha;
use_color = true;
}
private void vbo_set_texture(float u, float v) {
float_buffer[float_buffer_position + 3] = u;
float_buffer[float_buffer_position + 4] = v;
use_texture = true;
}
public int createVBO() {
if (use_vbo) {
if (vertex_count > 0) {
FloatBuffer vbo_buffer = BufferUtils.createFloatBuffer(float_buffer_position);
vbo_buffer.put(float_buffer, 0, float_buffer_position);
vbo_buffer.flip();
int vboId = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, vboId);
glBufferData(GL_ARRAY_BUFFER, vbo_buffer, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
int r2 = vboId | (draw_mode << 8) | (vertex_count << 16) | ((use_color ? 1 : 0) << 24) | ((use_texture ? 1 : 0) << 32);
reset();
return r2;
} else {
throw new IllegalAccessError("Vertex count < 1");
}
} else {
throw new IllegalAccessError("Drawing with vertex buffer object not started");
}
}
public void removeVBO(long vboData) {
glDeleteBuffers((int) (0b11111111 & vboData));
}
public void drawVBO(int vboData) {
glBindBuffer(GL_ARRAY_BUFFER, (int) (0b11111111 & vboData));
boolean has_color = (0b11111111 & vboData >>> 24) == 1;
boolean has_texture = (0b11111111 & vboData >>> 32) == 1;
if (has_color) {
glEnableClientState(GL_COLOR_ARRAY);
// 12L -> 3 << 2
glColorPointer(4, GL_FLOAT, 9 << 2, 5 << 2);
}
if (has_texture) {
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// X << 3 -> (X * 2) << 2
glTexCoordPointer(2, GL_FLOAT, 9 << 2, 3 << 2);
}
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 9 << 2, 0);
glDrawArrays((int) (0b11111111 & vboData >>> 8), 0, (int) (0b11111111 & vboData >>> 16));
if (has_texture) {
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
if (has_color) {
glDisableClientState(GL_COLOR_ARRAY);
}
glDisableClientState(GL_VERTEX_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
// VERTEX ARRAY (VA) ======================================================
public void startDrawingUseVA(int drawMode) { public void startDrawingUseVA(int drawMode) {
use_va = true; use_va = true;
draw_mode = drawMode; draw_mode = drawMode;
use_color = false; // TODO а надоли? есть же reset() has_color = false;
use_texture = false; has_texture = false;
} }
private void va_add_vertex(float x, float y, float z) { private void va_add_vertex(float x, float y, float z) {
float_buffer[float_buffer_position] = x; float_buffer[float_buffer_index] = x;
float_buffer[float_buffer_position + 1] = y; float_buffer[float_buffer_index + 1] = y;
float_buffer[float_buffer_position + 2] = z; float_buffer[float_buffer_index + 2] = z;
float_buffer_position += 9; float_buffer_index += 9;
vertex_count++; vertex_count++;
} }
private void va_set_color(float red, float green, float blue, float alpha) { private void va_set_color(float red, float green, float blue, float alpha) {
float_buffer[float_buffer_position + 5] = red; float_buffer[float_buffer_index + 5] = red;
float_buffer[float_buffer_position + 6] = green; float_buffer[float_buffer_index + 6] = green;
float_buffer[float_buffer_position + 7] = blue; float_buffer[float_buffer_index + 7] = blue;
float_buffer[float_buffer_position + 8] = alpha; float_buffer[float_buffer_index + 8] = alpha;
has_color = true;
use_color = true;
} }
private void va_set_texture(float u, float v) { private void va_set_texture(float u, float v) {
float_buffer[float_buffer_position + 3] = u; float_buffer[float_buffer_index + 3] = u;
float_buffer[float_buffer_position + 4] = v; float_buffer[float_buffer_index + 4] = v;
has_texture = true;
use_texture = true;
} }
public void drawVA() { public void drawVA() {
if (use_va) { if (use_va) {
if (vertex_count > 0) { if (vertex_count > 0) {
FloatBuffer va_buffer = BufferUtils.createFloatBuffer(float_buffer_position); FloatBuffer va_buffer = BufferUtils.createFloatBuffer(float_buffer_index);
va_buffer.put(float_buffer, 0, float_buffer_position); va_buffer.put(float_buffer, 0, float_buffer_index);
va_buffer.flip(); va_buffer.flip();
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, 9 << 2, va_buffer); glVertexPointer(3, GL_FLOAT, 9 << 2, va_buffer);
// 1 float = 32 bits = 4 bytes // 1 float = 32 bits = 4 bytes
// => sizeOf(float) * 9 = (4 bytes) * 9 = _36 bytes_ = (9 << 2) // => sizeOf(float) * 9 = (4 bytes) * 9 = _36 bytes_ = (9 << 2)
if (use_color) { if (has_color) {
va_buffer.position(5); va_buffer.position(5);
glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, 9 << 2, va_buffer); glColorPointer(4, GL_FLOAT, 9 << 2, va_buffer);
} }
if (use_texture) { if (has_texture) {
va_buffer.position(3); va_buffer.position(3);
glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, 9 << 2, va_buffer); glTexCoordPointer(2, GL_FLOAT, 9 << 2, va_buffer);
} }
glDrawArrays(draw_mode, 0, vertex_count); glDrawArrays(draw_mode, 0, vertex_count);
if (use_texture) if (has_texture) glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY); if (has_color) glDisableClientState(GL_COLOR_ARRAY);
if (use_color)
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_VERTEX_ARRAY);