/*
===============================================================================
  Fractal.mc :  フラクタル図形の表示
===============================================================================
*/

/*****/    // GK Library のモジュールをロードする場合
#include  <GkLib\GkDefs.mh>
#include  <GkLib\GkSysDefs.mh>
#include  <GkLib\GkKey.mh>

	if( ::Module.Include( "GkLibrary" ) > 0 )
		Main( argc, argv );
	return;
/*****/

/******   // GK Library のソースをインクルードする場合
#include  <GkLib\GkLibrary.mc>

	Main( argc, argv );
	return;
/*****/

//-----------------------------------------------------------------------------

/*****/	// デバッグプリント無効化（リリース時）
#set  pc	#comment
#set  pv	
#set  pi	#comment
#set  px	#comment
/*****/

/*****	// デバッグプリント有効化（デバッグ時）
#set  pc	print
#set  pv	print
#set  pi	print
#set  px	
/*****/

#set  p		print

//-----------------------------------------------------------------------------

///  マクロ定義  ///

#set	WndTitle	"フラクタル図形"	// ウィンドウ表題

#set	WndXo				// ウィンドウの左端位置（空白はデフォールト位置）
#set	WndYo				// ウィンドウの上端位置（空白はデフォールト位置）

#set	ViewXd		640		// OpenGL 描画領域の幅
#set	ViewYd		480		// OpenGL 描画領域の高

#set	LeftXm		0		// 左余白幅
#set	RightXm		0		// 右余白幅
#set	TopYm		33		// 上余白高
#set	BottomYm	0		// 下余白高

#set	ViewXo		#LeftXm		// OpenGL 描画領域の左端位置
#set	ViewYo		#TopYm		// OpenGL 描画領域の上端位置

#set	WndXd	( #LeftXm + #ViewXd + #RightXm )	// ウィンドウのクライアント領域幅
#set	WndYd	( #TopYm + #ViewYd + #BottomYm )	// ウィンドウのクライアント領域高

#set	PI			3.14159265358979323846
#set	SQRT_2		1.41421356237309504880
#set	DegToRad( deg )		(( #deg ) * ( #PI / 180.0 ))
#set	RadToDeg( rad )		(( #rad ) * ( 180.0 / #PI ))


#set	FF_KOCH_CURVE		"コッホ曲線"
#set	FF_DRAGON_CURVE		"ドラゴン曲線"
#set	FF_HILBERT_CURVE	"ヒルベルト曲線"
#set	FF_TREE				"木"

//-----------------------------------------------------------------------------

// OpenGL 関連のマクロ定義

#set	GL_COLOR_BUFFER_BIT		0x00004000
#set	GL_COMPILE				0x1300
#set	GL_LINE_STRIP			0x0003
#set	GL_LINES				0x0001
#set	GL_MODELVIEW			0x1700
#set	GL_PROJECTION			0x1701
#set	PFD_DRAW_TO_WINDOW		0x00000004
#set	PFD_MAIN_PLANE			0
#set	PFD_SUPPORT_OPENGL		0x00000020
#set	PFD_TYPE_RGBA			0

//=============================================================================

function	Main( argc, argv )
{
	#pc	"開始";
	^DefValue = null;

	if( SetupOpenGL() == #OK )
	{
		class ^MainWindow : ::GK.Window	{}
		class ^ViewWindow : ::GK.Window	{}

		R = ::GK.Rect( 0, 0, #WndXd, #WndYd );
		::GK.Window.GetAdjRect( R );
		^MainWindow.Construct( #WndTitle, #WndXo, #WndYo, R.Xd, R.Yd );
		^MainWindow.Open();

		::GK.WindowMsgLoop();
	}
	DeleteOpenGL();

  FIN:
	delete ^MainWindow;
	#pc	"終了";
	return;

  OnError:
	#p ::ErrorMessage( $err_code, $err_info ), $err_func;
	goto FIN;
}

//-----------------------------------------------------------------------------

function ^MainWindow.OnCreate()
{
	#pc	"Main OnCreate";
	^Type = #FF_KOCH_CURVE;
	^Order = 3;
	.MaxOrder ::=
	{
		.[ #FF_KOCH_CURVE    ] =  5;
		.[ #FF_DRAGON_CURVE  ] = 10;
		.[ #FF_HILBERT_CURVE ] =  7;
		.[ #FF_TREE ]          = 10;
	}

	^Cos := ::Math.cos;
	^Sin := ::Math.sin;
	.DefWidgetFont = 
		::GK.Font( "ＭＳ Ｐゴシック", 12, #SHIFTJIS_CHARSET, #VARIABLE_PITCH );
	.BackColor = ::GK.GetSysColor( #COLOR_BTNFACE );

  // ウィジェット
	R1 = ::GK.Rect( 16, 10, 40, 20 );
	R2 = ::GK.Rect( R1.Xo + R1.Xd + 10,  5, 120, 150 );
	R3 = ::GK.Rect( R2.Xo + R2.Xd + 20, 10,  40,  20 );
	R4 = ::GK.Rect( R3.Xo + R3.Xd + 10,  5,  60, 150 );

#pv	.TypeTitle = .AddLabel( "種類", R1, "right" );
#pv	.TypeList = .AddComboBox( , R2 );
	.TypeList.OnCommand =
		function() { .owner.SetFocus(); .owner.OnTypeSelect(); };
	.TypeList.SetItemYd( 15 );
	.TypeList.Add( #FF_KOCH_CURVE );
	.TypeList.Add( #FF_DRAGON_CURVE );
	.TypeList.Add( #FF_HILBERT_CURVE );
	.TypeList.Add( #FF_TREE );
	.TypeList.Select( 0 );

#pv	.OrderTitle = .AddLabel( "次数", R3, "right" );
#pv	.OrderList = .AddComboBox( , R4 );
	.OrderList.OnCommand =
		function() { .owner.SetFocus(); .owner.OnOrderSelect(); };
	.OrderList.SetItemYd( 15 );
	.SetOrderList( 5 );

  // OpenGL 描画用の子ウィンドウを生成
	.ViewWnd = ^ViewWindow( #ViewXo, #ViewYo, #ViewXd, #ViewYd, this );

}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

function ^MainWindow.SetOrderList( max )
{
	OL := .OrderList;
	if( OL.GetCount() != max )
	{
		OL.Empty();
		for( i = 0 ; i <= max ; i++ )
			OL.Add( "   " + i'd );
		^Order = ^Order'cut( 0, max );
		OL.Select( ^Order );
	}
}

//-----------------------------------------------------------------------------

function ^MainWindow.OnClose()
{
	#pc	"Main OnClose";
}

function ^MainWindow.OnDestroy()
{
	#pc	"Main OnDestroy";
}

//-----------------------------------------------------------------------------

function ^MainWindow.OnSize()
{
	#pc	"Main OnSize: ": .gc.Xd, .gc.Yd;

	.ViewXd = ( .gc.Xd - ( #LeftXm + #RightXm ))'cut( #ViewXd, );
	.ViewYd = ( .gc.Yd - ( #TopYm + #BottomYm ))'cut( #ViewYd, );
	R = ::GK.Rect( #ViewXo, #ViewYo, .ViewXd, .ViewYd );

	//#pc	.ViewWnd, .ViewWnd'from( ::GK.WindowBase ), .ViewWnd.Move;
	if( .ViewWnd'exist? )
		.ViewWnd.Move( R );

	R.Shift( -2, -2, +4, +4 );
	.ViewEdge <- R;
}

//-----------------------------------------------------------------------------

function ^MainWindow.OnPaint()
{
	#pc	"Main OnPaint";

	.GetHotRect( R'STRUCT );
	.gc.ClearRect( R, .BackColor );
	.gc.DrawEdge( .ViewEdge, #EDGE_SUNKEN, #BF_RECT );
}

//-----------------------------------------------------------------------------

function ^MainWindow.OnTypeSelect()
{
	#pc	"OnTypeSelect: ": .TypeList.GetText(), .TypeList.GetCurSel();
	^Type = .TypeList.GetText();
	//.SetTitle( "フラクタル図形 -- " + ^Type );
	.SetOrderList( .MaxOrder[ ^Type ] );

	^glDeleteLists( ^FractalDL, 1 );
	^GenFractalDL();
	.ViewWnd.InvalidateRect();
}

//-----------------------------------------------------------------------------

function ^MainWindow.OnOrderSelect()
{
	#pc	"OnOrderSelect: ": .OrderList.GetText(), .OrderList.GetCurSel();
	^Order = .OrderList.GetCurSel();

	^glDeleteLists( ^FractalDL, 1 );
	^GenFractalDL();
	.ViewWnd.InvalidateRect();
}

//-----------------------------------------------------------------------------

function ^MainWindow.OnKeyDown( vk )
{
	//#pc "Main OnKeyDown:": vk'x(4);
	.ViewWnd.OnKeyDown( vk );
}

//-----------------------------------------------------------------------------

function ^MainWindow.OnMouseMove( x, y, ks )
{
	if( ks == 0 )
		return;
	#pc "Main OnMouseMove: ": x, y, ks'x;
}

//-----------------------------------------------------------------------------

function ^MainWindow.OnMouseButton( x, y, ks )
{
	#pc "Main OnMouseButton: ": x, y, ks'x;
}

//-----------------------------------------------------------------------------

function ^MainWindow.OnMouseWheel( x, y, d )
{
	//#pc "Main OnMouseWheel: ": X, Y, x, y, d;
	.ViewWnd.OnMouseWheel( x, y, d );
}

//=============================================================================

///  OpenGL 描画ウィンドウ  ///


function ^ViewWindow.Construct( Xo, Yo, Xd, Yd, owner )
{
	#pc	"View Construct: ";
	.[ ::GK.Window.Construct ]( , Xo, Yo, Xd, Yd, #WS_CHILD, 0, owner );
	.Open();
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

function ^ViewWindow.Destruct()
{
	#pc	"View Destruct: ";
	.[ ::GK.Window.Destruct ]();
}

//-----------------------------------------------------------------------------

function ^ViewWindow.OnCreate()
{
	#pc	"View OnCreate";
	if( .InitializeOpenGL() != #OK )
	{
		#p "OpenGL 初期設定エラー！";
		.Close();
		return;
	}
	.CurScale = -6;				// 伸縮度合
	.MoveDx = .MoveDy = 0.0;	// 累積マウスドラッグ量（ワールド座標系）
	.TmpDx  = .TmpDy  = 0.0;	// 一時マウスドラッグ量（ワールド座標系）
	.LBtn = 0;					// マウスの左ボタン ON/OFF 状態
	.α = .β = .γ = 0;

	( .gc.Xd, .gc.Yd ) = ( #ViewXd, #ViewYd );
	.OnSize();		// 最初、.OnSize() に行かないため

	^GenFractalDL();
}

//-----------------------------------------------------------------------------

function ^ViewWindow.OnDestroy()
{
	#pc	"View OnDestroy";
	^glDeleteLists( ^FractalDL, 1 );
	.TerminateOpenGL();
}
//（注）子ウィンドウには、OnClose() が来ない

//-----------------------------------------------------------------------------

function ^ViewWindow.OnSize()
{
	#pc	"View OnSize: ": .gc.Xd, .gc.Yd;

	^glViewport( 0, 0, .gc.Xd, .gc.Yd );

	^glMatrixMode( #GL_PROJECTION );
	^glLoadIdentity();

	// ウィンドウサイズが変わっても、ウィンドウ内の図形のサイズを変えない場合
	X = 1.0 * .gc.Xd / #ViewXd;
	Y = 1.0 * .gc.Yd / #ViewXd;
	^glOrtho( -X/2, +X/2, -Y/2, +Y/2, -100.0, 100.0 );

	// ウィンドウサイズに応じて、ウィンドウ内の図形のサイズを変える場合
	//X = 0.5;
	//Y = X / .gc.Xd * .gc.Yd;
	//^glOrtho( -X, +X, -Y, +Y, -100.0, 100.0 );
}

//-----------------------------------------------------------------------------

function ^ViewWindow.OnPaint()
{
	//#pc	"View OnPaint";

	^glClear( #GL_COLOR_BUFFER_BIT ); 

	^glMatrixMode( #GL_MODELVIEW );
	^glLoadIdentity();

	k = ::Math.pow( 2.0, .CurScale * 0.25 );
	^glTranslated( .MoveDx * k, .MoveDy * k, 0.0 );
	^glScaled( k, k, k );
	if( .LBtn )
	{
		.TmpDx = .DragDx / k / #ViewXd;
		.TmpDy = .DragDy / k / #ViewXd;
		^glTranslated( .TmpDx, .TmpDy, 0.0 );
	}

	^glRotated( .α'float, 1.0, 0.0, 0.0 );	// X 軸まわりに回転（正：反時計方向）
	^glRotated( .β'float, 0.0, 1.0, 0.0 );	// Y 軸まわりに回転（正：反時計方向）
	^glRotated( .γ'float, 0.0, 0.0, 1.0 );	// Z 軸まわりに回転（正：反時計方向）

	// フラクタル図形を描画
	^glCallList( ^FractalDL );

	// 座標軸を描画
	//^glBegin( #GL_LINES );
	//D = 1.0;
	//  // X 軸
	//	^glColor3d( 1.0, 1.0, 0.0 );
	//	^glVertex2d( -D, 0.0 );
	//	^glVertex2d( +D, 0.0 ) ;
	//  // Y 軸
	//	^glColor3d( 0.0, 1.0, 1.0 );
	//	^glVertex2d( 0.0, -D );
	//	^glVertex2d( 0.0, +D );
	//  // Z 軸
	//	^glColor3d( 1.0, 0.0, 1.0 );
	//	^glVertex3d( 0.0, 0.0, -D );
	//	^glVertex3d( 0.0, 0.0, +D );
	//^glEnd();

	^glFlush(); 
}

//-----------------------------------------------------------------------------

function ^ViewWindow.OnKeyDown( vk )
{
	//#pc "View OnKeyDown:": vk'x(4);
	switch( vk & ~#KCF_REPEAT )
	{
	  case #VK_ESCAPE:
		^MainWindow.Close();
		return;

	  case #VK_HOME :
		.MoveDx = .MoveDy = 0.0;
		.CurScale = -6;
		.α = .β = .γ = 0;
		break;

	  case #VK_SPACE:
		#px	.GetMousePos( X'new!, Y'new! );
		#px	( X, Y ) = ( X - .gc.Xd / 2, .gc.Yd / 2 - Y );
		#pc	"Mx, My : ":	// ワールド座標系での現マウス位置
		#px	(X'float / #ViewXd)'f(3), (Y'float / #ViewXd)'f(3);
		#pc	"α,β,γ = ": .α, .β, .γ;
		return;

	  case #VK_DOWN	:	.α += 5;	break;
	  case #VK_UP   :	.α -= 5;	break;
	  case #VK_LEFT :	.β += 5;	break;
	  case #VK_RIGHT:	.β -= 5;	break;
	  case #VK_PRIOR:	.γ += 5;	break;
	  case #VK_NEXT :	.γ -= 5;	break;

	  default:		return;
	}
	.InvalidateRect();
}

//-----------------------------------------------------------------------------

function ^ViewWindow.OnMouseMove( x, y, ks )
{
	//#pc "View OnMouseMove: ": x, y, ks'x;
	if( ks & #MK_LBUTTON )
	{
		if( .LBtn == 0 )
		{
			( .DragXo, .DragYo ) = ( x, y );
			( .DragDx, .DragDy ) = ( 0, 0 );
		}
		else
			( .DragDx, .DragDy ) = ( x - .DragXo, .DragYo - y );
		.LBtn = 1;
		.InvalidateRect();
	}
	else
	{
		if( .LBtn != 0 )
		{
			.MoveDx += .TmpDx;
			.MoveDy += .TmpDy;
			
		}
		.LBtn = 0;
	}
}

//-----------------------------------------------------------------------------

function ^ViewWindow.OnMouseButton( x, y, ks )
{
	//#pc "View OnMouseButton: ": x, y, ks'x;
}

//-----------------------------------------------------------------------------

function ^ViewWindow.OnMouseWheel( x, y, d )
{
	//( X, Y ) = .ScreenToClient( x, y );
	//#pc "View OnMouseWheel: ": X, Y, x, y, d;
	.CurScale += d / 120;
	.InvalidateRect();
}

//-----------------------------------------------------------------------------

function ^ViewWindow.InitializeOpenGL()		// OpenGL の初期設定
{
	#pc	"InitializeOpenGL";

	PIXELFORMATDESCRIPTOR ::=
	{
		.nSize			'USHORT;
		.nVersion		'USHORT = 1;
		.dwFlags		'ULONG  = #PFD_DRAW_TO_WINDOW |	
								  #PFD_SUPPORT_OPENGL ;
		.iPixelType		'UBYTE  = #PFD_TYPE_RGBA;
		.cColorBits		'UBYTE  = 24;	// 24-bit color depth
		.cRedBits		'UBYTE  = 0;	// color bits ignored
		.cRedShift		'UBYTE  = 0;	// 			〃
		.cGreenBits		'UBYTE  = 0;	// 			〃
		.cGreenShift	'UBYTE  = 0;	// 			〃
		.cBlueBits		'UBYTE  = 0;	// 			〃
		.cBlueShift		'UBYTE  = 0;	// 			〃
		.cAlphaBits		'UBYTE  = 0;	// no alpha buffer
		.cAlphaShift	'UBYTE  = 0;	// shift bit ignored
		.cAccumBits		'UBYTE  = 0;	// accum bits ignored
		.cAccumRedBits	'UBYTE  = 0;	// 			〃
		.cAccumGreenBits'UBYTE  = 0;	// 			〃
		.cAccumBlueBits	'UBYTE  = 0;	// 			〃
		.cAccumAlphaBits'UBYTE  = 0;	// 			〃
		.cDepthBits		'UBYTE  = 32;	// 32-bit z-buffer
		.cStencilBits	'UBYTE  = 0;	// no stencil buffer
		.cAuxBuffers	'UBYTE  = 0;	// no auxiliary buffer
		.iLayerType		'UBYTE  = #PFD_MAIN_PLANE;	// main layer
		.bReserved		'UBYTE  = 0;
		.dwLayerMask	'ULONG  = 0;	// layer masks ignored
		.dwVisibleMask	'ULONG  = 0;	// 			〃
		.dwDamageMask	'ULONG  = 0;	// 			〃
	}
	PIXELFORMATDESCRIPTOR.nSize = PIXELFORMATDESCRIPTOR'size;

	pfd = ::Buffer( PIXELFORMATDESCRIPTOR.nSize );
	pfd.Write( PIXELFORMATDESCRIPTOR );
	pfd.Seek(0);

	if(( i = ^ChoosePixelFormat( .gc.hdc, pfd )) <= 0 )
		return #NG;
	if( ^SetPixelFormat( .gc.hdc, i, pfd ) == #FALSE )
		return #NG;
	if(( .hRC = ^wglCreateContext( .gc.hdc )) == #NULL )
		return #NG;
	if( ^wglMakeCurrent( .gc.hdc, .hRC ) == #FALSE )
		return #NG;

	return #OK;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

function ^ViewWindow.TerminateOpenGL()		// OpenGL の終了設定
{
	#pc	"TerminateOpenGL";
	^wglMakeCurrent( #NULL, #NULL ); 
	^wglDeleteContext( .hRC ); 
}

//=============================================================================

function ^GenFractalDL()
{
	//#pc	"GenFractalDL: ": ^Type, ^Order,
	^FractalDL = ^glGenLists( 1 );
	^glNewList( ^FractalDL, #GL_COMPILE );

	switch( ^Type )
	{
	  case #FF_KOCH_CURVE:
		( ^Xc, ^Yc, ^θc ) = ( -1.0, -0.2, 0.0 );
		^glColor3d( 1.0, 1.0, 1.0 );
		^glBegin( #GL_LINE_STRIP );
			^glVertex2d( ^Xc, ^Yc );
			^Koch( ^Order, 2.0, 0.0 );
		^glEnd();
		break;

	  case #FF_DRAGON_CURVE:
		( ^Xc, ^Yc, ^θc ) = ( -1.0, -0.25, 0.0 );
		^glColor3d( 1.0, 1.0, 1.0 );
		^glBegin( #GL_LINE_STRIP );
			^glVertex2d( ^Xc, ^Yc );
			^Dragon( ^Order, 1.75, 45.0 );
		^glEnd();
		break;

	  case #FF_HILBERT_CURVE:
		( ^Xc, ^Yc, ^Ls ) = ( 0.5, 0.5, 1.0 );
		for( i = 1 ; i < ^Order ; i++ )
		{
			^Ls /= 2;
			^Xc += ^Ls / 2;
			^Yc += ^Ls / 2;
		}
		^glColor3d( 1.0, 1.0, 1.0 );
		^glBegin( #GL_LINE_STRIP );
			^glVertex2d( ^Xc, ^Yc );
			^ldr( ^Order );
		^glEnd();
		break;

	  case #FF_TREE:
		( ^Xc, ^Yc, ^θc ) = ( 0.0, -1.0, 90.0 );
		^Width'DOUBLE( 11 ) = { 10, 6, 4, 3, 2, 1, 1, 1, 1, 1, 1 };
		^Tree( ^Order, 0.5 );
		^glLineWidth( 1.0'sfv );
		break;
	}
	^glEndList();
}

//-----------------------------------------------------------------------------

function ^Koch( N, D, θd )		// コッホ曲線
{
	^θc += θd;
	if( N <= 0 )
	{
		^Xc += D * ^Cos( #DegToRad( ^θc ) );
		^Yc += D * ^Sin( #DegToRad( ^θc ) );
		^glVertex2d( ^Xc, ^Yc );
		return;
	}
	^Koch( N - 1, D / 3,    0.0 );
	^Koch( N - 1, D / 3,  +60.0 );
	^Koch( N - 1, D / 3, -120.0 );
	^Koch( N - 1, D / 3,  +60.0 );
}

//-----------------------------------------------------------------------------

function ^Dragon( N, D, θd )		// ドラゴン曲線
{
	if( N <= 0 )
	{
		^Xc += D * ^Cos( #DegToRad( ^θc ) );
		^Yc += D * ^Sin( #DegToRad( ^θc ) );
		^glVertex2d( ^Xc, ^Yc );
		return;
	}
	^θc += θd;
	^Dragon( N - 1, D / #SQRT_2, -45.0 );
	^θc -= θd * 2;
	^Dragon( N - 1, D / #SQRT_2, +45.0 );
	^θc += θd;
}

//-----------------------------------------------------------------------------

// ヒルベルト曲線

function ^ldr( n )
{
	if( n <= 0 )
		return;
	dlu( n - 1 );  ^glVertex2d( ^Xc -= ^Ls, ^Yc );    // left
	ldr( n - 1 );  ^glVertex2d( ^Xc, ^Yc -= ^Ls );    // down
	ldr( n - 1 );  ^glVertex2d( ^Xc += ^Ls, ^Yc );    // right
	urd( n - 1 );
}

function ^urd( n )
{
	if( n <= 0 )
		return;
	rul( n - 1 );  ^glVertex2d( ^Xc, ^Yc += ^Ls );    // up
	urd( n - 1 );  ^glVertex2d( ^Xc += ^Ls, ^Yc );    // right
	urd( n - 1 );  ^glVertex2d( ^Xc, ^Yc -= ^Ls );    // down
	ldr( n - 1 );
}

function ^rul( n )
{
	if( n <= 0 )
		return;
	urd( n - 1 );  ^glVertex2d( ^Xc += ^Ls, ^Yc );    // right
	rul( n - 1 );  ^glVertex2d( ^Xc, ^Yc += ^Ls );    // up
	rul( n - 1 );  ^glVertex2d( ^Xc -= ^Ls, ^Yc );    // left
	dlu( n - 1 );
}

function ^dlu( n )
{
	if( n <= 0 )
		return;
	ldr( n - 1 );  ^glVertex2d( ^Xc, ^Yc -= ^Ls );    // down
	dlu( n - 1 );  ^glVertex2d( ^Xc -= ^Ls, ^Yc );    // left
	dlu( n - 1 );  ^glVertex2d( ^Xc, ^Yc += ^Ls );    // up
	rul( n - 1 );
}

//-----------------------------------------------------------------------------

function ^Tree( N, D )		// フラクタル木
{
	k = ( N + 1.0 ) / ( ^Order + 1.0 );
	^glColor3d( 0.5 + 0.1 * k, 1.0 - 0.8 * k, 0.2 - 0.2 * k );
	^glLineWidth( ^Width( ^Order - N )'sfv );
	^glBegin( #GL_LINES );
	^glVertex2d( Xo = ^Xc, Yo = ^Yc );
	^Xc += D * ^Cos( #DegToRad( ^θc ) );
	^Yc += D * ^Sin( #DegToRad( ^θc ) );
	^glVertex2d( ^Xc, ^Yc );
	^glEnd();
	if( N > 0 )
	{
		θo = ^θc;
		^θc -= 35.0;
		^Tree( N - 1, D * 0.7 );
		^θc = θo + 25.0;
		^Tree( N - 1, D * 0.8 );
		^θc = θo;
	}
	( ^Xc, ^Yc ) = ( Xo, Yo );
}

//=============================================================================

function  SetupOpenGL()		// OpenGL のＡＰＩを取得（必要分のみ）
{
	#pv	^ChoosePixelFormat = ::GK.Gdi32.GetEntry( "ChoosePixelFormat" );
	#pv	^SetPixelFormat = ::GK.Gdi32.GetEntry( "SetPixelFormat" );
	#pv	^GetPixelFormat = ::GK.Gdi32.GetEntry( "GetPixelFormat" );
	#pv	^DescribePixelFormat = ::GK.Gdi32.GetEntry( "DescribePixelFormat" );
	#pv	^SwapBuffers = ::GK.Gdi32.GetEntry( "SwapBuffers" );
	#pv	^GetEnhMetaFilePixelFormat = ::GK.Gdi32.GetEntry( "GetEnhMetaFilePixelFormat" );

	#pv	^GL = ::DLL.Link( "OPENGL32", "sys" );
	if( ^GL == null )
	{
		#p "OPENGL32.DLL not found!";
		return #NG;
	}

	#pv	^GLU = ::DLL.Link( "GLU32", "sys" );
	if( ^GLU == null )
	{
		#p "GLU32.DLL not found!";
		return #NG;
	}

	#pv	^glBegin = ^GL.GetEntry( "glBegin" );
	#pv	^glCallList = ^GL.GetEntry( "glCallList" );
	#pv	^glClear = ^GL.GetEntry( "glClear" );
	#pv	^glColor3d = ^GL.GetEntry( "glColor3d" );
	#pv	^glDeleteLists = ^GL.GetEntry( "glDeleteLists" );
	#pv	^glEnd = ^GL.GetEntry( "glEnd" );
	#pv	^glEndList = ^GL.GetEntry( "glEndList" );
	#pv	^glFlush = ^GL.GetEntry( "glFlush" );
	#pv	^glFrustum = ^GL.GetEntry( "glFrustum" );
	#pv	^glGenLists = ^GL.GetEntry( "glGenLists" );
	#pv	^glLineWidth = ^GL.GetEntry( "glLineWidth" );
	#pv	^glLoadIdentity = ^GL.GetEntry( "glLoadIdentity" );
	#pv	^glMatrixMode = ^GL.GetEntry( "glMatrixMode" );
	#pv	^glNewList = ^GL.GetEntry( "glNewList" );
	#pv	^glOrtho = ^GL.GetEntry( "glOrtho" );
	#pv	^glRotated = ^GL.GetEntry( "glRotated" );
	#pv	^glScaled = ^GL.GetEntry( "glScaled" );
	#pv	^glTranslated = ^GL.GetEntry( "glTranslated" );
	#pv	^glVertex2d = ^GL.GetEntry( "glVertex2d" );
	#pv	^glVertex3d = ^GL.GetEntry( "glVertex3d" );
	#pv	^glViewport = ^GL.GetEntry( "glViewport" );
	#pv	^wglCreateContext = ^GL.GetEntry( "wglCreateContext" );
	#pv	^wglDeleteContext = ^GL.GetEntry( "wglDeleteContext" );
	#pv	^wglMakeCurrent = ^GL.GetEntry( "wglMakeCurrent" );

	return #OK;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

function  DeleteOpenGL()
{
	delete ^GL;
	delete ^GLU;
}

//=============================================================================