are all your vertices numbered in the same direction (anti-clockwise when looking into the shape is the standard)? without this you can't trust the sign of the normal.

http://www.gamedev.net/page/resources/_/technical/graphics-programming-and-theory/3d-backface-culling-r1088

The vertices come from the processing box() method.

actually, running the code i think you have another problem (in addition?). it looks like you aren't using the transformed positions of the vertices. um, hard to explain. when you draw the boxes all the positions get transformed by the projection matrix. it's the transformed positions that you need to use (and i'm not sure you have access to these)

when i do this i do EVERYTHING myself. i have 3d points and i rotate them and perspective transform them and then i backface cull them and then (conditionally) 2d project them. because you're letting processing do at least half of those steps then the results are wrong.

this doesn't use peasycam, and is probably more dodecahedra than you possibly need, but it's probably my clearest example

1. // acd 2013
2. // static constant Dode members made global
3. private static final float MAX_ROT = .2;
4. private static final int FACES = 12;
5. private static final int VERTICES = 5;  // per face
6. private static final float A = 1.618033989; // (1 * sqr(5) / 2) - wikipedia
7. private static final float B = 0.618033989; // 1 / (1 * sqr(5) / 2) - wikipedia
8. private PVector[] vert = null; // list of vertices
9. private int[][] faces = null;  // list of faces (joining vertices)
10. private static final float SPACING = 40;
11. private static final float SIZE = 10;
12. 
    
13. Dodec dodec;
14. 
    
15. void setup() {
16.   size(1000, 500, P2D);
17.   dodec = new Dodec();
18.   smooth();
19. }
20. 
    
21. void draw() {
22.   background(255);
23.   stroke(0);
24.   noFill();
25.   smooth();
26. //  fill(255, 255, 255);
27.   for (int y = 0 ; y < (height / SPACING) ; y++) {
28.     for (int x = 0 ; x < (width / SPACING) ; x++) {
29.       Dodec dodec = new Dodec(x * SPACING + (SPACING / 2), y * SPACING + (SPACING / 2), 0, SIZE);
30.       dodec.setRotations(x, y, 0);
31.       dodec.draw();
32.     }
33.   } 
34.   noLoop();
35.   saveFrame("dodes.png");
36. }
37. 
    
38. void vertex(PVector v) {
39.   vertex(v.x, v.y, v.z);
40. }
41. 
    
42. class Dodec {
43.   private float sz; // size
44.   private float px, py, pz;  // position
45.   private float rx, ry, rz;  // rotations
46.   private float dx, dy, dz;  // rotations
47.   private float cangle = 0;  // centres sinusoidal
48. 
    
49.   public Dodec() {
50.     this(1.0, 2.0, 3.0, 1.0);
51.   }
52. 
    
53.   public Dodec(float _x, float _y, float _z, float _sz) {
54.     sz = _sz;
55.     rx = random(0, TWO_PI);
56.     ry = random(0, TWO_PI);
57.     rz = random(0, TWO_PI);
58.     dx = random(-MAX_ROT, MAX_ROT);
59.     dy = random(-MAX_ROT, MAX_ROT);
60.     dz = random(-MAX_ROT, MAX_ROT);
61.     px = _x;
62.     py = _y;
63.     pz = _z;
64.     if (vert == null) {
65.       // init verts
66.       vert = new PVector[20];
67.       vert[ 0] = new PVector(1, 1, 1);
68.       vert[ 1] = new PVector(1, 1, -1);
69.       vert[ 2] = new PVector(1, -1, 1);
70.       vert[ 3] = new PVector(1, -1, -1);
71.       vert[ 4] = new PVector(-1, 1, 1);
72.       vert[ 5] = new PVector(-1, 1, -1);
73.       vert[ 6] = new PVector(-1, -1, 1);
74.       vert[ 7] = new PVector(-1, -1, -1);
75.       vert[ 8] = new PVector(0, B, A);
76.       vert[ 9] = new PVector(0, B, -A);
77.       vert[10] = new PVector(0, -B, A);
78.       vert[11] = new PVector(0, -B, -A);
79.       vert[12] = new PVector(B, A, 0);
80.       vert[13] = new PVector(B, -A, 0);
81.       vert[14] = new PVector(-B, A, 0);
82.       vert[15] = new PVector(-B, -A, 0);
83.       vert[16] = new PVector(A, 0, B);
84.       vert[17] = new PVector(A, 0, -B);
85.       vert[18] = new PVector(-A, 0, B);
86.       vert[19] = new PVector(-A, 0, -B);
87.     }
88.     // rotate points
89.     for (int i = 0 ; i < 20 ; i++) {
90.       vert[i] = rotX(vert[i], rx);
91.       vert[i] = rotY(vert[i], ry);
92.       vert[i] = rotZ(vert[i], rz);
93.     }
94.    
95.     if (faces == null) {
96.       // init faces
97.       faces = new int[FACES][VERTICES];
98.       // faces connect points - worked out using trial and error
99.       faces[ 0] = new int[] { 0, 16,  2, 10,  8};
100.       faces[ 1] = new int[] { 0,  8,  4, 14, 12};
101.       faces[ 2] = new int[] { 0, 12,  1, 17, 16};
102.       faces[ 3] = new int[] { 1,  9, 11,  3, 17};
103.       faces[ 4] = new int[] { 1, 12, 14,  5,  9};
104.       faces[ 5] = new int[] { 2, 13, 15,  6, 10};
105.       faces[ 6] = new int[] { 2, 16, 17,  3, 13};
106.       faces[ 7] = new int[] { 3, 11,  7, 15, 13};
107.       faces[ 8] = new int[] { 4,  8, 10,  6, 18};
108.       faces[ 9] = new int[] { 4, 18, 19,  5, 14};
109.       faces[10] = new int[] { 5, 19,  7, 11,  9};
110.       faces[11] = new int[] {15,  7, 19, 18,  6};
111.     }
112.   }
113.  
114.   public void setPosition(float x, float y, float z) {
115.     px = x;
116.     py = y;
117.     pz = z;
118.   }
119.   public void setRotations(float x, float y, float z) {
120.     rx = x;
121.     ry = y;
122.     rz = z;
123.   }
124.  
125.   public void move() {
126.     rx += dx;
127.     ry += dy;
128.     rz += dz;
129.     cangle += .05;
130.     cangle = HALF_PI;
131.   }
132.   public void draw() {
133.     pushMatrix();
134.     translate(px, py);//, pz);
135.     scale(sz);
136.     for (int i = 0 ; i < FACES ; i++) {
137.       drawFace(i);
138.     }
139.     popMatrix();
140.   }
141.   private void drawFace(int face) {
142.     // check hlr
143.     PVector v1 = PVector.sub(vert[faces[face][1]], vert[faces[face][0]]);
144.     PVector v2 = PVector.sub(vert[faces[face][2]], vert[faces[face][1]]);
145.     PVector c = v2.cross(v1);
146.     float d = c.dot(0, 0, 1);
147. //    println("Face: " + face + " dot: " + d);
148.     if (d < 0) {
149.       beginShape(POLYGON);
150.       stroke(0); noFill();  // black lines
151.       // noStroke(); fill(d * -100);  // shade
152.       for (int i = 0 ; i < VERTICES ; i++) {
153.         vertex2d(vert[faces[face][i]]);
154.       }
155.       vertex2d(vert[faces[face][0]]);
156.       endShape();
157.     }
158.    
159.     // normal (debugging)
160.     if (false) {
161.       PVector centre = new PVector(0, 0, 0);
162.       centre.add(vert[faces[face][0]]);
163.       centre.add(vert[faces[face][1]]);
164.       centre.add(vert[faces[face][2]]);
165.       centre.add(vert[faces[face][3]]);
166.       centre.add(vert[faces[face][4]]);
167.       centre.div(5);
168.       if (d < 0) {
169.         stroke(255, 0, 0);
170.       } else {
171.         stroke(0, 255, 0);
172.       }
173.       line2d(centre, PVector.add(centre, c));
174.     }
175.   }
176.  
177.   private void vertex2d(PVector p) {
178.     vertex(p.x, p.y);
179.   }
180.  
181.   private void line2d(PVector p1, PVector p2) {
182.     line(p1.x, p1.y, p2.x, p2.y);
183.   }
184.  
185.   PVector rotX(PVector p, float angle) {
186.     float c = cos(angle);
187.     float s = sin(angle);
188.     PVector t = new PVector();
189.     t.x = p.x;
190.     t.y = c * p.y + s * p.z;
191.     t.z = -s * p.y + c * p.z;
192.     return t;
193.   }
194.  
195.   PVector rotY(PVector p, float angle) {
196.     float c = cos(angle);
197.     float s = sin(angle);
198.     PVector t = new PVector();
199.     t.x = c * p.x + s * p.z;
200.     t.y = p.y;
201.     t.z = -s * p.x + c * p.z;
202.     return t;
203.   }
204.  
205.   PVector rotZ(PVector p, float angle) {
206.     float c = cos(angle);
207.     float s = sin(angle);
208.     PVector t = new PVector();
209.     t.x = c * p.x + s * p.y;
210.     t.y = -s * p.x + c * p.y;
211.     t.z = p.z;
212.     return t;
213.   }
214. }

it looks like you aren't using the transformed positions of the vertices

> Why does it look like that?

educated guess 8)

the left sides are shown, on all boxes, when you'd be able to see the left hand side of boxes in the middle of the screen.
the right sides are shown, on all boxes, when you'd be able to see the right hand side of boxes in the middle of the screen.

the fact that it's roughly ok when y is near 0 suggests it's ignoring the y position of boxes and that suggests that it's calculating the hidden faces before the projection is applied.

example above might not be too useful as z is near 0 everywhere and there's no perspective. plus camera is static and on z axis (line 146). i might have a better example. will see how you get on first 8)

(oh, hlr in line 142 = hidden line removal. i'm not drawing lines that make up the faces that are facing away. it's virtually the same thing as backface culling, just for wireframe objects)

If i get rid of peasycam, would it fix the problem?