Форум программистов, компьютерный форум CyberForum.ru

Вращение кубика вокруг начала координат - C++

Восстановить пароль Регистрация
 
3def
0 / 0 / 0
Регистрация: 31.03.2013
Сообщений: 20
01.04.2013, 07:30     Вращение кубика вокруг начала координат #1
В общем следующая проблема: кубик должен крутиться вокруг начала координат, но он странно искажается и "убегает". Помогите пожалуйста. Делал через матрицы поворота.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
#include <iostream> 
#include <TxLib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
 
 
double a=3.1415/90;
double coord[8][3]= {{250, 250, 100},
                     {350, 250, 100},
                     {350, 150, 100},
                     {250, 150, 100},  
                     {250, 250, -100},
                     {350, 250, -100},
                     {350, 150, -100},
                     {250, 150, -100}};
double x[3][3] = {{1, 0, 0},
                   {0, cos(a), sin(a)},
                   {0, -sin(a),cos(a) }};
double y[3][3] = {{cos(a), sin(a), 0},
                   {-sin(a), cos(a), 0},
                   {0, 0, 1}}; 
double z[3][3] = {{cos(a), 0, sin(a)},
                   {0, 1, 0},
                   {-sin(a), 0, cos(a)}};
 
void draw()
{
  txClear();
  
  txSetPixel(coord[0][0]/*+x*/, coord[0][1]/*+y*/, TX_WHITE);
  txSetPixel(coord[1][0]/*+x*/, coord[1][1]/*+y*/, TX_WHITE);
  txSetPixel(coord[2][0]/*+x*/, coord[2][1]/*+y*/, TX_WHITE);
  txSetPixel(coord[3][0]/*+x*/, coord[3][1]/*+y*/, TX_WHITE);
  txSetPixel(coord[4][0]/*+x*/, coord[4][1]/*+y*/, TX_WHITE);
  txSetPixel(coord[5][0]/*+x*/, coord[5][1]/*+y*/, TX_WHITE);
  txSetPixel(coord[6][0]/*+x*/, coord[6][1]/*+y*/, TX_WHITE);
  txSetPixel(coord[7][0]/*+x*/, coord[7][1]/*+y*/, TX_WHITE);
  
  txLine(coord[0][0]/*+x*/, coord[0][1]/*+y*/, coord[1][0]/*+x*/, coord[1][1]/*+y*/);
  txLine(coord[1][0]/*+x*/, coord[1][1]/*+y*/, coord[2][0]/*+x*/, coord[2][1]/*+y*/);
  txLine(coord[2][0]/*+x*/, coord[2][1]/*+y*/, coord[3][0]/*+x*/, coord[3][1]/*+y*/);
  txLine(coord[3][0]/*+x*/, coord[3][1]/*+y*/, coord[0][0]/*+x*/, coord[0][1]/*+y*/);
  txLine(coord[4][0]/*+x*/, coord[4][1]/*+y*/, coord[5][0]/*+x*/, coord[5][1]/*+y*/);
  txLine(coord[5][0]/*+x*/, coord[5][1]/*+y*/, coord[6][0]/*+x*/, coord[6][1]/*+y*/);
  txLine(coord[6][0]/*+x*/, coord[6][1]/*+y*/, coord[7][0]/*+x*/, coord[7][1]/*+y*/);
  txLine(coord[7][0]/*+x*/, coord[7][1]/*+y*/, coord[4][0]/*+x*/, coord[4][1]/*+y*/);
  txLine(coord[0][0]/*+x*/, coord[0][1]/*+y*/, coord[4][0]/*+x*/, coord[4][1]/*+y*/);
  txLine(coord[1][0]/*+x*/, coord[1][1]/*+y*/, coord[5][0]/*+x*/, coord[5][1]/*+y*/);
  txLine(coord[2][0]/*+x*/, coord[2][1]/*+y*/, coord[6][0]/*+x*/, coord[6][1]/*+y*/);
  txLine(coord[3][0]/*+x*/, coord[3][1]/*+y*/, coord[7][0]/*+x*/, coord[7][1]/*+y*/);
}
 
void ox()
{
     a = a+0.5*a;
     for(int n=0; n<8; n++)
     {
                     coord[n][0] = coord[n][0]*x[0][0]+coord[n][1]*x[1][0]+coord[n][2]*x[2][0];
                     coord[n][0] = coord[n][1]*x[0][1]+coord[n][1]*x[1][1]+coord[n][2]*x[2][1];
                     coord[n][0] = coord[n][2]*x[0][2]+coord[n][1]*x[1][2]+coord[n][2]*x[2][2];                     
     }
}
 
void oz()
{
     a = a+0.5*a;
     for(int n=0; n<8; n++)
     {
                     coord[n][0] = coord[n][0]*z[0][0]+coord[n][1]*z[1][0]+coord[n][2]*z[2][0];
                     coord[n][1] = coord[n][1]*z[0][1]+coord[n][1]*z[1][1]+coord[n][2]*z[2][1];
                     coord[n][2] = coord[n][2]*z[0][2]+coord[n][1]*z[1][2]+coord[n][2]*z[2][2];                     
             
     }
}
 
void oy()
{
     a = a+0.5*a;
     for(int n=0; n<8; n++)
     {
             
                     coord[n][0] = coord[n][0]*y[0][0]+coord[n][1]*y[1][0]+coord[n][2]*y[2][0];
                     coord[n][1] = coord[n][1]*y[0][1]+coord[n][1]*y[1][1]+coord[n][2]*y[2][1];
                     coord[n][2] = coord[n][2]*y[0][2]+coord[n][1]*y[1][2]+coord[n][2]*y[2][2];                     
             
     }
}
 
void ox1()
{
     a = a-0.5*a;
     for(int n=0; n<8; n++)
     {
                     coord[n][0] = coord[n][0]*x[0][0]+coord[n][1]*x[1][0]+coord[n][2]*x[2][0];
                     coord[n][1] = coord[n][1]*x[0][1]+coord[n][1]*x[1][1]+coord[n][2]*x[2][1];
                     coord[n][2] = coord[n][2]*x[0][2]+coord[n][1]*x[1][2]+coord[n][2]*x[2][2];                     
     }
}
 
void oz1()
{
     a = a-0.5*a;
     for(int n=0; n<8; n++)
     {
                     coord[n][0] = coord[n][0]*z[0][0]+coord[n][1]*z[1][0]+coord[n][2]*z[2][0];
                     coord[n][1] = coord[n][1]*z[0][1]+coord[n][1]*z[1][1]+coord[n][2]*z[2][1];
                     coord[n][2] = coord[n][2]*z[0][2]+coord[n][1]*z[1][2]+coord[n][2]*z[2][2];                     
             
     }
}
 
void oy1()
{
     a = a-0.5*a;
     for(int n=0; n<8; n++)
     {
             
                     coord[n][0] = coord[n][0]*y[0][0]+coord[n][1]*y[1][0]+coord[n][2]*y[2][0];
                     coord[n][1] = coord[n][1]*y[0][1]+coord[n][1]*y[1][1]+coord[n][2]*y[2][1];
                     coord[n][2] = coord[n][2]*y[0][2]+coord[n][1]*y[1][2]+coord[n][2]*y[2][2];                     
             
     }
}
 
int main()
{
    char c;
txCreateWindow(600, 400);
txSetDefaults();
txSetColor ( TX_WHITE, 3);
txSetFillColor (TX_BLACK);
while(c!=27)
{
             draw();
             if(c == 'w')
             {
                  a = a+0.5*a;
                  ox();
             }
             if(c == 'a')
             {
                  a = a+0.5*a;
                  oy();
             }
             if(c == 'q')
             {
                  a = a+0.5*a;
                  oz();
             }
             if(c == 's')
             {
                  a = a-0.5*a;
                  ox();
             }
             if(c == 'd')
             {
                  a = a-0.5*a;
                  oy();
             }
             if(c == 'e')
             {
                  a = a-0.5*a;
                  oz();
             }
             c = getch();
}
getch();
 
return 0;
}
Добавлено через 2 часа 10 минут
...

Добавлено через 19 часов 53 минуты
Похоже, никто не поможет
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
SDev
43 / 41 / 10
Регистрация: 15.03.2013
Сообщений: 88
01.04.2013, 08:31     Вращение кубика вокруг начала координат #2
исходя из кода содержимое матриц поворота X,Y и Z у вас всегда будет постоянным, хотя вы во многих местах программы изменяете переменную "a", как я понял это попытка изменить элементы матриц поворота, но эти элементы нигде не просчитываются.
еще одно: в функции ox() трижды пересчитываете один элемент coord[n][0].
и угол "a" у вас меняется по странному закону a=a+0.5*a, т.е. прирастает не равными шагами.
3def
0 / 0 / 0
Регистрация: 31.03.2013
Сообщений: 20
03.04.2013, 01:24  [ТС]     Вращение кубика вокруг начала координат #3
Исправил, получилась та же фигня. самое вменяемое вращение вокруг y но и там все плохо. остальное - непонятно где центр вращения, такое ощущение, что он очень далеко и одновременно в нескольких местах
Croessmah
03.04.2013, 03:04
  #4

Не по теме:

Цитата Сообщение от 3def Посмотреть сообщение
Похоже, никто не поможет
помочь смогут те, у кого есть это:
C++
1
#include <TxLib.h>

3def
0 / 0 / 0
Регистрация: 31.03.2013
Сообщений: 20
03.04.2013, 07:52  [ТС]     Вращение кубика вокруг начала координат #5
Прошу прощения, вот ссылка: http://sourceforge.net/apps/trac/txlib/wiki/TXLib
SDev
43 / 41 / 10
Регистрация: 15.03.2013
Сообщений: 88
03.04.2013, 09:35     Вращение кубика вокруг начала координат #6
держи. вращает. жмешь <a,b,g> или <A,B,G>. правда при смене оси вращения берет исходное положения куба.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
#include <iostream> 
#include <TxLib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
 
double pi = 3.1415926535;
double h=2*pi/20;
double a=0,b=0,g=0;
 
double coord[8][3]= {{50, 150, 100},
                     {150, 150, 100},
                     {150, 50, 100},
                     {50, 50, 100},  
                     {50, 150, 00},
                     {150, 150, 00},
                     {150, 50, 00},
                     {50, 50, 00}};
double coord1[8][3];
 
double x[3][3] = {{1, 0, 0},
                   {0, cos(a), sin(a)},
                   {0, -sin(a),cos(a) }};
double y[3][3] = {{cos(a), sin(a), 0},
                   {-sin(a), cos(a), 0},
                   {0, 0, 1}}; 
double z[3][3] = {{cos(a), 0, sin(a)},
                   {0, 1, 0},
                   {-sin(a), 0, cos(a)}};
 
void draw()
{
  txClear();
  for(int n=0; n<8; n++)
  {
   coord1[n][0] = 200+coord1[n][0];
   coord1[n][1] = 200+coord1[n][1];
   coord1[n][2] = 200+coord1[n][2];
  }
 
  txSetPixel(coord1[0][0]/*+x*/, coord1[0][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[1][0]/*+x*/, coord1[1][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[2][0]/*+x*/, coord1[2][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[3][0]/*+x*/, coord1[3][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[4][0]/*+x*/, coord1[4][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[5][0]/*+x*/, coord1[5][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[6][0]/*+x*/, coord1[6][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[7][0]/*+x*/, coord1[7][1]/*+y*/, TX_WHITE);
  
  txLine(coord1[0][0]/*+x*/, coord1[0][1]/*+y*/, coord1[1][0]/*+x*/, coord1[1][1]/*+y*/);
  txLine(coord1[1][0]/*+x*/, coord1[1][1]/*+y*/, coord1[2][0]/*+x*/, coord1[2][1]/*+y*/);
  txLine(coord1[2][0]/*+x*/, coord1[2][1]/*+y*/, coord1[3][0]/*+x*/, coord1[3][1]/*+y*/);
  txLine(coord1[3][0]/*+x*/, coord1[3][1]/*+y*/, coord1[0][0]/*+x*/, coord1[0][1]/*+y*/);
  txLine(coord1[4][0]/*+x*/, coord1[4][1]/*+y*/, coord1[5][0]/*+x*/, coord1[5][1]/*+y*/);
  txLine(coord1[5][0]/*+x*/, coord1[5][1]/*+y*/, coord1[6][0]/*+x*/, coord1[6][1]/*+y*/);
  txLine(coord1[6][0]/*+x*/, coord1[6][1]/*+y*/, coord1[7][0]/*+x*/, coord1[7][1]/*+y*/);
  txLine(coord1[7][0]/*+x*/, coord1[7][1]/*+y*/, coord1[4][0]/*+x*/, coord1[4][1]/*+y*/);
  txLine(coord1[0][0]/*+x*/, coord1[0][1]/*+y*/, coord1[4][0]/*+x*/, coord1[4][1]/*+y*/);
  txLine(coord1[1][0]/*+x*/, coord1[1][1]/*+y*/, coord1[5][0]/*+x*/, coord1[5][1]/*+y*/);
  txLine(coord1[2][0]/*+x*/, coord1[2][1]/*+y*/, coord1[6][0]/*+x*/, coord1[6][1]/*+y*/);
  txLine(coord1[3][0]/*+x*/, coord1[3][1]/*+y*/, coord1[7][0]/*+x*/, coord1[7][1]/*+y*/);
}
 
void calcMatr(double a,double b,double g)
{
 x[0][0] = 1; x[0][1] =  0;     x[0][2] =  0;
 x[1][0] = 0; x[1][1] = cos(a); x[1][2] = sin(a);
 x[2][0] = 0; x[2][1] =-sin(a); x[2][2] = cos(a);
 
 y[0][0]= cos(b);  y[0][1]= sin(b); y[0][2]= 0;
 y[1][0]= -sin(b); y[1][1]= cos(b); y[1][2]= 0;
 y[2][0]= 0;       y[2][1]= 0;      y[2][2]= 1;
 
 z[0][0] = cos(g);  z[0][1] =  0; z[0][2] = sin(g);
 z[1][0] = 0;       z[1][1] = 1;  z[1][2] = 0;
 z[2][0] = -sin(g); z[2][1] =  0; z[2][2] =cos(g);
 
}
 
void ox()
{
     calcMatr( a,b,g);
     for(int n=0; n<8; n++)
     {
                     coord1[n][0] = coord[n][0]*x[0][0]+coord[n][1]*x[1][0]+coord[n][2]*x[2][0];
                     coord1[n][1] = coord[n][0]*x[0][1]+coord[n][1]*x[1][1]+coord[n][2]*x[2][1];
                     coord1[n][2] = coord[n][0]*x[0][2]+coord[n][1]*x[1][2]+coord[n][2]*x[2][2];                     
     }
}
 
void oz()
{
       calcMatr( a,b,g);
     for(int n=0; n<8; n++)
     {
                     coord1[n][0] = coord[n][0]*z[0][0]+coord[n][1]*z[1][0]+coord[n][2]*z[2][0];
                     coord1[n][1] = coord[n][0]*z[0][1]+coord[n][1]*z[1][1]+coord[n][2]*z[2][1];
                     coord1[n][2] = coord[n][0]*z[0][2]+coord[n][1]*z[1][2]+coord[n][2]*z[2][2];                     
             
     }
}
 
void oy()
{
      calcMatr( a,b,g);
     for(int n=0; n<8; n++)
     {
             
                     coord1[n][0] = coord[n][0]*y[0][0]+coord[n][1]*y[1][0]+coord[n][2]*y[2][0];
                     coord1[n][1] = coord[n][0]*y[0][1]+coord[n][1]*y[1][1]+coord[n][2]*y[2][1];
                     coord1[n][2] = coord[n][0]*y[0][2]+coord[n][1]*y[1][2]+coord[n][2]*y[2][2];                     
             
     }
}
 
int main()
{
    int c;
txCreateWindow(600, 600);
txSetDefaults();
txSetColor ( TX_WHITE, 3);
txSetFillColor (TX_BLACK);
c=0;
while(c!=27)
{
    c = getch();
             draw();
             if(c == 'a')
             {
                  a = a+h;
                  if( a < 0 )    a=2*pi+a;
                  if( a > 2*pi ) a=a-2*pi;
                  ox();
             }
             if(c == 'A')
             {
                  a = a-h;
                  if( a < 0 )    a=2*pi+a;
                  if( a > 2*pi ) a=a-2*pi;
                  ox();
             }
             if(c == 'b')
             {
                  b = b-h;
                  if( b < 0 )    b=2*pi+b;
                  if( b > 2*pi ) b=b-2*pi;
                  oy();
             }
             if(c == 'B')
             {
                   b = b+h;
                   if( b < 0 )    b=2*pi+b;
                   if( b > 2*pi ) b=b-2*pi;
                  oy();
             }
             if(c == 'g')
             {
                  g = g-h;
                  if( g < 0 )    g=2*pi+g;
                   if( g > 2*pi ) g=g-2*pi;
                  oz();
             }
             if(c == 'G')
             {
                  g = g+h;
                    if( g < 0 )    g=2*pi+g;
                   if( g > 2*pi ) g=g-2*pi;
                  oz();
             }
             
}
getch();
 
return 0;
}
3def
0 / 0 / 0
Регистрация: 31.03.2013
Сообщений: 20
03.04.2013, 20:37  [ТС]     Вращение кубика вокруг начала координат #7
Эмм, а ты уверен, что оно правильно работает? У меня всякая фигня вместо кубика. Кстати, именно для сохранения положения кубика при вращении по разным осям у меня заведен один массив координат, а не два, как у тебя

Добавлено через 31 минуту
Все, понял. Объясни только что это и зачем?
C++
1
2
3
                  g = g-h;
                  if( g < 0 )    g=2*pi+g;
                   if( g > 2*pi ) g=g-2*pi;
SDev
43 / 41 / 10
Регистрация: 15.03.2013
Сообщений: 88
04.04.2013, 04:45     Вращение кубика вокруг начала координат #8
сейчас вращает правильно.
клавиши: 'x' вокруг оси X, 'y' вокруг Y, 'z'-Z
чтобы увидеть трехмерность чередуй вращения по разным осям. в исходном положении ось Z смотрит в экран.
ошибка была в функциях пересчета ox(),oy(),oz()
старые координаты затирались раньше времени, хотя использовались в каждой формуле пересчета.
я добавил фигуру симметричную относительно начала координат, чтобы не уходила от центра осей.
можешь раскомментировать исходную фигуру, у нее амплитуда вращения побольше.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
#include <iostream> 
#include <TxLib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
 
double pi = 3.1415926535;
double h=pi/8;
double a=0,b=0,g=0;
/*
double coord[8][3]= {{50, 150, 100},
                     {150, 150, 100},
                     {150, 50, 100},
                     {50, 50, 100},  
                     {50, 150, 00},
                     {150, 150, 00},
                     {150, 50, 00},
                     {50, 50, 00}};
*/
 
 
double coord[8][3]= {{-20, 20, 100},
                     {20, 20, 100},
                     {20, -20, 100},
                     {-20, -20, 100},  
                     {-20, 20, -100},
                     {20, 20, -100},
                     {20, -20, -100},
                     {-20, -20, -100}};
 
double coord1[8][3];
 
double x[3][3] = {{1, 0, 0},
                   {0, cos(a), sin(a)},
                   {0, -sin(a),cos(a) }};
double z[3][3] = {{cos(a), sin(a), 0},
                   {-sin(a), cos(a), 0},
                   {0, 0, 1}}; 
double y[3][3] = {{cos(a), 0, sin(a)},
                   {0, 1, 0},
                   {-sin(a), 0, cos(a)}};
 
void draw()
{
  txClear();
  for(int n=0; n<8; n++)
  {
   coord1[n][0] = 200+coord[n][0];
   coord1[n][1] = 200+coord[n][1];
   coord1[n][2] = 200+coord[n][2];
  }
 
  txSetPixel(coord1[0][0]/*+x*/, coord1[0][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[1][0]/*+x*/, coord1[1][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[2][0]/*+x*/, coord1[2][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[3][0]/*+x*/, coord1[3][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[4][0]/*+x*/, coord1[4][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[5][0]/*+x*/, coord1[5][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[6][0]/*+x*/, coord1[6][1]/*+y*/, TX_WHITE);
  txSetPixel(coord1[7][0]/*+x*/, coord1[7][1]/*+y*/, TX_WHITE);
  
  txLine(coord1[0][0]/*+x*/, coord1[0][1]/*+y*/, coord1[1][0]/*+x*/, coord1[1][1]/*+y*/);
  txLine(coord1[1][0]/*+x*/, coord1[1][1]/*+y*/, coord1[2][0]/*+x*/, coord1[2][1]/*+y*/);
  txLine(coord1[2][0]/*+x*/, coord1[2][1]/*+y*/, coord1[3][0]/*+x*/, coord1[3][1]/*+y*/);
  txLine(coord1[3][0]/*+x*/, coord1[3][1]/*+y*/, coord1[0][0]/*+x*/, coord1[0][1]/*+y*/);
  txLine(coord1[4][0]/*+x*/, coord1[4][1]/*+y*/, coord1[5][0]/*+x*/, coord1[5][1]/*+y*/);
  txLine(coord1[5][0]/*+x*/, coord1[5][1]/*+y*/, coord1[6][0]/*+x*/, coord1[6][1]/*+y*/);
  txLine(coord1[6][0]/*+x*/, coord1[6][1]/*+y*/, coord1[7][0]/*+x*/, coord1[7][1]/*+y*/);
  txLine(coord1[7][0]/*+x*/, coord1[7][1]/*+y*/, coord1[4][0]/*+x*/, coord1[4][1]/*+y*/);
  txLine(coord1[0][0]/*+x*/, coord1[0][1]/*+y*/, coord1[4][0]/*+x*/, coord1[4][1]/*+y*/);
  txLine(coord1[1][0]/*+x*/, coord1[1][1]/*+y*/, coord1[5][0]/*+x*/, coord1[5][1]/*+y*/);
  txLine(coord1[2][0]/*+x*/, coord1[2][1]/*+y*/, coord1[6][0]/*+x*/, coord1[6][1]/*+y*/);
  txLine(coord1[3][0]/*+x*/, coord1[3][1]/*+y*/, coord1[7][0]/*+x*/, coord1[7][1]/*+y*/);
}
 
void calcMatr(double a,double b,double g)
{
 x[0][0] = 1; x[0][1] =  0;     x[0][2] =  0;
 x[1][0] = 0; x[1][1] = cos(a); x[1][2] = sin(a);
 x[2][0] = 0; x[2][1] =-sin(a); x[2][2] = cos(a);
 
 z[0][0]= cos(b);  z[0][1]= sin(b); z[0][2]= 0;
 z[1][0]= -sin(b); z[1][1]= cos(b); z[1][2]= 0;
 z[2][0]= 0;       z[2][1]= 0;      z[2][2]= 1;
 
 y[0][0] = cos(g);  y[0][1] =  0; y[0][2] = sin(g);
 y[1][0] = 0;       y[1][1] = 1;  y[1][2] = 0;
 y[2][0] = -sin(g); y[2][1] =  0; y[2][2] =cos(g);
 
}
 
void ox()
{ 
    double xx,yy,zz;
     calcMatr( a,b,g);
     for(int n=0; n<8; n++)
     {
                     xx = coord[n][0]*x[0][0]+coord[n][1]*x[1][0]+coord[n][2]*x[2][0];
                     yy = coord[n][0]*x[0][1]+coord[n][1]*x[1][1]+coord[n][2]*x[2][1];
                     zz = coord[n][0]*x[0][2]+coord[n][1]*x[1][2]+coord[n][2]*x[2][2];                     
                     coord[n][0] = xx;
                     coord[n][1] = yy;
                     coord[n][2] = zz;  
     }
}
 
void oz()
{
       //calcMatr( a,b,g);
       double cb=cos(b);
       double sb=sin(b);
       double xx,yy;
     for(int n=0; n<8; n++)
     {
                     xx = coord[n][0]*cb+coord[n][1]*sb;
                     yy = -coord[n][0]*sb+coord[n][1]*cb;
                     coord[n][0]=xx;
                     coord[n][1]=yy;
                     //coord[n][2] = coord[n][2];                     
             
     }
}
 
void oy()
{
    double xx,yy,zz;
   calcMatr( a,b,g);
     for(int n=0; n<8; n++)
     {
           xx = coord[n][0]*y[0][0]+coord[n][1]*y[1][0]+coord[n][2]*y[2][0];
           yy = coord[n][0]*y[0][1]+coord[n][1]*y[1][1]+coord[n][2]*y[2][1];
           zz = coord[n][0]*y[0][2]+coord[n][1]*y[1][2]+coord[n][2]*y[2][2]; 
           coord[n][0] = xx;
           coord[n][1] = yy;
           coord[n][2] = zz;    
     }
}
 
int main()
{
    int c;
txCreateWindow(600, 600);
txSetDefaults();
txSetColor ( TX_WHITE, 3);
txSetFillColor (TX_BLACK);
c=0;
draw();
while(c!=27)
{
      
             if(c == 'x')
             {
                  a=h;b=g=0;
                  ox();
             }
           
             if(c == 'z')
             {
                 
                 a=g=0;
                 b=h;
                 oz();
             }
             
             if(c == 'y')
             {
                
                 a=b=0;
                 g=h;
                  oy();
             }
                        
             draw();
             c = getch();
}
getch();
return 0;
}
Ольга5555
Сообщений: n/a
17.12.2013, 13:24     Вращение кубика вокруг начала координат #9
у вас получился кубик, вращающийся вокруг одной из осей?
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
17.12.2013, 17:07     Вращение кубика вокруг начала координат
Еще ссылки по теме:

C++ Найти сумму расстояний от начала координат до точек гиперболы
Подкиньте линк на готовую библиотеку для прокладки кратчайшего пути от кубика А до кубика Б C++
C++ Написать программу для вычисления расстояния от начала координат

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
SDev
43 / 41 / 10
Регистрация: 15.03.2013
Сообщений: 88
17.12.2013, 17:07     Вращение кубика вокруг начала координат #10
кубик может вращать вокруг трех осей попеременно, в соответствии с нажатой клавишей:
x,y,z
ось OZ направлена перпендикулярно плоскости экрана.
Yandex
Объявления
17.12.2013, 17:07     Вращение кубика вокруг начала координат
Ответ Создать тему
Опции темы

Текущее время: 12:29. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru