|
Реферат: Трехмерная анимация в 3D Studio MAX (Программирование)
Педагогический лицей №24
г. Липецк.
3D графика и анимация на примере прикладного пакета 3D Studio MAX2
(использование возможностей данного программного продукта в учебном
процессе).
Реферат по информатике
учащегося 11-А класса
Комар Феликса
руководитель: Шуйкова И. А.
Липецк 2000
Оглавление
1. Основы 3D графики и анимации.
1.1 Общее представление о 3D.
1.2 Реализация геометрических принципов в 3D Studio MAX2.
1.2.1 Трехмерное пространство.
1.2.2 3D объекты.
1.2.3 Проекции 3D объектов.
1.3 Теоретические основы построения сцены.
2. Моделирование объектов в 3D Studio MAX2.
2.1 Сплайн.
2.2 Примитивы.
2.3 Поверхности.
3. Перспективы развития 3D графики.
4. Разработка видео демонстрации к теме «Тела вращения».
Основы 3D графики и анимации.
В наше время CGI-образы (от слов Computer Graphics Imagery – изображение
созданное на компьютере) окружают нас повсеместно: на телевидении, в кино и
даже на страницах журналов. Компьютерная графика превратилась из
узкоспециальной области интересов ученых-компьюторщиков в дело, которому
стремиться посвятить себя множество людей. Среди программных комплексов
трехмерной графики, предназначенных для работы на компьютерах типа PC,
лидирующее место занимает 3D Studio MAX2.
Общее представление о 3D.
В самом названии рассматриваемой области – «трехмерная графика» - заложено
указание на то, что нам предстоит иметь дело с тремя пространственными
измерениями: шириной, высотой и глубиной. Если взглянуть вокруг: все, что
нас окружает, обладает тремя измерениями – стол, стул, жилые здания,
промышленные корпуса и даже тела людей. Однако термин «трехмерная графика»
все же является искажением истины. На деле трехмерная компьютерная графика
имеет дело всего лишь с двумерными проекциями объектов воображаемого
трехмерного мира.
Чтобы проиллюстрировать сказанное, можно представить оператора с
видеокамерой, с помощью которой он снимает объекты, расположенные в
комнате. Когда во время съемок он перемещается по комнате, то в объектив
попадают различные трехмерные объекты, но при воспроизведении отснятой
видеозаписи на экране телевизора будут видны всего лишь плоские двумерные
изображения, представляющие собой запечатленные образы снятых несколько
минут назад трехмерных объектов. Сцена на экране выглядит вполне реально
благодаря наличию источников света, естественной расцветке всех объектов и
присутствию теней, придающих изображению глубину и делающих его визуально
правдоподобными, хотя оно и остается всего лишь двумерным образом.
В компьютерной графике объекты существуют лишь в памяти компьютера. Они не
имеют физической формы – это не более чем совокупность математических
уравнений и движение электронов в микросхемах. Поскольку объекты, о которых
идет речь, не могут существовать вне компьютера, единственным способом
увидеть их является добавление новых математических уравнений, описывающих
источники света и съемочные камеры. Программный комплекс 3D Studio MAX2
позволяет выполнять все вышеперечисленные операции.
Использование программы, подобной 3D Studio MAX2, во многом сходно со
съемкой с помощью видеокамеры комнаты, полной сконструированных объектов.
Программный комплекс 3D Studio MAX2 позволяет смоделировать комнату и ее
содержимое с использованием разнообразных базовых объектов, таких как кубы,
сферы, цилиндры и конусы, а также с использованием инструментов,
необходимых для реализации разнообразных методов создания более сложных
объектов.
После того как модели всех объектов созданы и должным образом размещены в
составе сцены, можно выбрать из библиотеки любые готовые материалы, такие
как пластик, дерево, камень и т.д. и применить эти материалы к объектам
сцены. Можно создать и собственные материалы, пользуясь средствами
редактора материалов (Material Editor) 3D Studio MAX2, с помощью которых
можно управлять цветом, глянцевитостью, прозрачностью и даже применять
сканированные фотографии или нарисованные изображения, чтобы поверхность
объекта выглядела так, как это было задумано.
Применив к объектам материалы, необходимо создать воображаемые съемочные
камеры, через объективы которых будет наблюдаться виртуальный трехмерный
мир, и производиться съемка наполняющих его объектов. За счет настройки
параметров виртуальных камер можно получить широкоугольную панораму сцены
или укрупнить план съемки, чтобы сосредоточить свое внимание на отдельных
мелких деталях. Пакет 3D Studio MAX2 поддерживает модели камер с набором
параметров свойственных настоящим фото- или видеокамерам, с помощью которых
можно наблюдать сцену именно в том виде, какой требуется по замыслу
сценария.
Чтобы сделать сцену еще более реалистичной, можно добавить в ее состав
источники света. MAX позволяет включать в сцену источники света различных
типов, а также настраивать параметры этих источников.
Реализация геометрических принципов в 3D Studio MAX2
Трехмерное пространство
Работая с 3D Studio MAX2 пользователь имеет дело с воображаемым трехмерным
пространством. Трехмерное пространство – это куб в кибернетическом
пространстве, создаваемый в памяти компьютера. Кибернетическое пространство
отличается от реального физического мира тем, что создается и существует
только в памяти компьютера благодаря действию специального программного
обеспечения.
Однако подобно реальному пространству, трехмерное пространство также
неограниченно велико. Задача поиска объектов и ориентации легко решается
благодаря использованию координат.
Наименьшей областью пространства, которая может быть занята каким-то
объектом, является точка (point). Положение каждой точки определяется
тройкой чисел, называемых координатами (coordinates). Примером координат
может служить тройка (0;0;0), определяющая центральную точку трехмерного
пространства, называемую также началом координат (origin point). Другими
примерами координат могут являться тройки (200;674;96) или (23;67;12).
Каждая точка трехмерного пространства имеет три координаты, из которых одна
определяет высоту, другая – ширину, третья – глубину положения точки. Таким
образом, через каждую точку можно провести три координатных оси
киберпространства.
Координатная ось (axis) – это воображаемая линия киберпространства,
определяющая направление изменения координаты. В MAX имеются три
стандартные оси, называемые осями X, Y и Z. Можно условно считать, что ось
X представляет координату ширины, ось Y – высоты, а ось Z – глубины.
3D объекты
Если соединить две точки в киберпространстве, то будет создана линия
(line). Например, соединяя точки (0;0;0) и (5;5;0) получается линия. Если
продолжить эту линию, соединив ее конец с точкой (9;3;0) то получиться
полилиния (poliline), то есть линия, состоящая из нескольких сегментов. (В
3D Studio MAX2 термины линия и полилиния взаимозаменяемые.) Если соединить
последнюю точку с первой, то получиться замкнутая форма (closed shape), то
есть форма, у которой есть внутренняя и наружная области. Нарисованная
форма представляет собой простой трехсторонний многоугольник (polygon),
называемый также гранью (face), и составляет основу объектов, создаваемых в
виртуальном трехмерном пространстве. У многогранника имеются следующие
базовые элементы: вершина, ребро, грань.
Вершина (vertex) – это точка в которой соединяется любое количество линий.
Грань (face) – это фрагмент пространства, ограниченный ребрами
многоугольника. Ребро (edge) - это линия, формирующая границу грани.
В 3D Studio MAX2 объекты составляются из многоугольников, кусков Безье или
поверхности типа NURBS, причем чаще всего используются многоугольники,
расположенные таким образом, чтобы образовать оболочку нужной формы. В ряде
случаев для формирования объекта требуется всего несколько многоугольников.
Однако в большинстве случаев формирование объектов требует использования
сотен и тысяч многоугольников, образующих огромный массив данных. Так,
например, в процессе работы с кубом компьютер должен отслеживать положение
восьми вершин, шести граней и двенадцати видимых ребер. Для более сложных
объектов число элементов состоящих из многоугольников может достигать
десятков и сотен тысяч.
Проекции 3D объектов
Точка наблюдения (viewpoint) – это позиция в трехмерном пространстве,
определяющая положение наблюдателя. Точки наблюдения являются основой
формирования в MAX окон проекций (viewports), каждое из которых
демонстрирует результат проекции объектов трехмерной сцены на плоскость,
перпендикулярную направлению наблюдения из определенной точки.
Воображаемая плоскость, проходящая через точку наблюдения перпендикулярно
линии взгляда, называется плоскостью отображения, которая определяет
границы области видимой наблюдателю. Плоскость отображения иногда называют
плоскостью отсечки.
Чтобы увидеть объекты, расположенные позади плоскости отображения,
необходимо сменить положения точки наблюдения. Или «отодвигать» плоскость
отсечки, пока интересующие нас объекты не окажутся впереди плоскости.
В MAX окнах, позволяющих заглянуть в виртуальный трехмерный мир, называются
окнами проекций (viewports). Экран монитора сам по себе является плоскостью
отображения, поскольку пользователь может видеть только то, что
располагается в киберпространстве «за плоскостью» экрана монитора. Боковые
границы участка отображающегося в окне проекции, определяются границами
окна. Три из четырех демонстрируемых по умолчанию окон проекций в 3D Studio
MAX2 являются окнами ортографических проекций. При построении изображений в
этих окнах считается, что точка наблюдения удалена от сцены на бесконечное
расстояние, а все лучи, исходящие из точки наблюдения к объектам,
параллельны соответствующей оси координат. Четвертое окно проекции MAX из
числа принятых по умолчанию, Perspective (Перспектива), является окном не
ортографической, а центральной проекции и демонстрирует более реалистичное
на вид изображение трехмерной сцены, при построении которого лучи считаются
выходящими расходящимся пучком из точки наблюдения, как это происходит в
реальной жизни.
Примитивы
Трехмерные примитивы составляют основу многих программных пакетов
компьютерной графики и обеспечивают возможность создания разнообразных
объектов простой формы. Во многих случаях для формирования нужной модели
трехмерные примитивы приходится объединять или модифицировать. МАХ 2.0
предоставляет вам два набора примитивов: стандартные (Standard Primitives)
и улучшенные (Extended Primitives). К числу стандартных примитивов
относятся параллелепипед, сфера, геосфера, конус, цилиндр, труба, кольцо,
пирамида, чайник, призма. Улучшенными называются примитивы многогранник,
тороидальный узел, параллелепипед с фаской, цистерна, капсула, веретено,
тело L-экструзии, обобщенный многоугольник. Работая с примитивами почти
всегда необходимо прибегать к их преобразованию или модификации для
создания нужных объектов. Например, можно смоделировать стены здания
набором длинных и высоких параллелепипедов малой толщины. Создавая
дополнительные прямоугольные блоки меньшего размера и вычитая их из блоков
стен, можно создать проемы для окон и дверей. Сами по себе примитивы
используются довольно редко.
Составные объекты – это тела, составленные из двух или более простых
объектов (как правило объектов примитивов). Создание составных объектов
представляет собой продуктивный метод моделирования многих реальных
объектов, таких как морская мина, стены с проемами для дверей и окон, а
также фантастических тел, перетекающих из одной формы в другую как
жидкость. 3D Studio MAX2 предоставляет возможность использовать шесть типов
составных объектов.
. Морфинговые. Объекты данного типа позволяют выполнять анимацию плавного
преобразования одного тела в другое.
. Булевские. Объекты этого типа позволяют объединять два или несколько
трехмерных тел для получения одного нового. Применяются для создания
отверстий или проемов в объемных телах или для соединения нескольких
объектов в один. Этот тип идеально подходит для архитектурного
моделирования или любых других задач, в которых необходимо вычесть
(исключить) объем, занимаемый одним телом, из другого.
. Распределенные. Объекты этого типа представляют собой результат
распределения дубликатов одного трехмерного тела по поверхности другого.
Могут использоваться для имитации стеблей травы, ямочек на поверхности
мяча для гольфа или деревьев на модели ландшафта.
. Соответствующие. Данный тип объектов позволяет заставить одно трехмерное
тело принять форму другого. Это отлично подходит для создания таких
эффектов, как плавление, таяние или растекание.
. Соединяющиеся. Этот тип объектов позволяет соединить между собой
отверстия в двух исходных телах своеобразным тоннелем.
. Слитые с формой. Объекты этого типа позволяют соединять сплайновую форму
с поверхностью трехмерного тела. Фактически, это позволяет рисовать на
поверхностях трехмерных тел.
Реферат на тему: Трехмерная графика
Министерство образования Украины
Кафедра ПО ЭВМ
ОТЧЕТ
О лабораторной работе на тему:
«Трехмерная графика»
по дисциплине «Компьютерная графика»
Краткие теоретические сведения.
Каждая точка пространства (кроме начальной точки О) может быть задана
четверкой одновременно не равных нулю чисел ((x,y,z,1) или, более обще,
(hx,hy,hz,h), где [pic]). Эта четверка определена однозначно с точностью до
общего множителя. Предложенный подход дает возможность воспользоваться
матричной записью и в более сложных , трехмерных задачах.
Как известно, любое аффинное преобразование в трехмерном пространстве
может быть представлено в виде суперпозиции вращений растяжений, отражений
и переносов. Поэтому достаточно подробно описать матрицы только этих
последних преобразований.
A. Матрицы вращения в пространстве.
Матрица вращения вокруг оси абсцисс на угол q:
[pic]
Матрица вращения вокруг оси ординат на угол w:
[pic]
Матрица вращения вокруг оси аппликат на угол x:
[pic]
Б. Матрица растяжения (сжатия):
[pic]
здесь a>0 - коэффициент растяжения (сжатия) вдоль оси абсцисс,b>0-
коэффициент растяжения (сжатия) вдоль оси ординат,y>0-коэффициент
растяжения (сжатия) вдоль оси аппликат.
В. Матрица отражения .
Матрица отражения относительно плоскости xOy:
[pic]
Матрица отражения относительно плоскости yOz:
[pic]
Матрица отражения относительно плоскости zOx:
[pic]
Г. Матрица переноса :
[pic]
Здесь (r,q,v)-вектор переноса.
Заметим, что, как и в двумерном случае , все выписанные матрицы не
вырождены.
Ортографическая проекция - картинная плоскость совпадает с одной из
координатных плоскостей или параллельна ей. Матрица проектирования
вдоль оси Х на плоскость YOZ имеет вид
[pic]
В случае , если плоскость проектирования параллельна координатной
плоскости, необходимо умножить матрицу [Px] на матрицу сдвига . Имеем
[pic]
Аналогично записываются матрицы проектирования вдоль 2-х
координатных осей:
[pic]
Аксонометрическая проекция - проектирующие прямые перпендикулярны
картинной плоскости .
Различают три вида проекций в зависимости от взаимного расположения
плоскости проектирования и координатных осей:
триметрия-нормальный вектор картинной плоскости образует с ортами
координатных осей попарно различные углы(рис.15);
диметрия-два угла между нормалью картинной плоскости и координатными осями
равны (рис. 16).
- изометрия-все три угла между нормалью картинной плоскости и
координатными осями равны (рис. 17).
Каждый из трех видов указанных проекций получается комбинацией
поворотов, за которой следует параллельное проектирование.
Перспективные (центральные) проекции строятся более сложно .
Предположим что центр проектирования лежит на оси Z - C (0,0,c) а плоскость
проектирования совпадает с координатной плоскостью XOY (рис. 19) .
Возьмем в пространстве произвольную точку M(x,y,z), проведем через нее и
точку С прямую и запишем ее параметрические уравнения . Имеем:
X`= xt , Y`=yt, Z`= c+(z-c)t
Найдем координаты точки пересечения этой прямой с плоскостью XOY.
Из того , что z`=0, получаем
[pic]
Тот же самый результат мы получим, привлекая матрицу
[pic]
В самом деле,
[pic]
Mатрица проектирования, конечно, вырождена ; матрица же
соответствующего перспективного преобразования(без проектирования) имеет
следующий вид
[pic]
Язык С++ предоставляет очень удобные средства, позволяющие заметно
упростить работу с векторами и преобразованиями в пространстве.
Рассмотрим реализацию работы с векторами.
// Файл vector.h
#ifndef __VECTOR__
#define __VECTOR__
#include
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 Point ( double t ) { return Org + Dir * t; };
};
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
#include
#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
#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
#include
#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 methods
Polygon :: Polygon ( Vector * PointArr, int PointNum, int Col, int TS )
{
if ( PointNum br Matrix m = MirrorZ();br for ( int i = 0; i FacetNumber; i++ )br Facet[i].PolyMirrorZ ();br Coords = m * Coords;br}brbr// Space's methodsbrbrSpace :: Space ( GrObject * Obj, int ObjectNum )br{br if ( ObjectNum = MaxObjects )br {br ObjectNumber = ObjectNum;br for ( int i = 0; i < ObjectNumber; i++ )br Object[i] = &Obj[i];br };br}brbrvoid Space :: Add ( GrObject * Obj )br{br if ( ObjectNumber < MaxObjects ) Object [ObjectNumber++] = Obj;br}brbrvoid Space :: Draw ( const Vector& PrCenter )br{brbr}brbr// Other functionsbrbrint IsVisible ( const Polygon& Poly, const Vector& PrCenter )br{br return ( Poly.Normal & ( PrCenter - Poly.Point[0] )) < 0 ||brPoly.TwoSides;br}brbrvoid DrawBSPTree ( BSPNode * Tree, const Vector& PrCntr )br{br 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
#include
#include
#include
#include
#include
#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() ) {
case '+': Obj->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 ();
}
| |
