آموزشهای NeHe برای OpenGL درس اول - قسمت اول

با عرض سلام خدمت دوستان :

 

بدون مقدمه درس اول از سلسله دروس NeHe OpenGL Tutorials را با هم شروع میکنیم. فقط امیدوارم که دوستان مطالب پست قبل را به دقت مطالعه کرده باشند.

 

این مقاله طرز برپاکردن یک پنجره OpenGL را به شما آموزش خواهد داد. پنجره ای که میتواند در حالت تمام صفحه "full screen" و یا در اندازه اصلی یک پنجره "Windowed" و یا هر اندازه و رزولوشنی که شما بخواهید و با هر دقت رنگی نمایش داده شود. این کد ( برنامه ای که در این درس مینویسیم ) بسیار انعطاف پذیر بوده و شما میتوانید از آن در کلیه پروژه های OpenGL خود استفاده کنید. تمام کد هایی که من در طی این سلسله دروس استفاده کرده ام ((من یعنی نویسنده این آموزشها آقای جف مولوفی که ملقب به NeHe میباشد وگرنه من که تنها آنها را ترجمه کرده ام )) بر پایه این کد میباشد.من بطریقی این کد را نوشتم که انعطاف پذیر و قدرتمند باشد. این کد اشکال زدایی شده و از همه لحاظ تست شده است. بسیار خوانا بوده و به راحتی قابل اصلاح میباشد.

 

یک نکته مهم : بسیاری از کامپایلر ها ثابت CDS_FULLSCREEN را تعریف نمیکنند. پس اگر شما به خطایی در حین کامپایل برخورد کردید باید که این قطعه کد را به ابتدای برنامه خود اضافه کنید.

#define CDS_FULLSCREEN 4

 

خوب دیگه بریم سر اصل مطلب و برنامه خودمون رو شروع کنیم :

 

این چهار خط که در زیر آمده فایلهای هدر (سر آیند) مربوط به کتابخانه هایی که ما در برنامه مان استفاده میکنیم را به برنامه ضمیمه میکند :

در مرحله بعدی شما نیاز دارید که تمام متغیر هایی را که میخواهید در برنامه استفاده کنید برپا کنید (ایجاد کنید). این برنامه یک پنجره خالی OpenGL میسازد. پس ما فعلا نیازی به تعریف متغیر های زیاد نداریم. این متغیر هایی که ما ایجاد میکنیم بسیار مهم هستند و در برنامه هایی که شما با استفاده از این کد مینویسید استفاده میشوند.

اولین خط از خطوط زیر یک زمینه رندر یا "Rendering Context" را مقدمه چینی (برپا) میکند. هر برنامه OpenGL به یک زمینه رندر پیوند یافته است. یک زمینه رندر "Rendering Context" چیزی است که فراخوانی های OpenGL را به زمینه دستگاه "Device Context" پیوند میدهد. زمینه رندر OpenGL با عنوان hRC تعریف شده است. برای اینکه برنامه شما قادر به ترسیم چیزهایی بر روی پنجره باشد شما نیاز دارید که یک زمینه دستگاه "Device Context" طراحی کنید که این کار در خط دوم انجام شده است. زمینه دستگاه ویندوز با عنوان hDC تعریف شده است.

 

DC پنجره را به GDI (رابط دستگاه گرافیک Graphics Device Interface )مرتبط میسازد و RC به نوبه خود OpenGL را به DC مرتبط میسازد.

در خط سوم متغیر hWnd دستگیره ای را که توسط ویندوز به پنجره ما اختصاص یافته را نگهداری میکند و سر انجام خط چهارم یک رویداد برای برنامه ما میسازد.

اولین خط از خطوط زیر آرایه ای را برپا میکند که ما از آن برای مونیتور کردن ( ردیابی کردن ) کلید های فشرده شده از صفحه کلید استفاده میکنیم. البته راههای بسیاری برای اینکار وجود دارد اما من این راه را انتخاب کرده ام چون اولا قابل اطمینان است و در درجه دوم میتواند به فشرده شدن تعداد بیش از یک کلید در لحظه نیز رسیدگی کند.

متغیر فعال که ما در برنامه مان استفاده کرده ایم برای این است که به برنامه ما بگوید که آیا پنجره برنامه ما به صورت حداقل "Minimized" تبدیل شده است و یا نه. اگر برنامه ما به صورت حداقل "Minimized" در آمده باشد ما میتوانیم کارهایی از قبیل خروج از برنامه و یا متوقف کردن برنامه به صورت موقت را انجام دهیم. من شخصا ترجیح میدهم که در این طور مواقع برنامه را به صورت موقت متوقف کنم. این کار باعث میشود تا زمانی که برنامه به صورت حداقل در آمده در پشت صحنه همچنان اجرا نشود.

متغیر fullscreen هم که کاملا واضح است. اگر برنامه ما در حالت تمام صفحه در حالت اجرا شدن باشد مقدار این متغیر برابر با TRUE است و اگر برنامه در حالت پنجره شده "Windowed" در حالت اجرا باشد مقدار این متغیر برابر FALSE میباشد. بسیار مهم است که این متغیر از نوع سراسری یا همان "global" باشد چون در این صورت تمام پردازه ها ( رویه ها ) میتوانند بفهمند که برنامه در حالت فول اسکرین قرار دارد یا نه.

در گام بعدی ما باید WndProc() را تعریف کنیم. دلیل اینکه ما مجبور به انجام این کار هستیم اینست که تابع CreateGLWindow() یک ارجاع به WinProc() دارد ولی WinProc() بعد از تابع CreateGLWindow() آمده است. در زبان سی اگر ما بخواهیم به یک رویه یا قسمتی از کد دسترسی داشته باشیم که در جایی بعد از قسمتی از کد که در حال حاضر قرار داریم آمده باشد ما مجبوریم که قسمتی از کد را که میخواهیم به آن دسترسی داشته باشیم در بالای برنامه مان اعلام نماییم. بنابر این در خط زیر ما WinProc() را اعلان کردیم پس CreateGLWindow() میتواند به آن مراجعه نماید.

 

 

وظیفه بخش بعدی اینست که صحنه OpenGL را تغییر اندازه بدهد در هر زمانی که پنجره برنامه تغییر اندازه داده شد.(فرض میکنیم که برنامه شما در حالت پنجره ای در حال اجراست و نه در حالت فول اسکرین). اگر هم شما قادر به تغییر اندازه پنجره نباشید (( برای مثال در حالت فول اسکرین باشید )) این روتین حداقل یکبار در ابتدای شروع برنامه اجرا میشود تا نمای پرسپکتیو ما را برپا کند.

خطوط نمونه زیر صفحه را برای نمای پرسپکتیو برپا میکند. بدین معنی که چیزهایی که در فواصل دورتر هستند اندازه کوچکتری داشته باشند. این عمل باعث میشود که صحنه واقعی تر به نظر برسد. پرسپکتیو بر اساس یک نمای 45 درجه از طول و عرض پنجره محاسبه شده است. 0.1f نقطه شروع و 100.0f مقدار پایان برای مقدار عمقی است که ما میتوانیم بر روی صحنه ترسیم کنیم.

 

ادامه دارد.

مقدمه ای بر آموزشهای NeHe برای OpenGL

با عرض سلام خدمت دوستان عزیز :

 

در این قسمت میخواهیم اولین درس از سلسله دروس NeHe را با هم شروع کنیم. ولی قبل از آن لازم دیدم چند نکته را به دوستان یادآوری کنم.

 

نکته اول : دوستانی که مایلند کلیه 48 آموزش NeHe را به زبان اصلی و قالب PDF داشته باشند میتوانند از اینجا آن را دریافت کنند.

 

نکته دوم : سورس برنامه هایی که ما در طول آموزشهایمان از آنها استفاده میکنیم در قالب پروژه های آماده از سایت http://nehe.gamedev.net قابل دریافت میباشد. در انتهای هر درس لینکهایی برای دانلود سورس آن برنامه در زبانهای مختلف و در محیط های مختلف وجود دارد. البته من شخصا خودم تعداد سه لینک را در انتهای هر درس قرار میدهم برای دانلود سورس برنامه در محیط های Dev-CPP و Pelles C و CodeBlocks . که دوستان اگر از این محیط ها استفاده میکنند بتوانند راحت تر به سورس ها دسترسی داشته باشند. به نظر من این سه محیط بهترین محیط ها برای آموزش های ما میباشد.

 

نکته سوم : در بسیاری از آموزش های NeHe از کتابخانه GLAUX استفاده شده است. که دوستان باید خودشان شخصا آن را از اینترنت پیدا کرده و دانلود نموده و به کامپایلرشان معرفی نمایند. اما دوستانی که از کامپایلر Pelles C استفاده میکنند نیازی به اینکار ندارند چون این کامپایلر که IDE مخصوص به خودش را نیز دارد این کتابخانه را با خودش دارد. و نیازی به نصب و دانلود جداگانه آن نیست. اما برای محیط برنامه نویسی Dev-CPP که از کامپایلر MinGW استفاده میکند باید پکیج این کتابخانه را از این آدرس دریافت کنید و با دابل کلیک بر روی آن به راحتی آن را بر روی محیط خود نصب کنید. من این پکیج را برای شما در این آدرس آپلود کرده ام. بهمین جهت نیز دوستان اگر از یکی از این سه محیطی که معرفی کردم استفاده کنند مشکلی در استفاده از کتابخانه GLAUX ندارند.

البته بعد ها سعی میکنیم که از کتابخانه GLUT برای کارهایمان استفاده کنیم ( که کتابخانه ای بهتر و جدیدتر میباشد )ولی در حال حاضر آموزشهای NeHe بر پایه کتابخانه GLAUX بوده و ما مجبور به استفاده از این کتابخانه میباشیم.

باز هم میگویم دوستان میتوانند کامپایلر Pelles C v4.5 را با حجم تنها 7.5 MB دانلود کرده و در این آموزشها از آن استفاده کنند.

 

نکته چهارم : نظر به اینکه من این آموزشهای NeHe را در کنار آموزشهایی که از کتاب OpenGL SuperBible 3^rd Edition ترجمه میکنم در وبلاگ قرار میدهم دوستان لازم است که برای فهمیدن این مورد که این آموزش متعلق به کتاب است یا سایت NeHe در پایان هر مقاله به منبع آن توجه کنند. چون این آموزشها ربطی به همدیگر ندارند و هر کدام مسیر جداگانه خود را دنبال میکنند.

 

نکته پنجم : از آن جایی که تنها وجود بدون اشتباه از آن خداوند است امکان دارد در طول مطالعه این دروس به ایراد و یا اشکالی چه در تایپ و چه در ترجمه برخورد نمایید. در این صورت از دوستان تقاضامندم که من را از آن مشکل مطلع کنند. چون این وبلاگ در اصل متعلق به تمامی دوستداران OpenGL میباشد.

 

نکته ششم : انشالله به زودی سعی میکنم مطالبی که از کتاب و یا سایت NeHe ترجمه کرده ام را به صورت PDF برای دوستان آپلود کنم. تا امکان دانلود آنها برای دوستان میسر شود.

 

نکته هفتم : یکی از پیش نیاز هایی که دوستان برای استفاده از این دروس نیاز دارند دانستن روش برنامه نویسی ویندوز با توابع API میباشد که همانطور که قبلا نیز گفته ام دوستان میتوانند با مراجعه به سایت www.persian-designers.com به یک سری مقالات خوب که برنامه نویسی ویندوز با توابع API را آموزش میدهد دسترسی داشته باشند. البته یک مرجع بسیار خوب در اینترنت برای یادگیری برنامه نویسی ویندوز با توابع API وجود دارد که نام آن  forgers-win32-tutorialمیباشد و به زبان انگلیسی بوده و فرمت آن PDF میباشد و API را بسیار خوب و روان درس میدهد و حجم آن ۲۷۰ کیلو بایت است (دانلود کنید : فایل آموزش به صورت PDF ).

دوستانی که با زبان انگلیسی مشکلی ندارند میتوانند از آن بهره ببرند. این مجموعه به نظر من بهترین راه برای یادگیری برنامه نویسی با API ویندوز میباشد.

 

در پایان از دوستان دو تقاضا دارم :

 

1. اگر دوستان مقالات خوب دیگری در سایت های خارجی برای آموزش OpenGL سراغ دارند خوشحال میشوم آن را در قسمت نظرات و یا در آیدی من در یاهو بنویسند تا در صورت امکان از مطالب آنها نیز استفاده کنیم. My Yahoo ID :    Sasan_dracula_59

 

2. و به عنوان تقاضای دوم صمیمانه از دوستان خواهشمندم که با ارایه نظرات و پیشنهاداتشان در قسمت نظرات من را در ادامه این راه یاری نمایند. در ضمن دوستان این نظرخواهی در مورد زبانهای برنامه نویسی که در ستون سمت راست وبلاگ میباشد را نیز مورد عنایت قرار دهند تا بتوانیم بعد از مدتی یک جمع بندی از میزان محبوبیت زبانهای برنامه نویسی در بین کاربران ایرانی داشته باشیم.

 

شما را به مطالعه اولین درس از آموزشهای NeHe در پست بعدی دعوت میکنم. خدانگهدار

 

مقالات آموزش OpenGL قسمت هفتم

خطاها در OpenGL :

 

واضح است که در هر پروژه ای شما میخواهید که برنامه ای قوی و با تربیت بنویسید که بصورت مودبانه به کاربرانش پاسخ دهد و مقداری هم انعطاف پذیری داشته باشد. برنامه های گرافیکی هم که از OpenGL استفاده میکنند از این قاعده مستثنی نیستند. اگر شما میخواهید که برنامه هایتان بطور روان اجرا شوند شما باید خطاها و رویداد های غیر مترقبه را همیشه مد نظر قرار دهید.

OpenGL یک مکانیزم مفید و موثر مهیا کرده است که شما با کمک آن بتوانید یک بررسی صحت بر حسب موقعیت "Occasional sanity check" بر روی کدتان قرار دهید. این قابلیت میتواند بسیار مهم باشد.

 

هنگامی که اتفاقات بدی برای کدهای خوب روی میدهند :

 

OpenGL بطور ذاتی از مجموعه ای از شش پرچم حمایت میکند که هر پرچم یک نوع خاص از خطا را نشان میدهد. هر زمان که یکی از این خطاها اتفاق بیفتد پرچم متناظر با آن خطا برقرار میشود. برای اینکه بفهمیم آیاهیچ کدام از این پرچم ها برقرارند یا نه این تابع را صدا میزنیم :

 

glGetError:

Glenum glGetError(void);

 

تابع glGetError یکی از مقادیر جدول 3-2 را برمیگرداند. کتابخانه GLU سه خطای مخصوص به خودش را تعریف میکند اما این نقشه خطاها دقیقا دو پرچم خطا را ارائه میکنند. اگر بیشتر از یکی از پرچمهابرقرار باشد glGetError هنوز تنها یک پرچم خطا را بر میگرداند. این مقدار پس از فراخوانی glGetError پاک میشود و glGetError دوباره مقدار خطای پرچم بعدی را برمیگرداند و یا مقدار GL_NO_ERROR را برمیگرداند. پس شما نیاز دارید تا تابع glGetError رادر یک حلقه صدا بزنید تا همینطور به چک کردن پرچم های خطا ادامه دهد تا زمانی که مقدار GL_NO_ERROR را برگرداند.

 

شما همچنین میتوانید از تابع دیگری در کتابخانه GLU استفاده کنید که gluErrorString نام دارد تا رشته ای دریافت کنید که پرچم خطا را شرح میدهد.

 

const GLubyte* gluErrorString(GLenum errorCode);

 

این تابع پرچم خطایی را که توسط تابع glGetError برگشت داده شده را به عنوان تنها آرگومانش میگیرد و سپس یک رشته استاتیک را بر میگرداند که خطایی که اتفاق افتاده است را توصیف میکند. پرچم خطای GL_INVALID_ENUM این رشته را باز می گرداند.

 

 

 

 

شما میتوانید آسوده خاطر باشید که اگر خطایی بخاطر صدا زدن غیر مجاز توابع OpenGL اتفاق افتاده باشد آن دستور یا تابع نادیده گرفته میشود. تنها استثنا در این مورد توابعی هستند که اشاره گر هایی به حافظه دارند (که میتواند باعث کرش کردن برنامه بشود اگر اشاره گر نامعتبر باشد) که در مقالات بعدی بیشتر توضیح داده خواهند شد.

 

منبع : کتاب OpenGL SuperBible 3rd Edition