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

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
3def
0 / 0 / 0
Регистрация: 31.03.2013
Сообщений: 20
#1

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

01.04.2013, 07:30. Просмотров 962. Ответов 9
Метки нет (Все метки)

В общем следующая проблема: кубик должен крутиться вокруг начала координат, но он странно искажается и "убегает". Помогите пожалуйста. Делал через матрицы поворота.

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 минуты
Похоже, никто не поможет
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
01.04.2013, 07:30
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Вращение кубика вокруг начала координат (C++):

Вращение прямоугольника вокруг оси - C++
Программа должна вращать прямоугольник с заданными параметрами длины и ширины, вокруг оси. Общий алгоритм приведен ниже. Вопрос: как...

Вращение окружностей вокруг определенного центра - C++
Всем доброго времени и суток! Как сделать вращающиеся окружности вокруг центра? Рисунок есть. Не могу понять как задать цикл...

Вращение объекта вокруг оси. Матрицы поворота. - C++
добрый день, нужно сделать программу вращение куба вокруг оси z. Применил матрицу поворота к точкам и они далеко отошли От заданных. Не...

Подкиньте линк на готовую библиотеку для прокладки кратчайшего пути от кубика А до кубика Б - C++
Привет! Есть ли у кого - то на примете библиотека для прокладки кратчайшего пути от точки А до точки Б на графическом поле типа как в MS...

Найти сумму расстояний от начала координат до точек гиперболы - C++
Здравствуйте,объясните как делать задачу или покажите похожий пример. Вчера было первое занятие,разбираюсь со вчерашнего дня. С С++...

Написать программу для вычисления расстояния от начала координат - C++
Даны координаты 2-х точек на плоскости. Определить, какая из них лежит дальше от начала координат. Использовать функцию для вычисления...

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

Не по теме:

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

0
3def
0 / 0 / 0
Регистрация: 31.03.2013
Сообщений: 20
03.04.2013, 07:52  [ТС] #5
Прошу прощения, вот ссылка: http://sourceforge.net/apps/trac/txlib/wiki/TXLib
0
SDev
43 / 41 / 10
Регистрация: 15.03.2013
Сообщений: 89
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;
}
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;
0
SDev
43 / 41 / 10
Регистрация: 15.03.2013
Сообщений: 89
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;
}
0
Ольга5555
Сообщений: n/a
17.12.2013, 13:24 #9
у вас получился кубик, вращающийся вокруг одной из осей?
SDev
43 / 41 / 10
Регистрация: 15.03.2013
Сообщений: 89
17.12.2013, 17:07 #10
кубик может вращать вокруг трех осей попеременно, в соответствии с нажатой клавишей:
x,y,z
ось OZ направлена перпендикулярно плоскости экрана.
0
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
17.12.2013, 17:07
Привет! Вот еще темы с ответами:

Найти точку, расстояние от которой до начала координат минимальное - C++
На плоскости задано N точек с координатами (xi,yi) . Найти точку, расстояние от которой до начала координат минимальное. Для задания...

Осуществить "вращение" квадрата вокруг его центра - C++
вот есть не сложная задачка для Си: Осуществить &quot;вращение&quot; квадрата вокруг его центра. кто сможет сделать такое,буду очень...

Заданные точки плоскости рассортировать по возрастанию расстояния от начала координат - C++
Заданные точки плоскости рассортировать по возрастанию расстояния от начала координат. Для сортировки использовать алгоритм выбора...

Найти в массиве точки, которые максимально удалены от начала координат - C++
условие: точка плоскости может быть представлена двумя координатами X и Y. Дан массив, содержащий N точек. Найти точки, которые максимально...


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

Или воспользуйтесь поиском по форуму:
10
Yandex
Объявления
17.12.2013, 17:07
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru