//number of nodes as would return vector.size()
void SkeletonGraph::CreateGraphFromSkeleton(SkeletonMatchNode* root, int numOfNodes) {
FreeNodes();
nodes.reserve(numOfNodes);
for (int i = 0; i < numOfNodes; i++) {
SkeletonGraphNode* node = new SkeletonGraphNode(i);
nodes.push_back(node);
}
deque<SkeletonMatchNode*> queue;
queue.push_back(root);
int id = 0;
while (!queue.empty()) {
SkeletonMatchNode* sklNode = queue.front();
queue.pop_front();
nodes[id]->point = sklNode->point;
nodes[id]->oldID = sklNode->oldID;
//edges are not oriented and parent would handle parent edge so we add only child edges
for (int i = 0; i < sklNode->nodes.size(); i++) {
GraphEdge ge = GraphEdge(sklNode->betweenNodes[i], sklNode->dists[i]);
ge.oldIDs = sklNode->oldIDs[i];
ge.positions = sklNode->positions[i];
ge.fromId = sklNode->id;
ge.toId = sklNode->nodes[i]->id;
CreateEdge(sklNode->id, sklNode->nodes[i]->id, ge);
queue.push_back(sklNode->nodes[i]);
}
id++;
}
CollectBranchNodes();
}
int main()
{
Graph g;
g = Initialize(VERTEXNUM);
CreateVertex(g, 1);
CreateVertex(g, 2);
CreateVertex(g, 3);
CreateVertex(g, 4);
CreateEdge(g, 1, 2);
CreateEdge(g, 2, 3);
CreateEdge(g, 3, 2);
CreateEdge(g, 3, 1);
CreateEdge(g, 3, 4);
Unweighted(g, 1, VERTEXNUM);
DestoryGraph(g, VERTEXNUM);
return 0;
}
RandomWaypointPathFinder::DirectionList RandomWaypointPathFinder::ComputePath()
{
int avatarX = this->_avatar->GetPosition().x / Map::_MAP_SCALE;
int avatarY = this->_avatar->GetPosition().y / Map::_MAP_SCALE;
DirectionList directions;
if (this->_waypoints.size() == 0)
{
// Create a waypont at the avatar pos
node_type * node = new node_type;
node->X() = this->_avatar->GetPosition().x / Map::_MAP_SCALE;
node->Y() = this->_avatar->GetPosition().y / Map::_MAP_SCALE;
if (this->_edgeMap[node->Y()][node->X()] == 0)
{
node->GetData().dist = abs(node->X() - this->_goalX) + abs(node->Y() - this->_goalY);
if (this->_maxDepth < node->GetData().dist)
this->_maxDepth = node->GetData().dist;
this->_edgeMap[node->Y()][node->X()] = node;
this->_nodeList.push_back(node);
this->_nbNode++;
CreateEdge(this->_map, node);
}
else
delete node;
CreateWaypoint();
if (this->_waypoints.size() == 0 && this->_currentGridResolution)
{
this->_currentGridResolution >>= 1;
this->CreateGraph(this->_map, this->_currentGridResolution);
CreateEdge(this->_map, this->_edgeMap[this->_goalY][this->_goalX]);
std::cout << "Create new waypoint : " << this->_nbNode << " resolution : " << this->_currentGridResolution << std::endl;
}
int main()
{
//그래프 생성
Graph* G = CreateGraph();
// 정점 생성
Vertex* V1 = CreateVertex('1');
Vertex* V2 = CreateVertex('2');
Vertex* V3 = CreateVertex('3');
Vertex* V4 = CreateVertex('4');
Vertex* V5 = CreateVertex('5');
// 그래프에 정점을 추가
AddVertex(G, V1);
AddVertex(G, V2);
AddVertex(G, V3);
AddVertex(G, V4);
AddVertex(G, V5);
// 정점과 정점을 간선으로 잇기
AddEdge(V1, CreateEdge(V1, V2, 0));
AddEdge(V1, CreateEdge(V1, V3, 0));
AddEdge(V1, CreateEdge(V1, V4, 0));
AddEdge(V1, CreateEdge(V1, V5, 0));
AddEdge(V2, CreateEdge(V2, V1, 0));
AddEdge(V2, CreateEdge(V2, V2, 0));
AddEdge(V2, CreateEdge(V2, V5, 0));
AddEdge(V3, CreateEdge(V3, V1, 0));
AddEdge(V3, CreateEdge(V3, V2, 0));
AddEdge(V4, CreateEdge(V4, V1, 0));
AddEdge(V4, CreateEdge(V4, V5, 0));
AddEdge(V5, CreateEdge(V5, V1, 0));
AddEdge(V5, CreateEdge(V5, V2, 0));
AddEdge(V5, CreateEdge(V5, V4, 0));
PrintGraph(G);
// 그래프 소멸
DestroyGraph(G);
return 0;
}
void Dijkstra(Graph* G, Vertex* StartVertex, Graph* ShortestPath )
{
int i = 0;
PQNode StartNode = { 0, StartVertex };
PriorityQueue* PQ = PQ_Create(10);
Vertex* CurrentVertex = NULL;
Edge* CurrentEdge = NULL;
int* Weights = (int*) malloc( sizeof(int) * G->VertexCount );
Vertex** ShortestPathVertices =
(Vertex**) malloc( sizeof(Vertex*) * G->VertexCount );
Vertex** Fringes = (Vertex**) malloc( sizeof(Vertex*) * G->VertexCount );
Vertex** Precedences = (Vertex**) malloc( sizeof(Vertex*) * G->VertexCount );
CurrentVertex = G->Vertices;
while ( CurrentVertex != NULL )
{
Vertex* NewVertex = CreateVertex( CurrentVertex->Data );
AddVertex( ShortestPath, NewVertex);
Fringes[i] = NULL;
Precedences[i] = NULL;
ShortestPathVertices[i] = NewVertex;
Weights[i] = MAX_WEIGHT;
CurrentVertex = CurrentVertex->Next;
i++;
}
PQ_Enqueue ( PQ, StartNode );
Weights[StartVertex->Index] = 0;
while( ! PQ_IsEmpty( PQ ) )
{
PQNode Popped;
PQ_Dequeue(PQ, &Popped);
CurrentVertex = (Vertex*)Popped.Data;
Fringes[CurrentVertex->Index] = CurrentVertex;
CurrentEdge = CurrentVertex->AdjacencyList;
while ( CurrentEdge != NULL )
{
Vertex* TargetVertex = CurrentEdge->Target;
if ( Fringes[TargetVertex->Index] == NULL &&
Weights[CurrentVertex->Index] + CurrentEdge->Weight <
Weights[TargetVertex->Index] )
{
PQNode NewNode = { CurrentEdge->Weight, TargetVertex };
PQ_Enqueue ( PQ, NewNode );
Precedences[TargetVertex->Index] = CurrentEdge->From;
Weights[TargetVertex->Index] =
Weights[CurrentVertex->Index] + CurrentEdge->Weight;
}
CurrentEdge = CurrentEdge->Next;
}
}
for ( i=0; i<G->VertexCount; i++ )
{
int FromIndex, ToIndex;
if ( Precedences[i] == NULL )
continue;
FromIndex = Precedences[i]->Index;
ToIndex = i;
AddEdge( ShortestPathVertices[FromIndex],
CreateEdge(
ShortestPathVertices[FromIndex],
ShortestPathVertices[ToIndex],
Weights[i] ) );
}
free( Fringes );
free( Precedences );
free( ShortestPathVertices );
free( Weights );
PQ_Destroy( PQ );
}
int main( void )
{
/* 그래프 생성 */
Graph* G = CreateGraph();
/* 정점 생성 */
Vertex* V1 = CreateVertex( '1' );
Vertex* V2 = CreateVertex( '2' );
Vertex* V3 = CreateVertex( '3' );
Vertex* V4 = CreateVertex( '4' );
Vertex* V5 = CreateVertex( '5' );
/* 그래프에 정점을 추가 */
AddVertex( G, V1 );
AddVertex( G, V2 );
AddVertex( G, V3 );
AddVertex( G, V4 );
AddVertex( G, V5 );
/* 정점과 정점을 간선으로 잇기 */
AddEdge( V1, CreateEdge(V1, V2, 0) );
AddEdge( V1, CreateEdge(V1, V3, 0) );
AddEdge( V1, CreateEdge(V1, V4, 0) );
AddEdge( V1, CreateEdge(V1, V5, 0) );
AddEdge( V2, CreateEdge(V2, V1, 0) );
AddEdge( V2, CreateEdge(V2, V3, 0) );
AddEdge( V2, CreateEdge(V2, V5, 0) );
AddEdge( V3, CreateEdge(V3, V1, 0) );
AddEdge( V3, CreateEdge(V3, V2, 0) );
AddEdge( V4, CreateEdge(V4, V1, 0) );
AddEdge( V4, CreateEdge(V4, V5, 0) );
AddEdge( V5, CreateEdge(V5, V1, 0) );
AddEdge( V5, CreateEdge(V5, V2, 0) );
AddEdge( V5, CreateEdge(V5, V4, 0) );
PrintGraph( G );
/* 그래프 소멸 */
DestroyGraph( G );
return 0;
}
void FixMetaTJunctions( void ){
int i, j, k, f, fOld, start, vertIndex, triIndex, numTJuncs;
metaTriangle_t *tri, *newTri;
shaderInfo_t *si;
bspDrawVert_t *a, *b, *c, junc;
float dist, amount;
vec3_t pt;
vec4_t plane;
edge_t edges[ 3 ];
/* this code is crap; revisit later */
return;
/* note it */
Sys_FPrintf( SYS_VRB, "--- FixMetaTJunctions ---\n" );
/* init pacifier */
fOld = -1;
start = I_FloatTime();
/* walk triangle list */
numTJuncs = 0;
for ( i = 0; i < numMetaTriangles; i++ )
{
/* get triangle */
tri = &metaTriangles[ i ];
/* print pacifier */
f = 10 * i / numMetaTriangles;
if ( f != fOld ) {
fOld = f;
Sys_FPrintf( SYS_VRB, "%d...", f );
}
/* attempt to early out */
si = tri->si;
if ( ( si->compileFlags & C_NODRAW ) || si->autosprite || si->notjunc ) {
continue;
}
/* calculate planes */
VectorCopy( tri->plane, plane );
plane[ 3 ] = tri->plane[ 3 ];
CreateEdge( plane, metaVerts[ tri->indexes[ 0 ] ].xyz, metaVerts[ tri->indexes[ 1 ] ].xyz, &edges[ 0 ] );
CreateEdge( plane, metaVerts[ tri->indexes[ 1 ] ].xyz, metaVerts[ tri->indexes[ 2 ] ].xyz, &edges[ 1 ] );
CreateEdge( plane, metaVerts[ tri->indexes[ 2 ] ].xyz, metaVerts[ tri->indexes[ 0 ] ].xyz, &edges[ 2 ] );
/* walk meta vert list */
for ( j = 0; j < numMetaVerts; j++ )
{
/* get vert */
VectorCopy( metaVerts[ j ].xyz, pt );
/* debug code: darken verts */
if ( i == 0 ) {
VectorSet( metaVerts[ j ].color[ 0 ], 8, 8, 8 );
}
/* determine if point lies in the triangle's plane */
dist = DotProduct( pt, plane ) - plane[ 3 ];
if ( fabs( dist ) > TJ_PLANE_EPSILON ) {
continue;
}
/* skip this point if it already exists in the triangle */
for ( k = 0; k < 3; k++ )
{
if ( fabs( pt[ 0 ] - metaVerts[ tri->indexes[ k ] ].xyz[ 0 ] ) <= TJ_POINT_EPSILON &&
fabs( pt[ 1 ] - metaVerts[ tri->indexes[ k ] ].xyz[ 1 ] ) <= TJ_POINT_EPSILON &&
fabs( pt[ 2 ] - metaVerts[ tri->indexes[ k ] ].xyz[ 2 ] ) <= TJ_POINT_EPSILON ) {
break;
}
}
if ( k < 3 ) {
continue;
}
/* walk edges */
for ( k = 0; k < 3; k++ )
{
/* ignore bogus edges */
if ( fabs( edges[ k ].kingpinLength ) < TJ_EDGE_EPSILON ) {
continue;
}
/* determine if point lies on the edge */
dist = DotProduct( pt, edges[ k ].plane ) - edges[ k ].plane[ 3 ];
if ( fabs( dist ) > TJ_EDGE_EPSILON ) {
continue;
}
/* determine how far along the edge the point lies */
amount = ( pt[ edges[ k ].kingpin ] - edges[ k ].origin[ edges[ k ].kingpin ] ) / edges[ k ].kingpinLength;
if ( amount <= 0.0f || amount >= 1.0f ) {
continue;
}
#if 0
dist = DotProduct( pt, edges[ k ].edge ) - edges[ k ].edge[ 3 ];
if ( dist <= -0.0f || dist >= edges[ k ].length ) {
continue;
}
amount = dist / edges[ k ].length;
#endif
/* debug code: brighten this point */
//% metaVerts[ j ].color[ 0 ][ 0 ] += 5;
//% metaVerts[ j ].color[ 0 ][ 1 ] += 4;
VectorSet( metaVerts[ tri->indexes[ k ] ].color[ 0 ], 255, 204, 0 );
VectorSet( metaVerts[ tri->indexes[ ( k + 1 ) % 3 ] ].color[ 0 ], 255, 204, 0 );
/* the edge opposite the zero-weighted vertex was hit, so use that as an amount */
a = &metaVerts[ tri->indexes[ k % 3 ] ];
b = &metaVerts[ tri->indexes[ ( k + 1 ) % 3 ] ];
c = &metaVerts[ tri->indexes[ ( k + 2 ) % 3 ] ];
/* make new vert */
LerpDrawVertAmount( a, b, amount, &junc );
VectorCopy( pt, junc.xyz );
/* compare against existing verts */
if ( VectorCompare( junc.xyz, a->xyz ) || VectorCompare( junc.xyz, b->xyz ) || VectorCompare( junc.xyz, c->xyz ) ) {
continue;
}
/* see if we can just re-use the existing vert */
if ( !memcmp( &metaVerts[ j ], &junc, sizeof( junc ) ) ) {
vertIndex = j;
}
else
{
/* find new vertex (note: a and b are invalid pointers after this) */
firstSearchMetaVert = numMetaVerts;
vertIndex = FindMetaVertex( &junc );
if ( vertIndex < 0 ) {
continue;
}
}
/* make new triangle */
triIndex = AddMetaTriangle();
if ( triIndex < 0 ) {
continue;
}
/* get triangles */
tri = &metaTriangles[ i ];
newTri = &metaTriangles[ triIndex ];
/* copy the triangle */
memcpy( newTri, tri, sizeof( *tri ) );
/* fix verts */
tri->indexes[ ( k + 1 ) % 3 ] = vertIndex;
newTri->indexes[ k ] = vertIndex;
/* recalculate edges */
CreateEdge( plane, metaVerts[ tri->indexes[ 0 ] ].xyz, metaVerts[ tri->indexes[ 1 ] ].xyz, &edges[ 0 ] );
CreateEdge( plane, metaVerts[ tri->indexes[ 1 ] ].xyz, metaVerts[ tri->indexes[ 2 ] ].xyz, &edges[ 1 ] );
CreateEdge( plane, metaVerts[ tri->indexes[ 2 ] ].xyz, metaVerts[ tri->indexes[ 0 ] ].xyz, &edges[ 2 ] );
/* debug code */
metaVerts[ vertIndex ].color[ 0 ][ 0 ] = 255;
metaVerts[ vertIndex ].color[ 0 ][ 1 ] = 204;
metaVerts[ vertIndex ].color[ 0 ][ 2 ] = 0;
/* add to counter and end processing of this vert */
numTJuncs++;
break;
}
}
}
/* print time */
Sys_FPrintf( SYS_VRB, " (%d)\n", (int) ( I_FloatTime() - start ) );
/* emit some stats */
Sys_FPrintf( SYS_VRB, "%9d T-junctions added\n", numTJuncs );
}
