Thread: Java 3D Problems - Canvas 3d and QuadArray rendering

the width is the width of a cubie (sticker) and the distance is the distance between the stickers

Why isn't this documented in the code?

Sorry, I was not originally working with other people... :/ I generally comment my code at the end so that I can look back on it in the future, but this is a project I will only be working on for the next ~2-3 weeks (I am implementing a 2 step algorithm solver as well as a brute force solver, I am also making this into a fully functional keyboard cube)

Please though, if you have any questions, pleasea ask away, I know the code might not be clear in some parts.

I have also Partially figured out my problem.... Ill post the snippets that half solve the canvas3D problem. It works, except the keylistener doesnt work.

  canvas.addKeyListener(new Rotator());
		canvas.startRenderer();
		canvas.setFocusable(true);
    // universe = new SimpleUniverse(canvas); // Doesnt Work; No frame display4ed
		universe = new SimpleUniverse(); // Does Work; No canvas (No keyAdapter)
		canvas.preRender();
 
...
 
     View v = universe.getViewer().getView();
    v.addCanvas3D(canvas);
     v.getCanvas3D(0).requestFocus(); // I have tried both individually and I am not sure which one works
	  v.getCanvas3D(0).requestFocusInWindow();

Again, I do not know why the KeyListener is not working.... And I dont know why it does not render correctly.

Thanks

Ok, I'll wait for the commented version.

* sigh *

 
   import java.awt.Color;
   import com.sun.j3d.utils.geometry.GeometryInfo;
   import com.sun.j3d.utils.geometry.NormalGenerator;
   import com.sun.j3d.utils.universe.SimpleUniverse;
   import javax.media.j3d.*;
   import javax.vecmath.*;
   import java.io.*;
   import java.awt.event.*;
	import javax.swing.*;
// An Egyptian pyramid
// Base divided into two triangles
   public class PyramidExample {
 
      public static PrintStream a = null;
      public static Canvas3D canvas = null;
 
      public static Vector3f viewTranslation = null;
      public static  Transform3D viewTransform = null;
 
      public static Transform3D rotation = null;
      public static	SimpleUniverse universe = null;
 
      public static void main(String[] args) throws Exception{
		   a = System.out;
			a.println("Print Output Stream Initialized");
     canvas = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
        a.println("Canvas Initialized");
     viewTranslation = new Vector3f();
	  a.println("Vector Initialized");
      viewTransform = new Transform3D();
		a.println("Print Output Stream Initialized");
 
     rotation = new Transform3D();
 
 
		a.println("Initialized Public Variables");
         canvas.addKeyListener(new Rotator());
		canvas.startRenderer();
		canvas.setFocusable(true);
		a.println("Initialized canvas");
    // universe = new SimpleUniverse(canvas); // Doesnt Work; No frame display4ed
		universe = new SimpleUniverse(); // Does Work; No canvas (No keyAdapter)
		a.println("Instantiated universe");
		canvas.preRender();
		a.println("Rendered canvas");
 
	 universe.getViewingPlatform().setNominalViewingTransform();
a.println("Set Nominal Viewing Transform");
         RubiksCube joe = new RubiksCube(.2, .01, null);	
			a.println("Instantiated Rubiks Cube");
 
         viewTranslation.z = 3;
         viewTranslation.x = 0f;
         viewTranslation.y = .3f;
      a.println("Set View Translation Variables");
 
         initializeChild(universe, joe.getCubies() );
			a.println("Initialized Cubies");
 
         initializeChild(universe, joe.cubiesP);
			a.println("Initialized Points");
			a.println("Changing");
			Thread.sleep(1000);
      View v = universe.getViewer().getView();
    v.addCanvas3D(canvas);
 
	  v.getCanvas3D(0).requestFocus();
 
          //rotateX(universe, 10, 1);
//          Thread.sleep(1000);
//          rotateY(universe, 10, -1);
//          Thread.sleep(1000);
//          rotateZ(universe, 10, 1);
//          Thread.sleep(1000);
//          rotateZ(universe, 10, -1);
//          Thread.sleep(1000);
//          rotateX(universe, 10, 1);
 
 
      }
      public static void initializeChild(SimpleUniverse universe, GeometryArray results) // This method adds an array to the SimpleUniverse
      {
         BranchGroup group = new BranchGroup();
         GeometryArray result = results;
         if(!(results instanceof PointArray))
         {
 
            IndexedQuadArray indexedCube = (IndexedQuadArray)results;
 
            Vector3f[] normals = { new Vector3f(0.0f, 0.0f, 1.0f),
                  new Vector3f(0.0f, 0.0f, -1.0f),
                  new Vector3f(1.0f, 0.0f, 0.0f),
                  new Vector3f(-1.0f, 0.0f, 0.0f),
                  new Vector3f(0.0f, 1.0f, 0.0f), new Vector3f(0.0f, -1.0f, 0.0f) };
         //Define the indices used to reference vertex array
            int coordIndices[] = { 0, 1, 2, 3, 7, 6, 5, 4, 0, 3, 7, 4, 5, 6, 2, 1,
                  0, 4, 5, 1, 6, 7, 3, 2 };
         //Define the indices used to reference normal array
            int normalIndices[] = { 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
                  4, 4, 4, 4, 5, 5, 5, 5};
         //Set the data
            indexedCube.setNormals(0, normals);
            indexedCube.setCoordinateIndices(0, coordIndices);
            indexedCube.setNormalIndices(0, normalIndices);
         //Define an appearance for the shape
 
         //Create and return the shape
            group.addChild(new Shape3D(indexedCube));
            universe.addBranchGraph(group);
 
 
         }
         else
         {
            Appearance pointApp = new Appearance();
 
         // enlarge the points
            pointApp.setPointAttributes(new PointAttributes(50, true));
            Shape3D pointShape = new Shape3D(results, pointApp);
            group.addChild(pointShape);
            universe.addBranchGraph(group);
         }
 
      }
 
		// Note that all rotate methods rotate the universe. Speed is how fast it is turning and prime is which way it turns.
		// There is no need for comments here as it works, trust me.
      public static void rotateX(SimpleUniverse universe, int speed, int prime) throws Exception // prime is either negative or positive 1
      {
         for(int i = 0;i<(Math.PI*50);i++)
         {
            rotation.rotX(((double)i)/100*prime);
            rotation.mul(viewTransform);
            u();
            v(universe);
            Thread.sleep(speed);
         }		
      }
      public static void rotateY(SimpleUniverse universe, int speed, int prime) throws Exception // prime is either negative or positive 1
      {
         for(int i = 0;i<(Math.PI*50);i++)
         {
            rotation.rotY(((double)i)/100*prime);
            rotation.mul(viewTransform);
            u();
            v(universe);
            Thread.sleep(speed);
         }		
      }
      public static void rotateZ(SimpleUniverse universe, int speed, int prime) throws Exception // prime is either negative or positive 1
      {
         for(int i = 0;i<(Math.PI*50);i++)
         {
            rotation.rotZ(((double)i)/100*prime);
            rotation.mul(viewTransform);
            u();
            v(universe);
            Thread.sleep(speed);
         }		
      }
      public static void v(SimpleUniverse universe) // Used to simplify the Rotates
      {
         universe.getViewingPlatform().getViewPlatformTransform().setTransform(rotation);
      }
      public static void u()
      {
         viewTransform.setTranslation(viewTranslation);// Used to simplify the Rotates
      }
      private static class Rotator implements KeyListener // Key Listener
      {
		public void keyTyped(KeyEvent e)
		{
		}
		public void keyReleased(KeyEvent e)
		{
		}
         public void keyPressed(KeyEvent e)
         {
			System.out.println("Pressed"); // Turns the cube in the direction of the arrow pressed. To see if anything is pressed, I added the println
            try{
               switch(e.getKeyCode())
               {
                  case(KeyEvent.VK_LEFT):
                     rotateZ(universe, 10, -1);
                     break;
                  case(KeyEvent.VK_RIGHT):
                     rotateZ(universe, 10, 1);
                     break;
                  case(KeyEvent.VK_UP):
                     rotateY(universe, 10, 1);
                     break;
                  case(KeyEvent.VK_DOWN):
                     rotateY(universe, 10, -1);
                     break;
               }
            }
               catch(Exception WTF){}
 
         }
      }
   }

 import java.awt.Color;
import com.sun.j3d.utils.geometry.GeometryInfo;
import com.sun.j3d.utils.geometry.NormalGenerator;
import com.sun.j3d.utils.universe.SimpleUniverse;
import javax.media.j3d.*;
import javax.vecmath.*;  
	public class RubiksCube
   {
	int place = 0;
      public IndexedQuadArray cubies = new IndexedQuadArray(24,GeometryArray.COORDINATES | GeometryArray.COLOR_3|IndexedQuadArray.NORMALS,24); // Initializes an array of size 24; 6 sides with vertices at the Top right, Top left, Bottom Right, and Bottom Left
		public PointArray cubiesP = new PointArray(216, PointArray.COORDINATES);// Initializes an array with all points. This includes every sticker (9*6) * every corner of the sticker (4) = 216
		public Point3f[][][] getPoints(float width, float distance)
		{
		Point3f[][][] points = new Point3f[6][6][6]; // This creates the grid. There are 6 sides, a 6x6 grid is on all sides.
		int place = 0;
		for(int right = 0;right<6;right++)
		for(int up = 0;up<6;up++)
		for(int front = 0;front<6;front++)
		points[right][up][front]=new Point3f(getNumb(right, width, distance),getNumb(up, width, distance) ,getNumb(front, width, distance)); // Puts the point at the correct location
 
		return points; // returns the array
		}
		public IndexedQuadArray getCubies() // accessor... No reason really to have it here, but we need it for the grade
		{
		return cubies;
		}
		public float getNumb(int numb, float width, float distance) // This returns the correct distance.
		{
 
		switch(numb)
		{ 		case(0):
		return (float)(-1.5 * width -distance); //Far edge
		case(1):
		return (float)(-.5 * width - distance); //far edge + width of the first cube
		case(2):
		return (float)(-.5 * width); // far edge + width of the first cube + distance between first cube and second
		case(3):
		return (float)(.5 * width); // the rest is a mirror of it. 
		case(4):
		return (float)(.5 * width + distance);
		default:
		return (float)(1.5 * width + distance);
		}
 
		}
 
		public void init(double width2, double distance2, Color[] colors)
		{
 
		int place= 0;
		float width = (float)width2; // Initializes them as floats
		float distance = (float)distance2;
		Point3f[][][] points = getPoints(width,distance);
	 	int a = 0;
		Color3b white = new Color3b((byte)255,(byte)255,(byte)255); // Initializes colors. I have not checked the colors.
		Color3b red = new Color3b((byte)255,(byte)5,(byte)10);
		Color3b orange = new Color3b((byte)170,(byte)30,(byte)30);
		Color3b green = new Color3b((byte)5,(byte)255,(byte)10);
		Color3b yellow = new Color3b((byte)20,(byte)70,(byte)70);
		Color3b blue = new Color3b((byte)1,(byte)10,(byte)255);
 
		Point3f[] paint = {points[0][0][0], points[0][0][5], points[0][5][0], points[0][5][5], points[5][0][0], points[5][0][5], points[5][5][0], points[5][5][5]};
		cubies.setColor(a, red);// These add the points in along with their color. I have checked the coordinate system and it works. 
		cubies.setCoordinate(a++,paint[0] );// 4      5  
		cubies.setColor(a, red);
		cubies.setCoordinate(a++,paint[1] );//    0     1
		cubies.setColor(a, red);
		cubies.setCoordinate(a++,paint[3] ); //6      7
		cubies.setColor(a, red);
		cubies.setCoordinate(a++,paint[2] );  //  2     3
 
		cubies.setColor(a, white);
		cubies.setCoordinate(a++,paint[0] );
		cubies.setColor(a, white);
		cubies.setCoordinate(a++,paint[1] );
		cubies.setColor(a, white);
		cubies.setCoordinate(a++,paint[5] );
		cubies.setColor(a, white);
		cubies.setCoordinate(a++,paint[4] );
 
		cubies.setColor(a, blue);
		cubies.setCoordinate(a++,paint[2] );
		cubies.setColor(a, blue);
		cubies.setCoordinate(a++,paint[6] );
		cubies.setColor(a, blue);
		cubies.setCoordinate(a++,paint[7] );
		cubies.setColor(a, blue);
		cubies.setCoordinate(a++,paint[3] );
 
		cubies.setColor(a, yellow);
		cubies.setCoordinate(a++,paint[2] );
		cubies.setColor(a, yellow);
		cubies.setCoordinate(a++,paint[0] );
		cubies.setColor(a, yellow);
		cubies.setCoordinate(a++,paint[4] );
		cubies.setColor(a, yellow);
		cubies.setCoordinate(a++,paint[6] );
 
		cubies.setColor(a, orange);
		cubies.setCoordinate(a++,paint[1] );
		cubies.setColor(a, orange);
		cubies.setCoordinate(a++,paint[3] );
		cubies.setColor(a, orange);
		cubies.setCoordinate(a++,paint[7] );
		cubies.setColor(a, orange);
		cubies.setCoordinate(a++,paint[5] );
 
		cubies.setColor(a, green);
		cubies.setCoordinate(a++,paint[6] );
		cubies.setColor(a, green);
		cubies.setCoordinate(a++,paint[7] );
		cubies.setColor(a, green);
		cubies.setCoordinate(a++,paint[5] );
		cubies.setColor(a, green);
		cubies.setCoordinate(a++,paint[4] );
 
 
 
 
// 		for(int p = 0;p<5;p++)
// 		for(int i = 0;i<6;i+=2) 
//  		for(int r = 0;r<6;r+=2) 
//  		{
//  		cubies.setCoordinate(a++,points[p][i][r]);	//One that goes front,
//  		cubies.setCoordinate(a++,points[p][i][1 + r]);
//  		cubies.setCoordinate(a++,points[p][1 + i][1 + r]);
//  		cubies.setCoordinate(a++,points[p][1 + i][r]);
// 		
// 				cubies.setCoordinate(a++,points[p][i][r]);	//One that goes Left
//  		cubies.setCoordinate(a++,points[p][i+1][r]);
//  		cubies.setCoordinate(a++,points[p+1][1 + i][r]);
//  		cubies.setCoordinate(a++,points[p+1][i][r]);
// 		
// 				cubies.setCoordinate(a++,points[p][i][r]);	//One that goes Up
//  		cubies.setCoordinate(a++,points[p][i][1 + r]);
//  		cubies.setCoordinate(a++,points[p+1][i][1 + r]);
//  		cubies.setCoordinate(a++,points[p+1][i][r]);
// 		
// 			 		
//  		}	
a = 0;
		for(int p = 0;p<6;p++)
		for(int i = 0;i<6;i++) 
		for(int r = 0;r<6;r++) 
		cubiesP.setCoordinate(a++,points[p][i][r]); // Puts all points in a PointArray
			}
 
 
 
 
 
      public RubiksCube(double width, double distance, Color[] colors) 
      {
		init(width, distance, colors); // Initializes the cube. No real point besides that it is simplified
        }
   }

I guess there should be a class on how to comment programs.
A lot of your comments are similar to something like this:
int i = 1; // Set i to 1

Rather than
int i = 1; // Start the search index at 1 vs being zero based

the comment explains WHY i is being set to 1.

Ok, I am sorry that it is not exactly what you wanted... Is there any chance you could

A. Tell me which lines you are confused about

or

B. Help me fix the problem..?

Sorry, I took at look at installing the 3D stuff. It hits too many spots on my system.
I don't have a separate system for testing, so I'll leave this to some one with 3D installed.

Tell me which lines you are confused about

here are a couple of uncommented pieces:
(Math.PI*50)
rotation.rotY(((double)i)/100*prime);

Ok..

And to the uncommented piece, It says in there that that part should be ignored as I am certain it works correctly.

I am certain it works correctly

Famous last words.

Originally Posted by Norm

Famous last words.

perhaps I should have said that I am certain it is irrelevant. It does this with and without the method.

Another look at your approach to commenting.
There is a non obvious bit to your code that is not commented and you say: it is irrelevant
It looks like the code is executed, so what does it do?
If it is not executed, remove it from your code.

It is a method which is put into the KeyListener under the switch statement. "Pressed" is printed before hand so that I know when a button is pressed..

Simply put, All that it does is rotate the cube.

You're still missing the point. All this info about how your code works should be as comments in the code. Posting it here is a waste of time. Anyone reading your code won't be seeing it.

Norm is right. Although you should keep comments to a minimum because well-written code (e.g. informative variable/method/class names) should generally be clear, any code that is not obvious should be carefully commented.

Of course, you don't need to comment code if you work alone and are quite happy you'll understand it all after 6 months (or even 6 weeks) away from it (although experienced coders generally do write comments for themselves because they have discovered it pays to do so).

But in this particular case, you're asking other people to read and understand your code, so you're not working alone. If you want people to help you, you need to help them understand your code by clarifying it with appropriate comments.