تبلیغات

نسل باران

|

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

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

|

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

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

دانلود




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

توابع glEnable و glDisable در OpenGL

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

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

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

void glEnable(GLenum  cap);

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

GL_ALPHA_TEST
GL_AUTO_NORMAL
GL_BLEND
GL_CLIP_PLANEi
GL_COLOR_LOGIC_OP
GL_COLOR​_MATERIAL
GL_CULL_FACE
GL_DEPTH_TEST
GL_DITHER
GL_FOG
GL_INDEX_LOGIC_OP
GL_LIGHT​i
GL_LIGHTING
GL_LINE_SMOOTH
GL_LINE_STIPPLE
GL_LOGIC_OP
GL_MAP1_COLOR_4
GL_MAP1​_INDEX
GL_MAP1_NORMAL
GL_MAP1_TEXTURE_COORD_1
GL_MAP1_TEXTURE_COORD_2
GL_MAP1_TE​XTURE_COORD_3
GL_MAP1_TEXTURE_COORD_4
GL_MAP1_VERTEX_3
GL_MAP1_VERTEX_4
GL_MAP2_​COLOR_4
GL_MAP2_INDEX
GL_MAP2_NORMAL
GL_MAP2_TEXTURE_COORD_1
GL_MAP2_TEXTURE_COO​RD_2
GL_MAP2_TEXTURE_COORD_3
GL_MAP2_TEXTURE_COORD_4
GL_MAP2_VERTEX_3
GL_MAP2_VE​RTEX_4
GL_NORMALIZE
GL_POINT_SMOOTH
GL_POLYGON_OFFSET_FILL
GL_POLYGON_OFFSET_LIN​E
GL_POLYGON_OFFSET_POINT
GL_POLYGON_SMOOTH
GL_POLYGON_STIPPLE
GL_SCISSOR_TEST
G​L_STENCIL_TEST
GL_TEXTURE_1D
GL_TEXTURE_2D
GL_TEXTURE_GEN_Q
GL_TEXTURE_GEN_R
GL_​TEXTURE_GEN_S
GL_TEXTURE_GEN_T



نگران نباشید نیازی به حفظ کردن آنها ندارید به مرور با کاربرد هریک از این توابع آشنا می شوید.

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

// 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_1(void)
{
	glColor3f(0.0,1.0,0.0);
	gluOrtho2D(-15.0,15.0,-15.0,15.0);
	glPointSize(15);
	glEnable (GL_POINT_SMOOTH);
	glBegin(GL_POINTS);
		glVertex2f(9.0,9.0);
		glEnd();
	glDisable (GL_POINT_SMOOTH);
	glBegin(GL_POINTS);
		glVertex2f(6.0,9.0);
		glVertex2f(9.0,1.0);
	glEnd();
	glFlush();
}

void display(void)
{
	glClearColor(1.0,1.0,1.0,1.0);
	glClear(GL_COLOR_BUFFER_BIT);
	create_1();
	glFlush();

}

int WINAPI WinMain(HINSTANCE hinstance,
				   HINSTANCE hprevInstance,
				   LPSTR argv,
				   int argc)
{
	glutInit(&argc,&argv);
	glutInitDisplayMode(GLUT_SINGLE/*,GLUT_RGB*/);
	glutInitWindowSize(500,500);
	glutInitWindowPosition(200,200);
	glutCreateWindow("khoramsoft.com");
	glutDisplayFunc(display);
	glutMainLoop();
}

تابع glDisable
اگر به کدهای بالا توجه کنید ما در خط 16 از تابع glEnable با پارامتر GL_POINT_SMOOTH استفاده کرده ایم این ثابت باعث فعال کردن حالت Smooth برای نقاط در صحنه می شود بعد از کامپایل برنامه خواهید دید که لبه های نقطه ما گرد شده و از حالت چهار ضلعی خارج و به دایره نزدیکتر شده است.
در این مثال از یک تابع دیگر به نام glDisable استفاده کردیه ایم که دقیقاً همان ثابت GL_POINT_SMOOTH را به عنوان پارامتر خود گرفته است کار این تابع چیست؟
همانطور که از اسم تابع مشخص است از این تابع برای غیر فعال کردن قابلیت مورد نظرمان استفاده می کنیم .در این مثال ما می خواهیم حالت Smooth فقط برای نقطه اول اعمال شود و سایر نقاط به صورت چهار ظلعی باقی بمانند بنابراین بعد از نقطه اول این قابلیت را با استفاده از تابع glDisable غیر فعال کرده ایم.
شکل کلی این تابع به صورت زیر می باشد:

void glDisable(GLenum cap);
 

پارامترهایی که این تابع می تواند دریافت کند همان پارمترهای تابع glEnable می باشد.

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

GL_POINT_SMOOTH
GL_LINE_SMOOTH
GL_POLYGON_SMOOTH
برای همین بود که گفتیم نیاز به حفظ کردن آنها ندارید زیرا به راحتی با تمرین و در آینده همه کاربرد آنها را یاد خواهید گرفت.






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

در مورد ثابت GL_TRIANGLES به عنوان آرگومان glBeginتوضیح دادیم اما GL_TRIANGLES دو حالت دیگر دارد که در واقع هر کدام کاربردهای خودشان را دارند.

GL_TRIANGLE_STRIP

با استفاده از این ثابت ما می توانیم با استفاده از نقاط کمتر مثلث های بیشتری را ترسیم کنیم.این ثابت باعث میشود که بعد از ترسیم اولین مثلث با استفاده از سه نقطه اول ما بتوانیم از نقاط استفاده شده برای ترسیم مثلث هایی بعدی استفاده کنیم.
تعداد نقاطی که ممکن است برای ترسیم مثلث بعدی نیاز داشته باشیم بستگی به شکل و هنر ما در نوشتن درست برنامه می باشد ممکن است ما بتوانیم یک شکل را با استفاده از 5 نقطه به راحتی ترسیم اما فرد دیگری با استفاده از 6 نقطه آن را ترسیم کند. نگران نباشید به مرور یاد می گیرید که چگونه با کمترین تعداد نقاط بهترین حالت اشیاء را ترسیم کنید.البته کسانی که ریاضیات قوی تری داشته باشند به مراتب موفق تر از کسانی هستند که با ریاضیات مشکل دارند.

مثال:یک چهر ضلعی را با استفاده از دو مثلث ایجاد می کنیم:

void Create_Tetrahedron(void)
{    
	  glBegin(GL_TRIANGLE_STRIP);

	    glVertex2f(0.0,0.0);
	    glVertex2f(6.0,0.0);
	    glVertex2f(0.0,6.0);
	    glVertex2f(6.0,6.0);
	  glEnd();
    glFlush();   
}

نکته :کافیه این تابع را در برنامه پست های قبلی کپی نمایید و سپس در تابع Display آن را فراخوانی کنید.

با استفاده از این تابع ما یک چهار ضلعی (مربع) رو طراحی کردیم .همانطور که میدانید هر مربع چهار ضلع قائم دارد بنابراین برای ترسیم آن ما از دو مثلث قائم الزایه استفاده کره ایم.
شاید بپرسید دو زایه قائم دیگر چگونه ایجاد می شوند؟به شکل زیر نگاه کنید:

[attachment=696]
همانطور که می بینید مجموع زوایه های داخلی یک مثلث 180 درجه می باشد:

A+B+C =180
با توجه به شکل ب می بینید که یک چهار ضلعی با چهار زاویه قائم (مستطیل،مربع و...) از دو مثلث قائم الزایه تشکیل گردیده است .
اما توضیح مثال:
با استفاده از سه نقطه اول اولین مثلث رو ترسیم نموده ،یعنی خطوط 4-5-6 سپس یک نقطه در مختصات (6,6) تعریف کرده ایم ،GL_TRIANGLE_STRIP باعث می شود که دونقطه دیگر یعنی نقاطی که در خطوط 5-6 تعریف شده اند به همراه نقطه جدید بکار گرفته شده و یک مثلث دیگر نیز ترسیم شود می بینید که ما به راحتی توانستیم فقط با تعریف یک نقطه جدید یک مثلث دیگر نیز ترسیم و یک شکل هندسی دیگر را ترسیم کنیم.




ثابت GL_TRIANGLE_FAN

از این ثابت برای ترسیم مثلث های با یک مرکز مشتر استفاده می کنیم .با سه نقطه اول یک مثلث ترسیم می شود .و با تعریف نقطه بعدی یک مثلث دیگر نیز رسم می شود .
اما این همان کاری است که ثابت GL_TRIANGLE_STRIP انجام میدهد پس تفاوت این دو ثابت در چیست؟
در ثابت GL_TRIANGLE_STRIP هر دو راس بعدی با راس جدید تشکیل یک مثلث را میدهند اما در GL_TRIANGLE_FAN اولین نقطه یک راس مشترک در بین همه مثلث ها می باشد .به مثال زیر توجه کنید:

void Create_Tetrahedron(void)
{    
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
	  glBegin(GL_TRIANGLE_FAN);
	   glVertex2f(-0.0, 0.0); 
	   glVertex2f(-5.0, 0.0); 
	   glVertex2f(-5.0, 5.0); 
	   glVertex2f(0.0, 5.0); 
	   glVertex2f(5.0, 5.0); 
	  glEnd();
    glFlush();   
}

تابعی که در خط 3 استفاده کردیم رو در آینده به طور کامل توضیح خواهیم داد .این تابع را برای درک بهتر مطلب به برنامه اضافه کرده ایم.
اولین مثلث با استفاده از نقاطی که در خطوط 5-6-7 تعریف کرده ایم ایجاد می شود .سپس با استفاده از نقاط خطوط 5-7-8 مثلث دوم () و با استفاده از نقاط تعریف شده در خطوط 5-8-9 مثلث سوم () ایجاد می شود.متوجه می شوید که در همه مثلث ها خط 5 که اولین نقطه تعریف شده ما می باشد در همه مثلث ها وجود دارد فدر واقع با اینکار ما مثلث های با یک مرکز یکسان ترسیم کرده ایم .

به شکل های زیر توجه کنید:

[attachment=700] [attachment=699]

همانطور که می بینید نقاط 1 و p در همه مثلث ها مشترک می باشد.

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





ثابت GL_QUADS
این ثابت هنگامی که به عنوان آرومان تابع glbegin قرار می گیرد،باعث می شود که OpenGL با استفاده از هر چهار نقطه یک چهار ضلعی رسم کند.توجه کنید که این ثابت از هر چهار نقطه به صورت مجزا یک چهار ضلعی رسم می کند و اگر تعداد نقاط ما مضربی از 4 نباشد ممکن است باعث بروز خطا در برنامه گردد.

مثال:

void Create_Quad1(void)
{	
	  glBegin(GL_QUADS);
	   glVertex2f(2.0, 0.0); 
	   glVertex2f(2.0, 6.0); 
	   glVertex2f(6.0, 6.0); 
	   glVertex2f(6.0, 2.0); 
	  glEnd();
    glFlush();   
}

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

مثال:یک لوزی را با استفاده از ثابت GL_QOADS رسم می کنیم.

void Create_Quad1(void)
{	
	  glBegin(GL_QUADS);
	   glVertex2f(2.0, 4.0); 
	   glVertex2f(0.0, 0.0); 
	   glVertex2f(2.0, -4.0); 
	   glVertex2f(4.0, 0.0); 
	  glEnd();
    glFlush();   
}





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

void Create_Quad1(void)
{
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    glColor3f(0.0,0.0,1.0);    
	   glBegin(GL_QUAD_STRIP);    
		  glVertex2f(-12.0,-15.0);//v1
		  glVertex2f(18.0,-15.0);//v2
		  glVertex2f(-12.0,0.0);//v3
		  glVertex2f(18.0,0.0);//v4
		  glColor3f(0.0,1.0,0.0);
		  glVertex2f(-12.0,8.0);//v5
		  glVertex2f(18.0,8.0);//v6
		  glColor3f(1.0,0.0,0.0);
		  glVertex2f(-12.0,16.0);//v7
		  glVertex2f(18.0,16.0);//v8
	   glEnd(); 
}

به شکل های زیر نگاه کنید:

[attachment=711]

[attachment=712]

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

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





ثابت GL_POLYGON
از این ثابت برای رسم چند ضلعی های مختلف استفاده می کنیم .با استفاده از این ثابت ما می توانیم هر شکل هندسی را تقریباً ترسیم کنیم .اشکالی مانند مثلث ،مربع ،لوزی،ذوذنقه و ... حداقل تعداد نقاطی که هنگام استفاده از این ثابت بایستی تعریف نماییم 3 نقطه می باشد.در مثال زیر با استفاده از 3 نقطه یک مثلث را ترسیم نموده ایم.

مثال:رسم مثلث با استفاده از ثابت :GL_POLYGON

void Create_POLYGON1(void)
{
    
    glColor3f(0.0,0.0,1.0);    
	   glBegin(GL_POLYGON);
		  glVertex2f(-15.0,0.0);
		  glVertex2f(15.0,0.0);
		  glVertex2f(0.0,15);
	   glEnd(); 
}

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



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

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

برنامه زیرا اجرا کنید:

// 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)
{	
    GLdouble Array_Double[] ={8.0,-8.0};
    GLint Array_Integer[] = {8,8};
	    gluOrtho2D(-10,10,-10,10);
	   glBegin(GL_LINES);
		 glVertex2f(-8.0,8.0);//1
		 glVertex2iv(Array_Integer);//1
		 glVertex2dv(Array_Double);//2
		 glVertex2i(-8,-8);//2
	   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); 
    glPointSize(5.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    Create_Vertex();
    glFlush(); 
}
 //************* 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 
}


خروجی برنامه به شکل زیر می باشد:

[attachment=665]
اگر دقت کرده باشید برنامه با برنامه پست قبلی تفاوت چندانی نکرده و تنها تفاوت آنها در خط 17 می باشد که در آن آرگومان تابع glBegin از GL_POINTS به GL_LINES تغییر کرده است.قبل این موضوع را بیان کردیم که ما با استفاده از پارامتر تابع glBegin نوع ترسیم را در صحنه مشخص می سازیم . با استفاده از ثابت GL_LINES در واقع ما به OpenGL می گوییم که بعد از مشخص ساختن نقاط از آنها برای ترسیم خط استفاده نماید.
نکته:استفاده از ثابت GL_LINES باعث می شود که هر دونقطه پشت سر هم که تعریف کرده ایم یک خط را ایجاد کنند.یعنی برای ایجاد هر خط نیاز به یک زوج نقطه (2 بارفراخوانی یا استفاده ازتابع glVertex) دارد .در صورتی که ما تابع glVertex را به صورت فزد فراخوانی کنیم در هر صورت یکی از نقاط بلا استفاده و در صفحه دیده نخواهد شد.
void Create_Vertex(void)
{	
    GLdouble Array_Double[] ={8.0,-8.0};
    GLint Array_Integer[] = {8,8};
	    gluOrtho2D(-10,10,-10,10);
	   glBegin(GL_LINES);
		 glVertex2f(-8.0,8.0);//1
		  glVertex2iv(Array_Integer);//1
		  glVertex2dv(Array_Double);//2
		  glVertex2i(-8,-8);//2
	   glEnd();
	   glFlush();   
}

در تابع بالا خط های 7و8 خط اول و خط های 9 و 10 خط دوم را ترسیم می کنند.

تمرین :
1-دو خط را به موازات هم در صفحه نمایش رسم کنید.
2-با استفاده از مطالبی که تا کنون آموخته اید شکل زیر را رسم نمایید:

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

// 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)
{	
    gluOrtho2D(-10,10,-10,10);
	   glBegin(GL_LINE_STRIP);
		 glVertex2f(-8.0,8.0);
		 glVertex2f(8.0,8.0);
		 glVertex2f(8.0,-8.0);
		 glVertex2f(-8.0,-8.0);
	   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); 
    glPointSize(5.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    Create_Vertex();
    glFlush(); 
}
 //************* 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 
}
برنامه بالا را اجرا کنید تا نتیجه کار را مشاهده کنید.

چگونه می توان در برنامه بالا قسمتی خالی را به وسیله پاره خطی دیگه بهم متصل کرد؟

آخرین مطلب در مورد خطوط (lines) معرفی ثابت GL_LINE_LOOP می باشد .این ثابت همان کاری را می کند که ثابت GL_LINE__STRIP می کند، تنها تفاوت آنها این است که این ثابت باعث می شود اولین Vertex به آخرین Vertex متصل شود .
یکی از جوابهای سوال بالاM25


// 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)
{	
    gluOrtho2D(-10,10,-10,10);
	   glBegin(GL_LINE_LOOP);
		 glVertex2f(-8.0,8.0);
		 glVertex2f(8.0,8.0);
		 glVertex2f(8.0,-8.0);
		 glVertex2f(-8.0,-8.0);
	   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); 
    glPointSize(5.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    Create_Vertex();
    glFlush(); 
}
 //************* 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 
}





از اینجا به بعد می خواهیم در مورد polygon ها صحبت کنیم .در واقع با استفاده از Line ها ما می توانیم حالت Wire یا سیمی اشیاء رو ترسیم کنیم و برای حجم دهی به اجسام باید ابزار دیگه ایی رو به کار بگیریم .
یکی از راه ها استفاده از ثابت GL_TRIANGLES است .همانطور که میدانید این تابع به عنوان آرگومان تابع glBegin مورد استفاده قرار می گیره و باعث می شود هر سه نقطه در صفحه مختصات تشکیل یک مثلث بدهند.بدیهی است که بایستی برای ایجاد هر مثلث تعداد Vertex های ما در صحنه مضربی از 3 باشند وگرنه 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 Coordinate_Axis(void)//  Coordinate axis
{	
	GLfloat y_x,x_y ,i,j;

	for(j = 0; j < 2;j++)
	{
		if(j == 0)
		{
			y_x = 0;
			x_y = 0;
		}
		else
		{
			y_x = -10;
			x_y = -10;
		}
		for (i = 0;i < 10 ;i++)
			{
				if (i == 0 && j == 0)	
					glColor3f(1.0,0.0,0.0);
				else
					glColor3f(0.7,0.5,1.0);
				glBegin(GL_LINES);
					glVertex2f(10.0,y_x);// X-axis
					glVertex2f(-10.0,y_x);//X-axis 
					y_x++;
					glVertex2f(x_y,10.0);//Y-axis
					glVertex2f(x_y,-10.0);//Y-axis
					x_y++;
				glEnd();
			}
	}
	glFlush();   
}
void Create_Triangle(void)
{	
	   glBegin(GL_TRIANGLES);
		 glVertex2f(0.0,8.0);
		 glVertex2f(8.0,0.0);
		 glVertex2f(-8.0,0.0);
	   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); 
	gluOrtho2D(-10,10,-10,10);
    glPointSize(5.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    Create_Triangle();
	Coordinate_Axis();
    glFlush(); 
}
 //************* main **************
int WINAPI  WinMain(HINSTANCE hinstance,
	   HINSTANCE hPrevInstance,
	   LPSTR argv,
	   int argc) 
{ 
    glutInit(&argc, &argv);  // initialize the toolkit
    glutInitDisplayMode(GLUT_RGB);
    glutInitWindowSize(600,400);
    glutInitWindowPosition(150,180);
    glutCreateWindow ("khoramsoft.com"); // Create the window 
    glutDisplayFunc (Display);// Register the "display" function 
    glutMainLoop (); // Enter the OpenGL main loop 
}
 

خروجی:

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

در خط 12 تابع Coordinate_Axis را برای رسم محور مختصات تعریف کرده ایم این تابع چیز خاصی ندارد و تنها با استفاده از دو حلقه For و مطالب گذشته آن را نوشته ایم.البته حتماً تابع را مورد بررسی قرار بدهید چون نکات مفیدی در مورد تابع glColor در آن وجود دارد.

در خط 45 تابع Create_Triangle را تعریف کرده ایم و که سه نقطه را برای ترسیم آن تعریف کرده و مقدار دهی نموده ایم.و برای آرگومان glBegin از ثابت GL_TRIANGLES استفاده کرده ایم.
void Create_Triangle(void)
{
glBegin(GL_TRIANGLES);
glVertex2f(0.0,8.0);
glVertex2f(8​.0,0.0);
glVertex2f(-8.0,0.0);
glEnd();
glFlush();
}
تنها موردی که بایستی در مورد این تابع رعایت می کردیم این بود که تعداد نقاط مضربی از سه باشد چون قبلاً مطرح کردیم که ثابت GL_TRIANGLES باعث می شود OpenGL از هر سه نقطه به صورت جداگانه برای ترسیم مثلث استفاده کند.

نکته :ترتیب استفاده از نقاط به صورتی است که ما آنها را تعریف کرده ایم .

مثال:با استفاده از دو مثلث یک متوازی الاضلاع را رسم می کنیم:

// 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 Coordinate_Axis(void)//  Coordinate axis
{    
    GLfloat y_x,x_y ,i,j;

    for(j = 0; j < 2;j++)
    {
	   if(j == 0)
	   {
		  y_x = 0;
		  x_y = 0;
	   }
	   else
	   {
		  y_x = -10;
		  x_y = -10;
	   }
	   for (i = 0;i < 10 ;i++)
		  {
			 if (i == 0 && j == 0)    
				glColor3f(1.0,0.0,0.0);
			 else
				glColor3f(0.7,0.5,1.0);
			 glBegin(GL_LINES);
				glVertex2f(10.0,y_x);// X-axis
				glVertex2f(-10.0,y_x);//X-axis 
				y_x++;
				glVertex2f(x_y,10.0);//Y-axis
				glVertex2f(x_y,-10.0);//Y-axis
				x_y++;
			 glEnd();
		  }
    }
    glFlush();   
}
void Create_Triangle(void)
{    
	  glBegin(GL_TRIANGLES);
//First triangle
	    glVertex2f(0.0,0.0);
	    glVertex2f(3.0,4.0);
	    glVertex2f(6.0,0.0);
//Second triangle
	    glVertex2f(0.0,0.0);
	    glVertex2f(3.0,4.0);
	    glVertex2f(-3.0,4.0);
	  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); 
    gluOrtho2D(-10,10,-10,10);
    glPointSize(5.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    Create_Triangle();
    Coordinate_Axis();
    glFlush(); 
}
 //************* main **************
int WINAPI  WinMain(HINSTANCE hinstance,
	  HINSTANCE hPrevInstance,
	  LPSTR argv,
	  int argc) 
{ 
    glutInit(&argc, &argv);  // initialize the toolkit
    glutInitDisplayMode(GLUT_RGB);
    glutInitWindowSize(600,400);
    glutInitWindowPosition(150,180);
    glutCreateWindow ("khoramsoft.com"); // Create the window 
    glutDisplayFunc (Display);// Register the "display" function 
    glutMainLoop (); // Enter the OpenGL main loop 
}

در این مثال ما فقط سه نقطه دیگر را در تابع Create_Triangle تعریف کرده ایم
void Create_Triangle(void)
 {    
	   glBegin(GL_TRIANGLES);
 //First triangle
		glVertex2f(0.0,0.0);
		glVertex2f(3.0,4.0);
		glVertex2f(6.0,0.0);
 //Second triangle
		glVertex2f(0.0,0.0);
		glVertex2f(3.0,4.0);
		glVertex2f(-3.0,4.0);
	   glEnd();
	glFlush();   
 }
 
اگر به تعریف نقاط توجه کنید دو نقطه از نقاط مثلث دوم را برای مثلث اول نیز تعریف کرده ایم ،چون ثابت GL_TRIANGLES باعث می شود که هر 3 نقطه به صورت جداگانه برای رسم مثلث استفاده شوند مجبور هستیم نقاط را دوباره تعریف کنیم.البته در آینده بامعرفی ثابت دیگری تنها با تعریف یک نقطه دیگر می توانیم همین شکل را رسم نماییم.

تمرین :
یک هشت ضلعی همانند شکل زیر را رسم نمایید.






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

در جلسه قبل در مورد توابع glVertex صحبت کردیم و فقط از دوتابع از 24 تابع glVertex استفاده کردیم اما با استفاده از مثالی که در پست قبل زدیم، نمی توانستیم از همه توابع نام برده شده استفاده کنیم چرا؟
چون توابعی مثل glVertex2i فقط اعداد صحیح را قبول می کند و اعدادی مانند 0.1 که اعشاری هستند کاربردی در این تابع ندارند و باعث خطا در برنامه ما می شوند.و اگر از اعداد بزرگتر از 1 استفاده کنیم هیچ نقطه ایی در صفحه ایجاد نمی شد.
برای استفاده از این توابع باید چکار کنیم؟

برنامه زیر رو اجراء کنید .

// 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)
{	 
    GLdouble Array_Double[] ={8.0,-8.0};
    GLint Array_Integer[] = {8,8};
		 gluOrtho2D(-10,10,-10,10);
	    glBegin(GL_POINTS);
		   glVertex2f(-8.0,8.0);
		   glVertex2dv(Array_Double);//create point in coordinate (8.0,-8.0)
		   glVertex2i(-8,-8);
		   glVertex2iv(Array_Integer);//create point in coordinate (8.0,8.0)
	    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); 
    glPointSize(5.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    Create_Vertex();
    glFlush(); 
}
 //************* 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 
}

خروجی برنامه:

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

در این برنامه فقط یک تابع جدید اضافه شده است.تابع gluOrtho2D که برای تعریف ماتریس orthographic یا همون صفحه مختصات دو بعد مورد استفاده قرار می گیرد.(خط 16)
شکل کلی تابع به صورت زیر می باشد:

void gluOrtho2D(GLdouble  left,  GLdouble  right,  GLdouble  bottom,  GLdouble  top);

که در آن مقدار های Left,Right برای تعیین مقدار افقی و Top,Bottom برای تعیین مقدار عمودی مختصات می باشند.

در حالت پیشفرض مقدار آرگومانهای آن به صورت زیر می باشد:


void gluOrtho2D(-1.0, 1.0,  -1.0, 1.0);

با توجه به کد بالا در حالت پیشفرض مقدار آن یک ماتریس 2*2 می باشد. چرا؟

[attachment=659]
وقتی در برنامه بالا ما تعریف کردیم :

  gluOrtho2D(-10,10,-10,10);

منظورمان چیست؟

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


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


ما با اینکار یک ماتریس 20*20 را به وجود اورده ایم و می توانیم در محدوده 10.0 تا 10.0- برای متغیرهای اعشاری و در محدوده 10 تا 10- برای متغیرهای صحیح برای آرگومانهای تابع glVertex استفاده کنیم.

تابع gluOrtho یک حالت دیگر دارد ،و با توجه به اینکه فعلاً از آن استفاده نمی کنیم از توضیح آن خوداری می کنیم و در آینده در مباحث سه بعدی به تحلیل آن خواهیم پرداخت.


تمرین:

1- به جای ارگومانها تابع gluOrtho2D مقادیر زیر را وارد نمایید چه اتفاقی می افتد؟

الف:
 gluOrtho2D(0.0,10.0,0.0,10.0); 

ب:

gluOrtho2D(0.5,10.0,5.0,10.0);




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



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


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

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

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