Загрузка...
Учебная работа. Реферат: Трехмерная графика Теория
Короткие теоретические сведения.
Любая точка места (не считая исходной точки О) быть может задана четверкой сразу не равных нулю чисел ((x,y,z,1) либо, наиболее обще, (hx,hy,hz,h), где 
). Эта четверка определена совершенно точно с точностью до общего множителя. Предложенный подход дает возможность пользоваться матричной записью и в наиболее сложных , трехмерных задачках.
Как понятно, хоть какое аффинное преобразование в трехмерном пространстве быть может представлено в виде суперпозиции вращений растяжений, отражений и переносов. Потому довольно тщательно обрисовать матрицы лишь этих крайних преобразований.
A. Матрицы вращения в пространстве.
Матрица вращения вокруг оси абсцисс на угол q:
Матрица вращения вокруг оси ординат на угол w:
Матрица вращения вокруг оси аппликат на угол x:
Б. Матрица растяжения (сжатия):
тут a>0 — коэффициент растяжения (сжатия) вдоль оси абсцисс,b>0-коэффициент растяжения (сжатия) вдоль оси ординат,y>0-коэффициент растяжения (сжатия) вдоль оси аппликат.
В. Матрица отражения .
Матрица отражения относительно плоскости xOy:
Матрица отражения относительно плоскости yOz:
Матрица отражения относительно плоскости zOx:
Г. Матрица переноса :
тут (r,q,v)-вектор переноса.
Заметим, что, как и в двумерном случае , все выписанные матрицы не вырождены.
Ортографическая
В случае , если плоскость проектирования параллельна координатной плоскости, нужно помножить матрицу [Px] на матрицу сдвига . Имеем
Аналогично записываются матрицы проектирования вдоль 2-х координатных осей:
Аксонометрическая
Этот же самый итог мы получим, привлекая матрицу
По правде,
Mатрица проектирования, естественно, вырождена ; матрица же соответственного многообещающего преобразования(без проектирования) имеет последующий вид
язык С++ предоставляет весьма комфортные средства, дозволяющие приметно упростить работу с векторами и преобразованиями в пространстве.
Разглядим реализацию работы с векторами.
// Файл vector.h
#ifndef __VECTOR__#define __Vector__#include <math.h>class Vector{public: double x, y, z; Vector () {}; Vector ( double v ) { x = y = z = v; };
Vector ( const Vector& v ) { x = v.x; y = v.y; z = v.z; };
Vector ( double vx, double vy, double vz ) { x = vx; y = vy; z = vz; };
Vector& operator = ( const Vector& v ) { x = v.x; y = v.y; z = v.z;
return *this; }
Vector& operator = ( double f ) { x = y = z = f; return *this; };
Vector operator — () const;
Vector& operator += ( const Vector& );
Vector& operator -= ( const Vector& );
Vector& operator *= ( const Vector& );
Vector& operator *= ( double );
Vector& operator /= ( double );
friend Vector operator + ( const Vector&, const Vector& );
friend Vector operator — ( const Vector&, const Vector& );
friend Vector operator * ( const Vector&, const Vector& );
friend Vector operator * ( double, const Vector& );
friend Vector operator * ( const Vector&, double );
friend Vector operator / ( const Vector&, double );
friend Vector operator / ( const Vector&, const Vector& );
friend double operator & ( const Vector& u, const Vector& v )
{ return u.x * v.x + u.y * v.y + u.z * v.z; };
friend Vector operator ^ ( const Vector&, const Vector& );
double operator ! () { return (double) sqrt ( x * x + y * y + z * z ); };
double& operator [] ( int n ) { return *( &x + n ); };
int operator < ( double v ) { return x < v && y < v && z < v; };
int operator > ( double v ) { return x > v && y > v && z > v; };
};
class Ray
{
public:
Vector Org;
Vector Dir;
Ray () {};
Ray ( Vector& o, Vector& d ) { Org = o, Dir = d; };
Vector
};
inline Vector Vector :: operator — () const
{
return Vector ( -x, -y, -z );
}
inline Vector operator + ( const Vector& u, const Vector& v )
{
return Vector ( u.x + v.x, u.y + v.y, u.z + v.z );
}
inline Vector operator — ( const Vector& u, const Vector& v )
{
return Vector ( u.x — v.x, u.y — v.y, u.z — v.z );
}
inline Vector operator * ( const Vector& u, const Vector& v )
{
return Vector ( u.x * v.x, u.y * v.y, u.z * v.z );
}
inline Vector operator * ( const Vector& u, double f )
{
return Vector ( u.x * f, u.y * f, u.z * f );
}
inline Vector operator * ( double f, const Vector& v )
{
return Vector ( f * v.x, f * v.y, f * v.z );
}
inline Vector operator / ( const Vector& u, const Vector& v )
{
return Vector ( u.x / v.x, u.y / v.y, u.z / v.z );
}
inline Vector operator / ( const Vector& u, double f )
{
return Vector ( u.x / f, u.y / f, u.z / f );
}
inline Vector& Vector :: operator += ( const Vector& v )
{
x += v.x;
y += v.y;
z += v.z;
return *this;
}
inline Vector& Vector :: operator -= ( const Vector& v )
{
x -= v.x;
y -= v.y;
z -= v.z;
return *this;
}
inline Vector& Vector :: operator *= ( const Vector& v )
{
x *= v.x;
y *= v.y;
z *= v.z;
return *this;
}
inline Vector& Vector :: operator *= ( double v )
{
x *= v;
y *= v;
z *= v;
return *this;
}
inline Vector& Vector :: operator /= ( double v )
{
x /= v;
y /= v;
z /= v;
return *this;
}
inline Vector Normalize ( Vector& v ) { return v / !v; }
Vector RndVector ();
Vector& Clip ( Vector& v );
#endif
—————————————————————————-
// Файл vector.срр
#include <math.h>
#include <stdlib.h>
#include «Vector.h»
Vector operator ^ ( const Vector& u, const Vector& v )
{
return Vector ( u.y * v.z — u.z * v.y,
u.z * v.x — u.x * v.z,
u.x * v.y — u.y * v.x );
}
Vector RndVector ()
{
Vector v ( rand () — 0.5 * RAND_MAX,
rand () — 0.5 * RAND_MAX,
rand () — 0.5 * RAND_MAX );
return Normalize ( v );
}
Vector& Clip ( Vector& v )
{
if ( v.x < 0.0 ) v.x = 0.0;
else
if ( v.x > 1.0 ) v.x = 1.0;
if ( v.y < 0.0 ) v.y = 0.0;
else
if ( v.y > 1.0 ) v.y = 1.0;
if ( v.z < 0.0 ) v.z = 0.0;
else
if ( v.z > 1.0 ) v.z = 1.0;
return v;
}
С данной нам целью создается класс Vector, содержащий внутри себя составляющие вектора, и для этого класса переопределяются главные знаки операций.
— — унарный минус и поэлементное вычитание векторов;
+ — поэлементное сложение векторов;
* — умножение вектора на число;
* — поэлементное умножение векторов;
/ — деление вектора на число;
/ — поэлементное деление векторов;
& — скалярное произведение векторов;
^ — векторное произведение;
! — длина вектора;
[] — компонента вектора.
При всем этом обычные ценности операций сохраняются.
Не считая этих операций определяются также некие простые функции для работы с векторами:
Normalize – нормирование вектора;
RndVector – получение практически умеренно распределенного случайного единичного вектора;
Clip – отсечение вектора.
С внедрением этого класса можно в естественной и комфортной форме записывать сложные векторные выражения.
Аналогичным образом вводится класс Matrix, служащий для представления матриц преобразований в трехмерном пространстве. Для этого класса также делается переопределение главных символов операций.
//файл matrix.h
#ifndef __MATRIX__
#define __MATRIX__
#include «Vector.h»
class Matrix
{
public:
double x [4][4];
Matrix () {};
Matrix ( double );
Matrix& operator += ( const Matrix& );
Matrix& operator -= ( const Matrix& );
Matrix& operator *= ( const Matrix& );
Matrix& operator *= ( double );
Matrix& operator /= ( double );
void Invert ();
void Transpose ();
friend Matrix operator + ( const Matrix&, const Matrix& );
friend Matrix operator — ( const Matrix&, const Matrix& );
friend Matrix operator * ( const Matrix&, double );
friend Matrix operator * ( const Matrix&, const Matrix& );
friend Vector operator * ( const Matrix&, const Vector& );
};
Matrix Translate ( const Vector& );
Matrix Scale ( const Vector& );
Matrix RotateX ( double );
Matrix RotateY ( double );
Matrix RotateZ ( double );
Matrix Rotate ( const Vector&, double );
Matrix MirrorX ();
Matrix MirrorY ();
Matrix MirrorZ ();
#endif
//—————————————————————————
// файл matrix.cpp
#include <math.h>#include «matrix.h»Matrix :: Matrix ( double v ){ int j; for ( int i = 0; i < 4; i++ ) for ( j = 0; j < 4; j++ ) x [i][j] = ( i == j ) ? v : 0.0; x [3][3] = 1;}void Matrix :: Invert ()
{
Matrix Out ( 1 );
for ( int i = 0; i < 4; i++ ) {
double d = x [i][i];
if ( d != 1.0 ) {
for ( int j = 0; j < 4; j++ ) {
Out.x [i][j] /= d;
x [i][j] /= d;
}
}
for ( int j = 0; j < 4; j++ ) {
if ( j != i ) {
if ( x[j][i] != 0.0 ) {
double mulby = x[j][i];
for ( int k = 0; k < 4; k++ ) {
x [j][k] -= mulby * x [i][k];
Out.x [j][k] -= mulby * Out.x [i][k];
}
}
}
}
}
*this = Out;
}
void Matrix :: Transpose ()
{
double t;
int j;
for ( int i = 0; i < 4; i++ )
for ( j = 0; j < 4; j++ )
if ( i != j ) {
t = x [i][j];
x [i][j] = x [j][i];
x [j][i] = t;
}
}
Matrix& Matrix :: operator += ( const Matrix& A )
{
int j;
for ( int i = 0; i < 4; i++ )
for ( j = 0; j < 4; j++ )
x [i][j] += A.x [i][j];
return *this;
}
Matrix& Matrix :: operator -= ( const Matrix& A )
{
int j;
for ( int i = 0; i < 4; i++ )
for ( j = 0; j < 4; j++ )
x [i][j] -= A.x [i][j];
return *this;
}
Matrix& Matrix :: operator *= ( double v )
{
int j;
for ( int i = 0; i < 4; i++ )
for ( j = 0; j < 4; j++ )
x [i][j] *= v;
return *this;
}
Matrix& Matrix :: operator *= ( const Matrix& A )
{
Matrix res = *this;
int j;
for ( int i = 0; i < 4; i++ )
for ( j = 0; j < 4; j++ ) {
double sum = 0;
for ( int k = 0; k < 4; k++ )
sum += res.x [i][k] * A.x [k][j];
x [i][j] = sum;
}
return *this;
}
Matrix operator + ( const Matrix& A, const Matrix& B )
{
Matrix res;
int j;
for ( int i = 0; i < 4; i++ )
for ( j = 0; j < 4; j++ )
res.x [i][j] = A.x [i][j] + B.x [i][j];
return res;
}
Matrix operator — ( const Matrix& A, const Matrix& B )
{
Matrix res;
int j;
for ( int i = 0; i < 4; i++ )
for ( j = 0; j < 4; j++ )
res.x [i][j] = A.x [i][j] — B.x [i][j];
return res;
}
Matrix operator * ( const Matrix& A, const Matrix& B )
{
Matrix res;
int j;
for ( int i = 0; i < 4; i++ )
for ( j = 0; j < 4; j++ ) {
double sum = 0;
for ( int k = 0; k < 4; k++ )
sum += A.x [i][k] * B.x [k][j];
res.x [i][j] = sum;
}
return res;
}
Matrix operator * ( const Matrix& A, double v )
{
Matrix res;
int j;
for ( int i = 0; i < 4; i++ )
for ( j = 0; j < 4; j++ )
res.x [i][j] = A.x [i][j] * v;
return res;
}
Vector operator * ( const Matrix& M, const Vector& v )
{
Vector res;
res.x = v.x * M.x [0][0] + v.y * M.x [1][0] + v.z * M.x [2][0] + M.x [3][0];
res.y = v.x * M.x [0][1] + v.y * M.x [1][1] + v.z * M.x [2][1] + M.x [3][1];
res.z = v.x * M.x [0][2] + v.y * M.x [1][2] + v.z * M.x [2][2] + M.x [3][2];
double denom = v.x * M.x [0][3] + v.y * M.x [1][3] +
v.z * M.x [2][3] + M.x[3][3];
if ( denom != 1.0 )
res /= denom;
return res;
}
Matrix Translate ( const Vector& Loc )
{
Matrix res ( 1 );
res.x [3][0] = Loc.x;
res.x [3][1] = Loc.y;
res.x [3][2] = Loc.z;
return res;
};
Matrix Scale ( const Vector& v )
{
Matrix res ( 1 );
res.x [0][0] = v.x;
res.x [1][1] = v.y;
res.x [2][2] = v.z;
return res;
};
Matrix RotateX ( double Angle )
{
Matrix res ( 1 );
double Cosine = cos ( Angle );
double Sine = sin ( Angle );
res.x [1][1] = Cosine;
res.x [2][1] = — Sine;
res.x [1][2] = Sine;
res.x [2][2] = Cosine;
return res;
};
Matrix RotateY ( double Angle )
{
Matrix res ( 1 );
double Cosine = cos ( Angle );
double Sine = sin ( Angle );
res.x [0][0] = Cosine;
res.x [2][0] = — Sine;
res.x [0][2] = Sine;
res.x [2][2] = Cosine;
return res;
};
Matrix RotateZ ( double Angle )
{
Matrix res ( 1 );
double Cosine = cos ( Angle );
double Sine = sin ( Angle );
res.x [0][0] = Cosine;
res.x [1][0] = — Sine;
res.x [0][1] = Sine;
res.x [1][1] = Cosine;
return res;
};
Matrix Rotate ( const Vector& axis, double angle )
{
Matrix res ( 1 );
double Cosine = cos ( angle );
double Sine = sin ( angle );
res.x [0][0] = axis.x * axis.x + ( 1 — axis.x * axis.x ) * Cosine;
res.x [0][1] = axis.x * axis.y * ( 1 — Cosine ) + axis.z * Sine;
res.x [0][2] = axis.x * axis.z * ( 1 — Cosine ) — axis.y * Sine;
res.x [0][3] = 0;
res.x [1][0] = axis.x * axis.y * ( 1 — Cosine ) — axis.z * Sine;
res.x [1][1] = axis.y * axis.y + ( 1 — axis.y * axis.y ) * Cosine;
res.x [1][2] = axis.y * axis.z * ( 1 — Cosine ) + axis.x * Sine;
res.x [1][3] = 0;
res.x [2][0] = axis.x * axis.z * ( 1 — Cosine ) + axis.y * Sine;
res.x [2][1] = axis.y * axis.z * ( 1 — Cosine ) — axis.x * Sine;
res.x [2][2] = axis.z * axis.z + ( 1 — axis.z * axis.z ) * Cosine;
res.x [2][3] = 0;
res.x [3][0] = 0;
res.x [3][1] = 0;
res.x [3][2] = 0;
res.x [3][3] = 1;
return res;
};
Matrix MirrorX ()
{
Matrix res ( 1 );
res.x [0][0] = -1;
return res;
};
Matrix MirrorY ()
{
Matrix res ( 1 );
res.x [1][1] = -1;
return res;
};
Matrix MirrorZ ()
{
Matrix res ( 1 );
res.x [2][2] = -1;
return res;
}
В последующей библиотеке была реализована работа с трехмерными объектами: гранью, графическим объектом и местом. Реализованы последующие способности:
поворот объектов вокруг координатных осей;
зеркальное отображение объектов по отношению к координатным осям;
центральное и параллельное проектирование;
масштабирование объектов;
удаление невидимых поверхностей;
перемещение объектов в пространстве.
//файл 3dworks.h
#ifndef __3DWORKS__#define __3DWORKS__#include <graphics.h>
#include <stdlib.h>
#include «Vector.h»
#include «matrix.h»
#define OneSd 0
#define TwoSds 1
#define MaxPoints 10
#define MaxFacets 10
#define MaxObjects 10
class Polygon
{
public:
int PointNumber;
Vector * Point;
Vector Normal;
Vector Center;
int Color;
int TwoSides;
Polygon () {};
Polygon ( Vector *, int, int, int );
void Draw ( const Vector& );
void Move ( const Vector& );
void Rotate ( double, double, double );
void PolyScale ( const Vector& );
void PolyMirrorX ();
void PolyMirrorY ();
void PolyMirrorZ ();
};
class GrObject
{
public:
int FacetNumber;
Polygon * Facet;
Vector Coords;
GrObject () {};
GrObject ( Polygon *, int, const Vector& );
void Move ( const Vector& );
void Rotate ( double, double, double );
void ObjScale ( const Vector& );
void ObjMirrorX ();
void ObjMirrorY ();
void ObjMirrorZ ();
};
struct BSPNode
{
Polygon * Poly;
double d;
BSPNode * Left;
BSPNode * Right;
};
class Space
{
public:
int ObjectNumber;
GrObject * Object [MaxObjects];
Space () { ObjectNumber = 0; };
Space ( GrObject *, int );
void Add ( GrObject * );
void Draw ( const Vector& );
};
int IsVisible ( const Polygon&, const Vector& );
void DrawBSPTree ( BSPNode *, const Vector& );
#endif
//—————————————————————————-
//Файл 3dworks.cpp
#include «3dworks.h»// Polygon’s methodsPolygon :: Polygon ( Vector * PointArr, int PointNum, int Col, int TS ){ if ( PointNum <= MaxPoints ) { PointNumber = PointNum;
Normal = Normalize (
(
Center = 0;
for ( int i = 0; i < PointNumber; i++ )
Center +=
Center /= PointNumber;
}
}
void Polygon :: Move ( const Vector& v )
{
Matrix m = Translate ( v );
for ( int i = 0; i < PointNumber; i++ )
Point[i] = m *
Center = m * Center;
}
void Polygon :: Rotate ( double Alfa, double Beta, double Gamma )
{
Matrix m = RotateX ( Alfa ) * RotateY ( Beta ) * RotateZ ( Gamma );
for ( int i = 0; i < PointNumber; i++ )
Normal = m * Normal;
Center = m * Center;
}
void Polygon :: PolyScale ( const Vector& v )
{
Matrix m = Scale ( v );
for ( int i = 0; i < PointNumber; i++ )
Point[i] = m *
Center = m * Center;
}
void Polygon :: PolyMirrorX ()
{
Matrix m = MirrorX();
for ( int i = 0; i < PointNumber; i++ )
Center = m * Center;
Normal = m * Normal;
}
void Polygon :: PolyMirrorY ()
{
Matrix m = MirrorY();
for ( int i = 0; i < PointNumber; i++ )
Center = m * Center;
Normal = m * Normal;
}
void Polygon :: PolyMirrorZ ()
{
Matrix m = MirrorZ();
for ( int i = 0; i < PointNumber; i++ )
Center = m * Center;
Normal = m * Normal;
}
void Polygon :: Draw ( const Vector& PrCenter )
{
int VisPoint[MaxPoints * 2], k = 0;
for ( int i = 0; i < PointNumber; i++ ) {
double Coeff = 1 / ( 1 —
VisPoint[k++] = ( int )
VisPoint[k++] = ( int ) —
}
setcolor ( Color );
setfillstyle ( 1, Color );
fillpoly ( PointNumber, VisPoint );
}
// GrObject’s methods
GrObject :: GrObject ( Polygon * FacetArr, int FacetNum, const Vector& Crds )
{
if ( FacetNum <= MaxFacets )
{
FacetNumber = FacetNum;
Facet = FacetArr;
Coords = Crds;
}
}
void GrObject :: Move ( const Vector& v )
{
for ( int i = 0; i < FacetNumber; i++ )
Facet[i].Move ( v );
Coords = Translate ( v ) * Coords;
}
void GrObject :: Rotate ( double Alfa, double Beta, double Gamma )
{
for ( int i = 0; i < FacetNumber; i++ )
Facet[i].Rotate ( Alfa, Beta, Gamma );
Coords = RotateX ( Alfa ) * RotateY ( Beta ) * RotateZ ( Gamma ) * Coords;
}
void GrObject :: ObjScale ( const Vector& v )
{
for ( int i = 0; i < FacetNumber; i++ )
Facet[i].PolyScale ( v );
Coords = Scale ( v ) * Coords;
}
void GrObject :: ObjMirrorX ()
{
Matrix m = MirrorX();
for ( int i = 0; i < FacetNumber; i++ )
Facet[i].PolyMirrorX ();
Coords = m * Coords;
}
void GrObject :: ObjMirrorY ()
{
Matrix m = MirrorY();
for ( int i = 0; i < FacetNumber; i++ )
Facet[i].PolyMirrorY ();
Coords = m * Coords;
}
void GrObject :: ObjMirrorZ ()
{
Matrix m = MirrorZ();
for ( int i = 0; i < FacetNumber; i++ )
Facet[i].PolyMirrorZ ();
Coords = m * Coords;
}
// Space’s methods
Space :: Space ( GrObject * Obj, int ObjectNum )
{
if ( ObjectNum <= MaxObjects )
{
ObjectNumber = ObjectNum;
for ( int i = 0; i < ObjectNumber; i++ )
Object[i] = &Obj[i];
};
}
void Space :: Add ( GrObject * Obj )
{
if ( ObjectNumber < MaxObjects ) Object [ObjectNumber++] = Obj;
}
void Space :: Draw ( const Vector& PrCenter )
{
}
// Other functions
int IsVisible ( const Polygon& Poly, const Vector& PrCenter )
void DrawBSPTree ( BSPNode * Tree, const Vector& PrCntr )
{
if (( Tree -> Poly -> Normal & PrCntr ) > Tree -> d ) {
if ( Tree -> Right != NULL ) DrawBSPTree ( Tree -> Right, PrCntr );
Tree -> Poly -> Draw ( PrCntr );
if ( Tree -> Left != NULL ) DrawBSPTree ( Tree -> Left, PrCntr );
}
else {
if ( Tree -> Left != NULL ) DrawBSPTree ( Tree -> Left, PrCntr );
Tree -> Poly -> Draw ( PrCntr );
if ( Tree -> Right != NULL ) DrawBSPTree ( Tree -> Right, PrCntr );
}
}
Дальше представлена демо программка, которая делает все перечисленные выше операции с тетраэдром.
//файл 3dgame.cpp
#include <dos.h>#include <graphics.h>#include <math.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include «3dworks.h»
void DrawObject ( GrObject* Obj, const Vector& v )
{
for ( int i = 0; i < Obj->FacetNumber; i++ )
if ( IsVisible ( Obj->Facet[i], v )) Obj->Facet[i].Draw ( v );
}
main ()
{
Vector Poly1[3], Poly2[3], Poly3[3], Poly4[3];
Polygon O[4];
Vector A ( -50, 0, 0 ),
B ( 0, 0, 50 ),
C ( 50, 0, 0 ),
D ( 0, 100, 0 ),
PrCenter ( 0, 0, 1000 );
Poly1[0] = A; Poly2[0] = B;
Poly1[1] = D; Poly2[1] = D;
Poly1[2] = B; Poly2[2] = C;
Poly3[0] = C; Poly4[0] = C;
Poly3[1] = A; Poly4[1] = D;
Poly3[2] = B; Poly4[2] = A;
Polygon * P1 = new Polygon ( Poly1, 3, 11, OneSd );
Polygon * P2 = new Polygon ( Poly2, 3, 12, OneSd );
Polygon * P3 = new Polygon ( Poly3, 3, 13, OneSd );
Polygon * P4 = new Polygon ( Poly4, 3, 14, OneSd );
O[0] = *P1; O[1] = *P2;
O[2] = *P3; O[3] = *P4;
delete P1; delete P2;
delete P3; delete P4;
GrObject * Obj = new GrObject ( O, 4, Vector ( 0 ) );
double fi = 0.1, psi = 0.1, step = 0.1;
int ch = 0, Page = 3;
int driver = DETECT, mode, res;
initgraph ( &driver, &mode, «» );
if ( ( res = graphresult () ) != grOk ) {
printf ( «nGraphics error: %sn», grapherrormsg ( res ) );
exit ( 1 );
}
setgraphmode ( 1 );
DrawObject ( Obj, PrCenter );
do {
setactivepage ( Page % 2 );
clearviewport ();
if ( kbhit ())
{
switch ( ch = getch() ) {
caseactiveXObj->ObjScale ((1.1,1.1,1.1)); break;
case ‘-‘: Obj->ObjScale ((0.9,0.9,0.9)); break;
case ‘x’: Obj->ObjMirrorX (); break;
case ‘y’: Obj->ObjMirrorY (); break;
case ‘z’: Obj->ObjMirrorZ (); break;
};
if ( ch == 0 )
{
switch ( ch = getch () ) {
case 72 : fi -= step; break;
case 80 : fi += step; break;
case 75 : psi += step; break;
case 77 : psi -= step; break;
};
};
};
Obj->Rotate ( fi, psi, 0 );
DrawObject ( Obj, PrCenter );
setvisualpage ( Page++ % 2 );
if ( fi == 0 && psi == 0 ) while ( !kbhit ());
} while ( ch != 27 );
delete Obj;
closegraph ();
}
]]>