LWJGL

Question

所以我现在有两个关于这段代码的问题。我也有一个问题，编辑到最后。

当我生成图块时，似乎我将它们添加到我的数组列表中，当我读取它时显示为空，我在完成生成后确实读取了它，所以它不应该显示为空，并且它们确实从我所看到的中得到补充。有人知道怎么回事吗？
我还有鼠标左键在该位置添加四边形的功能，它被添加到drawQuads列表中然后渲染，看起来应该是有序的？完全相同的列表确实正确地添加了其他四边形并使它们渲染得很好。

如果重要的话，我正在使用 netbeans。我已经研究了一段时间了，我实际上是在考虑如何解决四边形问题的同时制作了生成器，然后我又遇到了一个，所以我想是时候寻求帮助了。

import java.util.*;
import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.*;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.util.glu.GLU.gluOrtho2D;


public class Main{
    Character tempChar;
Random rand = new Random();
    Timer t = new Timer();
    boolean randomChars = true;
    List<Character> listOfChars = new ArrayList<>();
    Render rend = new Render();
    Input input = new Input();
    Generator gen = new Generator();

    int dice = 0;

        int scrX = 1200;
        int scrY = 800;

        int mX;
        int mY;
        int currentFPS;

        long storedTime = System.nanoTime();
        int delta;
        int fps;
        long lastFPS;
        boolean secondPassed = false;
        int totalTime;

    public static void main(String []args){
        Main main = new Main();
        main.Main();
}
    public void Main(){
        createDisplay();
        createInput();
        //makeChar();
        rend.makeTestBackground();
        //rend.makeTestGrid(33,32,55,36,10,21);
        //rend.makeTestQuads();
        gen.generateGrid(33,32,55,36,10,10,21);

        //Testing why it isnt working with the left click method.
        rend.testMakeQuads(1f,0f,0.5f, 100,400, 20,20); //this works, then 
why dont input click makeQuad??????? Hmm..

        initGL();
        resizeGL();

        getDeltaTime();
        lastFPS = getTime();

        while(!Display.isCloseRequested() && 
!Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)){
            //getDeltaTime(); why?
            updateFPS();

            if(secondPassed){
                totalTime++;
                //System.out.println(totalTime+"+1");
                secondPassed = false;
            }

            input.update();
            rend.render();
            displayUpdate();

            Display.setTitle("App @"+currentFPS+"fps "
                    +Mouse.getX()+"mX "+Mouse.getY()+"mY "
                    +"Running for "+totalTime+ "seconds");
        } 

        destroyAll();
    }  
    public void getDeltaTime(){
        long currentTime = System.nanoTime();
        delta = (int) ((currentTime-storedTime) / 1000000);
        storedTime = currentTime;
    }
    public long getTime(){
        return (Sys.getTime() * 1000) / Sys.getTimerResolution();
    }
    public void updateFPS() {
        if (getTime() - lastFPS > 1000) {
            currentFPS = fps;
            fps = 0;
            lastFPS += 1000;
            secondPassed = true;
        }
        fps++;
    }
    public void displayUpdate(){
        Display.update();
        Display.sync(60);
    }
    public void initGL(){
        glClearColor(0.0f,0.0f,0.0f,0.0f);
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_LIGHTING);
    }
    public void resizeGL(){ //If im honest i dont even know what im doing.
    glViewport(0,0,scrX,scrY);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0f,scrX,0.0f,scrY);
    glPushMatrix();

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glPushMatrix();
    }
    public void destroyAll(){
        System.out.println("Goodbye cruel world...");
        Display.destroy();
        Keyboard.destroy();
        Mouse.destroy();
        System.exit(0);
    }
    public void createDisplay(){
        try{
            Display.setDisplayMode(new DisplayMode(scrX,scrY));
            Display.setFullscreen(false);
            Display.setTitle("Nothing lasts for ever, not even this 
title.");
            Display.create();
        }catch(LWJGLException e) {
            System.exit(0);
        }
    }
    public void createInput(){
        try {
            Keyboard.create();
            Mouse.create();
            Mouse.setGrabbed(false); //Dat booty doe.
        } catch (LWJGLException ex) {
            System.out.println("Input error. This shouldnt happen.");
        }
    }
    //Should probably make a generator class. Think about it, nerd. 
    //Comment to self; who do you think you are ? Some sort of programming 
expert?
    //Reply to you; dont you dare talk to me that way, try me, i will del 
sys32.
    //Comment to self; Do it then? If you're so ba... *sizzling noises*
public void makeChar(){
    if(randomChars){
                int tStrStat = makeStat();
                int tStrMod = tStrStat-6;
                int tAgiStat = makeStat();
                int tAgiMod = tAgiStat-6;
                int tStaStat = makeStat();
                int tStaMod = tStaStat-6;
                int tChaStat = makeStat();
                int tChaMod = tChaStat-6;
                int tIntStat = makeStat();
                int tIntMod = tIntStat-6;
                int tempArrStat[] = {tStrStat, tAgiStat, tStaStat, tChaStat, 
tIntStat};
                int arrStats[] = findHighestNums(tempArrStat);

                System.out.println(Arrays.toString(arrStats));
                System.out.println("Highest stat is: "+arrStats[0]);

                /*tempChar = new Character("Random Char Class",
                    tStrStat, tStrMod, tStrMod, tStrMod,
        tAgiStat, tAgiMod, tAgiMod, tAgiMod,
        tStaStat, tStaMod, tStaMod, tStaMod,
        tChaStat, tChaMod, tChaMod, tChaMod,
        tIntStat, tIntMod, tIntMod, tIntMod);
        listOfChars.add(tempChar);
                */

    }else{
        System.out.println("Not using Random Values");

                    tempChar = new Character("Low Char Class",
                            0, 0, 0, 0,
            0, 0, 0, 0,
            0, 0, 0, 0,
            0, 0, 0, 0,
            0, 0, 0, 0);
        listOfChars.add(tempChar);

                    tempChar = new Character("Avg Char Class",
                            1, 1, 1, 1,
            1, 1, 1, 1,
            1, 1, 1, 1,
            1, 1, 1, 1,
            1, 1, 1, 1);
        listOfChars.add(tempChar);

                    tempChar = new Character("High Char Class",
                            2, 1, 1, 1,
            1, 1, 1, 1,
            1, 1, 1, 1,
            1, 1, 1, 1,
            1, 1, 1, 1);
        listOfChars.add(tempChar);
    }

            testChar();

}
    public void testChar(){
        for(Character tChar : listOfChars){
            String tempName = tChar.getName();
            System.out.println(tempName + " ");
            System.out.println("Strength: "+tChar.strength);
            System.out.println("Agility: "+tChar.agility);
            System.out.println("Stamina: "+tChar.stamina);
            System.out.println("Charisma: "+tChar.charisma);
            System.out.println("Intellect: "+tChar.intellect);
        } 
    }
    public int rollDSix(){
        int tRandChoose = rand.nextInt(30)+1;
            for(int i=0;
                i < 30; //Yo dawg, i heard yo liek random, so i put a random 
in your random, making it extra random.
                i++)
            {

                int tRand = rand.nextInt(6)+1;

                if(i == tRandChoose){
                    //System.out.println("The randomizer chose "+i);
                    //System.out.println("The Randomest number was " + 
tRand);
                    dice = tRand;
                }
            }
        return dice;
    }
    public int makeStat(){
        int tDOne = rollDSix();
        int tDTwo = rollDSix();
        int tResultOne = tDOne+tDTwo;
        //System.out.println("The Stat Became " + tResultOne);
        //System.out.println(tResultOne-6 + " Was the adjusted Modifier");

        return tResultOne;
    }
    public int[] findHighestNums(int arrTemp[]){
        List tempList = new ArrayList();
        int sortedArray[] = {0,0,0,0,0};
        Arrays.sort(arrTemp);
        //System.out.print(Arrays.toString(arrTemp));
        //System.out.println("");
        for(int i=arrTemp.length-1;
                i >= 0;
                i--){
            //System.out.println(arrTemp[i]);
            tempList.add(arrTemp[i]);
        }

        int tNum=0;
        for (Iterator it = tempList.iterator(); it.hasNext();) {
            int i = (int) it.next();
            sortedArray[tNum] = i;
            tNum++;
            //System.out.println(i);
        }
        //System.out.println(Arrays.toString(sortedArray));
        return sortedArray;
    }
}

这是渲染图 class

import java.util.*;
import java.util.List;
import java.awt.*;
import org.lwjgl.opengl.GL11;
import static org.lwjgl.opengl.GL11.*;

public class Render {
Tile tile;
Quads quad;
List<Quads> drawQuads = new ArrayList<>();
List<Tile> tileMapOne = new ArrayList<>();

//int qX = 600; //half of screen
//int qY = 400;
//int qSize = 380;

public void render(){
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();

    for (Quads q : drawQuads) {
        glTranslatef(0f,0f,0f);
        glRotatef(0.0f,0.0f,0.0f,0.0f);
        glColor3f(q.colorR,q.colorB,q.colorG);
        glBegin(GL_QUADS);
        GL11.glVertex2f(q.posX-q.sizeX,q.posY-q.sizeY);
        GL11.glVertex2f(q.posX+q.sizeX,q.posY-q.sizeY);
        GL11.glVertex2f(q.posX+q.sizeX,q.posY+q.sizeY);
        GL11.glVertex2f(q.posX-q.sizeX,q.posY+q.sizeY);
        glEnd();
    }
    //readGridMap();
    renderGridMap();
}
public void readGridMap(){
    for(Tile t : tileMapOne){
        System.out.println(t.tileID);
    }
}
public void renderGridMap(){
    //System.out.println(tileMapOne.size()); empty?
    for (Tile t : tileMapOne){
        System.out.println("Do i get here?");
        glTranslatef(0f,0f,0f);
        glRotatef(t.rotation,0.0f,0.0f,0.0f);
        glColor3f(t.colorR,t.colorB, t.colorG);
        glBegin(GL_QUADS);
            /*GL11.glVertex2f(50-20,50-20);
            GL11.glVertex2f(50+20,50-20);
            GL11.glVertex2f(50+20,50+20);
            GL11.glVertex2f(50-20,50+20);*/
            GL11.glVertex2f(t.posX-t.sizeX,t.posY-t.sizeY);
            GL11.glVertex2f(t.posX+t.sizeX,t.posY-t.sizeY);
            GL11.glVertex2f(t.posX+t.sizeX,t.posY+t.sizeY);
            GL11.glVertex2f(t.posX-t.sizeX,t.posY+t.sizeY);
        glEnd();
    }
}
public void makeTestBackground(){
    quad = new Quads(0f,0f,0f, 600f, 400f, 600f, 400f);
    drawQuads.add(quad);
    quad = new Quads(1f,1f,1f, 600f, 400f, 595f, 395f);
    drawQuads.add(quad);
    quad = new Quads(0f,0f,0f, 600f, 400f, 580f, 380f);
    drawQuads.add(quad);
}
public void makeTestQuads(){
    /*quad = new Quads(1f,0f,0f, 720f, 400f, 20f, 100f);
    drawQuads.add(quad);
    quad = new Quads(0f,0f,1f, 880f, 200f, 30f, 60f);
    drawQuads.add(quad);
    quad = new Quads(0f,1f,0f, 1000f, 450f, 50f, 80f);
    drawQuads.add(quad);*/
}
public void makeTestGrid(int gridPosX, int gridPosY, 
                        int gridSizeX, int gridSizeY, 
                        int gridTileSize, int gridTileSpacing){
    // making a grid
    for(int iX = 0;
            iX< gridSizeX;
            iX++){
        for(int iY = 0;
                iY < gridSizeY;
                iY++){
            quad = new Quads(0.1f+iX,0.1f+iY,1f,
                    gridPosX+iX*gridTileSpacing,
                    gridPosY+iY*gridTileSpacing,
                    gridTileSize, gridTileSize);
            drawQuads.add(quad);
        }
    }
}
public void testMakeQuads(float cR, float cG, float cB,
                    float pX, float pY, 
                    float sX, float sY){

    for (int i = 0;
            i < 11;
            i++)
    {
        makeQuads(cR, cG, cB,
            pX+i*100, pY, 
            sX, sY);
    }
}
public void makeQuads(float cR, float cG, float cB,
                    float pX, float pY, 
                    float sX, float sY){
    quad = new Quads(cR,cG,cB, pX, pY, sX, sY);
    drawQuads.add(quad);
}
}

这是发电机和瓷砖 class

public class Generator {
Render rend = new  Render();
Tile tile;

int tempID = 0;
public void Generator (){
}
public void generateGrid(int gridPosX, int gridPosY, 
                        int gridSizeX, int gridSizeY, 
                        int gridTileSizeX, int gridTileSizeY, 
                        int gridTileSpacing){
    // making a grid
    for(int iX = 0;
            iX< gridSizeX;
            iX++){
        for(int iY = 0;
                iY < gridSizeY;
                iY++){
            tempID++;
            tile = new Tile(0.2f,1f,0.3f,
                    gridPosX+iX*gridTileSpacing,
                    gridPosY+iY*gridTileSpacing,
                    gridTileSizeX, gridTileSizeY,
                    0f, tempID);
            rend.tileMapOne.add(tile);
        }
    }
}
}

public class Tile {
float colorR; float colorB; float colorG;
float posX; float posY; 
float sizeX; float sizeY;
float rotation;
int tileID;

    Render rend = new Render();

public Tile(float cR, float cB, float cG,
                    float pX, float pY, 
                    float sX, float sY,
                    float rot, int tID){
    this.colorR = cR;
    this.colorB = cB;
    this.colorG = cG;

    this.posX = pX; this.posY = pY;
    this.sizeX = sX; this.sizeY = sY;
    this.rotation = rot;
    this.tileID = tID;
    System.out.println("Tile made with ID"+tileID);

}
public void setPosX(float tNum){
    this.posX = tNum;
}
public void setPosY(float tNum){
    this.posY = tNum;
}
public void setSizeX(float tNum){
    this.sizeX = tNum;
}
public void setSizeY(float tNum){
    this.sizeY = tNum;
}
public void setColor(float cR, float cB, float cG){
    this.colorR = cR;
    this.colorB = cB;
    this.colorG = cG;
}
public int getID(){
    return tileID;
}
public void setRot(float tNum){
    this.rotation = tNum;
}
public void Tile (){
}
}

这是输入 class

 import org.lwjgl.input.Keyboard;
 import org.lwjgl.input.Mouse;

 public class Input {
    Render rend = new Render();

    int mX; int mY;
    boolean leftClicking = false;
    boolean rightClicking = false;
    boolean keyPressed = false;

    float tPX; float tPY;
    float tSX; float tSY;
    float tCR; float tCG; float tCB;

public void Input(){
}
public void update(){
    mX = Mouse.getX();
    mY = Mouse.getY();

    checkForClick();
    checkForKey();
}
public void checkForKey(){
    if(Keyboard.isKeyDown(Keyboard.KEY_SPACE /*&& !keyPressed*/)){
            System.out.println("Baby.. I think we need more space..");
    }
    if(Keyboard.isKeyDown(Keyboard.KEY_RETURN)){
        System.out.println("*Enters the door* Honey! Im hooome!");
    }
    if(Keyboard.isKeyDown(Keyboard.KEY_1)){
        System.out.println("When the moon hits the sky");
    }
    if(Keyboard.isKeyDown(Keyboard.KEY_2)){
        System.out.println("Like a big pizza pie");
    }
    if(Keyboard.isKeyDown(Keyboard.KEY_3)){
        System.out.println("Thats, amoré!");
    }
    if(Keyboard.isKeyDown(Keyboard.KEY_4)){
        System.out.println("Shot to the heart, and you're to blame -");
    }
    if(Keyboard.isKeyDown(Keyboard.KEY_5)){
        System.out.println("Darlin', you give love, a bad name!");
    }
}
public void checkForClick(){
    if(Mouse.isButtonDown(0) && !leftClicking){
        //wrong
        //Hmm.. Click and hold, without activating this? Methinks

        System.out.println("Click!");
        leftClick();
    } leftClicking = Mouse.isButtonDown(0);

    if(Mouse.isButtonDown(1) && !rightClicking){
        //right

        //context menu goes here, hmm.
    } rightClicking = Mouse.isButtonDown(1);
}
public void leftClick(){
    tPX = mX;
    tPY = mY;
    //temp
    tCR = 0.6f; tCG = 0.8f; tCB = 1f;
    tSX = 50f; tSY = 50f;

    rend.makeQuads(tCR, tCG, tCB,
            tPX, tPY, tSX, tSY);

    /*while(!leftClicking){      //HMMMMMMMMM!!!!!!!!!!
        if(Mouse.isButtonDown(0)){
            System.out.println("Keeping on clicking!");
        }else{
            leftClicking = Mouse.isButtonDown(0);
        }
    }*/
}
}

这个不应该是相关的，但是这里是四边形 class 无论如何，为了很好的衡量标准

public class Quads {
float colorR; float colorG; float colorB;
float posX; float posY; float sizeX; float sizeY;


public Quads(float cR, float cG, float cB,
                    float pX, float pY, 
                    float sX, float sY){
    this.colorR = cR;
    this.colorG = cG;
    this.colorB = cB;

    this.posX = pX; this.posY = pY;
    this.sizeX = sX; this.sizeY = sY;

    System.out.println("Made a quad! @ X"+posX+" Y"+posY);

}
}

抱歉，如果我的错误太明显了。在一年没有编码之后重新开始。

编辑：差点忘了我的问题，我如何通过单击读取鼠标输入，而如果我按住它，它应该继续执行其他功能？ - 因为到目前为止，它只想做一个或另一个，或同时做两个，但我希望能够同时做两件事。
编辑：顶一下，有人吗？我真的需要一些帮助，我这辈子都弄不明白。
编辑：一直在努力，这是我尝试过的：
- 在尝试渲染时检查它是否在循环之前或循环期间读取，它没有。
- 检查我是否没有正确阅读列表，我是。
- 检查实例是否未正确初始化，它也适用于其他实例。
- 检查如果我将列表移动到它自己的列表是否有效class，仍然没有
- 检查我的生成器是否使用了正确的值并正确添加，是的。
- 正在检查我是否收到了一些未显示的堆栈错误，none。
- 正在检查是否有任何内容中断或编辑列表，但没有。

结果？应该可以工作，没有错误，它对于我正在渲染的其他对象列表来说工作得很好。另一个问题？仍然没有得到任何进一步的

所以有人可以检查一下，看看他们是否看到了我没有看到的东西吗？在弄清楚这一点之前，我无法改进我的代码，而且我不能，很明显。谢谢..

Answer 1

所以！我实际上想出了一个解决问题的简陋方法 - 将生成器代码移到我的渲染中 class - 虽然这只是一个解决方法，但后来我去检查了这个并且我看到了令人愉快的 "alex" 已经回答了我要具体问的问题。

问题是；实例本身似乎被初始化了两次，而它应该只使用同一个实例（？），但显然决定不这样做。所以现在我只需要找到一种方法来使用同一个实例并将其转移过来。谢谢大家的帮助！我希望我可以将这个答案贡献给亚历克斯，但我不确定如何投票或设置评论作为答案？

所以如果有人遇到同样的问题，这里有解决办法！它可能使用了几个实例。

这是为其他人解决问题的好方法！它是我用过的。 Java: Using same instance of a class in various other classes

编辑：感谢 alex https://imgur.com/a/ilPPC

LWJGL - 生成图块后 ArrayList 为空，单击鼠标时无法添加四边形

LWJGL - ArrayList empty after generating tiles, and quad failing to be added on mouse click

java

arraylist

rendering