Processing Forum

Orbit rotation: start rotating from a given position

[1 Reply]
- 23-Nov-2012 02:34 AM
- Forum: Programming Questions
Hi there, I need some input here. I'm having some trouble on calculationg some coords when making orbit rotations. I've made up a simple sketch just to point what I'm trying to do:

I got a planet which can have satellites. Each of them, rotates on its orbit. Everything ok so far.

In this sketch, you can add satellites dynamically by pressing the mouse, so it calculates the rotation angle and the orbit size based on the planet and mouse coords. This works, but since the satellite animation coords is based on millis(), once it starts getting drawn, it starts from a random (well, not really random) point in the orbit. What I want to achieve is that it starts its path right from the initial position provided by the mouse input, or the closer I can get. Any ideas on how can I handle this?

I'm trying to figure out this to apply it to another app I'm playing with, where I have particles that attract other particles and transform them into their satellites, but I made this sketch to keep it simple.
1. import processing.opengl.*;
2. Planet planet;
4. void setup(){
5. size(800, 600, OPENGL);
6. planet = new Planet(15, width/2, height/2, 0);
7. sphereDetail(4);
8. }
10. void draw(){
11. background(0);
12. frame.setTitle(int(frameRate) + " fps");
13. planet.display();
14. }
16. void mousePressed(){
17. planet.addSatellite();
18. }
21. class Planet{
22. float size, x, y, z;
23. ArrayList<Satellite> satellites;
24. Planet(float size, float x, float y, float z){
25. this.size = size;
26. this.x = x;
27. this.y = y;
28. this.z = z;
29. satellites = new ArrayList<Satellite>();
30. }
32. void display(){
33. pushMatrix();
34. translate(x,y,x);
35. fill(150); stroke(200);
36. sphere(size);
37. for (Iterator<Satellite> it = satellites.iterator(); it.hasNext(); ) {
38. it.next().display();
39. }
40. popMatrix();
41. }
43. void addSatellite(){
44. satellites.add(new Satellite(this, mouseX, mouseY, 0, random(2,5)));
45. }
46. }
48. class Satellite{
49. float size, x, y, z, orbitDuration, orbitRad, rotz;
51. Satellite(Planet parent, float sx, float sy, float sz, float size){
52. this.size = size;
53. orbitDuration = random(2000,4000); //random orbit cycle duration
54. orbitRad = dist(sx, sy, sz, parent.x, parent.y, parent.z)/4.3; //calculate the ortbit radius, based on the distance between planet coords (parent) and mouse coords. (WHY SHOULD I DIVIDE IT?)
55. //calculate the angle between the planet coords and mouse coords.
56. float dx = sx - parent.x;
57. float dy = sy - parent.y;
58. float ang = atan2(dy,dx);
59. if (ang < 0) ang += TWO_PI;
60. rotz = ang;
61. }
63. void display(){
64. //calculate coords
65. float ang = TWO_PI * millis()/orbitDuration*-1; //*-1 -> clockwise
66. x = cos(ang)*orbitRad;
67. y = 0;
68. z = sin(ang)*orbitRad;
69. //draw
70. pushMatrix();
71. rotateZ(rotz);
72. translate(x,y,z);
73. fill(75); stroke(125);
74. sphere(size);
75. popMatrix();
76. }
77. }
Note I'm calculating the orbit size (as I mentioned before) based on the distance between the mouse coords and the planet (parent)... but I had to divide it by 4 to get a closer result... not sure why.

Any help, suggestion or tip would be really appreciated.

Thanks in advance,

Jon

[OpenGL] HOW TO map-texture a subdivided icosahedron with VBOs?

[11 Replies]
- 03-Nov-2012 12:14 AM
- Forum: Contributed Library Questions
Hello there,
I'm starting with opengl and, after playing with GLGraphics, I became interested on learning a bit more about opengl.

What I'm trying to do sounds simple, but I'm getting some trouble with textures.

I'm basically computing a subdivided icosahedron, which after 3 o 4 subdivisions looks like a sphere. Then, I'm drawing this model using VBOs. This part works OK... but when i try to get it textured, the results are terrible. I'm not sure if the problem is on how I'm calculating the tex coords or the opengl calls.

This is what i got so far. Any ideas?
1. import processing.opengl.*; //OPENGL
2. import javax.media.opengl.*; // USE OF OPENGL DIRECTLY
3. import java.nio.FloatBuffer; //FLOATBUFFERS
4. import java.nio.IntBuffer; //INTBUFFERS
5. import com.sun.opengl.util.BufferUtil; //BUFFERS
6. //import com.sun.opengl.util.texture.*; //TEXTURES
7. import codeanticode.glgraphics.*;
9. PGraphicsOpenGL pgl;
10. GL gl;
11. //icosahedron
12. Ico ico;
13. //just a var for rotation testing
14. int rot = 0;
15. //texture
16. GLTexture tex;
19. void setup() {
20. size(800, 600, OPENGL);
21. frameRate(60);
23. pgl = (PGraphicsOpenGL) g; // g may change
24. gl = pgl.gl;
26. //buffers
27. int[] bufferID = new int[3];
28. gl.glGenBuffers(3, bufferID, 0);
29. //new icosahedron (lvl of subdivisions <0= regular icosahedron>), verts buffer, indices buffer, tex buffer)
30. ico = new Ico(2, bufferID[0], bufferID[1], bufferID[2]);
31. //load an img
32. tex = new GLTexture(this, "nebula.jpg");
34. }
37. void draw() {
38. frame.setTitle(str(frameRate));
39. background(100);
40. //rotation
41. rot++;
42. if (rot == 360) {
43. rot = 0;
44. }
46. //OpenGL calls
47. pgl = (PGraphicsOpenGL) g; // g may change
48. gl = pgl.gl;
50. pgl.beginGL();
52. setLghts(gl); //just some lights, nothing relevant
54. gl.glPushMatrix();
55. gl.glTranslatef(width/2, height/2, 0);
56. gl.glRotatef(rot, 1, 1, 0);
57. gl.glEnable(gl.GL_NORMALIZE);
58. gl.glScalef(50, 50, 50);
60. //VBO's
62. //set current VBO (vertices)
63. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, ico.vertBufferID);
64. //supply data to the current VBO --- glBufferData(int target, int size(in bytes), Buffer data, int usage)
65. //size*4, since 1 float = 4 bytes.
66. gl.glBufferData(GL.GL_ARRAY_BUFFER, ico.vertCont*4, ico.vertBuffer, GL.GL_STATIC_DRAW);
68. gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);
69. gl.glNormalPointer(GL.GL_FLOAT, 0, 0);
71. //tex -----
72. gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
73. gl.glEnable(GL.GL_TEXTURE_2D);
74. gl.glBindTexture(gl.GL_TEXTURE_2D, tex.getTextureID());
76. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, ico.texBufferID);
77. gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, 0);
78. //---------
80. //leave no buffer ID bound.
81. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
83. //set current VBO (indices)
84. gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ico.indBufferID);
85. gl.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, ico.indCont*4, ico.indBuffer, GL.GL_STATIC_DRAW);
86. //leave no buffer ID bound.
87. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
89. gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
90. gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
92. // Draw the triangles using the indices VBO
93. gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ico.indBufferID);
94. gl.glDrawElements(GL.GL_TRIANGLES, ico.indCont, GL.GL_UNSIGNED_INT, 0);
95. //leave no buffer ID bound.
96. gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
98. gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
99. gl.glDisableClientState(GL.GL_NORMAL_ARRAY);
100. gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
102. gl.glPopMatrix();
104. pgl.endGL();
106. }
The Icosahedron class (I wrote it following the "red book" and different approaches I found around)
1. class Ico{
2. float[][] vertices; //vertices
3. int[][] indices; //indices
4. ArrayList<Float> vertAL; //AL vertices
5. ArrayList<Integer> indAL; //AL indices
6. int vertCont, indCont, lvl; //vertices/indices count, subdivide level
7. int vertBufferID; //Buffer ID vertices
8. int indBufferID; //Buffer ID indices
9. int texBufferID; //Buffer ID texturas
10. FloatBuffer vertBuffer; //Buffer vertices
11. IntBuffer indBuffer; //Buffer indices
12. FloatBuffer texBuffer; //Buffer texturas
14. //CONSTRUCTOR
15. //computes the icosahedron data (normals and vertices are the same)
16. Ico(int lvl, int vertBufferID, int indBufferID, int texBufferID){
17. this.lvl = lvl;
18. this.vertBufferID = vertBufferID;
19. this.indBufferID = indBufferID;
20. this.texBufferID = texBufferID;
21. vertAL = new ArrayList<Float>();
22. indAL = new ArrayList<Integer>();
24. float x = .525731112119133606;
25. float z = .850650808352039932;
26. //vertices
27. vertices = new float[][] {
28. {-x, 0.0, z}, {x, 0.0, z}, {-x, 0.0, -z}, {x, 0.0, -z},
29. {0.0, z, x}, {0.0, z, -x}, {0.0, -z, x}, {0.0, -z, -x},
30. {z, x, 0.0}, {-z, x, 0.0}, {z, -x, 0.0}, {-z, -x, 0.0}
31. };
32. //indices
33. indices = new int[][] {
34. {0,4,1}, {0,9,4}, {9,5,4}, {4,5,8}, {4,8,1},
35. {8,10,1}, {8,3,10}, {5,3,8}, {5,2,3}, {2,7,3},
36. {7,10,3}, {7,6,10}, {7,11,6}, {11,0,6}, {0,1,6},
37. {6,1,10}, {9,0,11}, {9,11,2}, {9,2,5}, {7,2,11}
38. };
39. //add vertices to ArrayList
40. for (float[] v : vertices) {
41. vertAL.add(v[0]); vertAL.add(v[1]); vertAL.add(v[2]);
42. }
43. //subdivide each face as many times lvl
44. for (int[] f: indices) {
45. subdivide(f[0], f[1], f[2], vertAL, indAL, lvl);
46. }
47. //vertices and indices count
48. vertCont = vertAL.size();
49. indCont = indAL.size();
50. //vertices Buffer
51. vertBuffer = BufferUtil.newFloatBuffer(vertCont);
52. for (float v : vertAL){ vertBuffer.put(v); }
53. vertBuffer.rewind();
54. //indices Buffer
55. indBuffer = BufferUtil.newIntBuffer(indCont);
56. for (int i : indAL){ indBuffer.put(i); }
57. indBuffer.rewind();
58. //texture coords Buffer
59. texBuffer = BufferUtil.newFloatBuffer(vertCont*2); //nro. de caras * 3 vert * 2 uv cords
61. for (int i=0; i<vertCont; i+=3){
62. //get point
63. float[]punto = new float[]{vertAL.get(i), vertAL.get(i+1), vertAL.get(i+2)};
64. //calculate u and v
65. float[] uv = calcTexCoord(punto);
66. texBuffer.put(uv[0]);
67. texBuffer.put(uv[1]);
68. }
69. texBuffer.rewind();
71. }
74. // Given a point P on a unit sphere, calculate texture coords [u, v]
75. float[] calcTexCoord(float[] P){
76. // using spherical coords
77. // a is the angle from z axis [0, pi]
78. // t is the angle from x-axis [0, 2pi]
79. float a, t;
81. a = acos(P[2]);
82. float tmp = sin(a);
83. // check for poles
84. if(Math.abs(tmp) < 0.001) {
85. t = 0.0;
86. }
87. else {
88. float tmp2 = P[0]/tmp;
89. // clamp to [-1, 1] - due to small numerical errors
90. tmp2 = Math.min(Math.max(tmp2, -1.0), 1.0);
91. t = acos(tmp2);
92. if(P[1] < 0.0) {
93. t = 2.0*PI - t;
94. }
95. }
96. // convert to [0, 1]
97. float v = 1.0 - a/PI;
98. float u = t/(2.0*PI);
100. return new float[]{u, v};
101. }
104. //faces subdivision
105. void subdivide(int v1, int v2, int v3, ArrayList<Float> vertices, ArrayList<Integer> faces, int level) {
106. if (level == 0) {
107. faces.add(v1);
108. faces.add(v2);
109. faces.add(v3);
110. }
111. else {
112. float a1 = (vertices.get(3*v1) + vertices.get(3*v2));
113. float a2 = (vertices.get(3*v1+1) + vertices.get(3*v2+1));
114. float a3 = (vertices.get(3*v1+2) + vertices.get(3*v2+2));
115. float length = (float)Math.sqrt(a1*a1+a2*a2+a3*a3);
116. a1 /= length;
117. a2 /= length;
118. a3 /= length;
119. int indexA = vertices.size()/3;
120. vertices.add(a1);
121. vertices.add(a2);
122. vertices.add(a3);
124. float b1 = (vertices.get(3*v3) + vertices.get(3*v2));
125. float b2 = (vertices.get(3*v3+1) + vertices.get(3*v2+1));
126. float b3 = (vertices.get(3*v3+2) + vertices.get(3*v2+2));
127. length = (float)Math.sqrt(b1*b1+b2*b2+b3*b3);
128. b1 /= length;
129. b2 /= length;
130. b3 /= length;
131. int indexB = vertices.size()/3;
132. vertices.add(b1);
133. vertices.add(b2);
134. vertices.add(b3);
136. float c1 = (vertices.get(3*v1) + vertices.get(3*v3));
137. float c2 = (vertices.get(3*v1+1) + vertices.get(3*v3+1));
138. float c3 = (vertices.get(3*v1+2) + vertices.get(3*v3+2));
139. length = (float)Math.sqrt(c1*c1+c2*c2+c3*c3);
140. c1 /= length;
141. c2 /= length;
142. c3 /= length;
143. int indexC = vertices.size()/3;
144. vertices.add(c1);
145. vertices.add(c2);
146. vertices.add(c3);
148. subdivide(v1,indexA,indexC,vertices,faces,level-1);
149. subdivide(indexA,v2,indexB,vertices,faces,level-1);
150. subdivide(indexC,indexB,v3,vertices,faces,level-1);
151. subdivide(indexA,indexB,indexC,vertices,faces,level-1);
152. }
153. }
154. }
Without textures, the model displays perfect.

It'd be great to have some input from you guys, any correction/suggestion/tip/advice would be gladly welcome.
Thanks in advance!

GlGraphics - Simple questions: 4th value of a GlModel vert

[0 Replies]
- 17-Oct-2012 04:05 PM
- Forum: Contributed Library Questions
Hi there..
I've playing a bit with the amazing glgraphics lib, trying to learn how to handle models, lights and stuff.

This may sound noob/silly, but, when vertices are stored in its floatBuffer (model.vertices), it stores x,y,z and a 4th value. Whats this 4th value and what does it stands for? (it's set 1.0 by default)

I'm playing with a sphere model (in fact, it's an icosahedron i subdivide to make it look like a sphere). After it is calculated, I want to "distort" some of its vertices to get some "peaks". I've been trying this by modifying a certain model's vert, but i'm not sure which value should be modified to achieve this.

This is a basic sketch of what i'd like to achieve. Any tips? Thanks in advance!

Using VBOs and particles (generative/interactive)

[0 Replies]
- 01-Oct-2012 03:08 PM
- Forum: Contributed Library Questions
Hello there,
I've been playing with traer physics, glgraphics and toxiclibs for a couple days, terrific stuff!

I'm also getting my first steps into opengl and was reading about VBOs for performance improvements, which brought me here to read a couple posts about it. So, I need a little advice/tip regarding the use of VBOs:

As far as I understood, when using VBO I need to compute/store model vertices on setup, but I was wondering if this can be used 'on the fly'. For example, I'd like to create something simple:

- I have an object called customSphere, which computes a custom sphere from scratch storing its data on floatBuffers.

- I also have a particle system. Each time a certain event is called (i.e. mousePressed) a new particle is created, and it remains alive for a short time period.

- The thing is I'd like to create a 'customSphere' for each of these particles, being able to set/modify its size, polygon detail (subsdivision), texture mapping, polygon distortion, etc, since each particle would interact with the others.

So I was wondering... Which is the best approach for doing this (performance oriented)? Should I have each object calculated when it's created? Should I have a pre-calculated buffer and then, when the object is created, copy this into new buffers? or maybe just do operations like translate/rotate for each particle using an original pre-calculated buffer?

Any help/suggestion/advice would be really apreciated. Thanks in advance!

Jon

Activity Trend