I have created a simple alien character made of multiple shapes, and the physics for this character are behaving correctly, but of the 2 polygons that are attached to the body, only one or the other can be seen on the screen - one seems to be invisible (it cannot be seen but objects will collide with it nonetheless). I can manipulate the code to choose which polygon is drawn, just by changing the order that the fixtures are created in the code. Basically, the polygon that is drawn, is the shape that is attached to the fixture that was created last in my code. I have tried to find an answer in the box2d and jbox2d  documentations, and on the box2d forum, but I have hit a brick wall. Any insight would be appreciated.

Here is an image that shows the problem. The program just creates new alien objects in the mouse location whilst mousePressed is true, then gravity is acted upon the objects

There is a right 'antenna' there, with collisions being detected correctly for it, but it is invisible

I can change the order of the fixtures being created to choose which antenna is drawn and which one is invisible in this part of the code (inside the Alien class)

2.     body.createFixture(cs, 1);
3.     body.createFixture(csl, 1);
4.     body.createFixture(csr, 1);
5.     // right antenna
6.     body.createFixture(ps, 1);
7.     // left antenna
8.     body.createFixture(ps2, 1);

... the left antenna is rendered correctly because it is the last one created. I have now idea why the other antenna is invisible, they are both drawn with the same method

Here is all the code (requires the PBox2D library)

2. import pbox2d.*;
3. import org.jbox2d.collision.shapes.*;
4. import org.jbox2d.common.*;
5. import org.jbox2d.dynamics.*;
6. 
   
7. PBox2D box2d;
8. ArrayList<Alien> aliens;
9. Boundary bound;
10. 
    
11. void setup() {
12.   size(640,360);
13.   box2d = new PBox2D(this);
14.   box2d.createWorld();
15.   
16.   // Create ArrayLists
17.   aliens = new ArrayList<Alien>();
18.   
19.   // X and y are at the centre of the object
20.   bound = new Boundary(width/2,300,200,5);  
21. }
22. 
    
23. void draw() {
24.   box2d.step();
25.   background(255);
26.   
27.   if (mousePressed) {
28.     Alien a = new Alien();
29.     aliens.add(a);
30.   }
31.   
32.   for (Alien A: aliens) {
33.     A.display();
34.   }
35.   
36.     // Display the boundary / static object
37.   bound.display();
38. }
39. 
    
41. class Alien {
42.   Body body;
43.   int bodyr, footr;
44. 
    
45.   Alien() {
46.     bodyr = 30;
47.     footr = 10;
48. 
    
49.     BodyDef bd = new BodyDef();
50. 
    
51.     bd.type = BodyType.DYNAMIC;
52.     bd.position.set(box2d.coordPixelsToWorld(mouseX, mouseY));
53.     bd.bullet = true;
54.     body = box2d.createBody(bd);
55. 
    
56.     // Alien body
57.     CircleShape cs = new CircleShape();
58.     cs.m_radius = box2d.scalarPixelsToWorld(bodyr);
59. 
    
60.     // Left foot
61.     CircleShape csl = new CircleShape();
62.     // Converting the vector to Box2D world
63.     Vec2 offset = new Vec2(bodyr, bodyr-2);
64.     offset = box2d.vectorPixelsToWorld(offset);
65.     // Setting the local position of the circle
66.     csl.m_p.set(offset.x, offset.y);
67.     csl.m_radius = box2d.scalarPixelsToWorld(footr);
68. 
    
69. 
    
70.     // Right foot
71.     CircleShape csr = new CircleShape();
72.     // Converting the vector to Box2D world
73.     Vec2 offset2 = new Vec2(-bodyr, bodyr-2);
74.     offset2 = box2d.vectorPixelsToWorld(offset2);
75.     // Setting the local position of the circle
76.     csr.m_p.set(offset2.x, offset2.y);
77.     csr.m_radius = box2d.scalarPixelsToWorld(footr);
78. 
    
79. 
    
80.     // Right Antenna
81.     Vec2[] vertices = new Vec2[4];  // An array of 4 vectors
82.     vertices[0] = box2d.vectorPixelsToWorld(new Vec2(20, -10));
83.     vertices[1] = box2d.vectorPixelsToWorld(new Vec2(30, -10));
84.     vertices[2] = box2d.vectorPixelsToWorld(new Vec2(35, -55));
85.     vertices[3] = box2d.vectorPixelsToWorld(new Vec2(30, -55));
86.     //[full] Making a polygon from that array
87.     PolygonShape ps = new PolygonShape();
88.     ps.set(vertices, vertices.length);
89.     //[end]
90.     
91.     // Left Antenna
92.     Vec2[] vertices2 = new Vec2[4];  // An array of 4 vectors
93.     vertices2[0] = box2d.vectorPixelsToWorld(new Vec2(-20, -10));
94.     vertices2[1] = box2d.vectorPixelsToWorld(new Vec2(-30, -10));
95.     vertices2[2] = box2d.vectorPixelsToWorld(new Vec2(-35, -55));
96.     vertices2[3] = box2d.vectorPixelsToWorld(new Vec2(-30, -55));
97.     //[full] Making a polygon from that array
98.     PolygonShape ps2 = new PolygonShape();
99.     ps2.set(vertices2, vertices2.length);
100.     //[end] 
101.   
102.     body.createFixture(cs, 1);
103.     body.createFixture(csl, 1);
104.     body.createFixture(csr, 1);
105.     // right antenna
106.     body.createFixture(ps, 1);
107.     // left antenna
108.     body.createFixture(ps2, 1);
109.   }
110. 
     
111.   void display() {
112.     Vec2 pos = box2d.getBodyPixelCoord(body);
113.     float a = body.getAngle();
114. 
     
115.     fill(175);
116.     stroke(0);
117. 
     
118.     // Draw the body
119.     pushMatrix();
120.     translate(pos.x, pos.y);
121.     rotate(-a);
122.     ellipse(0, 0, bodyr * 2, bodyr * 2);
123.     popMatrix();
124. 
     
125.     // Draw the left foot
126.     pushMatrix();
127.     translate(pos.x, pos.y);
128.     rotate(-a);
129.     ellipse(bodyr, bodyr-2, footr * 2, footr * 2);
130.     popMatrix();
131. 
     
132.     // Draw the right foot
133.     pushMatrix();
134.     translate(pos.x, pos.y);
135.     rotate(-a);
136.     ellipse(-bodyr, bodyr-2, footr * 2, footr * 2);
137.     popMatrix();
138. 
     
139.     // First we get the Fixture attached to the body...
140.     Fixture f = body.getFixtureList();
141.     PolygonShape ps = (PolygonShape) f.getShape();
142. 
     
143.     rectMode(CENTER);
144. 
     
145.     // Draw right antenna (ps)
146.     pushMatrix();
147.     translate(pos.x, pos.y);
148.     rotate(-a);
149.     beginShape();
150.     //[offset-up] We can loop through that array and convert each vertex from Box2D space to pixels.
151.     for (int i = 0; i < ps.getVertexCount(); i++) {
152.       Vec2 v = box2d.vectorWorldToPixels(ps.getVertex(i));
153.       vertex(v.x, v.y);
154.     }
155.     endShape(CLOSE);
156.     popMatrix();
157. 
     
158.     Fixture f2 = body.getFixtureList();
159.     PolygonShape ps2 = (PolygonShape) f2.getShape();
160. 
     
161.     // Draw Left antenna (ps2)
162.     pushMatrix();
163.     translate(pos.x, pos.y);
164.     rotate(-a);
165.     beginShape();
166.     //[offset-up] We can loop through that array and convert each vertex from Box2D space to pixels.
167.     for (int i = 0; i < ps2.getVertexCount(); i++) {
168.       Vec2 v2 = box2d.vectorWorldToPixels(ps2.getVertex(i));
169.       vertex(v2.x, v2.y);
170.     }
171.     endShape(CLOSE);
172.     popMatrix();
173.   }
174. 
     
175.   void killBody() {
176.     box2d.destroyBody(body);
177.   }
178. }
179. 
     
181. class Boundary {
182. 
     
183.   //[full] A boundary is a simple rectangle with x, y, width, and height.
184.   float x,y;
185.   float w,h;
186.   //[end]
187.   Body b;
188. 
     
189.   Boundary(float x_,float y_, float w_, float h_) {
190.     x = x_;
191.     y = y_;
192.     w = w_;
193.     h = h_;
194. 
     
195.     // Build the Box2D Body and Shape.
196.     BodyDef bd = new BodyDef();
197.     bd.position.set(box2d.coordPixelsToWorld(x,y));
198.     // Make it fixed by setting type to STATIC!
199.     bd.type = BodyType.STATIC;
200.     b = box2d.createBody(bd);
201. 
     
202.     float box2dW = box2d.scalarPixelsToWorld(w/2);
203.     float box2dH = box2d.scalarPixelsToWorld(h/2);
204.     PolygonShape ps = new PolygonShape();
205.     // The PolygonShape is just a box.
206.     ps.setAsBox(box2dW, box2dH);
207. 
     
208.     // Using the createFixture() shortcut
209.     b.createFixture(ps,1);
210.   }
211. 
     
212.   // Since we know it can never move, we can just draw it
213.   // the old-fashioned way, using our original
214.   // variables. No need to query Box2D.
215.   void display() {
216.     fill(0);
217.     stroke(0);
218.     rectMode(CENTER);
219.     rect(x,y,w,h);
220.   }
221. }