OK. You are absolutely right. It was my mistake.

I am trying to rotate object in 3d space.

rotateX,rotateY,rotate Z doesn't work good.

Unfortunatelly object doesn't rotate using global rotation.

When attempting to create 3D programs there are two co-ordinate systems to work with
(1) World co-ordinates
      These don't move and are used to define a position in the world.
(2) Local co-ordinates
      These are used to define the 3D shape's vertices. The origin might be the centre of the shape (as in Shapes3D)

The important thing in 3D is to AVOID transforming local coordinates to rotate/translate a shape because it is very resource hungry. The correct approach is to modify the transofrmation matrix.

So in the main sketch you might have

1. void draw() {
2.   background(200);   
3.   translate(width/2, height/2);
   
4.   pushMatrix();
5.   drawShape();
6.  
7.   popMatrix();
8. }

Then to draw the shape

1. void drawShape(){
2.   pushStyle();
3.   pushMatrix();
4.   translate(pos.x, pos.y, pos.z);
5.   rotateX(rot.x);
6.   rotateY(rot.y);
7.   rotateZ(rot.z);
8.   scale(shapeScale);
9. 
   
10.   // Code to draw shape using untransformed local coordinates
    
11. 
    
12.   popMatrix();
13.   popStyle();
14. }

Where pos is a PVector objects that defines the world position of the shape, and rot is a PVector that defines the shapes rotation about the about local axis.

P.S. Do not use resetMatrix() even if it is suggested, what I am showing you here is 'good programming practice'

This is the approach used in the Shapes3D library.

Now if you ALSO want to rotate the world space then modify the draw method to something like

1. void draw() {
2.   background(200);   
3.   translate(width/2, height/2);
   
4.   pushMatrix();
5.   rotateX(wrot.x);
6.   rotateY(wrot.y);
7.   rotateZ(wrot.z);
8.   drawShape();
9.  
10.   popMatrix();
11. }

where wrot is a PVector to hold the world rotation angles.

The Rot and Quaternion classes are used to permanently transform the local coordinates used for a shape and as said before this should be avoided whenever possible.

HTH

Thanks, but i probably didn't wrote exactly.

The Rot and Quaternion classes are used to permanently transform the local coordinates used for a shape and as said before this should be avoided whenever possible.

`Using a Rot object to transform a PVector is done in two stages

1. create the Rot object using one of the constructors
2. use the Rot object methods to transform a PVector

This can be seen by this example

Example - rotation about the Z axis by angle in radians.
To create the Rot object we need to define the before and after rotation positions for an arbitrary vector. Since we are rotating about the Z axis we we use the vector [1, 0, 0] after rotating the vector it will be [cos(angle), sin(angle),0]
So to create the Rot object we have

1. Rot rot = new Rot(new PVector(1,0,0), new PVector(cos(angle), sin(angle),0));

Now to transform any PVector object (pv) so that it is rotated by rot

1. pv = rot.applyTo(pv);
2. // or to get a rotated copy of pv (leaving pv unchanged)
3. PVector pv_copy = rot.applyToNew(pv);

Since the rot is unchanged when applied to a PVector then it can be reused as often as you like.

I suggest that you study the Rot class reference materials, but the whole premise is based on the using the Rot objects to perform transformations and the user does not get involved in the quaternion maths.

The Rot and Quaternion classes are used to permanently transform the local coordinates used for a shape and as said before this should be avoided whenever possible.

If the centre of your shape is at world position (0,0,0) then there is no difference between world and local coordinates in that case are you sure that ' 2 axis are global, 1 is local' ???

I should point out that the Shapes3D library NEVER transforms the vertices to rotate an shape for drawing, it uses the approach in one of my previous posts. In fact I included the Rot class in the library to support the creation of the surface meshes. So I know it is possible to do what you want without using the Rot class

Having said that, 12 points is not a lot to transform so I suggest that you keep the original values safe and use the applyToNew method to create a new set for drawing with when a rotation is required. Since you are always starting with the original vertices then you can define the absolute angles of rotation.

When rotation is 0,0,0 it should be the same. 

I should point out that the Shapes3D library NEVER transforms the vertices to rotate an shape

When a shape is created with this library it calculates the coordinates of the surface mesh with the origin (0,0,0) being the centre of the shape. The shape also has 2 PVector for its world position and its rotation about the local axises.

When the time comes to draw the shape it foed

1. pushMatrix to save the current transformation matrix
2. translate using the world position PVector
3. rotateX, rotateY, rotateZ using the x,y,z values in the rotation vector
4. NOW use the mesh coordinates to display the shape
5. popMatrix to restore the previous transformation matrix

Note that actions 2 and 3 do NOT change the mesh coordinates, but do change the transformation matrix. In fact the mesh coordinates NEVER change using this technique.
The advantage of this is that the angles can be changed independently but the rotation is always about the local axis.

The problem with using Rot is that the final transformation is dependent on the order of rotations so you will have to solve the problem by trial and error.

I know that transforming 12 points will not adversely affect the frame-rate of your program but I strongly recommend attempting the first approach rather than using Rot

Note that actions 2 and 3 do NOT change the mesh coordinates, but do change the transformation matrix. In fact the mesh coordinates NEVER change using this technique.

 

It is true. Mesh coordinates are Const.