Листинг 8.2. Демонстрационная программа новой функции масштабирования (VYREN.C).

// ВКЛЮЧАЕМЫЕ ФАЙЛЫ ////////////////////////////////////////

#include < io.h>

#include < conio.h>

#include < stdio.h>

#include < stdlib.h>

#include < dos.h>

#include < bios.h>

#include < fcntl.h>

#include < memory.h>

#include < malloc.h>

#include < math.h>

#include < string.h>

#include < graph.h>

#include " graphics.h" // включаем нашу графическую библиотеку

// ПРОТОТИПЫ ////////////////////////////////////////////////////////

void Create_Scale_Data_X(int scale, int far *row);

void Create_Scale_Data_Y(int scale, int * row);

void Build_Scale_Table(void);

void Scale_Sprite(sprite_ptr sprite, int scale);

void Clear_Double_Buffer(void);

// ОПРЕДЕЛЕНИЯ /////////////////////////////////////////////

#define MAX_SCALE 200 // число звезд на звездном небе

#define SPRITE_X_SIZE 80 // максимальные размеры

#define SPRITE_Y_SIZE 48 // растрового изображения

// ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ ///////////////////////////////////

sprite object; // обобщенный спрайт, который

// содержит кадры с космическим

// кораблем

pcx_picture text_cells; // PCX-файл с изображениями

int *scale_table_y[MAX_SCALE+l]; // таблица с предварительно

// рассчитанными коэффициентами

// масштабирования

int far *scale_table_x[MAX_SCALE+l]; // таблица с предварительно

// рассчитанными коэффициентами

// масштабирования

// ФУНКЦИИ /////////////////////////////////////////////////

void Create_Scale_Data_X(int scale, int far *row)

{

// эта функция масштабирует полосу текстуры для всех возможных

// размеров и создает огромную таблицу соответствий

int х;

float x_scale_index=0, x_scale_step;

// рассчитываем шаг масштабирования или число исходных пикселей

// для отображения на результирующее изображение за цикл

x_scale_step = (float)(sprite_width)/(float)scale;

x_scale_index+=x_scale_step;

for (x=0; x< scale; x++)

{

// помещаем данные в массив для последующего использования

row[x] = (int)(x_scale index+, 5);

if (row[x] > (SPRITE_X_SIZE-1)) row[x] = (SPRITE_X_SIZE-1);

// рассчитываем следующий индекс

x_scale index+=x_scale_step;

} // конец цикла

} // конец Create_Scale_Data_X

///////////////////////////////////////////////////////////

void Create_Scale_Data Y(int scale, int *row)

{

// эта функция масштабирует полосу текстуры для всех возможных

// размеров и создает огромную таблицу соответствий

int у;

float y_scale_index=0, у scale_step;

// рассчитываем шаг масштабирования или число исходных пикселей

// для отображения на результирующее изображение за цикл

у_scale_step = (float)(sprite_height)/(float)scale;

y_scale index+=y_scale_step;

for (y=0; y< scale; y++)

{

// помещаем данные в-массив для последующего использования

row[y] = ((int)(y_scale_index+.5)) * SPRITE_X_SIZE;

if (row[y] > (SPRITE_Y_SIZE-1)*SPRITE_X_SIZE) row[y] = (SPRITE_Y_SIZE-1)*SPRITE_X_SIZE;

// рассчитываем следующий индекс

y_scale_index+==y_scale_step;

} // конец цикла

} // конец Create_Scale_Data_Y //////////////////////////////////////////

void Build_Scale_Table (void)

{ // эта функция строит таблицу масштабирования путем расчета

// коэффициентов масштабирования для всех возможных размеров

// от 1 до 200 пикселей

int scale;

// резервируем память

for (scale=l; scale< =MAX_SCALE; scale++)

{

scale_table_y[scale] = (int *)malloc(scale*sizeof(int)+1);

scale_table_x[scale] = (int far *)_fmalloc(scale*sizeof(int)+l);

} // конец цикла

// создаем таблицу масштабирования для осей X и Y

for (scale=l; scale< =MAX_SCALE; scale++) {

// рассчитываем коэффициент для данного масштаба

Create_Scale_Data_Y(scale, (int *)scale_table_y[scale]);

Create_Scale_Data_X(scale, (int far *)scale_table_x[scale]);

}// конец цикла

}// конец Build_Scale_Table ////////////////////////////////////////////////////////////

void Scale_Sprite(sprite_ptr sprite, int scale)

{

// эта функция масштабирует спрайт (без отсечения). Масштабирование производится с //использованием заранее рассчитанной таблицы, которая определяет, как будет изменяться //каждый вертикальный столбец. Затем другая таблица используется для учета //масштабирования этих столбцов по оси Х

char far *work_sprite; // текстура спрайта

int *row_y; // указатель на масштабированные

// по оси Y данные (заметьте, что

// это ближний указатель)

int far *row_x; // указатель на масштабированные

// по оси Х данные (заметьте, что

// это дальний указатель)

unsigned char pixel; // текущий текстель

lnt x, // рабочие переменные

У, column,

work_offset,

video_offset,

video_start;

// если объект слишком мал, то и рисовать его не стоит

if (scale< 1) return;

// рассчитываем необходимые для масштабирования данные

row_y = scale_table_y[scale];

row_x = scale table_x[scale];

// выбираем соответствующий кадр спрайта

work_sprite = sprite-> frames[sprite-> curr_frame];

// рассчитываем начальное смещение

video_start = (sprite-> y < < 8) + (sprite-> y < < 6) + sprite-> x;

// изображение рисуется слева направо и сверху вниз

for (x=0; x< scale; х++)

{

// пересчитываем адрес следующего столбца

video_offset = video_start + х;

// определяем, какой столбец должен быть отображен,

// исходя из индекса масштабирования по оси Х

column = row_x[x];

// Наконец рисуем столбец обычным образом

for (y=0; y< scale; y++)

{

// проверка на " прозрачность"

pixel = work_sprite[work_offset+column];

if (pixel)

double buffer[video_offset] = pixel;

// индекс следующей строки экрана и смещение

//в области хранения текстуры

video_offset += screen_width;

work_offset = row_y[y];

} // конец цикла по Y

} // конец цикла ро Х

} // конец Scale_Sprite

//////////////////////////////////////////

void Clear Double_Buffer(void) {

// угадали что это?

_fmemset(double_buffer, 0, SCREEN__WIDTH * SCREEN_HEIGHT + 1);

} // конец Clear_Double_Buffer

// ОСНОВНАЯ ПРОГРАММА //////////////////////////////////////

void main(void)

{

// Загружаем 12 предварительно отсканированных кадров спрайта

// и последовательно меняем их до тех пор пока игрок не изменит

// координату Z объекта, нажав клавишу ", " или "."

int done=0, // флаг завершения

count=0, // счетчик времени изменения кадра

scale=64; // текущий масштаб спрайта

float scale_distance = 24000, // произвольная константа

// для согласования

// плоской текстуры и трассированного

// пространства

view_distance = 256, // дистанция до объекта

х=0, // позиция корабля в трехмерном

// пространстве

у=0,

z=1024;

// установка видеорежима 320х200х256

_setvideomode(_MRES256COLOR);

sprite_width = 80;

sprite_height =48;

// создание таблицы для подсистемы масштабирования

Build_Scale_Table ();

// инициализация файла PCX, содержащего кадры

PCX_Init((pcx_picture_ptr)& text cells);

// загрузка файла PCX, содержащего кадры

PCX_Load(" vyrentxt.pcx", (pcx_picture_ptr)& text_cells, 1);

// резервируем память под дублирующий буфер

Init_Double_Buffer ();

Sprite_Init((sprite_ptr)& object, 0, 0, 0, 0, 0, 0);

// загружаем 12 кадров с космическим кораблем

PCX_Grap_Bitmap ((pcx_picture_ptr) & text_cells,

(sprite_ptr)& object, 0, 0, 0);

PCX_Grap_Bitmap((pcx_picture_ptr)& text_cells,

(sprite_ptr)& object, 1, 1, 0);

PCX_Grap_Bitmap((pcx_picture_ptr)& text_cells,

(sprite_ptr)& object, 2, 2, 0);

PCX_Grap_Bitmap ((pcx_picture_ptr)& text_cells,

(sprite_ptr)& object, 3, 0, 1);

PCX_Grap_Bitmap((pcx_picture_ptr)& text_cells, (sprite_ptr)& object, 4, 1, 1);

PCX_Grap_Bitmap ((pcx_picture_ptr)& text_cells,

(sprite_ptr)& object, 5, 2, 1);

PCX_Grap_Bitmap((pcx_picture_ptr)& text_cells,

(sprite_ptr)& object, 6, 0, 2);

PCX_Grap_Bitmap((pcx_picture_ptr)& text_cells,

(sprite_ptr)& object, 7, 1, 2);

PCX_Grap_Bitmap((pcx_picture_ptr)& text_cells,

(sprite_ptr)& object, 8, 2, 2);

PCX_Grap_Bitinap((pcx_picture_ptr)& text_cells,

(sprite_ptr)& object, 9, 0, 3);

PCX_Grap_Bitmap((pcx_picture_ptr)& text_cells,

(sprite_ptr)& object, 10, 1, 3);

PCX__Grap_Bitmap((pcx_picture_ptr) & text_cells,

(sprite_ptr)& object, 11, 2, 3);

// начальная позиция корабля

object.curr_frame =0;

object.x = 0;

object, у =0;

Clear_Double_Buffer();

// ожидаем нажатия клавиш и рисуем корабль

while(! done)

{

// нажал ли игрок клавишу?

if (kbhit())

{

switch(getch()) {

case '.': // отдаляем корабль

{

z+=16;

} break;

case ', ': // приближаем корабль

{

z-=l6;

//не позволяем кораблю подойти слишком близко

if(Z< 256)

z=256;

} break;

case 'q': // выход из программы

{

done=1;

} break;

default: break;

} // конец оператора switch

} // конец оператора if

//рассчитываем размер растрового изображения

scale = (int)(scale_distance/z);

// исходя из размера растрового изображения,

// рассчитываем проекции координат Х и Y

object.x= (int)((float)x*view_distance / (float)z) + 160 - (scale> > 1);

object.y = 100 - (((int)((float y*view_distanc=e / (float)z) + (scale> > 1)));

// увеличиваем счетчик кадров

if (++count==2)

{

count=0;

if (++object.curr_frame==12) object.curr_frame=0;

} // конец оператора if

// очищаем дублирующий буфер

Clear_Double_Buffer();

// масштабируем спрайт

Scale_Sprite((sprite_ptr)& object, scale);

Show_Double_Buffer(double_buffer);

// выводим информацию на экран

_settextposition(24, 0);

printf(" z Coordinate is %f", z);

} // конец оператора while

// Удаляем файл PCX

PCX_Delete((pcx_picture_ptr) & text_cells);

// восстанавливаем текстовый режим

_setvideomode(_DEFAULTMODE);

} // конец функции main

После выполнения программы из Листинга 8.2, вы, возможно, будете удивлены возможностями оцифровки изображений макетов и приведенным вариантом трехмерной мультипликации. Кто знает, может быть вы создадите что-нибудь именно по типу игры Wing Commander, а вовсе не очередную вариацию DOOM? Однако пора переходить к алгоритму отсечения.

Отсечение спрайтов в трехмерном пространстве

После построения аксонометрической проекции спрайта отсечение выполняется довольно легко. Алгоритм просто тестирует, не выходит ли проекция отмасштабированного спрайта за границы экрана, и, кроме того, проверяет, находится ли Z-координата спрайта внутри наблюдаемой области пространства. Следовательно, проблема отсечения сводится к проверке расположения прямоугольника относительно границ экрана. Решение этой проблемы мы уже рассмотрели раньше (в четвертой главе, «Механизмы двухмерной графики»).

Как вы помните, существует два подхода к этой проблеме: можно использовать алгоритм пространства образов и алгоритм пространства объектов. Первый путь намного проще. Перед обновлением каждого пикселя спрайта, мы проверяем, находится ли он внутри границ экрана (или окна просмотра), и если это так, то замещаем пиксель. Недостаток этого метода — низкая производи тельность (хотя иногда все же приходится прибегать к алгоритму пространства образов из-за чересчур сложной геометрической формы визуализируемого объекта). В общем же случае алгоритм пространства образов работает медленнее алгоритма пространства объектов.

При использовании объектно-пространственного алгоритма мы должны каким-то образом до прорисовки определить, какая часть спрайта будет нарисована и на основании этого вновь вычислить его проекцию. По существу, мы должны отсечь границами экрана прямоугольник, который получается в результате масштабирования спрайта. Это кажется несложным. Мы разбирали текст такой программы в предыдущей главе (Листинг 7.3), но я повторю этот алгоритм еще один раз! Такой уж я.

Алгоритм 8.1 предполагает, что:

§ Экран ограничивается точками (0, 0) и (scrfeen_x, screen_y);

§ Верхняя левая точка спрайта (sprifce_x, sprite_y);

§ Спрайт имеет размеры width и height.

Предположим, отсечение пространства по оси Z уже было сделано и внешне образ выглядит вполне правдиво. Пусть также были сосчитаны масштаб объекта и координаты проекций по осям Х и Y.