com.opengrave.og.base.Renderable2D.java Source code

Introduction

Here is the source code for com.opengrave.og.base.Renderable2D.java

Source

/*
 * Copyright 2016 Nathan Howard
 * 
 * This file is part of OpenGrave
 * 
 * OpenGrave is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * OpenGrave is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with OpenGrave. If not, see <http://www.gnu.org/licenses/>.
 */
package com.opengrave.og.base;

import java.nio.FloatBuffer;
import java.util.ArrayList;

import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.*;

import com.opengrave.og.Util;
import com.opengrave.og.light.Shadow;
import com.opengrave.og.resources.RenderStyle;
import com.opengrave.og.resources.Resources;
import com.opengrave.og.resources.Texture;
import com.opengrave.og.util.Matrix4f;
import com.opengrave.og.util.Vector3f;

public abstract class Renderable2D extends Renderable {

    protected Vector3f location2d = new Vector3f();
    ArrayList<Vertex2D> vertexList = new ArrayList<Vertex2D>();
    FloatBuffer posBuffer = BufferUtils.createFloatBuffer(0), colBuffer = BufferUtils.createFloatBuffer(0),
            texBuffer = BufferUtils.createFloatBuffer(0);
    int vaoID = 0, vbopID = 0, vbocID = 0, vbotID = 0;
    protected Texture texture;

    public static void init() {
    }

    @Override
    public void addVertex(VertexData vd) {
        if (vd instanceof Vertex2D) {
            vertexList.add((Vertex2D) vd);
        }
    }

    @Override
    public void dealWithChange() {
        Util.checkErr();
        if (vaoID == 0) {
            vaoID = GL30.glGenVertexArrays();
        }
        GL30.glBindVertexArray(vaoID);
        Util.checkErr();
        if (vbopID == 0) {
            vbopID = GL15.glGenBuffers();
        }
        Util.checkErr();
        if (vbocID == 0) {
            vbocID = GL15.glGenBuffers();
        }
        Util.checkErr();
        if (vbotID == 0) {
            vbotID = GL15.glGenBuffers();
        }
        Util.checkErr();
        if (changed) {
            changed = false;
            vertexList.clear();
            posBuffer.clear();
            colBuffer.clear();
            texBuffer.clear();
            recreate();
            Util.checkErr();
            int verts = vertexList.size();
            if (vertexList.size() == 0) {
                return;
            }
            if (posBuffer.capacity() != verts * 2) {
                posBuffer = BufferUtils.createFloatBuffer(verts * 2);
            }
            Util.checkErr();
            if (colBuffer.capacity() != verts * 4) {
                colBuffer = BufferUtils.createFloatBuffer(verts * 4);
            }
            if (texBuffer.capacity() != verts * 3) {
                texBuffer = BufferUtils.createFloatBuffer(verts * 3);
            }
            for (Vertex2D v2 : vertexList) {
                posBuffer.put(v2.x).put(v2.y);
                texBuffer.put(v2.tx).put(v2.ty).put(v2.tz);
                colBuffer.put(v2.r).put(v2.g).put(v2.b).put(v2.a);
            }
            posBuffer.flip();
            texBuffer.flip();
            colBuffer.flip();
            GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbopID);
            GL15.glBufferData(GL15.GL_ARRAY_BUFFER, posBuffer, GL15.GL_STREAM_DRAW);
            GL20.glVertexAttribPointer(0, 2, GL11.GL_FLOAT, false, 0, 0);
            Util.checkErr();
            GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbocID);
            GL15.glBufferData(GL15.GL_ARRAY_BUFFER, colBuffer, GL15.GL_STREAM_DRAW);
            GL20.glVertexAttribPointer(1, 4, GL11.GL_FLOAT, false, 0, 0);
            Util.checkErr();
            GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbotID);
            GL15.glBufferData(GL15.GL_ARRAY_BUFFER, texBuffer, GL15.GL_STREAM_DRAW);
            GL20.glVertexAttribPointer(2, 3, GL11.GL_FLOAT, false, 0, 0);
            Util.checkErr();
            GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);

        }
    }

    @Override
    public void renderForPicking(Matrix4f matrix, Pickable object) {
        dealWithChange();
        if (vertexList.size() == 0) {
            return;
        }
        int pID = Resources.loadShader("pickinggui.vs", "pickinggui.fs").getProgram();
        GL20.glUseProgram(pID);
        GL30.glBindVertexArray(vaoID);
        GL20.glEnableVertexAttribArray(0);
        Util.setMatrices(pID, location2d);
        Picking.registerObject(pID, getContext(), object);
        GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, vertexList.size());
        GL20.glDisableVertexAttribArray(0);
        GL30.glBindVertexArray(0);
        GL20.glUseProgram(0);
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
        GL30.glBindVertexArray(0);
    }

    @Override
    public void renderShadows(Matrix4f matrix, Shadow shadow) {
        // GUI never casts shadow
    }

    @Override
    public void render(Matrix4f matrix, RenderStyle style) {
        Util.checkErr();
        dealWithChange();
        Util.checkErr();
        if (vertexList.size() == 0) {
            return;
        }
        int pID = Resources.loadShader("gui.vs", "gui.fs").getProgram();
        GL20.glUseProgram(pID);
        GL30.glBindVertexArray(vaoID);
        GL20.glEnableVertexAttribArray(0);
        GL20.glEnableVertexAttribArray(1);
        GL20.glEnableVertexAttribArray(2);
        Util.checkErr();
        if (texture != null) {
            texture.bind(GL13.GL_TEXTURE0);
        }
        Util.setMatrices(pID, location2d);
        Util.checkErr();

        GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, vertexList.size());
        Util.checkErr();
        if (texture != null) {
            texture.unbind();
        }
        GL20.glDisableVertexAttribArray(0);
        GL20.glDisableVertexAttribArray(1);
        GL20.glDisableVertexAttribArray(2);
        Util.checkErr();

        GL30.glBindVertexArray(0);
        GL20.glUseProgram(0);
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
        GL30.glBindVertexArray(0);
        Util.checkErr();
    }

    public int textureIndex = 0;

    public void setTextureIndex(int i) {
        // If using an atlas, specify which texture we use
        textureIndex = i;
        setChanged();
    }

}