476 lines
10 KiB
C++
476 lines
10 KiB
C++
#include <Windows.h>
|
|
//#include <vector>
|
|
#include <math.h>
|
|
#include <time.h>
|
|
#include "string"
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <sstream>
|
|
#include "Leg.h"
|
|
#include <D3DX9.h>
|
|
using namespace std;
|
|
|
|
#define DRAW WM_USER + 1
|
|
|
|
#pragma region ConverToInt
|
|
#ifdef UNICODE
|
|
typedef std::wostringstream tstringstream;
|
|
#else
|
|
typedef std::ostringstream tstringstream;
|
|
#endif
|
|
|
|
LPCTSTR convertInt(const int number)
|
|
{
|
|
char str[512];
|
|
sprintf(str,"%d",number);
|
|
return str;
|
|
}
|
|
#pragma endregion ConverToInt
|
|
|
|
#pragma region Global
|
|
HWND ghMainWnd = 0;
|
|
HINSTANCE ghAppInst = 0;
|
|
bool gMouseDown = 0;
|
|
|
|
HDC backDC;
|
|
HDC BackDC2;
|
|
HBITMAP backBufferBMP;
|
|
HBITMAP backBufferBMP2;
|
|
int backBufferCX;
|
|
int backBufferCY;
|
|
|
|
Leg *La;
|
|
|
|
D3DXVECTOR3 Coordinates( 10, 15, 0);
|
|
D3DXVECTOR3 SuccessfulCoordinate;
|
|
D3DXVECTOR3 Offset( 250, 400, 0);
|
|
D3DXVECTOR3 Size( 15, 15, 15 );
|
|
#pragma endregion Global
|
|
|
|
#pragma region OtherFunctions
|
|
clock_t Fpres;
|
|
bool DD ( )
|
|
{
|
|
clock_t t = clock();
|
|
if ((t - Fpres) <= 200)
|
|
return 1;
|
|
else
|
|
{
|
|
Fpres = t;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
inline void draw()
|
|
{
|
|
HDC winhdc = GetDC( ghMainWnd ) ;
|
|
// Now copy the back buffer to the front buffer.
|
|
BitBlt(
|
|
|
|
winhdc, // destination buffer
|
|
0, 0, // x, y to start writing to in the destination buffer
|
|
// counted from top left corner of dest HDC (window)
|
|
|
|
// Width, height to copy for
|
|
backBufferCX, backBufferCY,
|
|
|
|
backDC, // SOURCE buffer. We're taking from that back canvas
|
|
|
|
0, 0, // x pt, y pt to START copying from
|
|
// SOURCE. counted from top left again
|
|
|
|
// And we just want a straight copy.
|
|
SRCCOPY );
|
|
|
|
ReleaseDC( ghMainWnd, winhdc ) ;
|
|
}
|
|
|
|
inline void copybtf( HDC back, HDC front )
|
|
{
|
|
// copy the back buffer to the front buffer.
|
|
BitBlt(
|
|
|
|
front, // destination buffer
|
|
0, 0, // x, y to start writing to in the destination buffer
|
|
// counted from top left corner of dest HDC (window)
|
|
|
|
// Width, height to copy for
|
|
backBufferCX, backBufferCY,
|
|
|
|
back, // SOURCE buffer. We're taking from that back canvas
|
|
|
|
0, 0, // x pt, y pt to START copying from
|
|
// SOURCE. counted from top left again
|
|
|
|
// And we just want a straight copy.
|
|
SRCCOPY );
|
|
}
|
|
|
|
void InitBackBuffer()
|
|
{
|
|
backBufferCX = 700;
|
|
backBufferCY = 850;
|
|
|
|
HDC winhdc = GetDC( ghMainWnd );
|
|
|
|
/*
|
|
|
|
Imagine you have 2 things:
|
|
- a canvas on which to draw (call this your HBITMAP)
|
|
- set of brushes you will use to draw (call this your HDC)
|
|
|
|
1. HBITMAP. Canvas
|
|
___________________
|
|
| * |
|
|
| * |
|
|
| HBITMAP |
|
|
| draw here |
|
|
|_________________|
|
|
|
|
2. HDC. Set of brushes.
|
|
<-*
|
|
[]-*
|
|
()-*
|
|
|
|
*/
|
|
|
|
// Create the HBITMAP "canvas", or surface on which we will draw.
|
|
backBufferBMP = CreateCompatibleBitmap( winhdc, backBufferCX, backBufferCY );
|
|
if(backBufferBMP == NULL)
|
|
printf( "failed to create backBufferBMP" );
|
|
|
|
|
|
// Create the HDC "device context", or collection of tools
|
|
// and brushes that we can use to draw on our canvas
|
|
backDC = CreateCompatibleDC( winhdc );
|
|
if(backDC == NULL)
|
|
printf( "failed to create the backDC" );
|
|
|
|
// Permanently associate the surface on which to draw
|
|
// ("canvas") (HBITMAP), with the "set of brushes" (HDC)
|
|
|
|
// "select in" the backBufferBMP into the backDC
|
|
HBITMAP oldbmp = (HBITMAP)SelectObject( backDC, backBufferBMP );
|
|
|
|
|
|
// Delete the "canvas" that the backDC was
|
|
// going to draw to. We don't care about it.
|
|
DeleteObject( oldbmp );
|
|
|
|
|
|
|
|
/// Release the dc of the main window itself
|
|
ReleaseDC( ghMainWnd, winhdc );
|
|
}
|
|
|
|
void InitBackBuffer2()
|
|
{
|
|
backBufferCX = 700;
|
|
backBufferCY = 850;
|
|
|
|
HDC winhdc = GetDC( ghMainWnd );
|
|
|
|
// Create the HBITMAP "canvas", or surface on which we will draw.
|
|
backBufferBMP2 = CreateCompatibleBitmap( winhdc, backBufferCX, backBufferCY );
|
|
if(backBufferBMP2 == NULL)
|
|
printf( "failed to create backBufferBMP" );
|
|
|
|
|
|
// Create the HDC "device context", or collection of tools
|
|
// and brushes that we can use to draw on our canvas
|
|
BackDC2 = CreateCompatibleDC( winhdc );
|
|
if(BackDC2 == NULL)
|
|
printf( "failed to create the backDC" );
|
|
|
|
// Permanently associate the surface on which to draw
|
|
// ("canvas") (HBITMAP), with the "set of brushes" (HDC)
|
|
|
|
// "select in" the backBufferBMP into the backDC
|
|
HBITMAP oldbmp = (HBITMAP)SelectObject( BackDC2, backBufferBMP2 );
|
|
|
|
|
|
// Delete the "canvas" that the backDC was
|
|
// going to draw to. We don't care about it.
|
|
DeleteObject( oldbmp );
|
|
|
|
|
|
|
|
/// Release the dc of the main window itself
|
|
ReleaseDC( ghMainWnd, winhdc );
|
|
}
|
|
|
|
inline void ClearBackDC()
|
|
{
|
|
// clear by filling out the back buffer with black rectangle
|
|
HBRUSH oldBrush = (HBRUSH)SelectObject( backDC, GetStockObject( BLACK_BRUSH ) ) ;
|
|
Rectangle( backDC, 0, 0, backBufferCX, backBufferCY );
|
|
SelectObject( backDC, oldBrush ) ; // put the old brush back, not bothering
|
|
// to catch the system BLACK_BRUSH
|
|
}
|
|
|
|
inline void ClearBackDC2()
|
|
{
|
|
// clear by filling out the back buffer with black rectangle
|
|
HBRUSH oldBrush = (HBRUSH)SelectObject( BackDC2, GetStockObject( BLACK_BRUSH ) ) ;
|
|
Rectangle( BackDC2, 0, 0, backBufferCX, backBufferCY );
|
|
SelectObject( BackDC2, oldBrush ) ; // put the old brush back, not bothering
|
|
// to catch the system BLACK_BRUSH
|
|
}
|
|
|
|
#pragma endregion OtherFunctions
|
|
|
|
LRESULT CALLBACK
|
|
WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HDC hdc = 0;
|
|
PAINTSTRUCT ps;
|
|
|
|
int mx = LOWORD(lParam);
|
|
int my = HIWORD(lParam);
|
|
|
|
D3DXVECTOR3 test;
|
|
|
|
switch( msg )
|
|
{
|
|
#pragma region CREATE
|
|
case WM_CREATE:
|
|
{
|
|
La = new Leg;
|
|
|
|
La->Offset( Offset );
|
|
La->Size( Size );
|
|
|
|
InitBackBuffer();
|
|
|
|
La->GetHDC( backDC );
|
|
|
|
InitBackBuffer2();
|
|
|
|
La->GetHDCSecondBuffer( BackDC2 );
|
|
|
|
La->GetPossibleMoveSpace();
|
|
|
|
La->PrintMoveSpaceOnWorldSpace();
|
|
|
|
PostMessage( hWnd, DRAW, wParam, lParam );
|
|
|
|
break;
|
|
}
|
|
#pragma endregion CREATE
|
|
case DRAW:
|
|
{
|
|
#pragma region DRAW
|
|
ClearBackDC();
|
|
|
|
copybtf( BackDC2, backDC );
|
|
|
|
La->Coordinates( Coordinates );
|
|
La->CalculateLegRight();
|
|
|
|
if( La->Error == true )
|
|
{
|
|
La->Coordinates( SuccessfulCoordinate );
|
|
La->CalculateLegRight();
|
|
|
|
La->CalculateWorldSpaceLineModel();
|
|
|
|
La->Print3DLinesOnWorldSpace();
|
|
|
|
La->PrintWorldSpaceLineModel();
|
|
}
|
|
else
|
|
{
|
|
La->CalculateWorldSpaceLineModel();
|
|
|
|
La->Print3DLinesOnWorldSpace();
|
|
|
|
La->PrintWorldSpaceLineModel();
|
|
|
|
SuccessfulCoordinate = La->Coordinate;
|
|
}
|
|
|
|
|
|
#pragma region Status
|
|
RECT rcWind;
|
|
POINT ptDiff;
|
|
GetWindowRect(hWnd, &rcWind);
|
|
ptDiff.x = (rcWind.right - rcWind.left);
|
|
ptDiff.y = (rcWind.bottom - rcWind.top);
|
|
|
|
//TextOut( backDC, ptDiff.x - 44, 0, convertInt( D->O1 ), ( sizeof( convertInt( D->O1 ) ) / sizeof( char ) - 1) );
|
|
//TextOut( backDC, ptDiff.x - 44, 20, convertInt( D->O2 ), ( sizeof( convertInt( D->O2 ) ) / sizeof( char ) - 1) );
|
|
//TextOut( backDC, ptDiff.x - 44, 40, convertInt( D->O3 ), ( sizeof( convertInt( D->O3 ) ) / sizeof( char ) - 1) );
|
|
TextOut( backDC, ptDiff.x - 44, 70, convertInt( Coordinates.x ), ( sizeof( convertInt( Coordinates.x ) ) / sizeof( char ) - 1) );
|
|
TextOut( backDC, ptDiff.x - 44, 90, convertInt( Coordinates.y ), ( sizeof( convertInt( Coordinates.y ) ) / sizeof( char ) - 1) );
|
|
TextOut( backDC, ptDiff.x - 44, 110, convertInt( Coordinates.z ), ( sizeof( convertInt( Coordinates.z ) ) / sizeof( char ) - 1) );
|
|
//TextOut( backDC, ptDiff.x - 44, 140, convertInt( D->X2 ), ( sizeof( convertInt( D->X2 ) ) / sizeof( char ) - 1) );
|
|
//TextOut( backDC, ptDiff.x - 44, 160, convertInt( D->Y2 ), ( sizeof( convertInt( D->Y2 ) ) / sizeof( char ) - 1) );
|
|
//TextOut( backDC, ptDiff.x - 44, 180, convertInt( D->Z2 ), ( sizeof( convertInt( D->Z2 ) ) / sizeof( char ) - 1) );
|
|
|
|
#pragma endregion Status
|
|
#pragma endregion DRAW
|
|
break;
|
|
}
|
|
case WM_KEYUP:
|
|
|
|
#pragma region KeyMove
|
|
if( GetAsyncKeyState( VK_UP ) == 1 )
|
|
Coordinates.y--;
|
|
if( GetAsyncKeyState( VK_DOWN ) == 1 )
|
|
Coordinates.y++;
|
|
if( GetAsyncKeyState( VK_LEFT ) == 1 )
|
|
Coordinates.x--;
|
|
if( GetAsyncKeyState( VK_RIGHT ) == 1 )
|
|
Coordinates.x++;
|
|
if( GetAsyncKeyState( VK_SUBTRACT ) == 1 )
|
|
{
|
|
Coordinates.z--;
|
|
|
|
ClearBackDC2();
|
|
|
|
La->MoveSpaceRenderd = 0;
|
|
|
|
La->GetPossibleMoveSpace();
|
|
|
|
La->PrintMoveSpaceOnWorldSpace();
|
|
}
|
|
if( GetAsyncKeyState( VK_ADD ) == 1 )
|
|
{
|
|
Coordinates.z++;
|
|
|
|
ClearBackDC2();
|
|
|
|
La->MoveSpaceRenderd = 0;
|
|
|
|
La->GetPossibleMoveSpace();
|
|
|
|
La->PrintMoveSpaceOnWorldSpace();
|
|
}
|
|
#pragma endregion KeyMove
|
|
|
|
PostMessage( hWnd, DRAW, wParam, lParam );
|
|
|
|
return 0;
|
|
case WM_LBUTTONDOWN:
|
|
SetCapture(hWnd);
|
|
|
|
gMouseDown = true;
|
|
|
|
break;
|
|
case WM_RBUTTONDOWN:
|
|
|
|
return 0;
|
|
case WM_MOUSEMOVE:
|
|
if( gMouseDown )
|
|
{
|
|
Coordinates.x = ((float) mx - Offset.x ) / Size.x;
|
|
Coordinates.y = ((float) my - Offset.y) / Size.y;
|
|
PostMessage( hWnd, DRAW, wParam, lParam );
|
|
}
|
|
break;
|
|
case WM_LBUTTONUP:
|
|
ReleaseCapture();
|
|
gMouseDown = false;
|
|
|
|
break;
|
|
case WM_RBUTTONUP:
|
|
ReleaseCapture();
|
|
gMouseDown = false;
|
|
|
|
UpdateWindow (hWnd);
|
|
|
|
break;
|
|
#pragma region PAINT
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT ps;
|
|
|
|
HDC winhdc = BeginPaint(hWnd, &ps);
|
|
|
|
// Do nothing here. All drawing happens in draw(),
|
|
// and you draw to the backbuffer, NOT the
|
|
// front buffer.
|
|
|
|
EndPaint(hWnd, &ps);
|
|
break;
|
|
}
|
|
#pragma endregion PAINT
|
|
case WM_DESTROY:
|
|
PostQuitMessage(0);
|
|
break;
|
|
default:
|
|
return DefWindowProc(hWnd, msg, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
#pragma region Functions
|
|
|
|
int WINAPI WinMain (HINSTANCE hInstance,
|
|
HINSTANCE hPrevInstance,
|
|
PSTR cmdLine,
|
|
int showCmd)
|
|
{
|
|
ghAppInst = hInstance;
|
|
|
|
WNDCLASS wc;
|
|
wc.style = CS_HREDRAW | CS_VREDRAW;
|
|
wc.lpfnWndProc = WndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = ghAppInst;
|
|
wc.hIcon = ::LoadIcon(0, IDI_APPLICATION);
|
|
wc.hCursor = ::LoadCursor(0, IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW)+1;
|
|
wc.lpszMenuName = 0;
|
|
wc.lpszClassName = "Hexapod";
|
|
|
|
RegisterClass( &wc );
|
|
|
|
ghMainWnd = ::CreateWindow("Hexapod", "Hexapod FrontView",
|
|
WS_OVERLAPPEDWINDOW, 50, 50, 700, 850, 0, 0, ghAppInst, 0);
|
|
|
|
if(ghMainWnd == 0)
|
|
{
|
|
::MessageBox(0, "CreateWindow - Failed", 0, 0);
|
|
return false;
|
|
}
|
|
|
|
ShowWindow(ghMainWnd, showCmd);
|
|
UpdateWindow(ghMainWnd);
|
|
|
|
MSG msg;
|
|
/*ZeroMemory(&msg, sizeof(MSG));
|
|
|
|
while( GetMessage(&msg, 0, 0, 0) )
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}*/
|
|
|
|
while(1)
|
|
{
|
|
if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
if(msg.message == WM_QUIT)
|
|
{
|
|
PostQuitMessage(0);
|
|
break;
|
|
}
|
|
TranslateMessage(&msg); // translates 'character' keyboard messages
|
|
DispatchMessage(&msg); // send off to WndProc for processing
|
|
}
|
|
else
|
|
{
|
|
// could put more update code in here
|
|
// before drawing.
|
|
draw();
|
|
}
|
|
}
|
|
|
|
//return (int)msg.wParam;
|
|
return 0;
|
|
}
|
|
|
|
|
|
|