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()
}
def lwjgl_ver = '2.9.3'
dependencies {
compile (['org.lwjgl.lwjgl:lwjgl:'+lwjgl_ver],
['org.lwjgl.lwjgl:lwjgl_util:'+lwjgl_ver])
def lwjgl_version = '3.0.0b';
compile (['org.lwjgl:lwjgl:' + lwjgl_version],
['org.lwjgl:lwjgl-platform:' + lwjgl_version + ':natives-linux'])
}
sourceSets {

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

@@ -1,37 +1,47 @@
package ru.dmitriymx.lwjgl.tools;
import org.lwjgl.BufferUtils;
import java.nio.FloatBuffer;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL15.*;
import java.nio.FloatBuffer;
import org.lwjgl.BufferUtils;
/**
* Инструмент, облегчающий рисование объектов в OpenGL
*
* @author DmitriyMX <mail@dmitriymx.ru>
* 2015
*/
public class Tessellator {
private static Tessellator instance = new Tessellator();
private int draw_mode;
private float[] float_buffer;
private int float_buffer_position;
private boolean use_dl, use_vbo, use_va;
private int vertex_count;
private boolean use_color, use_texture;
private int display_list_id;
private Tessellator() {
float_buffer = new float[0x200000];
}
private static final Tessellator instance = new Tessellator();
private int draw_mode = 0;
private boolean use_dl = false;
private boolean use_vbo = false;
private boolean use_va = false;
private int display_list_id = 0;
private float[] float_buffer = new float[0x200000];
private int float_buffer_index = 0;
private int vertex_count = 0;
private boolean has_color = false;
private boolean has_texture = false;
public static Tessellator getInstance() {
return instance;
}
public void reset() {
private Tessellator() {
}
private void reset() {
use_dl = false;
display_list_id = 0;
use_vbo = false;
draw_mode = 0;
vertex_count = 0;
float_buffer_position = 0;
use_color = false;
use_texture = false;
float_buffer_index = 0;
has_color = false;
has_texture = false;
}
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) {
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) {
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) {
use_dl = true;
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) {
glCallList(displayListId);
}
// VERTEX BUFFER OBJECT (VBO) =============================================
public void startDrawingUseVBO(int drawMode) {
draw_mode = drawMode;
use_vbo = true;
public void removeDL(int displayListId) {
glDeleteLists(displayListId, 1);
}
// =================================================================================================================
private void vbo_add_vertex(float x, float y, float z) {
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) ======================================================
// VERTEX ARRAY (VA) ===============================================================================================
public void startDrawingUseVA(int drawMode) {
use_va = true;
draw_mode = drawMode;
use_color = false; // TODO а надоли? есть же reset()
use_texture = false;
has_color = false;
has_texture = false;
}
private void va_add_vertex(float x, float y, float z) {
float_buffer[float_buffer_position] = x;
float_buffer[float_buffer_position + 1] = y;
float_buffer[float_buffer_position + 2] = z;
float_buffer[float_buffer_index] = x;
float_buffer[float_buffer_index + 1] = y;
float_buffer[float_buffer_index + 2] = z;
float_buffer_position += 9;
float_buffer_index += 9;
vertex_count++;
}
private void va_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;
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 va_set_texture(float u, float v) {
float_buffer[float_buffer_position + 3] = u;
float_buffer[float_buffer_position + 4] = v;
use_texture = true;
float_buffer[float_buffer_index + 3] = u;
float_buffer[float_buffer_index + 4] = v;
has_texture = true;
}
public void drawVA() {
if (use_va) {
if (vertex_count > 0) {
FloatBuffer va_buffer = BufferUtils.createFloatBuffer(float_buffer_position);
va_buffer.put(float_buffer, 0, float_buffer_position);
FloatBuffer va_buffer = BufferUtils.createFloatBuffer(float_buffer_index);
va_buffer.put(float_buffer, 0, float_buffer_index);
va_buffer.flip();
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, 9 << 2, va_buffer);
glVertexPointer(3, GL_FLOAT, 9 << 2, va_buffer);
// 1 float = 32 bits = 4 bytes
// => sizeOf(float) * 9 = (4 bytes) * 9 = _36 bytes_ = (9 << 2)
if (use_color) {
if (has_color) {
va_buffer.position(5);
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);
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);
if (use_texture)
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if (use_color)
glDisableClientState(GL_COLOR_ARRAY);
if (has_texture) glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if (has_color) glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);