434 lines
16 KiB
C++
434 lines
16 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "watchmaker/ll/ll_regen.h"
|
|
#include "watchmaker/classes/do_camera.h"
|
|
#include "watchmaker/render.h"
|
|
#include "watchmaker/struct.h"
|
|
#include "watchmaker/sysdef.h"
|
|
#include "watchmaker/utils.h"
|
|
#include "watchmaker/t2d/t2d.h"
|
|
#include "watchmaker/extraLS.h"
|
|
#include "watchmaker/ll/ll_mouse.h"
|
|
#include "watchmaker/define.h"
|
|
#include "watchmaker/3d/geometry.h"
|
|
#include "watchmaker/3d/t3d_body.h"
|
|
#include "watchmaker/ll/ll_system.h"
|
|
#include "watchmaker/ll/ll_util.h"
|
|
#include "watchmaker/ll/ll_string.h"
|
|
#include "watchmaker/renderer.h"
|
|
|
|
// 2d-regen
|
|
#define MAX_PAINT_RECTS MAX_DD_BITMAPS+MAX_REND_TEXTS
|
|
#define MAX_UPDATE_RECTS MAX_DD_BITMAPS+MAX_REND_TEXTS
|
|
|
|
namespace Watchmaker {
|
|
|
|
struct SDDBitmap PaintRect[MAX_PAINT_RECTS];
|
|
struct SDDBitmap OldPaintRect[MAX_PAINT_RECTS];
|
|
|
|
// frame-rate
|
|
t3dF32 hi, lo, ofps;
|
|
|
|
#define WM_CUR_VERSION "The Watchmaker v0.92"
|
|
|
|
/* -----------------30/10/98 12.19-------------------
|
|
* IntersecateRect
|
|
* --------------------------------------------------*/
|
|
int32 IntersecateRect(int32 x1, int32 y1, int32 x2, int32 y2, int32 x3, int32 y3, int32 x4, int32 y4, SRect *r) {
|
|
if ((x1 <= x4) && (x2 >= x3) && (y1 <= y4) && (y2 >= y3)) {
|
|
if (x3 > x1)
|
|
r->x1 = 0;
|
|
else
|
|
r->x1 = x1 - x3;
|
|
|
|
if (x2 < x4)
|
|
r->x2 = x2 - x3;
|
|
else
|
|
r->x2 = x4 - x3;
|
|
|
|
if (y3 > y1)
|
|
r->y1 = 0;
|
|
else
|
|
r->y1 = y1 - y3;
|
|
|
|
if (y2 < y4)
|
|
r->y2 = y2 - y3;
|
|
else
|
|
r->y2 = y4 - y3;
|
|
|
|
if (!(r->x2 - r->x1) || !(r->y2 - r->y1))
|
|
return 0;
|
|
|
|
return 1;
|
|
} else
|
|
return 0;
|
|
}
|
|
/* -----------------30/10/98 11.41-------------------
|
|
* Regen
|
|
* --------------------------------------------------*/
|
|
void Regen(WGame &game) {
|
|
struct SRect UpdateRect[MAX_UPDATE_RECTS], *p;
|
|
struct SDDBitmap *n, *o;
|
|
struct SRect r, ext;
|
|
int32 a, b, upn;
|
|
uint8 found, refresh[MAX_PAINT_RECTS];
|
|
|
|
#ifdef DEBUG_REGEN
|
|
DebugFile("----- Nuovo Frame -----");
|
|
#endif
|
|
upn = 0;
|
|
memset(refresh, 0, sizeof(refresh));
|
|
for (uint32 i = 0; i < ARRAYSIZE(UpdateRect); i++) UpdateRect[i].reset();
|
|
// I take the Extends of what the engine drew
|
|
rGetExtends(&ext.x1, &ext.y1, &ext.x2, &ext.y2);
|
|
// 1 - Compare each element of PaintRect to all OlPaintRect elements
|
|
for (a = 0; a < MAX_PAINT_RECTS; a++) {
|
|
n = &PaintRect[a];
|
|
if (!(n->dx) || !(n->dy))
|
|
continue;
|
|
#ifdef DEBUG_REGEN
|
|
DebugFile("%d: Controllo rect %d '%s': %d,%d %d,%d", a, n->tnum, rGetBitmapName(n->tnum), n->px + n->ox, n->py + n->oy, n->dx, n->dy);
|
|
#endif
|
|
found = 0;
|
|
for (b = 0; b < MAX_PAINT_RECTS; b++) {
|
|
o = &OldPaintRect[b];
|
|
if (!(o->dx) || !(o->dy))
|
|
continue;
|
|
|
|
if ((n->tnum == o->tnum) && (n->px == o->px) && (n->py == o->py) && (n->ox == o->ox) && (n->oy == o->oy) && (n->dx == o->dx) && (n->dy == o->dy)) {
|
|
#ifdef DEBUG_REGEN
|
|
DebugFile("-> Gia' disegnato");
|
|
#endif
|
|
refresh[b] = 1;
|
|
found ++;
|
|
}
|
|
}
|
|
// if it's a new rectangle, compile UpdateRect
|
|
if (true || !found) { // HACK: Just always treat everything as new, since we're doing GL
|
|
#ifdef DEBUG_REGEN
|
|
DebugFile("-> Nuovo rettangolo");
|
|
#endif
|
|
UpdateRect[upn].x1 = n->px + n->ox;
|
|
UpdateRect[upn].y1 = n->py + n->oy;
|
|
UpdateRect[upn].x2 = n->px + n->ox + n->dx;
|
|
UpdateRect[upn].y2 = n->py + n->oy + n->dy;
|
|
upn ++;
|
|
}
|
|
}
|
|
// 2 - If there are any reactangles that need to be deleted, compile UpdateRect
|
|
for (a = 0; a < MAX_PAINT_RECTS; a++) {
|
|
n = &OldPaintRect[a];
|
|
if (!(n->dx) || !(n->dy))
|
|
continue;
|
|
|
|
if ((!refresh[a]) && (n->dx) && (n->dy)) {
|
|
#ifdef DEBUG_REGEN
|
|
DebugFile("Non viene piu' ridisegnato %d '%s': %d,%d %d,%d", n->tnum, rGetBitmapName(n->tnum), n->px + n->ox, n->py + n->oy, n->dx, n->dy);
|
|
#endif
|
|
UpdateRect[upn].x1 = n->px + n->ox;
|
|
UpdateRect[upn].y1 = n->py + n->oy;
|
|
UpdateRect[upn].x2 = n->px + n->ox + n->dx;
|
|
UpdateRect[upn].y2 = n->py + n->oy + n->dy;
|
|
upn ++;
|
|
}
|
|
}
|
|
|
|
// 3 - For all UpdateRects delete the ScreenBuffer and copy what's left
|
|
for (a = 0; a < upn; a++) {
|
|
p = &UpdateRect[a];
|
|
if (!(p->x2 - p->x1) || !(p->y2 - p->y1))
|
|
continue;
|
|
|
|
// Clear ScreenBuffer
|
|
game._renderer->clearBitmap(BACK_BUFFER, (p->x1), (p->y1), (p->x2 - p->x1), (p->y2 - p->y1), 0, 0, 0);
|
|
}
|
|
|
|
for (a = 0; a < upn; a++) {
|
|
p = &UpdateRect[a];
|
|
if (!(p->x2 - p->x1) || !(p->y2 - p->y1))
|
|
continue;
|
|
|
|
#ifdef DEBUG_REGEN
|
|
DebugFile("Ridisegno quello che sta sopra a %d,%d %d,%d", p->x1, p->y1, p->x2 - p->x1, p->y2 - p->y1);
|
|
#endif
|
|
found = 0;
|
|
for (b = 0; b < MAX_PAINT_RECTS; b++) {
|
|
n = &PaintRect[b];
|
|
if (!(n->dx) || !(n->dy))
|
|
continue;
|
|
|
|
// If it intersects, copies intersection only
|
|
if ((IntersecateRect(p->x1, p->y1, p->x2, p->y2, n->px + n->ox, n->py + n->oy, n->px + n->ox + n->dx, n->py + n->oy + n->dy, &r)) &&
|
|
(n->ox + r.x2 - r.x1) && (n->oy + r.y2 - r.y1)) {
|
|
#ifdef DEBUG_REGEN
|
|
DebugFile("Copio %d '%s': P %d,%d O %d,%d D %d,%d", n->tnum, rGetBitmapName(n->tnum), (n->px + n->ox + r.x1), (n->py + n->oy + r.y1), (n->ox + r.x1), (n->oy + r.y1), (r.x2 - r.x1), (r.y2 - r.y1));
|
|
// DebugLogWindow( "Copio %d '%s': P %d,%d O %d,%d D %d,%d", n->tnum, rGetBitmapName(n->tnum), (n->px+n->ox+r.x1), (n->py+n->oy+r.y1), (n->ox+r.x1), (n->oy+r.y1), (r.x2-r.x1), (r.y2-r.y1) );
|
|
#endif
|
|
rBlitter(game, BACK_BUFFER, n->tnum, (n->px + n->ox + r.x1), (n->py + n->oy + r.y1), (n->ox + r.x1), (n->oy + r.y1), (r.x2 - r.x1), (r.y2 - r.y1));
|
|
found ++;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
if (p) p->reset();
|
|
}
|
|
}
|
|
|
|
// 4 - Copy on screen only the UpdateRects by stretching them.
|
|
for (a = 0; a < MAX_PAINT_RECTS; a++) {
|
|
n = &PaintRect[a];
|
|
if (!(n->dx) || !(n->dy))
|
|
continue;
|
|
|
|
if ((n->px + n->ox) < ext.x1) ext.x1 = n->px + n->ox;
|
|
if ((n->py + n->oy) < ext.y1) ext.y1 = n->py + n->oy;
|
|
if ((n->px + n->ox + n->dx) > ext.x2) ext.x2 = n->px + n->ox + n->dx;
|
|
if ((n->py + n->oy + n->dy) > ext.y2) ext.y2 = n->py + n->oy + n->dy;
|
|
}
|
|
for (a = 0; a < upn; a++) {
|
|
p = &UpdateRect[a];
|
|
if (!(p->x2 - p->x1) || !(p->y2 - p->y1))
|
|
continue;
|
|
|
|
if (p->x1 < ext.x1) ext.x1 = p->x1;
|
|
if (p->y1 < ext.y1) ext.y1 = p->y1;
|
|
if (p->x2 > ext.x2) ext.x2 = p->x2;
|
|
if (p->y2 > ext.y2) ext.y2 = p->y2;
|
|
}
|
|
auto windowInfo = game._renderer->getScreenInfos();
|
|
if (ext.x1 < 0) ext.x1 = 0;
|
|
if (ext.y1 < 0) ext.y1 = 0;
|
|
if (ext.x2 > (int32)windowInfo.width) ext.x2 = windowInfo.width;
|
|
if (ext.y2 > (int32)windowInfo.height) ext.y2 = windowInfo.height;
|
|
#ifdef DEBUG_REGEN
|
|
DebugFile("Aggiorna video %d,%d %d,%d", ext.x1, ext.y1, ext.x2 - ext.x1, ext.y2 - ext.y1);
|
|
// DebugLogWindow( "Aggiorna video %d,%d %d,%d", ext.x1, ext.y1, ext.x2-ext.x1, ext.y2-ext.y1 );
|
|
#endif
|
|
rUpdateExtends(ext.x1, ext.y1, ext.x2, ext.y2);
|
|
game._renderer->blitScreenBuffer();
|
|
rResetExtends();
|
|
|
|
// 5 - Copy PaintRect to OldPaintRect
|
|
memcpy(OldPaintRect, PaintRect, sizeof(OldPaintRect));
|
|
// memset( OldPaintRect, 0, sizeof( OldPaintRect ) );
|
|
}
|
|
|
|
|
|
/* -----------------16/11/98 17.29-------------------
|
|
* ResetScreenBuffer
|
|
* --------------------------------------------------*/
|
|
void ResetScreenBuffer() {
|
|
for (uint i = 0; i < ARRAYSIZE(OldPaintRect); i++) OldPaintRect[i].reset();
|
|
|
|
if (!rClearBuffers(rCLEARSCREENBUFFER | rCLEARZBUFFER))
|
|
warning("Unable to clear screenbuffer");
|
|
}
|
|
|
|
/* -----------------30/10/98 16.18-------------------
|
|
* AfterRender
|
|
* --------------------------------------------------*/
|
|
void AfterRender(WGame &game) {
|
|
PaintT2D(*game._renderer);
|
|
PaintInventory(game);
|
|
PaintText(game);
|
|
}
|
|
|
|
/* -----------------31/10/98 15.56-------------------
|
|
* AddPaintRect
|
|
* --------------------------------------------------*/
|
|
void AddPaintRect(int32 tnum, int32 px, int32 py, int32 ox, int32 oy, int32 dx, int32 dy) {
|
|
int32 a;
|
|
for (a = 0; a < MAX_PAINT_RECTS; a++)
|
|
if (!PaintRect[a].tnum)
|
|
break;
|
|
|
|
// ce ne sono troppe
|
|
if (a >= MAX_PAINT_RECTS) {
|
|
warning("Too many PaintRects!");
|
|
return ;
|
|
}
|
|
|
|
PaintRect[a].tnum = tnum;
|
|
PaintRect[a].px = (px);
|
|
PaintRect[a].py = (py);
|
|
PaintRect[a].ox = (ox);
|
|
PaintRect[a].oy = (oy);
|
|
PaintRect[a].dx = (dx);
|
|
PaintRect[a].dy = (dy);
|
|
}
|
|
|
|
void Renderer::add2DStuff() {
|
|
// Insert pre-calculated images and texts
|
|
_2dStuff.writeBitmapListTo(PaintRect);
|
|
|
|
_2dStuff.garbageCollectPreRenderedText();
|
|
|
|
// Put mouse over everything
|
|
if ((!mHide) && (CurDialog <= dSUPERVISORE) && (!bTitoliCodaStatic) && (!bTitoliCodaScrolling)) {
|
|
int32 cmx = mPosx - mHotspotX;
|
|
int32 cmy = mPosy - mHotspotY;
|
|
|
|
if (cmx >= MousePointerLim.x2)
|
|
cmx = MousePointerLim.x2 - 1;
|
|
else if (cmx <= MousePointerLim.x1)
|
|
cmx = MousePointerLim.x1 + 1;
|
|
|
|
if (cmy >= MousePointerLim.y2)
|
|
cmy = MousePointerLim.y2 - 1;
|
|
else if (cmy <= MousePointerLim.y1)
|
|
cmy = MousePointerLim.y1 + 1;
|
|
|
|
// Draw the current mouse pointer
|
|
if (CurMousePointer > 0)
|
|
AddPaintRect(CurMousePointer, (cmx), (cmy), 0, 0, this->getBitmapDimX(CurMousePointer), this->getBitmapDimY(CurMousePointer));
|
|
}
|
|
|
|
Regen(*_game);
|
|
|
|
_2dStuff.clearBitmapList();
|
|
_2dStuff.clearTextList();
|
|
|
|
//check
|
|
CheckExtraLocalizationStrings(*this, 0);
|
|
}
|
|
|
|
/* -----------------27/10/98 17.14-------------------
|
|
* Add3DStuff
|
|
* --------------------------------------------------*/
|
|
void Add3DStuff(WGame &game) {
|
|
extern uint32 StatNumTris, StatNumVerts;
|
|
struct SD3DRect *p;
|
|
struct SD3DTriangle *t;
|
|
int32 a, y = 0;
|
|
// char *PauseAnimStr[] = { "", "(PAUSE)" };
|
|
|
|
if (bShowBoundingBox) {
|
|
t3dShowBoundingBox(t3dCurRoom);
|
|
for (a = ocCUOCO; a < ocCURPLAYER; a++)
|
|
if ((Character[a]) && (Character[a]->Body) && !(Character[a]->Flags & T3D_CHARACTER_HIDE))
|
|
t3dShowBoundingBox(Character[a]->Body);
|
|
}
|
|
|
|
if (bShowPanels && Player && Player->Walk.Panel)
|
|
t3dShowBounds(Player->Walk.Panel, Player->Walk.PanelNum);
|
|
else if (bShowPanels)
|
|
t3dShowBounds(t3dCurRoom->Panel[t3dCurRoom->CurLevel], t3dCurRoom->NumPanels[t3dCurRoom->CurLevel]);
|
|
|
|
//DisplayDDBitmap( TrecLogo, 800-10-rGetBitmapRealDimX(TrecLogo),0, 0,0, 0,0 );
|
|
if (bShowInfo) {
|
|
//display version
|
|
uint32 date = 0, time = 0, d = 0, m = 0, yy = 0, h = 0, min = 0;
|
|
t3dForceNOFastFile(1);
|
|
if (t3dGetFileDate(&date, &time, "wm.exe ")) {
|
|
d = date - (date / 100) * 100;
|
|
date /= 100;
|
|
m = date - (date / 100) * 100;
|
|
date /= 100;
|
|
yy = date;
|
|
|
|
time /= 100;
|
|
min = time - (time / 100) * 100;
|
|
time /= 100;
|
|
h = time;
|
|
} else {
|
|
d = m = yy = h = min = 0;
|
|
}
|
|
t3dForceNOFastFile(0);
|
|
DebugVideo(*game._renderer, 1, 600 - 20, "%s (%02d/%02d/%4d - %d.%d)", WM_CUR_VERSION, d, m, yy, h, min);
|
|
|
|
if (LoaderFlags & T3D_DEBUGMODE) {
|
|
auto windowInfo = game._renderer->getScreenInfos();
|
|
if (CurFps > 100.0f) CurFps = 100.0f;
|
|
if (AvgFps > 100.0f) AvgFps = 100.0f;
|
|
if (!AvgFps) AvgFps = CurFps;
|
|
if (AvgFps != ofps) {
|
|
ofps = AvgFps;
|
|
hi = 0.0f;
|
|
lo = 999.0f;
|
|
}
|
|
if (CurFps > hi) hi = CurFps;
|
|
if (CurFps < lo) lo = CurFps;
|
|
DisplayD3DRect(*game._renderer, 1, 1, (int32)((t3dF32)windowInfo.width * (CurFps / 101.0f)), 13, 78, 78, 78, 228);
|
|
DebugVideo(*game._renderer, 1, y += 16, "FPS: ( LOW %2d | AVG %2d | HI %2d ) TRI: %d VERT: %d", (int)lo, (int)AvgFps, (int)hi, StatNumTris, StatNumVerts);
|
|
// DebugVideo(1,y+=16,"(%d) CUR %f %s",(int)(1000.0f/CurFps),CurFps,PauseAnimStr[bPauseAllAnims]);
|
|
DebugVideo(*game._renderer, 1, y += 16, "%d,%d: %s (%d %d) %X", game._gameVars.getCurRoomId(), CurObj, ObjectUnderCursor, NextPortalObj, NextPortalAnim, game.init.Obj[CurObj].flags);
|
|
// DebugVideo(1,y+=16,"Player: %d %d %d %d",Player->Mesh->BlendPercent,Player->Mesh->CurFrame,Player->Mesh->LastFrame,Player->Walk.CurAction);
|
|
DebugVideo(*game._renderer, 1, y += 16, "DialogActive: %d AnimWaitText: %d PlayerInAnim: %d | %d", bDialogActive, bAnimWaitText, bPlayerInAnim, Player->Mesh->CurFrame);
|
|
DebugVideo(*game._renderer, 1, y += 16, "CurCamera %d CurTime %d (%f %f)", game._cameraMan->getCurCameraIndex() + 1, t3dCurTime, t3dCurCamera->Source.x, t3dCurCamera->Source.z);
|
|
// DebugVideo(1,y+=16,"xy(%f %f)",Character[1]->Mesh->Trasl.x,Character[1]->Mesh->Trasl.y);
|
|
// DebugVideo(1,y+=16,"xy(%f %f)",Character[2]->Dir.x,Character[2]->Dir.y);
|
|
DebugVideo(*game._renderer, 1, y += 16, "bPlayerSuBasamento %d", bPlayerSuBasamento);
|
|
DebugVideo(*game._renderer, 1, y += 16, "%f %f ", Player->Mesh->Trasl.y, Player->Pos.y);
|
|
// DebugVideo(1,y+=16,"CurP %d",CurPlayer);
|
|
// DebugVideo(1,y+=16,"InvStatus ON%d (1)%d (2)%d (3)%d (4)%d (5)%d",InvStatus&1,InvStatus&2,InvStatus&4,InvStatus&8,InvStatus&16,InvStatus&32);
|
|
DebugVideo(*game._renderer, 1, y += 16, "bMovingCamera%d", bMovingCamera);
|
|
|
|
// DebugVideo(1,y+=16,"1-%s",PlayerStand[0].RoomName);
|
|
// DebugVideo(1,y+=16,"2-%s",PlayerStand[1].RoomName);
|
|
/* if( Character[1]->CurRoom )
|
|
{
|
|
if( Character[1]->CurRoom->Name[0]=='\0' ) DebugVideo(1,y+=16,"1-NULLA");
|
|
else DebugVideo(1,y+=16,"1-%s",Character[1]->CurRoom->Name);
|
|
}
|
|
|
|
if( Character[2]->CurRoom )
|
|
{
|
|
if( Character[2]->CurRoom->Name[0]=='\0' ) DebugVideo(1,y+=16,"2-NULLA");
|
|
else DebugVideo(1,y+=16,"2-%s",Character[2]->CurRoom->Name);
|
|
}
|
|
*/
|
|
DebugVideo(*game._renderer, 1, windowInfo.height - 40, "%s", CurDebugString);
|
|
} else {
|
|
// extern t3dU8 t3dCurCameraIndex;
|
|
// DebugVideo(1,y+=16,"CurCamera %d CurTime %d",t3dCurCameraIndex+1,t3dCurTime);
|
|
// extern t3dU8 t3dCurCameraIndex;
|
|
|
|
// if( !AvgFps ) AvgFps = CurFps;
|
|
// if( AvgFps != ofps ) { ofps = AvgFps; hi = 0.0f; lo = 999.0f; }
|
|
// if( CurFps > hi ) hi = CurFps;
|
|
// if( CurFps < lo ) lo = CurFps;
|
|
// DebugVideo(1,y+=16,"mHide %d",mHide);
|
|
// DebugVideo(1,1,"FPS: %3d TRI: %d VERT: %d",(int)AvgFps,StatNumTris,StatNumVerts);
|
|
// DebugVideo(1,y+=16,"CurTime %d CurCamera %d",t3dCurTime,t3dCurCameraIndex+1);
|
|
// DebugVideo(1,y+=16,"CurDialog %d, obj %d",CurDialog,Dialog[CurDialog].obj);
|
|
// DebugVideo(1,y+=16,"%d,%d: %s (%d %d) %X",CurRoom,CurObj,ObjectUnderCursor,NextPortalObj,NextPortalAnim,Obj[CurObj].flags); //_remove
|
|
}
|
|
}
|
|
// Aggiunge i rettangoli D3D
|
|
for (a = 0, p = &D3DRectsList[0]; a < MAX_D3D_RECTS; a++, p++)
|
|
if (p->dx || p->dy)
|
|
t3dAddQuad((t3dF32)(p->px), (t3dF32)(p->py), (t3dF32)(p->px + p->dx), (t3dF32)(p->py),
|
|
(t3dF32)(p->px), (t3dF32)(p->py + p->dy), (t3dF32)(p->px + p->dx), (t3dF32)(p->py + p->dy),
|
|
p->r, p->g, p->b, p->a);
|
|
for (a = 0, p = &D3DRectsList[0]; a < MAX_D3D_RECTS; a++, p++)
|
|
p->dx = p->dy = 0;
|
|
// Aggiunge i triangoli D3D
|
|
for (a = 0, t = &D3DTrianglesList[0]; a < MAX_D3D_TRIANGLES; a++, t++)
|
|
if (t->x1 || t->y1 || t->x2 || t->y2)
|
|
t3dAddTriangle((t3dF32)(t->x1), (t3dF32)(t->y1), (t3dF32)(t->x2), (t3dF32)(t->y2),
|
|
(t3dF32)(t->x3), (t3dF32)(t->y3), t->r, t->g, t->b, t->a);
|
|
for (a = 0, t = &D3DTrianglesList[0]; a < MAX_D3D_TRIANGLES; a++, t++)
|
|
t->x1 = t->y1 = t->x2 = t->y2 = t->x3 = t->y3 = 0;
|
|
}
|
|
|
|
} // End of namespace Watchmaker
|