mirror of
https://github.com/kevinbentley/Descent3.git
synced 2025-01-22 19:55:23 +00:00
616 lines
15 KiB
C++
616 lines
15 KiB
C++
/*
|
|
* Descent 3
|
|
* Copyright (C) 2024 Parallax Software
|
|
*
|
|
* 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/>.
|
|
|
|
--- HISTORICAL COMMENTS FOLLOW ---
|
|
|
|
* $Logfile: /DescentIII/Main/editor/EPath.cpp $
|
|
* $Revision: 1.1.1.1 $
|
|
* $Date: 2003-08-26 03:57:38 $
|
|
* $Author: kevinb $
|
|
*
|
|
* Code to create & modify paths
|
|
*
|
|
* $Log: not supported by cvs2svn $
|
|
*
|
|
* 13 8/20/99 9:43p Gwar
|
|
* changes to InsertNodeIntoPath and DrawAllPaths for NEWEDITOR
|
|
*
|
|
* 12 8/18/99 7:00a Gwar
|
|
* changes to add EPath.cpp to NEWEDITOR project
|
|
*
|
|
* 11 4/18/99 5:42a Chris
|
|
* Added the FQ_IGNORE_RENDER_THROUGH_PORTALS flag
|
|
*
|
|
* 10 2/26/99 6:14p Matt
|
|
* Made new nodes go at the viewer position instead of in front of it, and
|
|
* make the selected path draw in a different color than the others.
|
|
*
|
|
* 9 2/26/99 12:40p Matt
|
|
* Changed occluded messages to (hopefully) be more understandable
|
|
*
|
|
* 8 2/26/99 12:26p Matt
|
|
* Fixed spelling error.
|
|
*
|
|
* 7 2/18/99 2:01p Dan
|
|
* Fixed outside/inside problem
|
|
*
|
|
* 6 2/08/99 3:29p Chris
|
|
* Added a no orient move for objects
|
|
*
|
|
* 5 2/03/99 6:56p Chris
|
|
* Added the "Move node to current object" function
|
|
*
|
|
* 4 10/14/98 2:48p Kevin
|
|
* Changed memory code to comply with mem lib
|
|
*
|
|
* 3 5/03/98 8:36p Chris
|
|
* Additional debug info
|
|
*
|
|
* 2 2/10/98 10:48a Matt
|
|
* Moved editor code from gamepath.cpp to epath.cpp
|
|
*
|
|
* 1 2/10/98 10:13a Matt
|
|
*
|
|
*/
|
|
|
|
#include <memory.h>
|
|
|
|
#ifndef NEWEDITOR
|
|
#include "d3edit.h"
|
|
#else
|
|
#include "globals.h"
|
|
#include "terrain.h"
|
|
#include "renderer.h"
|
|
#endif
|
|
|
|
#include "epath.h"
|
|
|
|
#include "object.h"
|
|
#include "findintersection.h"
|
|
|
|
uint8_t Show_paths = 1;
|
|
|
|
// Allocs a gamepath that a robot will follow. Returns an index into the GamePaths
|
|
// array
|
|
int AllocGamePath ()
|
|
{
|
|
int i;
|
|
|
|
if(Viewer_object->flags & OF_OUTSIDE_MINE)
|
|
{
|
|
OutrageMessageBox("You must be in a room or on the terrain to create a path");
|
|
return -1;
|
|
}
|
|
|
|
for (i=0;i<MAX_GAME_PATHS;i++)
|
|
{
|
|
if (GamePaths[i].used==0)
|
|
{
|
|
GamePaths[i].used=1;
|
|
GamePaths[i].name[0]=0;
|
|
GamePaths[i].num_nodes = 0;
|
|
GamePaths[i].flags=0;
|
|
|
|
GamePaths[i].pathnodes=(node *) mem_malloc (MAX_NODES_PER_PATH * sizeof(node));
|
|
mprintf((0, "Path %d got some\n", i));
|
|
|
|
Num_game_paths++;
|
|
return i;
|
|
}
|
|
}
|
|
|
|
OutrageMessageBox("ERROR: Too many paths to add another.");
|
|
return -1;
|
|
}
|
|
|
|
int MovePathNode(int pathnum, int nodenum, vector *delta_pos)
|
|
{
|
|
vector attempted_pos = GamePaths[pathnum].pathnodes[nodenum].pos + *delta_pos;
|
|
|
|
return MovePathNodeToPos(pathnum, nodenum, &attempted_pos);
|
|
}
|
|
|
|
int MovePathNodeToPos(int pathnum, int nodenum, vector *attempted_pos)
|
|
{
|
|
fvi_query fq;
|
|
fvi_info hit_info;
|
|
|
|
fq.p0 = &GamePaths[pathnum].pathnodes[nodenum].pos;
|
|
fq.startroom = GamePaths[pathnum].pathnodes[nodenum].roomnum;
|
|
fq.p1 = attempted_pos;
|
|
fq.rad = 0.0f;
|
|
fq.thisobjnum = -1;
|
|
fq.ignore_obj_list = NULL;
|
|
fq.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;
|
|
|
|
fvi_FindIntersection(&fq, &hit_info);
|
|
|
|
// Check if new node is valid
|
|
if(nodenum >= 1)
|
|
{
|
|
fvi_query fq1;
|
|
fvi_info hit_info1;
|
|
|
|
fq1.p0 = &GamePaths[pathnum].pathnodes[nodenum - 1].pos;
|
|
fq1.startroom = GamePaths[pathnum].pathnodes[nodenum - 1].roomnum;
|
|
fq1.p1 = &hit_info.hit_pnt;
|
|
fq1.rad = 0.0f;
|
|
fq1.thisobjnum = -1;
|
|
fq1.ignore_obj_list = NULL;
|
|
fq1.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;
|
|
|
|
fvi_FindIntersection(&fq1, &hit_info1);
|
|
if(vm_VectorDistance(&hit_info.hit_pnt, &hit_info1.hit_pnt) > .005)
|
|
{
|
|
OutrageMessageBox("Cannot move point. There is no line of sight from the previous node to the new position.");
|
|
return -1;
|
|
}
|
|
|
|
}
|
|
|
|
// Check if new node is valid
|
|
if(nodenum < GamePaths[pathnum].num_nodes - 1)
|
|
{
|
|
fvi_query fq1;
|
|
fvi_info hit_info1;
|
|
|
|
fq1.p0 = &GamePaths[pathnum].pathnodes[nodenum + 1].pos;
|
|
fq1.startroom = GamePaths[pathnum].pathnodes[nodenum + 1].roomnum;
|
|
fq1.p1 = &hit_info.hit_pnt;
|
|
fq1.rad = 0.0f;
|
|
fq1.thisobjnum = -1;
|
|
fq1.ignore_obj_list = NULL;
|
|
fq1.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;
|
|
|
|
fvi_FindIntersection(&fq1, &hit_info1);
|
|
if(vm_VectorDistance(&hit_info.hit_pnt, &hit_info1.hit_pnt) > .005)
|
|
{
|
|
OutrageMessageBox("Cannot move point. There is no line of sight from the next node to the new position.");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
GamePaths[pathnum].pathnodes[nodenum].pos = hit_info.hit_pnt;
|
|
GamePaths[pathnum].pathnodes[nodenum].roomnum = hit_info.hit_room;
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Given a path number, and a node number in that path, adds another node after the
|
|
// specified node
|
|
// Returns the index number of the new node
|
|
// If nodenum is -1, this node was not added
|
|
// roomnum is only valid if this is the first node in a room
|
|
#ifndef NEWEDITOR
|
|
int InsertNodeIntoPath (int pathnum,int nodenum,int flags)
|
|
#else
|
|
int InsertNodeIntoPath (int pathnum,int nodenum,int flags,int roomnum,vector pos,matrix orient)
|
|
#endif
|
|
{
|
|
int i;
|
|
vector attempted_pos;
|
|
|
|
fvi_query fq;
|
|
fvi_info hit_info;
|
|
|
|
if(Viewer_object->flags & OF_OUTSIDE_MINE)
|
|
{
|
|
OutrageMessageBox("Error: Must be in mine or on terrain to insert a node.");
|
|
return -1;
|
|
}
|
|
|
|
if(GamePaths[pathnum].num_nodes >= MAX_NODES_PER_PATH)
|
|
{
|
|
OutrageMessageBox("Error: Path already has its maximum amount of nodes.");
|
|
return -1;
|
|
}
|
|
|
|
// First, move all nodes up one
|
|
for (i=GamePaths[pathnum].num_nodes-1;i>nodenum;i--)
|
|
{
|
|
memcpy (&GamePaths[pathnum].pathnodes[i+1],&GamePaths[pathnum].pathnodes[i],sizeof(node));
|
|
}
|
|
|
|
#ifndef NEWEDITOR
|
|
attempted_pos = Viewer_object->pos; // + Viewer_object->orient.fvec * 10.0;
|
|
#else
|
|
attempted_pos = pos; // + Viewer_object->orient.fvec * 10.0;
|
|
#endif
|
|
|
|
|
|
#ifndef NEWEDITOR
|
|
fq.p0 = &Viewer_object->pos;
|
|
fq.startroom = Viewer_object->roomnum;
|
|
#else
|
|
fq.p0 = &pos;
|
|
fq.startroom = roomnum;
|
|
#endif
|
|
fq.p1 = &attempted_pos;
|
|
fq.rad = 0.0f;
|
|
fq.thisobjnum = -1;
|
|
fq.ignore_obj_list = NULL;
|
|
fq.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;
|
|
|
|
fvi_FindIntersection(&fq, &hit_info);
|
|
|
|
// Check if new node is valid
|
|
if(nodenum >= 0)
|
|
{
|
|
fvi_query fq1;
|
|
fvi_info hit_info1;
|
|
|
|
fq1.p0 = &GamePaths[pathnum].pathnodes[nodenum].pos;
|
|
fq1.startroom = GamePaths[pathnum].pathnodes[nodenum].roomnum;
|
|
fq1.p1 = &hit_info.hit_pnt;
|
|
fq1.rad = 0.0f;
|
|
fq1.thisobjnum = -1;
|
|
fq1.ignore_obj_list = NULL;
|
|
fq1.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;
|
|
|
|
fvi_FindIntersection(&fq1, &hit_info1);
|
|
if(vm_VectorDistance(&hit_info.hit_pnt, &hit_info1.hit_pnt) > .005)
|
|
{
|
|
OutrageMessageBox("Cannot add new point. There is no line of sight from the previous node.");
|
|
return -1;
|
|
}
|
|
|
|
}
|
|
|
|
// Check if new node is valid
|
|
if(nodenum >= 0 && nodenum < GamePaths[pathnum].num_nodes - 1)
|
|
{
|
|
fvi_query fq1;
|
|
fvi_info hit_info1;
|
|
|
|
fq1.p0 = &GamePaths[pathnum].pathnodes[nodenum + 1].pos;
|
|
fq1.startroom = GamePaths[pathnum].pathnodes[nodenum + 1].roomnum;
|
|
fq1.p1 = &hit_info.hit_pnt;
|
|
fq1.rad = 0.0f;
|
|
fq1.thisobjnum = -1;
|
|
fq1.ignore_obj_list = NULL;
|
|
fq1.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;
|
|
|
|
fvi_FindIntersection(&fq1, &hit_info1);
|
|
if(vm_VectorDistance(&hit_info.hit_pnt, &hit_info1.hit_pnt) > .005)
|
|
{
|
|
OutrageMessageBox("Cannot add new point. There is no line of sight from the next node.");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int newnode = nodenum + 1;
|
|
|
|
GamePaths[pathnum].pathnodes[newnode].pos = hit_info.hit_pnt;
|
|
GamePaths[pathnum].pathnodes[newnode].roomnum = hit_info.hit_room;
|
|
|
|
#ifndef NEWEDITOR
|
|
GamePaths[pathnum].pathnodes[newnode].fvec = Viewer_object->orient.fvec;
|
|
GamePaths[pathnum].pathnodes[newnode].uvec = Viewer_object->orient.uvec;
|
|
#else
|
|
GamePaths[pathnum].pathnodes[newnode].fvec = orient.fvec;
|
|
GamePaths[pathnum].pathnodes[newnode].uvec = orient.uvec;
|
|
#endif
|
|
|
|
GamePaths[pathnum].num_nodes++;
|
|
|
|
GamePaths[pathnum].pathnodes[newnode].flags = flags;
|
|
|
|
return newnode;
|
|
}
|
|
|
|
|
|
// Given a pathnum and a node index, deletes that node and moves all the following nodes down
|
|
// by one
|
|
void DeleteNodeFromPath (int pathnum,int nodenum)
|
|
{
|
|
int i;
|
|
|
|
// First, move all nodes up one
|
|
for (i=nodenum;i<GamePaths[pathnum].num_nodes-1;i++)
|
|
{
|
|
memcpy (&GamePaths[pathnum].pathnodes[i],&GamePaths[pathnum].pathnodes[i+1],sizeof(node));
|
|
}
|
|
|
|
GamePaths[pathnum].num_nodes--;
|
|
}
|
|
|
|
|
|
// Gets next path from n that has actually been alloced
|
|
int GetNextPath (int n)
|
|
{
|
|
int i;
|
|
|
|
ASSERT (n>=0 && n<MAX_GAME_PATHS);
|
|
|
|
if (Num_game_paths==0)
|
|
return -1;
|
|
|
|
for (i=n+1;i<MAX_GAME_PATHS;i++)
|
|
if (GamePaths[i].used)
|
|
return i;
|
|
for (i=0;i<n;i++)
|
|
if (GamePaths[i].used)
|
|
return i;
|
|
|
|
// this is the only one
|
|
|
|
return n;
|
|
}
|
|
|
|
// Gets previous path from n that has actually been alloced
|
|
int GetPrevPath (int n)
|
|
{
|
|
int i;
|
|
|
|
ASSERT (n>=0 && n<MAX_GAME_PATHS);
|
|
|
|
if (Num_game_paths==0)
|
|
return -1;
|
|
|
|
for (i=n-1;i>=0;i--)
|
|
{
|
|
if (GamePaths[i].used)
|
|
return i;
|
|
}
|
|
for (i=MAX_GAME_PATHS-1;i>n;i--)
|
|
{
|
|
if (GamePaths[i].used)
|
|
return i;
|
|
}
|
|
|
|
// this is the only one
|
|
return n;
|
|
|
|
}
|
|
|
|
// returns the index of the first path (from 0) alloced
|
|
// returns -1 if there are no paths
|
|
int GetFirstPath ()
|
|
{
|
|
int i;
|
|
for (i=0;i<MAX_GAME_PATHS;i++)
|
|
{
|
|
if (GamePaths[i].used)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
#ifndef NEWEDITOR
|
|
#include "editor/d3edit.h"
|
|
#endif
|
|
|
|
#include "gr.h"
|
|
|
|
void DrawAllPaths (grViewport *vp,vector *viewer_eye,matrix *viewer_orient,float zoom)
|
|
{
|
|
int i,current_path_index=0,t;
|
|
g3Point rot_points[300];
|
|
int sort_index[300];
|
|
|
|
if (!Show_paths)
|
|
return;
|
|
|
|
current_path_index=GetFirstPath();
|
|
|
|
for (i=0;i<Num_game_paths;i++,current_path_index=GetNextPath(current_path_index))
|
|
{
|
|
|
|
game_path *gp=&GamePaths[current_path_index];
|
|
|
|
#ifndef NEWEDITOR
|
|
int curnode=D3EditState.current_node;
|
|
#else
|
|
int curnode=Editor_state.GetCurrentNode();
|
|
#endif
|
|
|
|
|
|
for (t=0;t<gp->num_nodes;t++)
|
|
{
|
|
g3_RotatePoint(&rot_points[t],&gp->pathnodes[t].pos);
|
|
sort_index[t]=t;
|
|
}
|
|
|
|
#ifndef NEWEDITOR
|
|
ddgr_color path_color = (current_path_index==D3EditState.current_path) ? GR_RGB(255,255,255) : GR_RGB(36,99,238);
|
|
#else
|
|
ddgr_color path_color = (current_path_index==Editor_state.GetCurrentPath()) ? GR_RGB(255,255,255) : GR_RGB(36,99,238);
|
|
#endif
|
|
|
|
for (t=0;t<gp->num_nodes-1;t++)
|
|
{
|
|
g3Point p1=rot_points[t];
|
|
g3Point p2=rot_points[t+1];
|
|
|
|
g3_DrawLine (path_color,&p1,&p2);
|
|
}
|
|
|
|
|
|
for (t=0;t<gp->num_nodes;t++)
|
|
{
|
|
for (int k=0;k<gp->num_nodes;k++)
|
|
{
|
|
if (rot_points[k].p3_vec.z<rot_points[t].p3_vec.z)
|
|
{
|
|
g3Point temp;
|
|
int tindex;
|
|
|
|
|
|
memcpy (&temp,&rot_points[t],sizeof(g3Point));
|
|
memcpy (&rot_points[t],&rot_points[k],sizeof(g3Point));
|
|
memcpy (&rot_points[k],&temp,sizeof(g3Point));
|
|
|
|
tindex=sort_index[t];
|
|
sort_index[t]=sort_index[k];
|
|
sort_index[k]=tindex;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
for (t=0;t<gp->num_nodes;t++)
|
|
{
|
|
int color;
|
|
float size;
|
|
|
|
#ifdef NEWEDITOR
|
|
ddgr_color oldcolor;
|
|
|
|
if (TSearch_on)
|
|
{
|
|
rend_SetPixel (GR_RGB(16,255,16),TSearch_x,TSearch_y);
|
|
oldcolor=rend_GetPixel (TSearch_x,TSearch_y);
|
|
}
|
|
#endif
|
|
|
|
#ifndef NEWEDITOR
|
|
if (current_path_index==D3EditState.current_path && curnode == sort_index[t])
|
|
#else
|
|
if (current_path_index==Editor_state.GetCurrentPath() && curnode == sort_index[t])
|
|
#endif
|
|
{
|
|
color=GR_RGB (100,128,255);
|
|
size=1.2f;
|
|
}
|
|
else
|
|
{
|
|
color=GR_RGB (0,128,160);
|
|
size=1.2f;
|
|
}
|
|
|
|
g3_DrawSphere(color,&rot_points[t],size);
|
|
|
|
vector fpos = gp->pathnodes[sort_index[t]].pos + gp->pathnodes[sort_index[t]].fvec * (size - size/10.0);
|
|
vector upos = gp->pathnodes[sort_index[t]].pos + gp->pathnodes[sort_index[t]].uvec * (size - size/10.0);
|
|
|
|
g3Point frot;
|
|
g3Point urot;
|
|
|
|
g3_RotatePoint(&frot,&fpos);
|
|
g3_RotatePoint(&urot,&upos);
|
|
|
|
g3_DrawLine (GR_RGB(0,255,0),&rot_points[t], &frot);
|
|
g3_DrawLine (GR_RGB(0,0,255),&rot_points[t], &urot);
|
|
g3_DrawSphere(GR_RGB(0,255,0),&frot,size/10.0);
|
|
g3_DrawSphere(GR_RGB(0,0,255),&urot,size/10.0);
|
|
|
|
#ifdef NEWEDITOR
|
|
if (TSearch_on)
|
|
{
|
|
if (rend_GetPixel (TSearch_x,TSearch_y)!=oldcolor)
|
|
{
|
|
TSearch_found_type=TSEARCH_FOUND_NODE;
|
|
TSearch_seg=current_path_index;
|
|
TSearch_face=sort_index[t];
|
|
}
|
|
}
|
|
#endif
|
|
|
|
DrawNumber (sort_index[t] + 1,gp->pathnodes[sort_index[t]].pos,size * .5);
|
|
}
|
|
}
|
|
}
|
|
|
|
static float ArrayX[10][20]={ {-1,1,1,-1,-1},
|
|
{-.25, 0.0, 0.0, 0.0, -1.0, 1.0},
|
|
{-1.0, 1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0},
|
|
{-1.0, 1.0, 1.0, -1.0, 1.0, 1.0, -.5},
|
|
{-1.0, -1.0, -1.0, 1.0, 1.0, 1.0},
|
|
{-1.0, 1.0, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, 1.0},
|
|
{-1.0, 1.0, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, 1.0},
|
|
{-1.0, 1.0, 1.0, 1.0},
|
|
{-1.0, 1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0},
|
|
{1.0, -1.0, -1.0, 1.0, 1.0, 1.0}
|
|
};
|
|
|
|
static float ArrayY[10][20]={ {1,1,-1,-1,1},
|
|
{.75, 1.0, 1.0, -1.0, -1.0, -1.0},
|
|
{1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, -1.0, -1.0},
|
|
{1.0, 1.0, -1.0, -1.0, -1.0, 0, 0.0},
|
|
{1.0, 0.0, 0.0, 0.0, 1.0, -1.0},
|
|
{1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, -1.0, -1.0},
|
|
{1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0},
|
|
{1.0, 1.0, 1.0, -1.0},
|
|
{1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, 0.0, 0.0},
|
|
{1.0, 1.0, 0.0, 0.0, 1.0, -1.0}
|
|
};
|
|
|
|
static int NumOfPoints[]={5,6,10,7,6,10,10,4,10,6};
|
|
|
|
void DrawNumber (int num,vector pos,float size)
|
|
{
|
|
g3Point basepnt,rot_pnt[20];
|
|
int num_array[10];
|
|
int i,j;
|
|
int total = num;
|
|
size/=2;
|
|
|
|
if(num < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int num_numbers = log10(num) + 1;
|
|
if (num_numbers > 10)
|
|
{
|
|
mprintf((0, "Cannot represent a number with over 10 digits\n"));
|
|
Int3();
|
|
return;
|
|
}
|
|
|
|
for(j = num_numbers - 1; j >= 0; j--)
|
|
{
|
|
num_array[j] = total / (pow(10, j));
|
|
total -= num_array[j] * pow(10,j);
|
|
}
|
|
|
|
for(j = 0; j < num_numbers; j++)
|
|
{
|
|
vector cur_pos;
|
|
|
|
if (num_numbers & 0x00000001)
|
|
cur_pos = pos + (2.1 * size * ((num_numbers >> 1) - j)) * Viewer_object->orient.rvec;
|
|
else
|
|
cur_pos = pos + (2.1 * size * ((num_numbers >> 1) - j) - size) * Viewer_object->orient.rvec;
|
|
|
|
g3_RotatePoint (&basepnt,&cur_pos);
|
|
|
|
for (i=0;i<NumOfPoints[num_array[j]];i++)
|
|
{
|
|
rot_pnt[i]=basepnt;
|
|
|
|
rot_pnt[i].p3_vec.x+=(ArrayX[num_array[j]][i]*size);
|
|
rot_pnt[i].p3_vec.y+=(ArrayY[num_array[j]][i]*size);
|
|
|
|
rot_pnt[i].p3_flags=0;
|
|
g3_CodePoint (&rot_pnt[i]);
|
|
g3_ProjectPoint (&rot_pnt[i]);
|
|
}
|
|
|
|
for (i=0;i<NumOfPoints[num_array[j]]-1;i++)
|
|
{
|
|
g3Point p1,p2;
|
|
|
|
p1=rot_pnt[i];
|
|
p2=rot_pnt[i+1];
|
|
|
|
g3_DrawLine (GR_RGB(255,255,255),&p1,&p2);
|
|
}
|
|
}
|
|
}
|
|
|