HowFastAll

1. OS 및 일반 프로그래밍 관련

응용 운영 체제 개념(Applied Operating System Concepts)

( http://kangcom.com/common/bookinfo/bookinfo.asp?sku=200302080008 )

: 책이 두꺼운 만큼 매일 조금씩 공부하기를 권합니다. 그리고 이 책을 보면 자료구조가 어떻게 활용 되는지도 알 수 있습니다.

CODE COMPLETE 2/E

( http://kangcom.com/common/bookinfo/bookinfo.asp?sku=200504110013 )

: Coding과 관련된 것인데 개인적으로 필독서 라고 생각합니다. 이것도 두꺼우므로 매일 조금씩 보기를 권합니다.

Debugging Applications for Microsoft .NET and Microsoft Windows

( http://kangcom.com/common/bookinfo/bookinfo.asp?sku=200403190013 )

: Windows 플랫폼에서의 디버깅에 대해서 잘 가르쳐주는 책입니다. 특히 덤프를 남기게 하는 방법과 보는 방법은 꼭 배워야 서버 비정상 종료가 되어도 문제를 찾아 낼 수가 있습니다.

http://en.wikipedia.org/wiki/Bresenham's_line_algorithm

      o-------                         |
     p1       --------                 | deltay
                      -------      p2  |
                             -------o  |
      ----------------------------------
                  deltax

where p1 = (x1,y1),
      p2 = (x2, y2),
      x and y are both increasing from p1 to p2,
      deltax = x2 - x1,
      deltay = y2 - y1 and
      deltax >= deltay.

#include 
#include 
#include 
#include 

/*
 * Point size의 Default 값은 1.0 이다.
 */
GLfloat size = 1.0;
GLint flag = 0;
GLint St_x=0, St_y=0, Ed_x=0, Ed_y=0;

/*
 * 파라메터로 들어온 x좌표와 y좌표를 이용하여 점을 찍는다.
 */
void RenderPoint(GLint x, GLint y)
{
	glColor3f(1.0, 1.0, 1.0);
	glPointSize(size);

	glBegin(GL_POINTS);
		glVertex3f(x/300.0, (300-y)/300.0, 0.0);
	glEnd();
	glFlush();
}

/*
 * 전역 좌표인 St_x, St_y, Ed_x, Ed_y를 이용하여 선분을 그리는 함수이다.
 */
void RenderLine()
{
	int DeltaX, DeltaY;
    int X, Y;
    int D;
	
    DeltaX = Ed_x - St_x;
	DeltaY = Ed_y - St_y;

	/*
	 * RenderPoint를 이용하여 Point를 찍어줄 때 
	 * X좌표와 Y좌표의 증가량의 변수이다.
	 * 기본 Default값은 양의 1이다.
	 */
	X = 1;
	Y = 1;
	
	/*
	 * X의 증가량이 음의 수 이므로 X의 증가량의 절대값을 구하고
	 * Line을 그리면 그릴 수록 RenderPoint함수를 통해 표현할 
	 * 점의 좌표가 -값을 갖고 후퇴하며 표현해야 하므로 X값을 -1값으로 한다.
	 */
	if( DeltaX < 0 )
	{
		DeltaX = -DeltaX;
		X = -1;
	}

	/*
	 * Y의 증가량이 음의 수 이므로 Y의 증가량의 절대값을 구하고
	 * Line을 그리면 그릴 수록 RenderPoint함수를 통해 표현할 
	 * 점의 좌표가 -값을 갖고 후퇴하며 표현해야 하므로 Y값을 -1값으로 한다.
	 */
	if( DeltaY < 0 )
	{
		DeltaY = -DeltaY;
		Y = -1;
	}
	
	/*
	 * 첫 시작점을 그린다.
	 */
	RenderPoint( St_x, St_y );
	
	/*
	 * X의 증가량이 Y의 증가량보다 큰 경우이다.
	 * 기울기는 "0< 기울기 < 1"의 크기를 갖고 있다.
	 */
	if( DeltaX > DeltaY )
	{
		/*
		 * 결정변수의 값은 2DeltaY - DeltaX의 값을 갖는다. (초기화) 
		 */
		D = ( 2*DeltaY) - DeltaX;
		
		/*
		 * x좌표를 검사하여 마지막 점을 표시할 때까지 무한 반복한다.
		 */
		while( St_x != Ed_x )
		{
			/*
			 * 결정변수의 값을 검사한다.
			 * 
			 * 양의 값인 경우 X좌표와 Y좌표를 증가시키면서 
			 * 다음 래스터를 결정하게 된다.
			 * 결정변수의 연산결과는 D += 2DeltaY - 2DeltaX이다.
			 * 
			 * 음인 경우 X좌표만을 증가시키며
			 * 다음 래스터를 결정한다.
			 * 결정변수의 연산결과는 D += 2DeltaY이다. 
			 */
			if( D >= 0 )
			{
				St_y += Y;
				D -= 2*DeltaX;
			}
			St_x += X;
			D += 2*DeltaY;
			
			/*
			 * 다음 래스터로 결정된 좌표에 점 찍기
			 */
			RenderPoint( St_x, St_y );
		}
	}

	/*
	 * Y의 증가량이 X의 증가량보다 큰 경우이다.
	 * 기울기는 " 1<기울기 "의 크기를 갖고 있다.
	 * 위의 연산과 정 반대의 연산을 갖는다.
	 */
	else
	{
		/*
		 * 결정변수의 값은 2DeltaY - DeltaX의 값을 갖는다. (초기화) 
		 */
		D = ( 2*DeltaX ) - DeltaY;
		
		/*
		 * y좌표를 검사하여 마지막 점을 표시할 때까지 무한 반복한다.
		 */
		while( St_y != Ed_y )
		{
			/*
			 * 결정변수의 값을 검사한다.
			 * 
			 * 양의 값인 경우 X좌표와 Y좌표를 증가시키면서 
			 * 다음 래스터를 결정하게 된다.
			 * 결정변수의 연산결과는 D += 2DeltaX - 2DeltaY이다.
			 * 
			 * 음인 경우 Y좌표만을 증가시키며
			 * 다음 래스터를 결정한다.
			 * 결정변수의 연산결과는 D += 2DeltaX이다. 
			 */
			if( D >= 0 )
			{
				St_x += X;
				D -= 2*DeltaY;
			}
			
			St_y += Y;
			D += 2*DeltaX;
			
			/*
			 * 다음 래스터로 결정된 좌표에 점 찍기
			 */
			RenderPoint( St_x, St_y );
		}
	}
	return;
}

/*
 * 마우스 이벤트 발생시 실행되는 함수이다.
 */
void MyMouse(GLint button, GLint state, GLint x, GLint y)
{
	/*
	 * 마우스 이벤트 발생의 상태가 클릭상태이고,(state)
	 * 버튼의 방향이 왼쪽인 경우 (button)
	 * 점을 하나 찍어준다.
	 */
	if(state == GLUT_DOWN && button == GLUT_LEFT_BUTTON)
	{
		/* 
		 * 선택한 좌표를 확인하도록 점을 찍어준다.
		 */
		RenderPoint(x,y);

		/*
		 * Flag는 이번 입력들어온 마우스의 좌표가 첫 번째 입력인지
		 * 두번째 입력인지를 구분한다.
		 * 첫번째인 경우 두번째 입력을 기다린다.
		 * 두번째인 경우 RenderLine함수를 호출하여 선분을 그린다. 
		 */
		if(flag ==1)
		{
			Ed_x = x;
			Ed_y = y;

			/* 
			 * 선분을 그리는 함수 호출 
			 */
			RenderLine();
			flag = 0;
		}
		else
		{
			St_x = x;
			St_y = y;

			/* 
			 * flag 값을 설정하여 첫번째 입력이 들어왔음을 표시한다.
			 */
			flag = 1;
		}
		/* 색은 흰색이다.*/
	}
}


/* 처음 윈도우를 만들 때 그리는 함수 */
void MyDisplay()
{
	/* Window의 색을 기본 색으로 채운다. 검은색이다. */
	glClear(GL_COLOR_BUFFER_BIT);
	glFlush();
}

/* 윈도우를 생성하고 콜백함수를 선언하는 메인함수이다. */
int main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGB);
	glutInitWindowSize(300,300);
	glutInitWindowPosition(100,100);
	glutCreateWindow("CG HW#7 - Bresenham Algorithm");
	
	/* 검은색을 기본 색으로 한다.*/
	glClearColor(0.0, 0.0, 0.0, 1.0);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	/* 윈도우의 좌표계를 왼쪽 하단부를 0.0 에서 오른쪽 상단부를 1.0으로 지정한다.*/
	glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

	/* 콜백함수를 선언한다.*/
	glutDisplayFunc(MyDisplay);
	glutMouseFunc(MyMouse);

	/* 루프에 들어간다. */
	glutMainLoop();
	return 0;
}

Lesson 1:  Getting Started with Direct3D  



#include  // 헤더

// 라이브러리 include the Direct3D Library file 
#pragma comment ( lib, "d3d9.lib")

// 전역 정의 global declarations
LPDIRECT3D9 d3d; // the pointer to our Direct3D interface
LPDIRECT3DDEVICE9 returned_d3ddev; // the pointer to the device class

// 함수 원형 fuctions prototype
void initD3D(HWND hWnd); // 기초 설정 3디 초기화 sets up and initializes Direct3D
void render_frame(void); // 사실화 단일 프레임 renders a single frame 
void cleanD3D(void);     // 닫기와 메모리 해제 close Direct3D and releases memory

// 윈도우 함수 원형 the WindowProc function prototype

LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

// 기초 설정 3디 초기화 sets up and initializes Direct3D
// this function initializes and prepares Direct3D for use
void initD3D(HWND hWnd)
{
 d3d = Direct3DCreate9(D3D_SDK_VERSION);  // create the Direct3D interface

 // presentation parameters d3dpp
 D3DPRESENT_PARAMETERS d3dpp;    // create a struct to hold various device informations
 ZeroMemory( &d3dpp, sizeof(d3dpp) );  // clear out the struct for use
 
 d3dpp.Windowed = TRUE;       // program windowed , not fullscreen
 d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;  // discard old frames
 d3dpp.hDeviceWindow = hWnd;      // set the window to be used by Direct3D

 // create a device class using this information 
 // and information from the d3dpp struct

 d3d->CreateDevice(D3DADAPTER_DEFAULT,
      D3DDEVTYPE_HAL,
      hWnd,
      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
      &d3dpp,
      &returned_d3ddev);

 /*
 HRESULT CreateDevice(
    UINT Adapter,
    D3DDEVTYPE DeviceType,
    HWND hFocusWindow,
    DWORD BehaviorFlags,
    D3DPRESENT_PARAMETERS *pPresentationParameters,
    IDirect3DDevice9 **ppReturnedDeviceInterface);
 UINT Adapter,
 */
}
// 사실화 단일 프레임 renders a single frame 
// In this function we will render a single frame
// The frame will be rather simple, and will consist of a blue background
void render_frame(void)
{
 // clear the window to a deep blue
 returned_d3ddev->Clear(0,
       NULL,
       D3DCLEAR_TARGET,
       D3DCOLOR_XRGB(0,40,100),
       1.0f,
       0);
 // begins the 3d scene
 returned_d3ddev->BeginScene();

 // do 3D rendering on the back buffer here

 // ends the 3d scene

 returned_d3ddev->EndScene();

 // displays the created frame
 returned_d3ddev->Present(NULL,NULL,NULL,NULL);
}
// 닫기와 메모리 해제 close Direct3D and releases memory
void cleanD3D(void)
{

 // close and release the 3D device
 returned_d3ddev->Release();

 // close and release Direct3D
 d3d->Release();
}

// the entry point for any Windows program
int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{
    HWND hWnd;
    WNDCLASSEX wc;

    ZeroMemory(&wc, sizeof(WNDCLASSEX));

    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
    wc.lpszClassName = L"WindowClass";

    RegisterClassEx(&wc);

    hWnd = CreateWindowEx(NULL,
                          L"WindowClass",
                          L"첫번째 3D 프로그램",
                          WS_OVERLAPPEDWINDOW,
                          300, 300,
                          800, 600,
                          NULL,
                          NULL,
                          hInstance,
                          NULL);

    ShowWindow(hWnd, nCmdShow);

    // set up and initialize Direct3D
    initD3D(hWnd);

    // enter the main loop:

    MSG msg;

    while(TRUE)
    {
        while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        if(msg.message == WM_QUIT)
            break;

        render_frame();
    }

    // clean up DirectX and COM
    cleanD3D();

    return msg.wParam;
}


// this is the main message handler for the program
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_DESTROY:
            {
                PostQuitMessage(0);
                return 0;
            } break;
    }

    return DefWindowProc (hWnd, message, wParam, lParam);
}