为什么在创建 VBO 时静态方法会占用内存？

Question

I have a program that draws six fields on screen that contain around 2000 vertices per. To create the VBOs for these I need to use Buffer objects (Int/Float). I need to be able to save the vertex positions etc to an xml file so I want serialize the model objects, convert to B64 and save them as a string. Problem is Buffer objects are not serializable.

So, to get around this problem I removed all VBO code from the model objects (it was originally extended from a separate class) and created static methods to create my VBOs. So, I call the static method to create the VBO for a model and then return the handles so I can call render, update vertices etc. This, however, has had the effect of seriously ramping up memory when the models are created.

Why would this be? Originally the memory usage was not even noticeable. Now it crashes the JVM. I haven't changed any of the code logic, the methods are the same except now they are static and pass back the handles. Do static methods somehow use more memory when creating VBO's? I thought it would be less? I do clear all buffers after use. I do dispose of all culled models.

Edit: Here is the Render class that contains the static methods

package Drawing;

import static org.lwjgl.opengl.GL11.GL_FLOAT;
import static org.lwjgl.opengl.GL15.GL_ARRAY_BUFFER;
import static org.lwjgl.opengl.GL15.GL_DYNAMIC_DRAW;
import static org.lwjgl.opengl.GL15.GL_ELEMENT_ARRAY_BUFFER;
import static org.lwjgl.opengl.GL15.GL_STATIC_DRAW;
import static org.lwjgl.opengl.GL15.glBindBuffer;
import static org.lwjgl.opengl.GL15.glBufferData;
import static org.lwjgl.opengl.GL15.glBufferSubData;
import static org.lwjgl.opengl.GL15.glGenBuffers;
import static org.lwjgl.opengl.GL20.glEnableVertexAttribArray;
import static org.lwjgl.opengl.GL20.glVertexAttribPointer;
import static org.lwjgl.opengl.GL30.glBindVertexArray;
import static org.lwjgl.opengl.GL30.glGenVertexArrays;

import java.nio.FloatBuffer;
import java.nio.IntBuffer;

import org.lwjgl.BufferUtils;

/**
* This class calls all vbo functions in a static way which allows me to 
 * separate the Int/FloatBuffers from the model classes like Cube and
 * Quad.  Int/FloatBuffers will not serialize so the Cube/Quad classes
 * cannot be saved to file.  Keeping them static and separated 
 * will overcome this problem.
 */
public class Render {

static int VERTEXCOUNT = 0;//((QUAD_SIZE * QUAD_SIZE) * 12);
static FloatBuffer fbData = null;//BufferUtils.createFloatBuffer(VERTEXCOUNT);
static FloatBuffer fbNorm = null;//BufferUtils.createFloatBuffer(VERTEXCOUNT);
static FloatBuffer fbtex = null;//BufferUtils.createFloatBuffer((VERTEXCOUNT / 12) * 8);
static IntBuffer Indices = null;
private static int _VAOHandle = 0;
private static IntBuffer vboHandles;

static final int POSITION_INDEX = 0; // index of vertex attribute "in_Position"
static final int NORMALS_IDX = 1;
static final int TEXTURE_IDX = 2;
static final int IBO_IDX = 3;

public static VBOIndexes createVBO(int QUAD_SIZE,
        float[] vertBuffer,
        float[] normals,
        float[] UVs,
        int[] idxBuffer)  throws Exception {

    VBOIndexes vboINDEXES = new VBOIndexes();

    try{

        VERTEXCOUNT = (int) ((QUAD_SIZE * QUAD_SIZE) * 12);
        fbData = BufferUtils.createFloatBuffer(VERTEXCOUNT);
        fbNorm = BufferUtils.createFloatBuffer(VERTEXCOUNT);
        fbtex = BufferUtils.createFloatBuffer((VERTEXCOUNT / 12) * 8);
        Indices = BufferUtils.createIntBuffer(VERTEXCOUNT / 2);


        _VAOHandle = glGenVertexArrays();

        vboINDEXES.VAOHandle = _VAOHandle;

        System.out.println("VAOHandle is : " + _VAOHandle);

        glBindVertexArray(_VAOHandle);

        vboHandles =  BufferUtils.createIntBuffer(4);
        glGenBuffers(vboHandles);

        vboINDEXES.idxPOS = vboHandles.get(POSITION_INDEX);
        vboINDEXES.idxNORM = vboHandles.get(NORMALS_IDX);
        vboINDEXES.idxTEX = vboHandles.get(TEXTURE_IDX);
        vboINDEXES.idxIBO = vboHandles.get(IBO_IDX);

        //FloatBuffer fbData = BufferUtils.createFloatBuffer(vertBuffer.length);
        fbData.put(vertBuffer);
        fbData.rewind(); // rewind, otherwise LWJGL thinks our buffer is empty

        glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get(POSITION_INDEX));

        glBufferData(GL_ARRAY_BUFFER, fbData, GL_DYNAMIC_DRAW);
        fbData.clear(); //don't need this anymore  


        //populate the normals buffer
        //FloatBuffer fbNorm = BufferUtils.createFloatBuffer(normalsBuffer.length );
        fbNorm.put(normals);
        fbNorm.rewind();
        glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get(NORMALS_IDX)); //the vertex data
        glBufferData(GL_ARRAY_BUFFER, fbNorm, GL_STATIC_DRAW);
        fbNorm.clear(); //don't need this anymore 

        //populate the texture buffer

        fbtex.put(UVs);  
        fbtex.rewind();
        glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get(TEXTURE_IDX)); 
        glBufferData(GL_ARRAY_BUFFER, fbtex, GL_DYNAMIC_DRAW);
        fbtex.clear(); //don't need this anymore  

        Indices.put(idxBuffer);
        Indices.rewind();
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboHandles.get(IBO_IDX));

        glBufferData(GL_ELEMENT_ARRAY_BUFFER, Indices, GL_STATIC_DRAW);

        glEnableVertexAttribArray(POSITION_INDEX);
        glEnableVertexAttribArray(NORMALS_IDX);
        glEnableVertexAttribArray(TEXTURE_IDX);

        glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get(POSITION_INDEX)); 
        glVertexAttribPointer(0,3, GL_FLOAT, false,0,0);    

        //normals
        glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get(NORMALS_IDX));
        glVertexAttribPointer(1, 3, GL_FLOAT, false, 0, 0);  

        glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get(TEXTURE_IDX));
        glVertexAttribPointer(2, 2, GL_FLOAT, false, 0, 0); 

        //bind IBO
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboHandles.get(IBO_IDX));

        glBindVertexArray(0);

        glBindBuffer(GL_ARRAY_BUFFER, 0);


        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

        Indices.clear();

    }catch (Exception ex){
        System.out.println("createVBO: " + ex.getMessage());
        throw ex;
    }
    return vboINDEXES;
}

public static VBOIndexes createLineVBO( float[] vertBuffer,
                            int[] idxBuffer)  throws Exception {

    VBOIndexes vboINDEXES = new VBOIndexes();

    try{

        fbData = BufferUtils.createFloatBuffer(vertBuffer.length);
        Indices = BufferUtils.createIntBuffer(vertBuffer.length / 2);

        _VAOHandle = glGenVertexArrays();

        vboINDEXES.VAOHandle = _VAOHandle;

        glBindVertexArray(_VAOHandle);

        vboHandles =  BufferUtils.createIntBuffer(4);
        glGenBuffers(vboHandles);

        vboINDEXES.idxPOS = vboHandles.get(POSITION_INDEX);
        vboINDEXES.idxIBO = vboHandles.get(IBO_IDX);

        fbData.put(vertBuffer);
        fbData.rewind(); // rewind, otherwise LWJGL thinks our buffer is empty

        glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get(POSITION_INDEX));

        glBufferData(GL_ARRAY_BUFFER, fbData, GL_STATIC_DRAW);
        fbData.clear(); //don't need this anymore  

        //IntBuffer Indices = BufferUtils.createIntBuffer(idxBuffer.length);
        Indices.put(idxBuffer);
        Indices.rewind();
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboHandles.get(IBO_IDX));
        //Util.checkGLError();
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, Indices, GL_STATIC_DRAW);

        glEnableVertexAttribArray(POSITION_INDEX);
        glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get(POSITION_INDEX)); 
        glVertexAttribPointer(0,3, GL_FLOAT, false,0,0);    

        //bind IBO
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboHandles.get(IBO_IDX));

        Indices.clear();

        glBindVertexArray(0);

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        //Util.checkGLError();

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    }catch (Exception ex){
        System.out.println("createVBO: " + ex.getMessage());
        throw ex;
    }
    return vboINDEXES;
}

  public static void updateVertices(int offset,
                            float[] vertBuffer,
                            int idxPOS)
  {
      //populate the vertex buffer
      FloatBuffer fbData = BufferUtils.createFloatBuffer(vertBuffer.length);
      fbData.put(vertBuffer);   
      fbData.rewind();
      //glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get(POSITION_INDEX)); //the vertex data
      glBindBuffer(GL_ARRAY_BUFFER, idxPOS);
      glBufferSubData(GL_ARRAY_BUFFER, offset, fbData);
      fbData.clear(); //don't need this anymore  
  }

  public static void updateNormals(int offset,
                              float[] normals,
                              int idxNORM)
  {

      //populate the vertex buffer
      FloatBuffer fbData = BufferUtils.createFloatBuffer(normals.length);
      fbData.put(normals);
      fbData.rewind();
      //glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get( NORMALS_IDX)); //the vertex data
      glBindBuffer(GL_ARRAY_BUFFER, idxNORM);
      glBufferSubData(GL_ARRAY_BUFFER, 0, fbData);
      fbData.clear(); //don't need this anymore  
  }

  public static void updateTexture(int offset,
          float[] UVs,
          int idxTEX)
  {

      //populate the texture buffer
      FloatBuffer fbtex = BufferUtils.createFloatBuffer(UVs.length);
      fbtex.put( UVs );
      fbtex.rewind();

      //glBindBuffer(GL_ARRAY_BUFFER, vboHandles.get(TEXTURE_IDX)); //the texture data
      glBindBuffer(GL_ARRAY_BUFFER, idxTEX);
      glBufferSubData(GL_ARRAY_BUFFER, offset, fbtex);
      fbtex.clear(); //don't need this anymore  
  }

  public Render(){

  }

}

The static calls are made in the constructor of the fields (array of tile objects) as follows:

public Quad(Map<Integer, Cube> c, int SIZE) throws Exception{
//public Quad(ArrayList<Cube> c, int SIZE) throws Exception{
    QUAD_SIZE = SIZE;
    initArrays();
    initVBOData(SIZE);
    createVBO();
    cubes = c;

}

Answer 1

I believe the answer is that static classes do not provide GC. With all of the data being passed around creating VBOs the G really starts to pile up...

Answer 2

Your code looks very confusing, you should spend some time in order to better understand how OpenGL works and make it cleaner and more readable. I'd suggest you to take inspiration from this sample .

Few considerations:

• you don't need static at all
• I don't know lwjgl, but I guess it needs direct buffers and you have no guarantee they are going to be removed by the garbage collector, so you should allocate them by yourself and free them when you don't need them anymore. I created a small class to deallocate direct buffers, taken from JM3 here
• avoid redundancy by saving the opengl resources names inside vboINDEXES . You are already using vboHandles directly
• if the dimension of your buffers doesn't change, allocate them once and keep them ( fbData , fbNorm , fbTex ), don't need to clear() them too
• for this reason, when you updateNormals() don't instantiate a new buffer, use the one already instantiated at the begin
• by a logic point of view, IBO_INDEX should not be part of the vboINDEXES
• when you call glVertexAttribPointer pass as first argument the variable holding the attribute index, such as POSITION_INDEX

ps: the plural of index is indices