Библиотека для работы с 3D графикой

bbAnimateMD2(World3D.my_dragon, 1, .05, 40, 46);

bbAnimateMD2(World3D.my_dragon, 1, .05, 66, 72);

bbAnimateMD2(World3D.my_dragon, 1, .05, 100, 72);

C++ Programming
 
The following is a simple C++ application featuring a rotating cube using the Blitz3DSDK library.
 
#include <windows.h>
 
#include "blitz3dsdk.h"
 
extern int WINAPI WinMain(HINSTANCE hThisInst,HINSTANCE hPrevInst,LPSTR lpszArgs,int nWinMode){
 
    bbBeginBlitz3D();
 
    bbGraphics3D(800,600,0,2);
 
    BBLight light=bbCreateLight();
    BBCamera camera=bbCreateCamera();
    BBMeshModel cube=bbCreateCube();
 
    bbPositionEntity(camera,0,0,-4);
 
    while (!bbKeyHit(1)){
        bbTurnEntity(cube,1,2,3);
        bbRenderWorld();
        bbFlip();
    }
 
    bbEndBlitz3D();
    return 0;
}

        // инициализация движка
        bbBeginBlitz3D();
 
        // создание графического окна 800 пикселей на 600
        bbGraphics3D(800,600,0,2);
 
        // создание источника света
        BBLight light=bbCreateLight();
        
        // создание камеры
        BBCamera camera=bbCreateCamera();
        
        // создание 3Д примитива
        BBMeshModel cube=bbCreateCube();
 
        // установка камеры в глобальных координатах
        bbPositionEntity(camera,0,0,-4);
 
        // запуск рендера, пока не будет нажата клавиша ESCAPE 
        while (!bbKeyHit(1)){
                // функция, которая вращает модель
                bbTurnEntity(cube,1,2,3);
                // функция, которая отрисовывает 3Д сцену
                bbRenderWorld();
                // обмен буфера (в одном буфере строится сцена, затем готовый буфер меняется новым)
                bbFlip();
        }
        // остановка работы с движком 
        bbEndBlitz3D();

#ifndef TXPlayer_H
#define TXPlayer_H
 
#include "blitz3dsdk.h"
 
// тип управления объектом
enum TControlMode {
    ctrlMouse = 1, ctrlJoystic
};
 
// тип привязки камеры
enum TCameraMode {
    cmCamAfterObject = 1, cmCamBesideObject, cmCamFromObject, cmCamWithoutObject
};
 
// структура, описывающая данные игрока
struct xplayer {
    // сам 3Д узел
    BBEntity entity;
    // камера, привязанная к объекту
    BBCamera camera;
    // режим управления - камера или джойстик
    TControlMode ControlMode;
    // режим положения камеры - за объектом, возле объекта, камера смотрит из объекта, камера отдельно от объекта
    TCameraMode CameraMode;
    // ускорение
    int ignition;
    // тангаж, курс, скорость по тангажу, скорость по курсу, крен, скольжение
    float pitch, yaw, pitch_speed, yaw_speed, roll, thrust;
    // указатель на следующего игрока
    xplayer *next;
};
 
// статический класс игры
class TXPlayer {
private:
    // список игроков
    static xplayer *xplayerlist;
 
    // функция по загрузке сцены
    static BBTerrain CreateXScene();
 
    // загрузка карты высот
    static BBPivot LoadXPlane(const char *file);
 
    // создание игрока, где
    // ............. BBPivot plane                          - ось центра координат 3Д модели
    // ............. int vp_x, int vp_y, int vp_w, int vp_h - размеры окна (ViewPort) текущего игрока
    // ............. TControlMode AControlMode              - тип управления игроком (джойстик или мышка)
    // ............. BBTerrain terr                         - поверхность, к которой будет привязан объект
    static xplayer *CreateXPlayer(BBPivot plane, int vp_x, int vp_y, int vp_w,
        int vp_h, TControlMode AControlMode, BBTerrain terr);
 
    // обновление данных игроков
    static void UpdateXPlayers();
 
protected:
 
public:
    // вызов игры из класса
    static void xfighter();
};
 
#endif // TXPlayer_H

#include <vcl.h>
#pragma hdrstop
 
#include "Xplayer.h"
 
// инициализируем список игроков
xplayer *TXPlayer::xplayerlist = 0;
 
// *********************** xfighter *******************************
 
// загрузка сцены
BBTerrain TXPlayer::CreateXScene() {
    // установка источника освещения
    BBLight l = bbCreateLight();
    // поворот его по тангажу - 45, курсу - 45, крену - 0
    bbRotateEntity(l, 45, 45, 0);
    // установка света окружающей среды, в значениях R G B
    // по умолчанию 127 127 127
    bbAmbientLight(32, 32, 32);
 
    // Загрузка местности из файла карты высот
    BBTerrain terr = bbLoadTerrain("media/xfighter/hmap_1024.bmp");
    // масштабирование местности
    // увеличение по оси X в 20 раз, по оси Y в 800 раз, по оси Z в 20 раз
    bbScaleEntity(terr, 20, 800, 20);
    // установка местности в глобальных координатах
    // X = -20*512
    // Y = 0
    // Z = -20*512
    bbPositionEntity(terr, -20*512, 0, -20*512);
    // установка для объекта флага ПОЛНОЕ ОСВЕЩЕНИЕ
    bbEntityFX(terr, 1);
    // установка типа коллизии (столкновения для этого узла - местности)
    bbEntityType(terr, 10);
 
    // применение текстуры к местности
    // загрузка текстуры
    BBTexture tex1 = bbLoadTexture("media/xfighter/coolgrass2.bmp", 1);
    // масштабирование
    bbScaleTexture(tex1, 10, 10);
    // загрузка текстуры
    BBTexture tex2 = bbLoadTexture("media/xfighter/lmap_256.bmp");
    // масштабирование
    bbScaleTexture(tex2, bbTerrainSize(terr), bbTerrainSize(terr));
    // применение текстуры tex1 к местности
    bbEntityTexture(terr, tex1, 0, 0);
    // применение текстуры tex2 к местности
    bbEntityTexture(terr, tex2, 0, 1);
 
    // создание плоскости земли
    BBPlaneModel plane = bbCreatePlane();
    bbScaleEntity(plane, 20, 1, 20);
    bbPositionEntity(plane, -20*512, 0, -20*512);
    bbEntityTexture(plane, tex1, 0, 0);
    bbEntityOrder(plane, 3);
    bbEntityFX(plane, 1);
    bbEntityType(plane, 10);
 
    // создание облаков
    BBTexture tex = bbLoadTexture("media/xfighter/cloud_2.bmp", 3);
    bbScaleTexture(tex, 1000, 1000);
    BBPlaneModel p = bbCreatePlane();
    bbEntityTexture(p, tex);
    bbEntityFX(p, 1);
    bbPositionEntity(p, 0, 450, 0);
    p = bbCopyEntity(p);
    bbRotateEntity(p, 0, 0, 180);
 
    // создание воды
    BBTexture tex3 = bbLoadTexture("media/xfighter/water-2_mip.bmp", 3);
    bbScaleTexture(tex3, 10, 10);
    BBPlaneModel p1 = bbCreatePlane();
    bbEntityTexture(p1, tex3);
    bbEntityBlend(p1, 1);
    bbEntityAlpha(p1, .75);
    bbPositionEntity(p1, 0, 10, 0);
    bbEntityFX(p1, 1);
 
    return terr;
}
 
// главная функция вызова по работе с классом
void TXPlayer::xfighter() {
    // загрузка 3Д окна
    bbGraphics3D(960, 540, 0, 6);
    // включение антиалиазинга
    bbAntiAlias(BBTRUE);
 
    // установка коллизий
    bbCollisions(1, 10, 2, 2); // sphere-to-polygon, colliding collisions
 
    // создаём местность
    BBTerrain terr = CreateXScene();
 
    // загружаем модель самолётика
    BBPivot plane = LoadXPlane("media/xfighter/biplane.x");
 
    // создаём игрока
    xplayer *player1 = CreateXPlayer(plane, 0, 0, bbGraphicsWidth(),
        bbGraphicsHeight(), ctrlMouse, terr);
 
    // вводим переменную ФПС
    const float FPS = 30;
 
    int period = 1000 / FPS;
    int time = bbMilliSecs() - period;
 
    // деталировка местности, количество треугольников
    int detail = 2000;
    // включить трансформацию вершин (плавность переходов)
    int morph = 1;
 
    // устанавливаем деталировку земли
    bbTerrainDetail(terr, detail, morph);
 
    // переменная, которая будет отвечать за включение-выключение 3Д каркаса
    int wire = 0;
 
    // пока не нажата клавиша ESCAPE
    while (!bbKeyHit(KEY_ESCAPE)) {
        int elapsed;
        do {
            // считаем, сколько времени прошло
            elapsed = bbMilliSecs() - time;
        }
        while (elapsed == 0);
 
        // сколько 'frames(кадров)' пропущено
 
        int ticks = (int)elapsed / period;
 
        // tween based render
 
        float tween = float(elapsed % period) / float(period);
        for (int k = 1; k <= ticks; k++) {
            if (k == ticks)
            { /* делаем захват 3Д сцены, включая положение, поворот, масштаб и альфа-канал всех объектов.
                 эта команда используется при двойной буферизации
                 Часто игра разрабатывается таким образом, чтобы обновление элементов управления и физики происходили при низких частотах, примерно 10 раз в секунду, в целях сокращения нагрузки на сеть и процессор.
                 Вызов bbCaptureWorld после такого обновления, позволяет заполнить пробелы отрисовки, которые появляются со времени последнего bbUpdateWorld.
                 Отдельно стоящие вертексы не захватываются командой CaptureWorld и поэтому VertexCoords анимации должны быть анимированы вручную.
                 */
 
                bbCaptureWorld();
            }
            time = time + period;
            // обновляем данные об игроках
            UpdateXPlayers();
            // обновляем 3Д сцену
            bbUpdateWorld();
        }
 
        // каркас 3Д сцены будет включаться клавишей W
        if (bbKeyHit(KEY_W)) {
            wire = !wire;
            bbWireFrame(wire);
        }
 
        // левой скобкой в англ. раскладке уменьшаем деталировку земли
        if (bbKeyHit(KEY_LEFTBRACKET)) {
            detail = detail - 100;
            if (detail < 100)
                detail = 100;
            bbTerrainDetail(terr, detail, morph);
        } // правой скобкой увеличиваем
        else if (bbKeyHit(KEY_RIGHTBRACKET)) {
            detail = detail + 100;
            if (detail > 10000)
                detail = 10000;
            bbTerrainDetail(terr, detail, morph);
        }
 
        // включение-выключение морфинга вершин
        if (bbKeyHit(KEY_M)) {
            morph = !morph;
            bbTerrainDetail(terr, detail, morph);
        }
        // визуализация сцены за период tween
        bbRenderWorld(tween);
 
        // отрисовка 2Д текста
        // текст будет красного цвета
        bbColor(255, 0, 0);
        const AnsiString sText2D = "Detail:" + AnsiString(detail) + " Morph:" +
            AnsiString(morph == true ? "Y" : "N");
        bbText(0, 0, sText2D.c_str());
 
        // переключение переднего и заднего буфера
        bbFlip();
    }
}
 
// обновление данных игроков
void TXPlayer::UpdateXPlayers() {
    xplayer *p;
    // проходимся, по списку игроков
    for (p = xplayerlist; p; p = p->next) {
        int x_dir = 0, y_dir = 0, z_dir = 0;
        // режим управления
        switch (p->ControlMode) {
        case ctrlMouse:
            if (bbKeyDown(KEY_LEFT))
                x_dir = -1;
            if (bbKeyDown(KEY_RIGHT))
                x_dir = 1;
 
            if (bbKeyDown(KEY_UP))
                y_dir = -1;
            if (bbKeyDown(KEY_DOWN))
                y_dir = 1;
 
            if (bbKeyDown(KEY_A))
                z_dir = 1;
            if (bbKeyDown(KEY_Z))
                z_dir = -1;
 
            // изменение положения привязки камеры к объекту
            if (bbKeyHit(KEY_F1))
                p->CameraMode = cmCamAfterObject;
            if (bbKeyHit(KEY_F2))
                p->CameraMode = cmCamBesideObject;
            if (bbKeyHit(KEY_F3))
                p->CameraMode = cmCamFromObject;
            if (bbKeyHit(KEY_F4))
                p->CameraMode = cmCamWithoutObject;
            break;
 
            // если подключен джойстик
        case ctrlJoystic:
            x_dir = bbJoyXDir();
            y_dir = bbJoyYDir();
            if (bbJoyDown(1))
                z_dir = 1;
            if (bbJoyDown(2))
                z_dir = -1;
 
            if (bbKeyHit(63))
                p->CameraMode = cmCamAfterObject;
            if (bbKeyHit(64))
                p->CameraMode = cmCamBesideObject;
            if (bbKeyHit(65))
                p->CameraMode = cmCamFromObject;
            if (bbKeyHit(66))
                p->CameraMode = cmCamWithoutObject;
            break;
        }
 
        // рассчитываем ускорения поворота по курсу
        if (x_dir < 0) {
            p->yaw_speed = p->yaw_speed + (4 - p->yaw_speed) * .04;
        }
        else {
            if (x_dir > 0) {
                p->yaw_speed = p->yaw_speed + (-4 - p->yaw_speed) * .04;
            }
            else {
                p->yaw_speed = p->yaw_speed + (-p->yaw_speed) * .02;
            }
        }
 
        // рассчитываем ускорения поворота по тангажу
        if (y_dir < 0) {
            p->pitch_speed = p->pitch_speed + (2 - p->pitch_speed) * .2;
        }
        else {
            if (y_dir > 0) {
                p->pitch_speed = p->pitch_speed + (-2 - p->pitch_speed) * .2;
            }
            else {
                p->pitch_speed = p->pitch_speed + (-p->pitch_speed) * .1;
            }
        }
 
        // угол поворота по курсу
        p->yaw = p->yaw + p->yaw_speed;
        if (p->yaw < -180)
            p->yaw = p->yaw + 360;
        if (p->yaw >= 180)
            p->yaw = p->yaw - 360;
 
        // угол поворота по тангажу
        p->pitch = p->pitch + p->pitch_speed;
        if (p->pitch < -180)
            p->pitch = p->pitch + 360;
        if (p->pitch >= 180)
            p->pitch = p->pitch - 360;
 
        p->roll = p->yaw_speed * 30;
        // поворачиваем объект в трёх плоскостях
        bbRotateEntity(p->entity, p->pitch, p->yaw, p->roll);
 
        // меняем ускорение
        if (p->ignition) {
            if (z_dir > 0) { // faster?
                p->thrust = p->thrust + (1.5 - p->thrust) * .04; // '1.5
            }
            else {
                if (z_dir < 0) { // slower?
                    p->thrust = p->thrust + (-p->thrust) * .04;
                }
            }
            bbMoveEntity(p->entity, 0, 0, p->thrust);
        }
        else {
            if (z_dir > 0)
                p->ignition = 1;
        }
 
        // если назначена камера объекту (игроку, самолётику в нашем случае)
        if (p->camera) {
            // в зависимости от положения камеры
            switch (p->CameraMode) {
            case cmCamAfterObject:
                    // присоединяем камеру к объекту
                    bbEntityParent(p->camera, p->entity);
                // поворачиваем камеру по курсу
                bbRotateEntity(p->camera, 0, p->yaw, 0, BBTRUE);
                // задаём камере положение
                bbPositionEntity(p->camera, bbEntityX(p->entity),
                    bbEntityY(p->entity), bbEntityZ(p->entity), BBTRUE);
                bbMoveEntity(p->camera, 0, 1, -5);
                // подстраиваем курс и тангаж
                bbPointEntity(p->camera, p->entity, p->roll / 2);
                break;
            case cmCamBesideObject:
                    // отсоединяем камеру от объекта
                    bbEntityParent(p->camera, 0);
                bbPositionEntity(p->camera, bbEntityX(p->entity),
                    bbEntityY(p->entity), bbEntityZ(p->entity));
                bbTranslateEntity(p->camera, 0, 1, -5);
                bbPointEntity(p->camera, p->entity, 0);
                break;
            case cmCamFromObject:
                    // присоединяем камеру к объекту
                    bbEntityParent(p->camera, p->entity);
                bbPositionEntity(p->camera, 0, .25, 0);
                bbRotateEntity(p->camera, 0, 0, 0);
                break;
            case cmCamWithoutObject:
                    // отсоединяем камеру от объекта
                    bbEntityParent(p->camera, 0);
                bbPointEntity(p->camera, p->entity, 0);
                break;
            }
        }
    }
}
 
BBPivot TXPlayer::LoadXPlane(const char *file) {
    // загружаем центр осей
    BBPivot pivot = bbCreatePivot();
    // создаём каркас, загружая данные из файла и привязываем к нему центр осей
    BBMeshModel plane = bbLoadMesh(file, pivot);
    // масштабируем, делая более сферичным
    bbScaleMesh(plane, .125, .25, .125); // make it more spherical!
    // поворачиваем на 180 по курсу
    bbRotateEntity(plane, 0, 180, 0); // and align to z axis
    // устанавливаем радиус действия коллизии (в данном случае он будет сферичным)
    bbEntityRadius(pivot, 1);
    // указваем коллизию
    bbEntityType(pivot, 1);
    // прячем центр осей
    bbHideEntity(pivot);
    // возвращаем центр осей, так как движок будет двигать именно его
    return pivot;
}
 
xplayer *TXPlayer::CreateXPlayer(BBPivot plane, int vp_x, int vp_y, int vp_w,
    int vp_h, TControlMode AControlMode, BBTerrain terr) {
    // создаём новый экземпляр структуры
    xplayer *p = new xplayer;
    // указатель на следующего игрока
    p->next = xplayerlist;
    // в данном примере будет только один игрок, поэтому пока сделаем замыкание
    xplayerlist = p;
 
    // заполняем данные текущего игрока
    // тип управления
    p->ControlMode = AControlMode;
    // тип привязки камеры
    p->CameraMode = cmCamAfterObject;
    float x = AControlMode * 10;
    float z = AControlMode * 10 - 2500;
    // объектом нашего игрока будет самолётик, копируем 3Д модель
    p->entity = bbCopyEntity(plane);
    // ускорение
    p->ignition = 0;
    // тангаж
    p->pitch = 0.0f;
    // курс
    p->yaw = 0.0f;
    // скорость поворота по тангажу
    p->pitch_speed = 0.0f;
    // скорость поворота по курсу
    p->yaw_speed = 0.0f;
    // крен
    p->roll = 0.0f;
    // скольжение
    p->thrust = 0.0f;
    // устанавливаем пространственное положение нашего объекта
    bbPositionEntity(p->entity, x, bbTerrainY(terr, x, 0, z) + 50, z);
    bbRotateEntity(p->entity, 0, 180, 0);
    bbResetEntity(p->entity);
    // устанавливаем камеру
    p->camera = bbCreateCamera(p->entity);
    // перемещаем её в исходную позицию
    bbPositionEntity(p->camera, 0, 3, -10);
    // определяем окно камеры
    bbCameraViewport(p->camera, vp_x, vp_y, vp_w, vp_h);
    bbCameraClsColor(p->camera, 0, 192, 255);
    // делаем туманчик
    bbCameraFogColor(p->camera, 0, 192, 255);
    // диапазон тумана
    bbCameraFogRange(p->camera, 1000, 3000);
    // устанавливаем дальность видимости
    bbCameraRange(p->camera, 1, 3000);
    // CameraZoom p\camera,1.5
    // if(use_fog) bbCameraFogMode(p->camera,1);
    return p;
}

// ---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "UnitBlitzLesson.h"
#include "blitz3dsdk.h"
#include "XPlayer.h"
// ---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 
// ---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) {
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender) {
    // инициализация движка
    bbBeginBlitz3D();
    // вызов функции из примера
        // выход из 3Д графики по ESCAPE
    TXPlayer::xfighter();
    // остановка работы с движком
    bbEndBlitz3D();
}
// ---------------------------------------------------------------------------