Joshua Waring

Okay we'll that was a tiny fail
It's a scenario error where it doesn't appear tr way expected although has no returned errors.
The plane has a constant lighting (ambient) and if unaffected my the actual light. Basically it's dark grey all the time even if I place it dead on with the light or at least I think I am.

Recently I've moved into a more advance part of OpenGL which is lighting, but as what follows is an error which I keep hitting, I don't know if it's light positioning or what, but I've tried playing with positions and I can't seem to get it working correctly. There's just a plane which is positioned on the screen and I've created a moving triangle which moved horizontal to the light and the same problem occurs. simple enough said no one ever(apart from everyone who's not me:) Help is greatly appreciated.

import java.nio.ByteBuffer; import java.nio.FloatBuffer; import org.lwjgl.LWJGLException; import org.lwjgl.opengl.Display; import org.lwjgl.opengl.DisplayMode; import org.lwjgl.opengl.GL11; public class window { public static void main(String[] args){ try { Display.setDisplayMode(new DisplayMode(800, 800)); Display.create(); GL11.glMatrixMode(GL11.GL_PROJECTION); GL11.glLoadIdentity(); GL11.glOrtho(0, 5, 0, 5, -10, 10); GL11.glMatrixMode(GL11.GL_MODELVIEW); GL11.glLoadIdentity(); GL11.glEnable(GL11.GL_LIGHTING); GL11.glEnable(GL11.GL_LIGHT0); float light0Position[] = {3f, 3f, 2f, 1f}; float light0Color[] = {1f, 0f, 1f, 1f}; float light0Ambient[] = {0.3f, 1f, 1f, 1f}; ByteBuffer byteBuffer = ByteBuffer.allocateDirect(16); //GL11.glLightModel(GL11.GL_LIGHT_MODEL_AMBIENT, (FloatBuffer)byteBuffer.asFloatBuffer().put(light0Color).flip()); GL11.glLight(GL11.GL_LIGHT0, GL11.GL_DIFFUSE, (FloatBuffer) byteBuffer.asFloatBuffer().put(light0Color).flip()); GL11.glLight(GL11.GL_LIGHT0, GL11.GL_POSITION, (FloatBuffer) byteBuffer.asFloatBuffer().put(light0Position).flip()); GL11.glLight(GL11.GL_LIGHT0, GL11.GL_AMBIENT, (FloatBuffer) byteBuffer.asFloatBuffer().put(light0Ambient).flip()); GL11.glEnable(GL11.GL_NORMALIZE); while(!Display.isCloseRequested()){ GL11.glClear(GL11.GL_COLOR_BUFFER_BIT); GL11.glLoadIdentity(); GL11.glBegin(GL11.GL_QUADS); GL11.glNormal3f(0, 0, 1); GL11.glVertex3f(2, 2, 3); GL11.glVertex3f(4, 2, 3); GL11.glVertex3f(4, 4, 3); GL11.glVertex3f(2, 4, 3); GL11.glEnd(); Display.update(); } System.exit(1); } catch (LWJGLException e) { e.printStackTrace(); } } }

I'm a beginner but more than willing to continue learning and able to dedicate large amount of time.
Though If you want my assistance than I'm more than willing to join you in your journey to complete your games idea.

9 months later

I've changed my direction of programming, guess having a working system is better than having a fast system without function.
So for particle collision, I guess the way to go would be split the area into sections and test for collision of particles in those positions instead of all with all.
I've rearranged some names and joined Linked List's with my arrays, which is faster than a object.

Though using the iteration it's giving me an error, which doesn't make sense, since the condition is interation.hasNext but gives an error on the .next(), not right away but after a few hundred cycles.
public void manageParticles(int width, int height){ Iterator<float[]> cachedList = particles.iterator(); for(int x = 0; cachedList.hasNext(); x++){ cacheParticles = cachedList.next(); cacheParticles[0] += cacheParticles[2] ; cacheParticles[1] += cacheParticles[3] ;

Okay So I've created a very basic version of the above (no gravity or cull, no cull since I don't test the performance difference Yet at a point where they would be cullable)
so I've gone from about 4ms renders to 80ms, and increasing with more particles.
I think making too many objects has become a problem, since my other method was fast, as in really fast.
I thought it would be nice, because this IS my first time using another class and object in such way.

import java.util.LinkedList; import java.util.Random; import org.lwjgl.opengl.GL11; public class particleVersion2{ Random rand = new Random(); LinkedList<particles> atoms = new LinkedList<particles>(); // gets the render time int MAXPARTICLES = 0; int ACTIVEPARTICLES = 0; float MAXVELOCITY = 0; float MINVELOCITY = 0; float deltaTime = 0; float frame = 0; float framenext = 0; particles parts; particleVersion2(float maxVelocity, float minVelocity, int maxParticles){ this.MAXPARTICLES = maxParticles; this.MAXVELOCITY = maxVelocity; this.MINVELOCITY = minVelocity; } public float renderTime(){ deltaTime = (framenext - frame); frame = framenext; framenext = System.nanoTime() / 1000000; return deltaTime; } // Creates a random float number private float randomNumber(float max, float min){ float number = rand.nextFloat() % max; if(number <= min) number = rand.nextFloat() % max; return number; } public void addParticle(int numberofParticles, int X, int Y){ for(int x = numberofParticles; x > 0; x--) atoms.addLast(new particles(randomNumber(MAXVELOCITY, MINVELOCITY), randomNumber(MAXVELOCITY, MINVELOCITY), X, Y)); } // Checks the particle and culls it if it's out of range public void cullParticle(int width, int height){ } // Creates a new point of gravity public void addGravityPoint(float X, float Y, float strength){ } // calculates the new position from it's velocity public void moveParticles(){ for(int x = 0; x < atoms.size(); x++){ parts = atoms.get(x); parts.positionX -= parts.velocityX; parts.positionY -= parts.velocityY; } } // renders each particle as a point on the screen public void renderParticles(){ for(int x = 0; x < atoms.size(); x++){ parts = atoms.get(x); GL11.glColor3f(1, 1, 0); GL11.glBegin(GL11.GL_POINTS); GL11.glVertex2f(parts.positionX, parts.positionY); GL11.glEnd(); } System.out.println("Render time is: " + renderTime()); } }

Guess that's what I get for being a beginner, I've never heard of a LinkedList but after a quick look the principle is easily understood.

I've created a particle system in java (OBVIOUSLY -facepalm) and the code should be explanatory since I put a lot of comments inside, but I was wondering if the opproach was rather efficient in memory use and calculations ect


import java.util.ArrayList; import java.util.Stack; import java.util.Random; import org.lwjgl.input.Mouse; public class particle{ Random rand = new Random(); public int MAX_PARTICLES = 50000; public int ACT_PARTICLES = 0; public int activeParticles = 0; public int gravityPoints = 0; public ArrayList<float[]> gravityCords = new ArrayList<float[]>(); // Position particles[0][x] is the array's reader // [0][0] contains particle count // [x][4] Active or not public float[][] particles = new float[MAX_PARTICLES][5]; private Stack<Integer> freeIndexs = new Stack<Integer>(); private long frame; private long framenext; public long deltaTime; // gets the render time public void renderTime(){ deltaTime = (framenext - frame); frame = framenext; framenext = System.nanoTime() / 1000000; } // Creates a random float number private float randomNumber(float max, float min){ float number = rand.nextFloat() % max; if(number <= min) number = rand.nextFloat() % max; return number; } /** * The idea behind the particle system is to make a large array and place all of the particles * coordinates and speed inside the array. * But the thing is, once the particles index has finished, it just remains there doing nothing * as the array increases in size with addition of particles. The solution to this is to reuse * the index since reuse is a lot faster than editing an array's size. * When a particle falls out of the window the particle is set as inactive, which is stored at * particles[index][4] 1 for active and 0 for inactive and the index is added to a stack. * When a new particle is being created the stack is checked to see if there's any index's * which can be reused. If so then the new particle will take the index and use it's own new * data and will be set as active again; otherwise a new particle is added onto the end of the * array, which has a maximum size of MAX_PARTICLES * * Reuse is faster than destroying and creating anything. */ public void addParticle(int numberofParticles){ int num = numberofParticles; while(num > 0){ // This is where the freeIndex is checked to see if it is empty or not, if it's empty // it will return true if(freeIndexs.isEmpty() == false){ //System.out.println("Replacement Particle Added"); // if replaceable positions are available in the particles array // [x][0] X position // [x][1] Y position // [x][2] X Velocity // [x][3] Y Velocity // [x][4] Active // the index is taken from the stack and placed into TEMO int TEMP = freeIndexs.pop(); // Use the stack to retrieve a free index in the particles array // Mouse click X particles[TEMP][0] = Mouse.getX(); // Mouse click Y particles[TEMP][1] = Mouse.getY(); // Random X velocity particles[TEMP][2] = randomNumber(100f, -100f); // Random Y velocity particles[TEMP][3] = randomNumber(100f, -100f); // Set particle as Active particles[TEMP][4] = 1; }else{ //System.out.println("Particle Added"); // If no replaceable positions are available in the particles array // Mouse click X particles[ACT_PARTICLES][0] = (float) Mouse.getX(); // Mouse click Y particles[ACT_PARTICLES][1] = (float) Mouse.getY(); // Random X velocity particles[ACT_PARTICLES][2] = randomNumber(100f, -100f); // Random Y velocity particles[ACT_PARTICLES][3] = randomNumber(100f, -100f); // Set particle as Active particles[ACT_PARTICLES][4] = 1; } // Since multiple particles can be added per click, this will lower the counter of remaining // particles to be added num -= 1; // add one to the actual number of particles ACT_PARTICLES += 1; } } // Checks the particle and culls it if it's out of range public void cullParticle(int width, int height){ if(gravityPoints != 0){ if(ACT_PARTICLES != 0){ // cycles through all particles and looks for the ones which are out of the scope for(int x = 1; x <= ACT_PARTICLES; x++){ // check to see if it's active, there's no point though through inactive ones. if(particles[x][4] == 1){ float X = particles[x][0]; float Y = particles[x][1]; // Checks to see if the particle is outside the screen if(Y < 0 | X < 0 | X > width | Y > height){ // Particle is places in an area which can't be seen. particles[x][0] = -1; particles[x][1] = -1; particles[x][2] = 0; particles[x][3] = 0; // set to inactive particles[x][4] = 0; //System.out.println("Particle: " + x + " is culled and is up for replacement"); freeIndexs.push(x); } } } } } } // Creates a new point of gravity public void addGravityPoint(float X, float Y, float strength){ float[] TEMP = {X, Y, strength}; gravityCords.add(TEMP); gravityPoints += 1; } // calculates the new position from it's velocity public void moveParticles(){ if(ACT_PARTICLES != 0){ for(int x = 1; x <= ACT_PARTICLES; x++){ // if particle is active then if(particles[x][4] == 1){ particles[x][0] += particles[x][2] ; particles[x][1] += particles[x][3] ; // time to change the velocity accoring to the gravity // gravity is still being thought out and will look nice soon, right now it's just // velocity -= deltaPosition * 0.00001 if(gravityPoints != 0){ float Gravity[] = gravityCords.get(0); /* float angle = 0; angle = (float) Math.toDegrees( Math.atan((Gravity[1] - particles[x][1]) / (Gravity[0] - particles[x][0]))); particles[x][2] = (float) ((Math.cos(angle) * Gravity[2]) * particles[x][2]); particles[x][3] = (float) ((Math.sin(angle) * Gravity[2]) * particles[x][3]); System.out.print(angle);*/ particles[x][3] -= (particles[x][1] - Gravity[1]) * 0.00001; particles[x][2] -= (particles[x][0] - Gravity[0]) * 0.00001; } } } } } }

I'm trying to create my first particle system, when you click it creates a particle with addParticle at the position of the mouse click (LWJGL) and if the location of the particle (X,Y) fallse out of the range the index will be added to a stack which marks unused index's in the particles array so I can save space and reuse
but the problem is the cull, or maybe it's the add Particle, because the position is always being set to 0.0, EVEN THOUGH I've used a system.out.println to see the values given by Mouse.getX and it is working perfectly. That's the mind((()
Can someone please help.

import java.util.Stack; import java.util.Random; import org.lwjgl.input.Mouse; public class particle extends calculation{ Random rand = new Random(); private int MAX_PARTICLES = 30000; private int ACT_PARTICLES = 0; // positon particles[0][x] is the array's geader // [0][0] contains particle count private float[][] particles = new float[MAX_PARTICLES][4]; private Stack<Integer> freeParticleArray = new Stack<Integer>(); particle(){ // constructor particles[0][0] = 1; } private float randomNumber(float max, float min){ float number = rand.nextFloat() % max; if(number <= 0) number = rand.nextFloat() % max; return number; } private int TEMP; public void addParticle(int numberofParticles){ int num = numberofParticles; int length = ACT_PARTICLES; while(num > 0){/* if(freeParticleArray.isEmpty() == false){ System.out.println("Replacement Particle Added"); // if replaceable positions are available in the particles array // [x][0] X positon // [x][1] Y position // [x][2] X Velocity // [x][3] Y Velocity TEMP = freeParticleArray.pop(); // Use the stack to retrieve a free index in the particles array // Mouse click X particles[TEMP][0] = X; // Mouse click Y particles[TEMP][1] = Y; // Random X velocity particles[TEMP][2] = randomNumber(1f, 0.01f); // Random Y velocity particles[TEMP][3] = randomNumber(1f, 0.01f); }else{*/ System.out.println("Particle Added"); // If no replaceable positions are available in the particles array // Mouse click X particles[length][0] = (float) Mouse.getX(); // Mouse click Y particles[length][1] = (float) Mouse.getY(); // Random X velocity particles[length][2] = randomNumber(1f, 0.01f); // Random Y velocity particles[length][3] = randomNumber(1f, 0.01f); //} System.out.println(num); num -= 1; ACT_PARTICLES += 1; System.out.println(particles[0][0]); } } public void cullParticle(int width, int height){ if(ACT_PARTICLES >= 0){ for(int x = 1; x <= ACT_PARTICLES; x++){ float X = particles[x][0]; float Y = particles[x][1]; if(Y <= 0 | X <= 0 | X >= width){ //System.out.print(x + " " +particles[x][0] + // " "+ particles[x][1] + " "+ particles[x][2] + " " + particles[x][3]); particles[x][0] = 10; particles[x][1] = 10000; particles[x][2] = 0; particles[x][3] = 0; System.out.println("Particle: " + x + " is culled and up for replacement"); freeParticleArray.push(x); } } } } public void renderParticles(){ } }

My silly mistake an array of 10 index's starts at 0 and ends at 9
I was going from 0 to one higher than the arrays length.

And the error was a arrayoutofbound

BufferedImage image = ImageIO.read(new FileInputStream(path)); int WIDTH = image.getWidth(); int HEIGHT = image.getHeight(); int[][] png = new int[WIDTH][HEIGHT]; for(int y = 0; y <= HEIGHT; y++){ for(int x = 0; x <= WIDTH; x++){ png[x][y] = image.getRGB(x, y); } }

I have no idea what the problem is, I'm trying to read an image and place the colour inside an array which I'll use as a height map later, but right now... How to get pixel colour into a two dimensional array.

I thought it would be nice to explain the problem..
Firstly, the shape seemed REALLY weird due to it being in a perspective view and the values being a bit weird. So that was changed by using glOrtho which gives a straight view.
Secondly during rotation the near clipping was being hit so a simple glTranslate on the view solved that problem (I moved it back 5)

The solution was.

GL11.glMatrixMode(GL11.GL_PROJECTION); GL11.glLoadIdentity(); GL11.glOrtho(-8f, 8f, -8f, 8f, 1f, 10.0f); GL11.glTranslatef(0, 0, -5); GL11.glEnable(GL11.GL_DEPTH_TEST); while(!Display.isCloseRequested()){ GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT); GL11.glMatrixMode(GL11.GL_MODELVIEW); GL11.glLoadIdentity(); GL11.glClearColor(1, 1, 1, 0); // Draw a Cube GL11.glLoadIdentity(); GL11.glPopMatrix(); GL11.glRotatef(yaw, 0f, 1f, 0f); GL11.glRotatef(pitch, 1f, 0f, 1f); GL11.glBegin(GL11.GL_QUADS);

I've got no idea why, I'm new to the 3D area, though I've made a nice pong in 2D.
I've compaired my code to working samples and I can't see the difference, but when I import their code it works normally, but as I said I can't see the difference.

So here it is
Before the loop is
GL11.glMatrixMode(GL11.GL_PROJECTION); GL11.glLoadIdentity(); GL11.glFrustum(-10, 10, -10, 10, 1, 10); GL11.glMatrixMode(GL11.GL_MODELVIEW); GL11.glEnable(GL11.GL_DEPTH_TEST);
and then
while(!Display.isCloseRequested()){ GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT); GL11.glClearColor(1, 1, 1, 0); // Draw a Cube GL11.glLoadIdentity(); GL11.glRotatef(yaw, 0f, 1f, 0f); GL11.glRotatef(pitch, 1f, 0f, 1f); GL11.glBegin(GL11.GL_QUADS); GL11.glColor3f(1f, 0f, 0f); GL11.glVertex3f(-2, -2, -2); GL11.glVertex3f(-2, -2, -6); GL11.glVertex3f(-2, 2, -6); GL11.glVertex3f(-2, 2, -2); GL11.glColor3f(0f, 1f, 0f); GL11.glVertex3f(-2, -2, -2); GL11.glVertex3f(2, -2, -2); GL11.glVertex3f(2, -2, -6); GL11.glVertex3f(-2, -2, -6); GL11.glColor3f(0f, 0f, 1f); GL11.glVertex3f(-2, -2, -6); GL11.glVertex3f( 2, -2, -6); GL11.glVertex3f( 2, 2, -6); GL11.glVertex3f(-2, 2, -6); GL11.glColor3f(1f, 1f, 0f); GL11.glVertex3f( 2,-2, -2); GL11.glVertex3f( 2,-2, -6); GL11.glVertex3f( 2, 2, -6); GL11.glVertex3f( 2, 2, -2); GL11.glColor3f(1f, 0f, 1f); GL11.glVertex3f(-2, 2, -2); GL11.glVertex3f( 2, 2, -2); GL11.glVertex3f( 2, 2, -6); GL11.glVertex3f(-2, 2, -6); GL11.glColor3f(1f, 1f, 1f); GL11.glVertex3f(-2,-2, -2); GL11.glVertex3f( 2,-2, -2); GL11.glVertex3f( 2, 2, -2); GL11.glVertex3f(-2, 2, -2); GL11.glEnd(); if(Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) break; Display.update(); if(Keyboard.isKeyDown(Keyboard.KEY_LEFT)) yaw += 1; if(Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) yaw += -1; if(Keyboard.isKeyDown(Keyboard.KEY_UP)) pitch += 1; if(Keyboard.isKeyDown(Keyboard.KEY_DOWN)) pitch += -1; }