تبلیغات

نسل باران

|

بانک شماره و موبایل popup window

قالب های حرفه ای وردپرس

|

پلاگین وردپرس popup window

وب سایت دانشجویان کارشناسی و ارشد کامپیوتر خرم آباد - مطالب opengl
نسل باران
وب سایت دانشجویان کارشناسی و ارشد کامپیوتر خرم آباد
امام علی (ع) می فرمایند: « زکات العلم نشرهُ» زکات علم نشر آن است.
به سایت ما خوش آمدید

از این جلسه بعد بیشتر سراغ ترسیم اشیاء در صحنه خواهیم رفت .نوصیه می کنم قبل از خواندن مطالب این قسمت برای درک بهتر مفاهیم با یک نرم افزار 3D مانند 3Ds max ,Mayaو...... آشنایی مختصری پیدا کنید .و البته امیدوارم با مفاهیم مثل بردارها و محور مختصات و همچنین ماتریس ها آشنایی داشته باشید.

در این جلسه می خواهیم در مورد رسم Vertex یا نقطه در صحنه صحبت کنیم.
در openGL تمام اشکال ما با استفاده از رئوس ایجاد می شوند و ما برای تعیین این رئوس از Vertex ها استفاده می کنیم.پس در این جلسه نحوه ایجاد این رئوس رو توضیح خواهیم داد.

// Includes Header Files
#include <windows.h>
#include "GL.H"
#include "GLU.H"
#include "glut.h"
// Include Library Files
#pragma comment(lib,"OPENGL32.LIB")
#pragma comment(lib,"glut32.lib")
#pragma comment(lib,"GLU32.LIB")
void Create_Vertex(void)
{  
	   glBegin(GL_POINTS);
	   glVertex3f(-0.9,0.5,0.5);
	   glVertex3f(0.,0.0,0.0);
	   glVertex2f(0.2,0.2);
	   glVertex2f(0.9,0.9);
	   glEnd();
    glFlush(); 
}
void Display(void)
{    
    glClearColor(0.5,0.5,0.5,1);
    glColor3f(1.0,1.0,0.0);
    glClear(GL_COLOR_BUFFER_BIT); // Clear the window 
    glPointSize(5.0); // a ‘dot’ is 4 by 4 pixels
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    Create_Vertex();
    glFlush(); // send all output to display
}
 //*** main ***

int WINAPI  WinMain(HINSTANCE hinstance,
		  HINSTANCE hPrevInstance,
		  LPSTR argv,
		  int argc) 
{ 
    glutInit(&argc, &argv);  // initialize the toolkit
    glutInitDisplayMode(GLUT_RGB);
    glutInitWindowSize(800,600);
    glutInitWindowPosition(150,180);
    glutCreateWindow ("khoramsoft"); // Create the window 
    glutDisplayFunc (Display);// Register the "display" function 
    glutMainLoop (); // Enter the OpenGL main loop 
}

این برنامه را اجرا کنید،بایستی چهار نقطه قرمز رنگ را در صفحه مشاهده نمایید.
اما توضیح برنامه
اگر برنامه را با برنامه پست قبلی مقایسه کنید می بینید که یک تابع جدید به برنامه اضافه نموده ایم که همین تابع کار ترسیم Vertexها را برای ما انجام میدهد.

void Create_Vertex(void)
{
glBegin(GL_POINTS);
glVertex3f(-0.9,0.5,0.5);
glVertex3f(0.,0.0,0.0);
glVertex2f(0.2,0.2);
glVertex2f(0.9,0.9);
​glEnd();
glFlush();
}

خط اول تعریف تابع ما می باشد.
در خط سوم و هشتم توابع glBegin ,glEnd را فراخوانی نموده ایم.از این توابع برای ترسیم اشیاء با استفاده از رئوس استفاده می نماییم.شکل کلی این دو تابع به صورت زیر می باشد.
void glBegin(GLenum  mode);

void glEnd( void);

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

تابع glBegin تابع شروع کننده ترسیم شی است، دارای یک آرگومان می باشد که مشخص کننده نوع ترسیم می باشد و می تواند یکی از مقادیر زیر را دریافت کند :

دیدن لینک ها برای شما امکان پذیر نیست. لطفا ثبت نام کنید یا وارد حساب خود شوید تا بتوانید لینک ها را ببینید.

در مثال بالا

glBegin(GL_POINTS);

به OpenGL می گوید تمام Vertex ها را به دید نقاط نگاه کند و یا

glBegin(GL_LINES)

یعنی هر دو Vertex را یک خط در نظر می گیرد و در صفحه نمایش خط را رسم می کند.

در خط های 4 تا 7 چهار بار تابع glVertex را فراخوانی کرده ایم .از این تابع برای ایجاد راس ها یا همون Vertex ها استفاده می کنیم در یعنی با توجه به فراخوانی این توابع چهار نقطه در صفحه باید رسم شود.در واقع Vertex پایین ترین سطح طراحی اشیاء در OpenGL می باشند.و یکی از پرکاربردترین توابع OpenGL تابع glVertex می باشد.
در مورد glVertex2f اعداد و حروف بعد از نام تابع هم قبلاً توضیح داده شده است .حرف f و رقم 2 یعنی تابع 2 پارامتر از نوه GLfloat دریافت می کند.توابع glVertex2 برای رسم نقاط به صورت دوبعدی (محور مختصات دوبعدی X,Y) و glVertex3 برای رسم نقاط به صورت سه بعدی (محور مختصات سه بعدی X,Y,Z) مورد استفاده قرار می گیرند .این نکته را هم در نظر بگیرید که رعایت راسها بسیار مهم می باشد .

توابعی دیگری هم وجود دارند که 4 پارامتر دریافت می کنند که در مورد آنها در آینده صحبت خواهیم نمود.

لیست توابع glVertex
void glVertex2s(GLshort  x,  GLshort  y);
void glVertex2i(GLint  x,  GLint  y);
void glVertex2f(GLfloat  x,  GLfloat  y);
void glVertex2d(GLdouble  x,  GLdouble  y);
void glVertex3s(GLshort  x,  GLshort  y,  GLshort  z);
void glVertex3i(GLint  x,  GLint  y,  GLint  z);
void glVertex3f(GLfloat  x,  GLfloat  y,  GLfloat  z);
void glVertex3d(GLdouble  x,  GLdouble  y,  GLdouble  z);
void glVertex4s(GLshort  x,  GLshort  y,  GLshort  z,  GLshort  w);
void glVertex4i(GLint  x,  GLint  y,  GLint  z,  GLint  w);
void glVertex4f(GLfloat  x,  GLfloat  y,  GLfloat  z,  GLfloat  w);
void glVertex4d(GLdouble  x,  GLdouble  y,  GLdouble  z,  GLdouble  w);			   
void glVertex2sv(const GLshort *  v);
void glVertex2iv(const GLint *  v);
void glVertex2fv(const GLfloat *  v);
void glVertex2dv(const GLdouble *  v);
void glVertex3sv(const GLshort *  v);
void glVertex3iv(const GLint *  v);
void glVertex3fv(const GLfloat *  v);
void glVertex3dv(const GLdouble *  v);
void glVertex4sv(const GLshort *  v);
void glVertex4iv(const GLint *  v);
void glVertex4fv(const GLfloat *  v);
void glVertex4dv(const GLdouble *  v);

از خط 1 تا 12 فرم اسکالر توابع و از 13 تا 24 فرم برداری توابع می باشد.
برای مثال

void glVertex3dv(const GLdouble * v);
v یک اشاره گر به آرایه سه عنصری از نوع Double می باشد.که به ترتیب مقادیر مختصات Z,Y,X نقطه (Vertex )مورد نظر می باشد.
نکته: استفاده از توابع glVertex خارج از توابع glBegin ,glEnd باعث بوجود آمدن خطای تعریف نشده می شود.

تابع glFlush() برای اطمینان از اجراء تمام دستوراتی که باید برای ترسیم اجراء شوند.در واقع باعث می شود که OpenGL مطمئن شود تمام ترسیمات که باید رسم می شدند انجام گرفته اند.
شکل کلی آن به صورت زیر است:

void glFlush(void);

همانطور که می بینید این تابع نه مقداری می گیرد نه مقداری را بر می گرداند.
تابع Create_Vertex را به طور کامل توضیح دادیم .
تابع بعدی Display می باشد که چهار خط جدید در آن وجود دارد .

در خط 23 تابع glColor3f را داریم از این تابع برای تغییر اشیاء درون صحنه استفاده می کنیم و تا زمانی که مجدداً فراخوانی یا استفاده نشوند رنگ اشیاء صحنه به با همان رنگ اول رنگ آمیزی می شوند.

در مثال بالا ما از رنگ زرد برای نقاط رسم شده استفاده نموده ایم .

لیست توابع glColor
void glColor3b(GLbyte  red,  GLbyte  green,  GLbyte  blue);
void glColor3s(GLshort  red,  GLshort  green,  GLshort  blue);
void glColor3i(GLint  red,  GLint  green,  GLint  blue);
void glColor3f(GLfloat  red,  GLfloat  green,  GLfloat  blue);
void glColor3d(GLdouble  red,  GLdouble  green,  GLdouble  blue);
void glColor3ub(GLubyte  red,  GLubyte  green,  GLubyte  blue);
void glColor3us(GLushort  red,  GLushort  green,  GLushort  blue);
void glColor3ui(GLuint  red,  GLuint  green,  GLuint  blue);
void glColor4b(GLbyte  red,  GLbyte  green,  GLbyte  blue,  GLbyte  alpha);
void glColor4s(GLshort  red,  GLshort  green,  GLshort  blue,  GLshort  alpha);
void glColor4i(GLint  red,  GLint  green,  GLint  blue,  GLint  alpha);
void glColor4f(GLfloat  red,  GLfloat  green,  GLfloat  blue,  GLfloat  alpha);
void glColor4d(GLdouble  red,  GLdouble  green,  GLdouble  blue,  GLdouble  alpha);
void glColor4ub(GLubyte  red,  GLubyte  green,  GLubyte  blue,  GLubyte  alpha);
void glColor4us(GLushort  red,  GLushort  green,  GLushort  blue,  GLushort  alpha);
void glColor4ui(GLuint  red,  GLuint  green,  GLuint  blue,  GLuint  alpha);
void glColor3bv(const GLbyte *  v);
void glColor3sv(const GLshort *  v);
void glColor3iv(const GLint *  v);
void glColor3fv(const GLfloat *  v);
void glColor3dv(const GLdouble *  v);
void glColor3ubv(const GLubyte *  v);
void glColor3usv(const GLushort *  v);
void glColor3uiv(const GLuint *  v);
void glColor4bv(const GLbyte *  v);
void glColor4sv(const GLshort *  v);
void glColor4iv(const GLint *  v);
void glColor4fv(const GLfloat *  v);
void glColor4dv(const GLdouble *  v);
void glColor4ubv(const GLubyte *  v);
void glColor4usv(const GLushort *  v);
void glColor4uiv(const GLuint *  v);

16 تابع اول فرم اسکالر و 16 تابع بعدی فرم برداری توابع glColor می باشند.

تابع بعدی که در خط 25 بکار برده شده است تابع glPointSize می باشد .از این تابع برای مشخص کردن اندازه نقاطی که در صفحه ترسیم می کنیم استفاده می شود.
فرم کلی تابع به صورت زیر می باشد:

void glPointSize(GLfloat  size);

مقدار پیشفرض آن 1 می باشد.یعنی در صورتی که ما از این تابع استفاده نکنیم قطر نقطه یا نقاط مورد نظر را 1 در نظر می گیرد.

تابع بعدی تابع glMatrixMode می باشد که در خط 26 به کار برده شده و از آن برای تعیین ماتریس صفحه که برای تعیین و تغییر مکان اشیاء و یا دوربین ها مورد استفاده قرار می گیرد.
شکل کلی آن به صورت زیر می باشد:

void glMatrixMode(GLenum  mode);

آرگومان این تابع می تواند سه مقدار زیر را دریافت نماید:
GL_MODELVIEW
GL_PROJECTION
GL_TEXTURE

مقدار پیشفرض این تابع GL_MODELVIEW می باشد.
این تابع همچنین یک مقدار دیگه هم دریافت می کند.

در مورد این تابع و ثوابت آن در آینده بیشتر صحبت خواهیم کرد.بنابراین نگران یادگیری آن نباشید.

تابع بعدی تابع glLoadIdentity می باشد که آخرین تابعی است که توضیح آن باقی مانده است.شکل کلی تابع به صورت زیر است:

  void glLoadIdentity(  void); 

این تابع مانند بسیاری از توابع دیگر OpenGL نه مقداری از ورودی دریافت و نه مقداری را بر می گرداند.این تابع ماتریس فعلی را به ماتریس واحد تبدیل می کند.
ماتریس واحد چیست؟
ماتریس واحد ماتریسی است که عناصری که در قطر آن قرار دارند 1 و بقیه عناصر آن صفر می باشند.

[attachment=639][attachment=640][attachment=641]

تمرین:
1-سه نقطه در صفحه در نقاط دلخواه رسم کنید که دوتای آنها به رنگ آبی و قطر 4 و یکی به رنگ سبز در وسط صفحه به قطر 20
2-یک نقطه با مختصات (25و43) رسم کنید.
3-یک نقطه دایره ایی شکل با قطر 50 در وسط صفحه با رنگ بنفش ایجاد کنید.رنگ صفحه رو به سفید تغییر دهید.
m15



نوع مطلب : گرافیک کامپیوتری، opengl، 
برچسب ها :
لینک های مرتبط :


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

برای مثال :

glClearColor(0.5,0.5,0.5,1.0);

با

GLfloat Array_Color[] ={0.5,.05,0.5,1.0};
    glVertex3fv (Array_Color);

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

متغیرهای در OpenGL

تعریف متغیرهای در OpenGL مانند تعریف متغیر در زبان ++C می باشد با این تفاوت که OpenGL دارای نوع های مستقل است .چون OpenGL یک API مستقل از پلتفرم هست بنابراین برای اجرا شدن بهتر و بدون درسر برنامه های نوشته شده با آن، دارای نوع های مستقل می باشد.
در جدول زیر همه نوع های OpenGL معرفی شده اند که تقریباً همان نوع های به کار رفته در زبانهای دیگر مثل ++C هستند.

دیدن لینک ها برای شما امکان پذیر نیست. لطفا ثبت نام کنید یا وارد حساب خود شوید تا بتوانید لینک ها را ببینید.


نوع های GLclampf و GLclampfd همان نوع های GLfloat و GLdouble هستند با این تفاوت که به ما می گه که محدوده اعداد از 0.0 تا 1.0 می باشد.

نوع size که مشخص کننده مقدار طول یا عمق میباشد. بطور مثال GLsizei یکی از توابع OpenGL است که نشان دهنده این است که این تابع یک متغیر از نوع صحیح را به عنوان آرگومان میگیرد.



چند مثال:
GLfloat m;//متغیری از نوع Float
GLdouble Array_Depth[10]; // آرایه 10 عنصری از نوع اعشاری Double
GLint *ints_pointers[3]; // آرایه از 3 اشاره گر به متغیرهای صیح int






با مقدمات اولیه تا اندازه ایی آشنا شدیم امروز می خوایم درباره یه برنامه خیلی ساده بحث کنیم و با بعضی از توابع GL وglut آشنا بشیم.

// Includes Header Files

#include <windows.h>
#include "GL.H"
#include "GLU.H"
#include "glut.h"

// Include Library Files
#pragma comment(lib,"OPENGL32.LIB")
#pragma comment(lib,"glut32.lib")
#pragma comment(lib,"GLU32.LIB")



void Display(void)
{
    glClear(GL_COLOR_BUFFER_BIT); // Clear the window 
    glFlush(); // send all output to display
}

 //*** main ***

int WINAPI  WinMain(HINSTANCE hinstance,
		  HINSTANCE hPrevInstance,
		  LPSTR argv,
		  int argc) 
{ 
    glutInit(&argc, &argv);  // initialize the toolkit
    glutCreateWindow ("khoramsoft"); // Create the window 
    glutDisplayFunc (Display); // Register the "display" function 
    glutMainLoop (); // Enter the OpenGL main loop 

}

در خط های 1 تا 9 کتابخانه ها و هدر فایل های لازم رو فراخوانی کردیم همونطور که قبلاً هم گفتم این خطوط جزء همیشگی برنامه های ما در این سری آموزش هستند.

در خط 16 ما تابع اصلی mian رو برای برنامه نویسی در محیط win32 نوشتیم.همه برنامه ها در ++C درای این تابع می باشند و برنامه ها از این تابع شروع به اجرا کرده و از طریق این تابع به قسمت های دیگر برنامه هدایت می شوند. اگه می خواید در مورد اون بیشتر بدونید به دیدن لینک ها برای شما امکان پذیر نیست. لطفا ثبت نام کنید یا وارد حساب خود شوید تا بتوانید لینک ها را ببینید.
برید.(16 تا 19 مربوط به تابع main و آرگومانهای آن)

در خط 22 تابع ()glutInit را مقدار دهی کردیم این تابع در برنامه های openGL که از کتابخانه glut استفاده می کند و یک بار مقداردهی اولیه می شود .در واقع این تابع کتابخانه glut رو معرفی می کنه.
شکل کلی آن به صورت زیر است:

void glutInit(int *argcp, char **argv);


این تابع دارای 2 آرگومان هست :

argcp: که اشاره گری به متغیر argc تابع main است . argc تعداد آرگومانهای ارسالی رو ذخیره می کند.
argv: اشاره گری به متغیر argv تابع main است و argv مقدار آرگومانها رو ذخیر ه می کند .
در آینده در مورد این تابع بیشتر بحث خواهیم کرد.



glutCreateWindow ("khoramsoft");

با فراخوانی این تابع پنجره ما ساخته میشه و در titel آن عبارت khoramsoft را قرار می دهد.شکل کلی آن به صورت زیر است.

int glutCreateWindow(char *name);

همانطور که می بینید این تابع یک مقدار int را بر می گرداند که با استفاده از آن به کنترل پنجره های گرافیکی دیگر می پردازیم.
آرگومان این تابع یه مقدار رشته ایی می باشد.


glutDisplayFunc (Display);

این تابع یک تابع دیگه رو فراخوانی می کنه ،که ما نوشتیم در واقع آرگومان اون یک تابع است.به اینگونه توابع CallBack گفته میشه و شکل کلی اون به صورت زیر:

void glutDisplayFunc(void (*func)(void));

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

در تابع Display دوتا به دیگه داریم. . این دو تابع از دستورات کتابخانه اصلی OpenGl هستند.

glClear(GL_COLOR_BUFFER_BIT); 

که با استفاده از اون بافر mask رو پاک می کنیم که مقصود از بافر همون حافظه ماست که رنگ نقاط در اون ذخیره میشه و همیشه باید قبل از ترسیم هر چیزی اونها رو پاک کنیم. شکل کلی اون به صورت زیر است:

void glClear(GLbitfield  mask);

آرگومان اون فقط اجازه استفاده از 4 ثابت زیر رو داره

GL_COLOR_BUFFER_BIT
بافر رنگی

GL_DEPTH_BUFFER_BIT

بافر عمق

GL_ACCUM_BUFFER_BIT

بافر انباره
GL_STENCIL_BUFFER_BIT

بافر استنسیل

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

آخرین تابع ما هم تابع ()glFlush هست که باعث اجرای تمام دستورات OpenGL در تابع Display می شود که تا کنون اجرا نشده اند همونطور که می بینید ما در تابع Display فقط یک دستور داریم .
شکل کلی این دستور به صورت زیر است:

void glFlush(void);





امروز می خوایم 4 تابع دیگه رو بهتون معرفی کنیم که به ما کمک می کنند پنجره ایی که در درس قبلی ایجاد کردیم رو بیشتر کنترل کنیم.
// Includes Header Files
#include <windows.h>
#include "GL.H"
#include "GLU.H"
#include "glut.h"
// Include Library Files
#pragma comment(lib,"OPENGL32.LIB")
#pragma comment(lib,"glut32.lib")
#pragma comment(lib,"GLU32.LIB")
void Display(void)
{
    glClearColor(0.5,0.5,0.5,1.0);
    glClear(GL_COLOR_BUFFER_BIT); // Clear the window 
    glFlush(); // send all output to display
}
 //*** main ***
int WINAPI  WinMain(HINSTANCE hinstance,
		HINSTANCE hPrevInstance,
		LPSTR argv,
		int argc) 
{ 
    glutInit(&argc, &argv);  // initialize the toolkit
glutInitDisplayMode(GLUT_SINGLE,GLUT_RGB);
    glutInitWindowSize(600,400);
    glutInitWindowPosition(150,180);
    glutCreateWindow ("khoramsoft"); // Create the window 
    glutDisplayFunc (Display); // Register the "display" function 
    glutMainLoop (); // Enter the OpenGL main loop 
}
 

اولین تابع اضافه شده ما در خط 12 قرار دارد.

glClearColor(0.5,0.5,0.5,1.0);

کار این تابع اینه که رنگ پاک کننده صفحه را با مقادیر داده شده در Mode رنگی RGBA تنظیم می کند.شکا کلی تابع به صورت زیر می باشد.

void glClearColor(GLclampf  red,  GLclampf  green,  GLclampf  blue,  GLclampf  alpha);

آرگومانهای این تابع از نوع GLclampf می باشند که اگه پست های قبلی رو مطالعه کرده باشید میدونید که مقدار آنها در محدوده 0. تا 1.0 می باشد.با تغییر هریک از سه متغیر red,green,blue می توانیم رنگهای زیادی رو به وجود بیاریم .متغیر چهارم alpha یا همان مقدار شفافیت می باشد.

اما چطور مقدار رنگها رو پیدا کنیم؟
راه های زیادی وجود داره که من یه راه ساده رو معرفی می کنم . ما می تونیم Paint ویندوز رو باز کنیم و قسمت پالت رنگ روی Edit Color کلیک کنید در پنجره باز شده رنگ مورد نظر رو انتخاب کنید .من رنگ خاکستری رو انتخاب کردم .

دیدن لینک ها برای شما امکان پذیر نیست. لطفا ثبت نام کنید یا وارد حساب خود شوید تا بتوانید لینک ها را ببینید.
در قسمت مشخص شده می بینید که اعداد هر یک از رنگها نشان داده شده ولی در محدوده 0 تا 255 برای تبدیل اونها به اعداد در محدوده 0.0 تا 1.0 کافیه اونا رو بر 256 تقسیم کنیم.
128/256=0.5


مقدار آلفا رو فعلاً برای برنامه ها روی یک قرار بدید،در جای خودش از اون هم استفاده خواهیم کرد.

تابع بعدی تابع

glutInitDisplayMode(GLUT_SINGLE,GLUT_RGB);

که در خط 24 اضافه شده با استفاده از این تابع mode نمایشی رو برای ما مشخص می کنه و در مثال بالا mode پنجره تک بافری در mode رنگی RGB رو مشخص کرده است .شکل کلی تابع به صورت زیر است .

 void glutInitDisplayMode (unsigned int mode);   

آرگومانهای آن می تواند هر یک از مقادیر زیر باشد.

GLUT_RGBA 
GLUT_RGB   
GLUT_INDEX   
GLUT_SINGLE    
GLUT_DOUBLE    
GLUT_ACCUM    
GLUT_ALPHA
GLUT_DEPTH
GLUT_STENCIL
GLUT_MULTISAMPLE
GLUT_STEREO
GLUT_LUMINANCE
​



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

glutInitWindowSize(600,400);

که در این مثال عرض رو 600 و ارتفاع اون رو 400 پیکسل در نظر گرفتیم .شکل کلی تابع به صورت زیر است:

void glutInitWindowSize(int width, int height);

تابع آخر تابع glutInitWindowPosition است که برای تعیین مکان پنجره ایجاد شده مورد استفاده قرار می گیرد.

شکل کلی آن به صورت زیر است :

void glutInitWindowPosition(int x, int y);

درواقع این تابع موقعیت پنجره رو از بالا ،سمت چپ بر حسب پیکسل تغییر میدهد .مقدار پیشفرض آن 300*300 می باشد.

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






نوع مطلب : گرافیک کامپیوتری، opengl، 
برچسب ها :
لینک های مرتبط :

در پست قبلی در مورد نحوه به کارگیر کتابخانه های OpenGL در کامپایلر VS2010 صحبت کردیم در این پست می خوام نحوه استفاده از این کتابخانه رو با یه روش دوم رو توضیح بدم که به مراتب بهتر از روش قبلی هست و دردسرها کمتری داره.

در این روش تمام فایل ها پوشه lib و پوشه include رو در داخل پوشه پروژه میریزیم .

برای مثال من در VS2010 یک پروژه WIN32 با نام
opengl ایجاد کردم .فایلهای موجود در پوشه های lib و include رو در مسیر زیر کپی می کنم :

D:\Documents\Visual Studio 2010\Projects\opengl\opengl

نکته ایی که اینجا باید بگن مسیر پیشفرض پروژه های من

D:\Documents\Visual Studio 2010\Projects

بعد از انجام اینکار
فایلهای داخل پوشه dlls needed رو
اگه از ویندوز 64 بیتی استفاده می کنید در مسیر

C:\windows\SysWOW64

و اگه از ویندوز 32 بیتی استفاده می کنید در مسیر

C:\windows\system32

کپی کنید.

نکته :برای برنامه هایی که با OpenGL می نویسید حتماً بایستی همراه فایل EXE فایلهای DLL رو هم همراه پروژه ارائه بدید .

اما برای فراخوانی هدر فایلها و فایلهای کتابخانه ایی باید چکار کنیم؟

برای فایلهای کتابخانه ایی (Lib) از دستور

#pragma comment(lib,"نام کتابخانه")

و هدر فایلها از ذستور

#include "نام هدر فایل"

برای مثال پروژه قبلی رو با این روش اجرا کنید.

/* Copyright © Mark J. Kilgard, 1997. */
 
/* This program is freely distributable without licensing fees 
   and is provided without guarantee or warrantee expressed or 
   implied. This program is -not- in the public domain. */
 
/* This program was requested by Patrick Earl; hopefully someone else
   will write the equivalent Direct3D immediate mode program. */
#include <Windows.h>
#include "glut.h"
#pragma comment(lib,"OPENGL32.LIB")
#pragma comment(lib,"glut32.lib")
#pragma comment(lib,"GLU32.LIB")
#pragma comment(lib,"GLAUX.LIB")
GLfloat light_diffuse[] = {1.0, 0.0, 0.0, 1.0};  /* Red diffuse light. */
GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0};  /* Infinite light location. */
GLfloat n[6][3] = {  /* Normals for the 6 faces of a cube. */
  {-1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {1.0, 0.0, 0.0},
  {0.0, -1.0, 0.0}, {0.0, 0.0, 1.0}, {0.0, 0.0, -1.0} };
GLint faces[6][4] = {  /* Vertex indices for the 6 faces of a cube. */
  {0, 1, 2, 3}, {3, 2, 6, 7}, {7, 6, 5, 4},
  {4, 5, 1, 0}, {5, 6, 2, 1}, {7, 4, 0, 3} };
GLfloat v[8][3];  /* Will be filled in with X,Y,Z vertexes. */
void
drawBox(void)
{
  int i;
 
  for (i = 0; i < 6; i++) {
    glBegin(GL_QUADS);
    glNormal3fv(&n[i][0]);
    glVertex3fv(&v[faces[i][0]][0]);
    glVertex3fv(&v[faces[i][1]][0]);
    glVertex3fv(&v[faces[i][2]][0]);
    glVertex3fv(&v[faces[i][3]][0]);
    glEnd();
  }
}
 
void
display(void)
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  drawBox();
  glutSwapBuffers();
}
 
void
init(void)
{
  /* Setup cube vertex data. */
  v[0][0] = v[1][0] = v[2][0] = v[3][0] = -1;
  v[4][0] = v[5][0] = v[6][0] = v[7][0] = 1;
  v[0][1] = v[1][1] = v[4][1] = v[5][1] = -1;
  v[2][1] = v[3][1] = v[6][1] = v[7][1] = 1;
  v[0][2] = v[3][2] = v[4][2] = v[7][2] = 1;
  v[1][2] = v[2][2] = v[5][2] = v[6][2] = -1;
 
  /* Enable a single OpenGL light. */
  glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  glEnable(GL_LIGHT0);
  glEnable(GL_LIGHTING);
 
  /* Use depth buffering for hidden surface elimination. */
  glEnable(GL_DEPTH_TEST);
 
  /* Setup the view of the cube. */
  glMatrixMode(GL_PROJECTION);
  gluPerspective( /* field of view in degree */ 40.0,
    /* aspect ratio */ 1.0,
    /* Z near */ 1.0, /* Z far */ 10.0);
  glMatrixMode(GL_MODELVIEW);
  gluLookAt(0.0, 0.0, 5.0,  /* eye is at (0,0,5) */
    0.0, 0.0, 0.0,    /* center is at (0,0,0) */
    0.0, 1.0, 0.);    /* up is in positive Y direction */
 
  /* Adjust cube position to be asthetic angle. */
  glTranslatef(0.0, 0.0, -1.0);
  glRotatef(60, 1.0, 0.0, 0.0);
  glRotatef(-20, 0.0, 0.0, 1.0);
}
 
int WINAPI WinMain(HINSTANCE hinstance,
	   HINSTANCE hPrevInstance,
	   LPSTR argv,
	   int argc) 
{ 
    glutInit(&argc, &argv); 
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutCreateWindow("red 3D lighted cube");
  glutDisplayFunc(display);
  init();
  glutMainLoop();
  return 0;	    /* ANSI C requires main to return int. */
}

یادمون باشه که این چهار خط همیشه جزء برنامه های ما خواهند بود پس همیشه اونها رو قبل از هر کاری بعد از فراخوانی هدر فایلها قرار بدید.

 #pragma comment(lib,"OPENGL32.LIB")
 #pragma comment(lib,"glut32.lib")
 #pragma comment(lib,"GLU32.LIB")
 #pragma comment(lib,"GLAUX.LIB")
*****************************
کم کم بریم سراغ خود OpenGL و برنامه نویسی رو شروع کنیم .

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

توابع اصلی OpenGL با gl شروع و در ادامه حرف اول آن با حروف بزرگ نوشته می شود .برای مثال

glClear

glColor

glGetPolygonStipple


توابع glu با glu شروع و در ادامه حرف اول هرکدام از واژه ها به صورت بزرگ نوشته می شود.


gluBuild2DMipmaps

gluNewTess

gluDisk


یا توابع glut با glut شروع و در ادامه حرف اول هرکدام از واژه ها به صورت بزرگ نوشته می شود.


glutInit

glutInitDisplayMode

glutMainLoop



همانطور که در بالا می بینید نامگذاری توابع از قانون خاصی پیروی می کنه و به خاطر سپردن و تشخیص توابع هر کتابخانه به راحتی امکان پذیر است.

علاوه بر توابع در OpenGL ثابتها هم وجود دارند که نحوه نام گذاری آنها به اینصورت است .

در ابتدای آنها GL با حروف بزرگ نوشته می شود و بعد از آن یک "_" (underscore) قرار می گیرد و سپس نام ثابت با حروف بزرگ نوشته می شود.در صورتی که نام یک ثابت از چندین واژه تشکیل شده باشد بعد از هر واژه یک "_" قرار می گیرد.

مثال


GL_LINES

GL_COLOR_BUFFER_BIT


بعضی از توابع OpenGL به اعداد ختم میشن اون اعداد چی هستند؟

glColor3f

glVertex3fv


درواقع اعداد نشان دهنده تعداد آرگومانهای ورودی تابع هستند که ما باید قرار بدیم .

مثلاً در تابع glColor3f عدد 3 نشان دهنده این است که تابع بایستی دارای 3 آرگومان ورودی باشد که نوع آنها Float می باشد اما چرا Float ؟به خاطر حرف f بعد از 3 هست که به ما میگه نوع آرگومانها بایستی از نوع Float باشند.

اما ممکنه به سوال دیگه پیش بیاد اون حرف V واسه چیه؟
جواب این سوال باشه واسه پست بعدی
M25




نوع مطلب : opengl، 
برچسب ها :
لینک های مرتبط :

برای کار با OpenGL قبل از هر کاری بایستی کامپایلر رو آماده کنیم .
مبنای آموزش ما کامپایلر Microsoft Visual Studio 2010 در ویندوز 7 و به صورت WIN32 هست .البته برای کار با کامپایلرهای دیگه هم نیاز به تغییر چندانی نیست .ما دور روش رو برای آماده سازی و به کار گیری کتابخانه های اون بیان می کنیم.که دوستانی که به این کامپایلر دسترسی ندارند به مشکل بر نخورند.

ابتدا فایل زیر رو دریافت کنید.

[attachment=589]

فایل رو از حالت فشرده خارج کنید ،فایلهای داخل پوشه dlls needed رو
اگه از ویندوز 64 بیتی استفاده می کنید در مسیر

C:\windows\SysWOW64

و اگه از ویندوز 32 بیتی استفاده می کنید در مسیر

C:\windows\system32

کپی کنید به احتمال زیاد یعضی از فایل ها در مسیر های گفته شده موجود هست که نیازی به جایگزینی نیست.

فایل های داخل پوشه compiler needs رو هم در مسیرهای زیر کپی کنید

پوشه include

C:\Program Files\Microsoft SDKs\Windows\v7.0A\Include\gl

و پوشه lib

C:\Program Files\Microsoft SDKs\Windows\v7.0A\Lib

کامپایلر ما الان آماده شده است .فقط باید اونو تست کنیم تا مطمئن بشیم بدون مشکل می تونیم کار با Opengl رو شروع کنیم.

به این دیدن لینک ها برای شما امکان پذیر نیست. لطفا ثبت نام کنید یا وارد حساب خود شوید تا بتوانید لینک ها را ببینید.
برید و طبق ارسال شماره 4 یک پروژ WIN32 ایجاد کنید.

حالا کد زیر رو توی API.cpp کپی کنید و اون رو اجرا کنید .در صورتی که همه کارها رو درست انجام داده باشید باید شکل یک مکعب قرمز رو مشاهده کنید.



/* Copyright © Mark J. Kilgard, 1997. */
/* This program is freely distributable without licensing fees 
   and is provided without guarantee or warrantee expressed or 
   implied. This program is -not- in the public domain. */
 
/* This program was requested by Patrick Earl; hopefully someone else
   will write the equivalent Direct3D immediate mode program. */
#include <Windows.h>
#include <GL/glut.h>
 
GLfloat light_diffuse[] = {1.0, 0.0, 0.0, 1.0};  /* Red diffuse light. */
GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0};  /* Infinite light location. */
GLfloat n[6][3] = {  /* Normals for the 6 faces of a cube. */
  {-1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {1.0, 0.0, 0.0},
  {0.0, -1.0, 0.0}, {0.0, 0.0, 1.0}, {0.0, 0.0, -1.0} };
GLint faces[6][4] = {  /* Vertex indices for the 6 faces of a cube. */
  {0, 1, 2, 3}, {3, 2, 6, 7}, {7, 6, 5, 4},
  {4, 5, 1, 0}, {5, 6, 2, 1}, {7, 4, 0, 3} };
GLfloat v[8][3];  /* Will be filled in with X,Y,Z vertexes. */
 
void
drawBox(void)
{
  int i;
 
  for (i = 0; i < 6; i++) {
    glBegin(GL_QUADS);
    glNormal3fv(&n[i][0]);
    glVertex3fv(&v[faces[i][0]][0]);
    glVertex3fv(&v[faces[i][1]][0]);
    glVertex3fv(&v[faces[i][2]][0]);
    glVertex3fv(&v[faces[i][3]][0]);
    glEnd();
  }
}
 
void
display(void)
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  drawBox();
  glutSwapBuffers();
}
 
void
init(void)
{
  /* Setup cube vertex data. */
  v[0][0] = v[1][0] = v[2][0] = v[3][0] = -1;
  v[4][0] = v[5][0] = v[6][0] = v[7][0] = 1;
  v[0][1] = v[1][1] = v[4][1] = v[5][1] = -1;
  v[2][1] = v[3][1] = v[6][1] = v[7][1] = 1;
  v[0][2] = v[3][2] = v[4][2] = v[7][2] = 1;
  v[1][2] = v[2][2] = v[5][2] = v[6][2] = -1;
 
  /* Enable a single OpenGL light. */
  glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  glEnable(GL_LIGHT0);
  glEnable(GL_LIGHTING);
 
  /* Use depth buffering for hidden surface elimination. */
  glEnable(GL_DEPTH_TEST);
 
  /* Setup the view of the cube. */
  glMatrixMode(GL_PROJECTION);
  gluPerspective( /* field of view in degree */ 40.0,
    /* aspect ratio */ 1.0,
    /* Z near */ 1.0, /* Z far */ 10.0);
  glMatrixMode(GL_MODELVIEW);
  gluLookAt(0.0, 0.0, 5.0,  /* eye is at (0,0,5) */
    0.0, 0.0, 0.0,	/* center is at (0,0,0) */
    0.0, 1.0, 0.);	/* up is in positive Y direction */
 
  /* Adjust cube position to be asthetic angle. */
  glTranslatef(0.0, 0.0, -1.0);
  glRotatef(60, 1.0, 0.0, 0.0);
  glRotatef(-20, 0.0, 0.0, 1.0);
}
 
int WINAPI WinMain(HINSTANCE hinstance,
		HINSTANCE hPrevInstance,
		LPSTR argv,
		int argc) 
{ 
    glutInit(&argc, &argv); 
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutCreateWindow("red 3D lighted cube");
  glutDisplayFunc(display);
  init();
  glutMainLoop();
  return 0;		 /* ANSI C requires main to return int. */
}




نوع مطلب : گرافیک کامپیوتری، opengl، 
برچسب ها :
لینک های مرتبط :

این مطلب رمزدار است، جهت مشاهده باید کلمه رمز این مطلب را وارد کنید.




نوع مطلب :
برچسب ها :
لینک های مرتبط :



( کل صفحات : 3 )    1   2   3   
درباره وبلاگ


امام صادق(ع) می فرمایند: «اِنُّ لِکلِّ شیءٍ زکاةً و زکاةُ العِلمِ اَنْ یُعَلِّمَهُ اَهلَهُ» برای هر چیزی زکاتی است،و زکات علم آن است که آن را به اشخاص شایسته بیاموزید. (منبع: تحف.ص 364)

امام علی (ع) می فرمایند: « زکات العلم نشرهُ» زکات علم نشر آن است.

مدیر وبلاگ : s1390
مطالب اخیر
نویسندگان
صفحات جانبی
آمار وبلاگ
  • کل بازدید :
  • بازدید امروز :
  • بازدید دیروز :
  • بازدید این ماه :
  • بازدید ماه قبل :
  • تعداد نویسندگان :
  • تعداد کل پست ها :
  • آخرین بازدید :
  • آخرین بروز رسانی :
فرم تماس
نام و نام خانوادگی
آدرس ایمیل
امکانات دیگر
دریافت كد ختم صلوات
کلیه حقوق این وبلاگ برای وب سایت دانشجویان کارشناسی و ارشد کامپیوتر خرم آباد محفوظ است