mainfrm.cpp

2D Collsion Detection in Real-time Demonstration This is the sample application that accompanies G

					(temp.x - m_edgelist[loop].pos.x) +
					(temp.y - m_edgelist[loop].pos.y) * 
					(temp.y - m_edgelist[loop].pos.y); 
			if (dist < 100)
			{
				m_temppoint.x = m_edgelist[loop].pos.x;
				m_temppoint.y = m_edgelist[loop].pos.y;
				m_point = &m_edgelist[loop].pos;
				Invalidate(TRUE);
				break;
			}
		}
	}
	CFrameWnd::OnLButtonDown(nFlags, point);
}

void CMainFrame::OnLButtonUp(UINT nFlags, CPoint point) 
{
	short loop;
	char message[80];
	short t_edge,next;
	if (m_point != NULL)
	{
		SnapPoint(m_point);
		// Check if I need to delete similar edges
		CheckDeleteEdges(&m_temppoint,m_point);
		// MOVE ALL POINTS THAT WERE AT THE SAME LOCATION
		for (loop = 0; loop < m_edgecnt; loop++)
		{
			if (m_temppoint.x == m_edgelist[loop].pos.x &&
				m_temppoint.y == m_edgelist[loop].pos.y)
			{
				m_edgelist[loop].pos.x = m_point->x;
				m_edgelist[loop].pos.y = m_point->y;
			}
			// STORE OFF THE MOVED POINT
			if (m_point == &m_edgelist[loop].pos)
				t_edge = loop;
		}
		// CHECK IF I NEED TO DELETE THIS EDGE
		next = m_edgelist[t_edge].nextedge;
		if (m_point->x == m_edgelist[next].pos.x &&
			m_point->y == m_edgelist[next].pos.y)
		{
			DeleteEdge(t_edge);
		}

		CheckDoubleSided();

		sprintf(message,"Sectors = %d  Edges = %d",m_sectorcnt,m_edgecnt);
		SetStatusText(1,message);
		Invalidate(TRUE);
	}
	CFrameWnd::OnLButtonUp(nFlags, point);
}

void CMainFrame::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	tPoint2D temp;
	char message[80];
	short sec;

	temp.x = (long)((point.x + m_offX - (m_sizeX / 2)) / m_scale);
	temp.y = (long)-((point.y + m_offY - (m_sizeY / 2)) / m_scale);

	sec = InsideSector(&temp);

	if (sec == -1)
	{
		MessageBox("Not inside any..","Inside Sector Test",MB_OK);
	}
	else
	{
		sprintf(message,"Inside Sector %d",sec);
		MessageBox(message,"Inside Sector Test",MB_OK);
	}
	CFrameWnd::OnLButtonDblClk(nFlags, point);
}

void CMainFrame::OnMouseMove(UINT nFlags, CPoint point) 
{
	long startX,startY;
	short nearest;
	CClientDC dc(this); // device context for painting
	if ((nFlags & MK_LBUTTON) == MK_LBUTTON)
	{

		if ((nFlags & MK_SHIFT) > 0)
		{
			m_offY += m_clickpoint.y - point.y;
			m_offX += m_clickpoint.x - point.x;
			Invalidate(TRUE);
			m_clickpoint = point;
		}
		else if (m_point != NULL)
		{
			dc.SetROP2(R2_NOT);
			// ERASE OLD POINT
			startX = (m_point->x * m_scale) - m_offX + (m_sizeX / 2);
			startY = (-m_point->y * m_scale) - m_offY + (m_sizeY / 2);
			dc.MoveTo(startX-2,startY-2);
			dc.LineTo(startX+2,startY-2);
			dc.LineTo(startX+2,startY+2);
			dc.LineTo(startX-2,startY+2);
			dc.LineTo(startX-2,startY-2);

			m_point->x = (long)((point.x + m_offX - (m_sizeX / 2)) / m_scale);
			m_point->y = -(long)((point.y + m_offY - (m_sizeY / 2)) / m_scale);

			startX = (m_point->x * m_scale) - m_offX + (m_sizeX / 2);
			startY = (-m_point->y * m_scale) - m_offY + (m_sizeY / 2);
			dc.MoveTo(startX-2,startY-2);
			dc.LineTo(startX+2,startY-2);
			dc.LineTo(startX+2,startY+2);
			dc.LineTo(startX-2,startY+2);
			dc.LineTo(startX-2,startY-2);
		}
	}
	else
	{
		dc.SetROP2(R2_NOT);
		nearest = GetNearestEdge(point);
		if (nearest >= 0)
		{
			m_nearest_edge = nearest;
			// TODO: m_old_pnt is not defined at start
			dc.MoveTo(m_old_pnt.x-1,m_old_pnt.y-1);
			dc.LineTo(m_old_pnt.x+1,m_old_pnt.y-1);
			dc.LineTo(m_old_pnt.x+1,m_old_pnt.y+1);
			dc.LineTo(m_old_pnt.x-1,m_old_pnt.y+1);
			dc.LineTo(m_old_pnt.x-1,m_old_pnt.y-1);
			startX = (m_nearest_pnt.x * m_scale) - m_offX + (m_sizeX / 2);
			startY = (-m_nearest_pnt.y * m_scale) - m_offY + (m_sizeY / 2);
			dc.MoveTo(startX-1,startY-1);
			dc.LineTo(startX+1,startY-1);
			dc.LineTo(startX+1,startY+1);
			dc.LineTo(startX-1,startY+1);
			dc.LineTo(startX-1,startY-1);
			m_old_pnt.x = startX;
			m_old_pnt.y = startY;
		}
	}
	CFrameWnd::OnMouseMove(nFlags, point);
}

void CMainFrame::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	
	Draw2DView(&dc);
	// Do not call CFrameWnd::OnPaint() for painting messages
}



void CMainFrame::OnFileNew() 
{
	// RESET THE WORLD TO NOTHING
	char message[80];
	m_sectorcnt = 0;
	m_edgecnt = 0;
	sprintf(message,"Sectors = %d  Edges = %d",m_sectorcnt,m_edgecnt);
	SetStatusText(1,message);
	Invalidate(TRUE);
}

// LOAD A SET OF SECTORS FROM A FILE
void CMainFrame::OnFileOpen() 
{
/// Local Variables ///////////////////////////////////////////////////////////
	char BASED_CODE szFilter[] = "Fate Files (*.fte)|*.FTE|All Files (*.*)|*.*||";
	char directory[80];
	CFileDialog	*dialog;
	FILE	*fp;
///////////////////////////////////////////////////////////////////////////////		
	// HAD TO ADD DIRECTORY STUFF SINCE DIALOG CHANGES DIRECTORY
	_getcwd(directory,80);
	dialog = new CFileDialog(TRUE,"FTE",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,szFilter);
	if (dialog->DoModal() == IDOK)
	{
		fp = fopen(dialog->GetPathName(),"rb");
		if (fp != NULL)
		{
			fread(&m_sectorcnt,sizeof(short),1,fp);
			fread(m_sectorlist,sizeof(tSector),m_sectorcnt,fp);
			fread(&m_edgecnt,sizeof(short),1,fp);
			fread(m_edgelist,sizeof(tEdge),m_edgecnt,fp);
			fread(&m_cam_pos,sizeof(tPoint3D),1,fp);
			fclose(fp);
		}
	}
	// RESET THE MAIN DIRECTORY
	_chdir(directory);
	Invalidate(TRUE);
}

// SAVE THE CURRENT SETUP TO A FILE
void CMainFrame::OnFileSave() 
{
/// Local Variables ///////////////////////////////////////////////////////////
	char BASED_CODE szFilter[] = "Fate Files (*.fte)|*.FTE|All Files (*.*)|*.*||";
	char directory[80];
	CFileDialog	*dialog;
	FILE	*fp;
///////////////////////////////////////////////////////////////////////////////		
	// HAD TO ADD DIRECTORY STUFF SINCE DIALOG CHANGES DIRECTORY
	_getcwd(directory,80);
	dialog = new CFileDialog(FALSE,"PFTE",NULL,OFN_OVERWRITEPROMPT,szFilter);
	if (dialog->DoModal() == IDOK)
	{
		fp = fopen(dialog->GetPathName(),"wb");
		if (fp != NULL)
		{
			fwrite(&m_sectorcnt,sizeof(short),1,fp);
			fwrite(m_sectorlist,sizeof(tSector),m_sectorcnt,fp);
			fwrite(&m_edgecnt,sizeof(short),1,fp);
			fwrite(m_edgelist,sizeof(tEdge), m_edgecnt,fp);
			fwrite(&m_cam_pos,sizeof(tPoint3D),1,fp);
			fclose(fp);
		}
	}
	// RESET THE MAIN DIRECTORY
	_chdir(directory);
}

/////////////////////////////////////////////////////////////////////////////
// CMainFrame Implementation Functions

// CREATE A FIXED POINT TRIG TABLE
void CMainFrame::InitTrig()
{
	int     angle;
	float   f_angle;

	for(angle = 0; angle < MAX_ANGLE; angle++)
	{
		f_angle = ((float)angle * M_PI) / (MAX_ANGLE / 2);      // Convert degrees to radians
		m_sin[angle] = (long)(sin(f_angle) * (1 << PRECISION));           // Get fixed point sine 2^16
		m_cos[angle] = (long)(cos(f_angle) * (1 << PRECISION));         // Get fixed point cosine 2^16
	}
}

/////////////////////////////////////////////////////////////////////////////
// Procedure:	DrawCurPos
// Purpose:		Draw the current POV Position on the Map
void CMainFrame::DrawCurPos(CDC* pDC)
{
	CPen penPOV;
	long startX,startY,endX,endY;
	double lenX,lenY;
	short left,right;

	penPOV.CreatePen(PS_SOLID,1,0x00005000);
	pDC->SelectObject(&penPOV);

	lenX = (double)((10 * m_sin[m_cam_yaw])/PRECMULT);
	lenY = (double)((15 * m_cos[m_cam_yaw])/PRECMULT);

	startX = (m_cam_pos.x * m_scale) - m_offX + (m_sizeX / 2);
	startY = (-m_cam_pos.z * m_scale) - m_offY + (m_sizeY / 2);

	endX = startX + lenX;
	endY = startY - lenY;

	pDC->MoveTo(startX,startY);
	pDC->LineTo(endX,endY);

	// DO THE ARROWHEAD PART

	startX = endX;
	startY = endY;

	left = m_cam_yaw + 4096 - 512;
	left %= 4096;

	lenX = (m_sin[left]>>13);
	lenY = (m_cos[left]>>13);

	endX = startX - lenX;
	endY = startY + lenY;

	pDC->MoveTo(startX,startY);
	pDC->LineTo(endX,endY);

	right = m_cam_yaw + 512;
	right %= 4096;

	lenX = (m_sin[right]>>13);
	lenY = (m_cos[right]>>13);

	endX = startX - lenX;
	endY = startY + lenY;

	pDC->MoveTo(startX,startY);
	pDC->LineTo(endX,endY);

}

/////////////////////////////////////////////////////////////////////////////
// CMainFrame drawing
void CMainFrame::Draw2DView(CDC* pDC)
{
	long startX,startY,tempX,tempY;
	long loop,loop2,pos;
	tPoint2D *pnt;
	CPen pengrid,penclosedline,pendoublesided,penblue,penltblue,*curpen;
	CRect aRect;
	pDC->SetROP2(R2_COPYPEN);

	pengrid.CreatePen(PS_SOLID,1,0x00c0c0c0);
	penclosedline.CreatePen(PS_SOLID,1,0x00505050);
	pendoublesided.CreatePen(PS_SOLID,1,0x000000FF);
	penblue.CreatePen(PS_SOLID,1,0x00FF0000);
	penltblue.CreatePen(PS_SOLID,1,0x00FF4040);
	pDC->SelectObject(&pengrid);


	GetWindowRect(&aRect);
	m_sizeX = aRect.right - aRect.left;
	m_sizeY = aRect.bottom - aRect.top;


	if (m_gridsize > 1)
	{
		startX = -65536;
		startY = -65536;
		// DO ALL THE COLUMNS
		for (loop = startX; loop < 65536; loop += m_gridsize)	
		{
			pos = (long)((double)loop * m_scale);
			pos = pos - m_offX + (m_sizeX / 2);
			if (pos >=0 && pos < m_sizeX)
			{
				pDC->MoveTo(pos,0);
				pDC->LineTo(pos,m_sizeY);
			}
		}
		// DO ALL THE COLUMNS
		for (loop = startY; loop < 65536; loop += m_gridsize)	
		{
			pos = (long)((double)loop * m_scale);
			pos = pos - m_offY + (m_sizeY / 2);
			if (pos >=0 && pos < m_sizeY)
			{
				pDC->MoveTo(0,pos);
				pDC->LineTo(m_sizeX,pos);
			}
		}
	}
	
	// DRAW ALL THE LINES
	for (loop = 0; loop < m_sectorcnt; loop++)	// FOR ALL THE SECTORS
	{
		if ((m_sectorlist[loop].flags & SECTOR_FLAGS_CLOSED) == 0)
		{
			curpen = &penltblue;
		}
		else
		{
			curpen = &penclosedline;
		}
		pos = m_sectorlist[loop].edge;
		for (loop2 = 0; loop2 < m_sectorlist[loop].edgecnt; loop2++)
		{
			pnt = &m_edgelist[pos].pos;
			tempX = (pnt->x * m_scale) - m_offX + (m_sizeX / 2);
			tempY = (-pnt->y * m_scale) - m_offY + (m_sizeY / 2);
			if (loop2 == 0)	// FIRST EDGE SAVE POINT
			{
				pDC->MoveTo(tempX,tempY);
				startX = tempX;
				startY = tempY;
			}
			else
			{
				pDC->LineTo(tempX,tempY);
			}
			if (m_edgelist[pos].backedge > -1)
			{
				pDC->SelectObject(&pendoublesided);
			}
			else
			{
				pDC->SelectObject(curpen);
			}
			pos = m_edgelist[pos].nextedge;
		}
		if ((m_sectorlist[loop].flags & SECTOR_FLAGS_CLOSED) > 0)
		{
			pDC->LineTo(startX,startY);
		}
	}

	// DRAW THE POINTS
	for (loop = 0; loop < m_sectorcnt; loop++)	// FOR ALL THE SECTORS
	{
		pDC->SelectObject(&penblue);
		pos = m_sectorlist[loop].edge;
		for (loop2 = 0; loop2 < m_sectorlist[loop].edgecnt; loop2++)
		{
			pnt = &m_edgelist[pos].pos;
			startX = (pnt->x * m_scale) - m_offX + (m_sizeX / 2);
			startY = (-pnt->y * m_scale) - m_offY + (m_sizeY / 2);
			pDC->MoveTo(startX-2,startY-2);
			pDC->LineTo(startX+2,startY-2);
			pDC->LineTo(startX+2,startY+2);
			pDC->LineTo(startX-2,startY+2);
			pDC->LineTo(startX-2,startY-2);
			pos = m_edgelist[pos].nextedge;
		}
	}

	if (m_nearest_edge > -1)
	{
		pDC->SelectObject(&penltblue);
		startX = (m_nearest_pnt.x * m_scale) - m_offX + (m_sizeX / 2);
		startY = (-m_nearest_pnt.y * m_scale) - m_offY + (m_sizeY / 2);
		pDC->MoveTo(startX-1,startY-1);
		pDC->LineTo(startX+1,startY-1);
		pDC->LineTo(startX+1,startY+1);
		pDC->LineTo(startX-1,startY+1);
		pDC->LineTo(startX-1,startY-1);
	}

	DrawCurPos(pDC);
/*
	sprintf(message,"Nearest #%d",m_nearest_edge);
	m_MainFrame->SetStatusText(0,message);*/
}

void CMainFrame::TransformPoint(long world_x, long world_z, long *camera_x, long *camera_z)
{
	long move_x, move_z;

	/* DO POSITION. TRANSLATE ABOUT LOOK AT POINT.. */
	move_x = world_x - m_cam_pos.x;
	move_z = world_z - m_cam_pos.z;

	/* DO YAW... */
	*camera_x = (FixMult(m_cos[m_cam_yaw],move_x)) -
				(FixMult(m_sin[m_cam_yaw],move_z));

	*camera_z = (FixMult(m_cos[m_cam_yaw],move_z)) +
				(FixMult(m_sin[m_cam_yaw],move_x));

}

BOOL CMainFrame::OnSamePos(short pos1,short pos2)
{
	if (m_edgelist[pos1].pos.x == m_edgelist[pos2].pos.x &&
		m_edgelist[pos1].pos.y == m_edgelist[pos2].pos.y)
		return TRUE;
	else
		return FALSE;
}