‫را﹨﹠﹝︀ی ‪opengl‬‬

‫ﺑﻬﺎر ‪91‬‬
 ‫ﺗﻘﺪﯾﻢ ﺑﻪ ‪:‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﺑﺮاي ﺗﺤﻤﻞ آراي دﯾﮕﺮان ﺗﻤﺮﯾﻦ ﻣﯽﮐﻨﻨﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﺑﻪواﺳﻄﻪ زﺣﻤﺘﯽ ﮐﻪ ﻣﯽﮐﺸﻨﺪ ﻫﻤﯿﺸﻪ ﺧﺴﺘﻪاﻧﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﺑﺮاي ﭼﻬﻞ ﺳﺎل آﯾﻨﺪه ﺧﻮد ﺑﺮﻧﺎﻣﻪ دارﻧﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﻓﺮق ﺑﯿﻦ ﻫﺸﺖ و ﻫﺸﺖوﯾﮏ دﻗﯿﻘﻪ را ﻣﯽداﻧﻨﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ رﻧﮓﻫﺎي ﺷﺎد ﺧﻠﻘﺖ را در ﻇﺎﻫﺮ ﺧﻮد ﺳﭙﺎس ﻣﯽدارﻧﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﺑﺎ ﻣﺤﺎﺳﺒﻪ ﺣﺮوف اﺿﺎﻓﻪ ﺳﺨﻦ ﻣﯽﮔﻮﯾﻨﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﻗﺎﻋﺪهﻣﻨﺪ ﻓﮑﺮ ﻣﯽﮐﻨﻨﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﺑﺮاي ﻫﺮ ﺳﺆاﻟﯽ ﭼﻨﺪﯾﻦ ﭘﺎﺳﺦ ﻣﺘﻔﺎوت ﻗﺎﯾﻠﻨﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﻋﺼﺒﺎﻧﯿﺖ ﺧﻮد را ﺑﻪ ﺗﺄﺧﯿﺮ ﻣﯽاﻧﺪازﻧﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﺷﺄن را ﺑﺮ ﻗﺪرت ﻣﻘﺪم ﻣﯽﺷﻤﺎرﻧﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ در رﻓﺘﺎر ﻗﺎﺑﻞ ﭘﯿﺶﺑﯿﻨﯽاﻧﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﻣﻌﻨﺎي ﺗﻨﺎﺳﺐ‪ ،‬درﺻﺪ و ﮐﺎر ﺗﺪرﯾﺠﯽ را ﻣﯽداﻧﻨﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﻋﻘﻞﺷﺎن ﺑﺮ اﺣﺴﺎسﺷﺎن ﻏﻠﺒﻪ ﻣﯽﮐﻨﺪ‪.‬‬

‫داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ ﺑﺮاي ﺟﻠﺐ اﻋﺘﻤﺎد دﯾﮕﺮان ﺣﺘﯽ در ﻧﮕﺎهﮐﺮدن دﻗﺖ ﻣﯽﮐﻨﻨﺪ‪.‬‬

‫و داﻧﺸﺠﻮﯾﺎﻧﯽ ﮐﻪ دﻏﺪﻏﻪ وﻓﺎي ﺑﻪ ﻋﻬﺪ آنﻫﺎ را ﺷﺐ از ﺧﻮاب ﺑﯿﺪار ﻣﯽﮐﻨﺪ‪.‬‬

‫اﺣﻤﺪ ﭘﻮررﺿﺎ‬

‫‪2‬‬
 ‫ﻣﻘﺪﻣﻪ ‪:‬‬

‫‪ OpenGL ،‬ﻣﺨﻔﻒ ﮐﻠﻤﺎت‬ ‫اﺑﺘﺪا از ﻧﺎم ‪ OpenGL‬ﺷﺮوع ﻣﯽ ﮐﻨﯿﻢ ﮐﻪ ﻧﺸﺎن دﻫﻨﺪه ﻣﻔﻬﻮم آن ﻧﯿﺰ ﻣﯽ ﺑﺎﺷﺪ‬
‫‪ Open source Graphic Library‬ﻣﯽ ﺑﺎﺷﺪ ‪ ،‬ﺧﻮب اﺑﺘﺪا ﻣﺨﺘﺼﺮي درﺑﺎره ﻧﺮم اﻓﺰار ﻫﺎي ‪ open source‬ﯾﺎ ﻫﻤﺎن ﻣﺘﻦ‬
‫ﺑﺎز ﺗﻮﺿﯿﺢ ﻣﯽ دﻫﯿﻢ ‪:‬‬

‫ﺣﺘﻤﺎ ﺑﺎ ﻧﺮم اﻓﺰار ﻫﺎي ﻣﺘﻦ ﺑﺎز ﯾﺎ ﺑﻪ اﺻﻄﻼح اﺻﻠﯽ ‪ open source‬آﺷﻨﺎﯾﯽ دارﯾﺪ و ﻣﯽ داﻧﯿﺪ ﮐﻪ اﯾﻦ ﻧﺮم اﻓﺰار ﻫﺎ ﺑﻪ ﺻﻮرت راﯾﮕﺎن‬
‫در اﺧﺘﯿﺎر ﻋﻤﻮم ﻗﺮار ﻣﯽ ﮔﯿﺮﻧﺪ و ﺗﻬﯿﻪ ﮐﻨﻨﺪه ﮔﺎن آﻧﻬﺎ ﺳﻮرس اﺻﻠﯽ ﺑﺮﻧﺎﻣﻪ را ﺑﯿﺸﺘﺮ ﺑﻪ ﻣﻨﻈﻮر ﻋﯿﺐ ﯾﺎﺑﯽ و ﮐﺎﻫﺶ ﺧﻄﺎ ﻫﺎ و ‪ bug‬ﻫﺎي‬
‫اﺣﺘﻤﺎﻟﯽ ﺑﺮﻧﺎﻣﻪ در اﺧﺘﯿﺎر ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن ﻗﺮار ﻣﯽ دﻫﻨﺪ ﺗﺎ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن و ﻋﻼﻗﻤﻨﺪان ﺑﺘﻮاﻧﻨﺪ ﺑﻪ راﺣﺘﯽ ﮐﺪ آن ﺑﺮﻧﺎﻣﻪ را وﯾﺮاﯾﺶ ﮐﺮده و‬
‫ﺗﻐﯿﯿﺮات دﻟﺨﻮاه را روي آن اﻧﺠﺎم دﻫﻨﺪ ) ﯾﮑﯽ از ﻣﻌﺮوﻓﺘﺮﯾﻦ ﺑﺮﻧﺎﻣﻪ ﻫﺎي ‪ open surce‬ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﻟﯿﻨﻮﮐﺲ اﺳﺖ و اﻟﺒﺘﻪ ﭘﯿﺸﺮﻓﺖ‬
‫ﻫﺎ و ﻣﻮﻓﻘﯿﺖ ﻫﺎي ﺟﺪﯾﺪ آن را ‪ ،‬ﮐﻪ ﻣﻬﻤﺘﺮﯾﻦ ﻋﺎﻣﻞ اﯾﻦ ﭘﯿﺸﺮﻓﺖ ﻫﺎ ﻫﻤﯿﻦ ﻣﺘﻦ ﺑﺎز ﺑﻮدن ﻟﯿﻨﻮﮐﺲ ﺑﻮده و اﺳﺖ ( ‪.‬‬

‫‪ opengl‬ﻫﻢ ﻫﻤﺎﻧﻄﻮر ﮐﻪ از ﻧﺎم آن ﻣﺸﺨﺺ اﺳﺖ ﺟﺰء ﻧﺮم اﻓﺰار ﻣﺘﻦ ﺑﺎز ﺑﻪ ﺷﻤﺎر ﻣﯽ رود ﮐﻪ ﯾﮏ از ﻣﺰﯾﺖ ﻫﺎ و اﻣﺘﯿﺎزات آن ﻧﯿﺰ ﺑﻪ‬
‫ﺷﻤﺎر ﻣﯽ رود ‪ ،‬ﺣﺎل ﻧﻮﺑﺖ ﺑﻪ ‪ graphic library‬ﻣﯽ رﺳﺪ ‪:‬‬

‫‪ graphic library‬ﯾﺎ ﻫﻤﺎن ﮐﺘﺎﺑﺨﺎﻧﻪ ﮔﺮاﻓﯿﮑﯽ ﺑﻪ ﻣﺠﻤﻮﻋﻪ ﮐﺘﺎﺑﺨﺎﻧﻪ ﻫﺎ ﯾﺎ ﮐﺎﻣﭙﻮﻧﻨﺖ ﻫﺎي ﮔﻔﺘﻪ ﻣﯽ ﺷﻮد ﮐﻪ ﺑﺮاي اﺳﺘﻔﺎده از‬
‫دﺳﺘﻮرات ﻣﺨﺼﻮص ﮔﺮاﻓﯿﮑﯽ ﺗﻬﯿﻪ ﺷﺪه اﺳﺖ و ﺑﺎ اﻟﺼﺎق ) ‪ ( include‬آن ﻫﺎ ﺑﻪ ﺑﺮﻧﺎﻣﻪ اﺻﻠﯽ ) ﻫﻨﮕﺎم ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ( ﻣﯽ ﺗﻮاﻧﯿﻢ ‪ ،‬از‬
‫دﺳﺘﻮرات ﮔﺮاﻓﯿﮑﯽ ﻣﺠﺎز ﺑﺮاي اﯾﺠﺎد راﺑﻄﻪ ﺑﺎ ﺑﺨﺶ ﮔﺮاﻓﯿﮏ ﺳﯿﺴﺘﻢ اﺳﺘﻔﺎده ﻧﻤﺎﯾﯿﻢ ) از ﺟﻤﻠﻪ ﮐﺎر ﻫﺎﯾﯽ ﮐﻪ ﺑﺎ ﮔﺮاﻓﯿﮏ ﺳﯿﺴﺘﻢ ﺳﺮ و ﮐﺎر‬
‫دارد ﻧﻮﺷﺘﻦ ﺑﺎزي ﻫﺎ و اﺷﮑﺎل ﺳﻪ ﺑﻌﺪي و دو ﺑﻌﺪي و ﮐﻼ ﺑﺮﻧﺎﻣﻪ ﻫﺎﯾﯽ ﮐﻪ ﺑﺎ ﻣﺎﻧﯿﺘﻮر در ارﺗﺒﺎط ﺑﺎﺷﻨﺪ (‪.‬‬

‫ﮐﺘﺎﺑﺨﺎﻧﻪ ﻫﺎ ﯾﺎ ﻫﻤﺎن ﻓﺎﯾﻞ ﻫﺎي ﺑﺎ ﭘﺴﻮﻧﺪ ‪ lib‬ﮐﻪ ﻣﺨﻔﻒ ﺷﺪه ‪ library‬ﻣﯽ ﺑﺎﺷﺪ ‪ ،‬ﺑﻪ ﻣﻨﻈﻮر آﺳﺎن ﺗﺮ ﺷﺪن ﮐﺎر ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن در‬
‫ﻣﻮﻗﻊ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ اﯾﺠﺎد و ﺗﻬﯿﻪ ﻣﯽ ﺷﻮﻧﺪ ‪ ،‬ﺑﻪ اﯾﻦ ﺻﻮرت ﮐﻪ ﻣﺜﻼ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ داﺧﻞ ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﺧﻮد از ﺗﺎﺑﻊ ﺧﺎﺻﯽ ﭼﻨﺪﯾﻦ ﺑﺎر )‬
‫ﺷﺎﯾﺪ ﻫﻢ ﺻﺪ ﻫﺎ و ﻫﺰاران ﺑﺎر ( ﺑﻪ ﺻﻮرت ﻣﺘﻮاﻟﯽ اﺳﺘﻔﺎده ﻣﯽ ﮐﻨﺪ ‪ ،‬ﺧﻮب ﻧﻮﺷﺘﻦ اﯾﻦ ﺗﺎﺑﻊ ﺧﺎص ﺑﻪ اﯾﻦ ﺗﻌﺪاد در ﮐﺪ اﺻﻠﯽ ﺑﺮﻧﺎﻣﻪ ﺣﺠﻢ‬
‫ﻓﺎﯾﻞ ﻧﻬﺎﯾﯽ را ﺑﺎﻻ ﺑﺮده و اﻟﺒﺘﻪ وﻗﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ را ﻫﻢ ﺧﻮاﻫﺪ ﮔﺮﻓﺖ ‪ ،‬اﯾﻨﺠﺎﺳﺖ ﮐﻪ ﮐﺘﺎﺑﺨﺎﻧﻪ ﻫﺎ ﯾﺎ ‪ lib‬ﻫﺎ وارد ﻋﻤﻞ ﻣﯽ ﺷﻮﻧﺪ و ﺗﺎﺑﻊ‬
‫ﺧﺎص را داﺧﻞ ﺧﻮد ﻗﺮار ﻣﯽ دﻫﻨﺪ ﺗﺎ ﻣﻮﻗﻊ ﻧﯿﺎز ﺑﻪ ﺗﺎﺑﻊ از آن اﺳﺘﻔﺎده ﺷﻮد ‪.‬‬

‫اﯾﻦ ﻫﻢ از ﻣﻔﻬﻮم ‪ ، graphic library‬ﺣﺎل ﺷﻤﺎ ﺑﺎ ﻣﻔﻬﻮم اﺳﻢ ‪ OpenGL‬ﯾﺎ ﻫﻤﺎن ‪Open source Graphic‬‬
‫‪ Library‬آﺷﻨﺎﯾﯽ ﮐﺎﻣﻞ را دارﯾﺪ ‪.‬‬

‫ﭘﺲ در اﯾﻨﺠﺎ ﻧﺘﯿﺠﻪ ﻣﯽ ﮔﯿﺮﯾﻢ ﮐﻪ ‪ OpenGL‬ﯾﮏ زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻧﯿﺴﺖ ‪ ،‬ﯾﮏ ﺳﺮي ﮐﺘﺎﺑﺨﺎﻧﻪ از ﭘﯿﺶ ﺗﻌﺮﯾﻒ ﺷﺪه ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ‬
‫ﮐﺎر اﯾﻦ ﮐﺘﺎﺑﺨﺎﻧﻪ ارﺗﺒﺎط راﺣﺖ ﺗﺮ ﺑﺎ ﺑﺨﺶ ﺳﺨﺖ اﻓﺰاري ﮔﺮاﻓﯿﮏ ﺳﯿﺴﺘﻢ ﻣﯽ ﺑﺎﺷﺪ ‪ ،‬ﺑﺮاي درك ﺑﯿﺸﺘﺮ اﯾﻦ ﻣﻄﻠﺐ ﺑﺎﯾﺪ ﺗﻮﺿﯿﺤﯽ ﻫﻢ‬
‫درﺑﺎره راﺑﻂ ﻫﺎي ﻧﺮم اﻓﺰاري ﯾﺎ ﻫﻤﺎن ‪ API‬ﻫﺎ ﺑﺪﻫﯿﻢ ‪:‬‬

‫ﺑﺮاي اﯾﻨﮑﻪ ﺑﺘﻮاﻧﯿﻢ ﺑﺎ ﺳﺨﺖ اﻓﺰار ﻫﺎي ﻣﻮﺟﻮد در ﺳﯿﺴﺘﻢ ﺧﻮد ﻣﺜﻞ ﮐﺎرت ﺷﺒﮑﻪ ‪ ،‬ﮐﺎرت ﮔﺮاﻓﯿﮏ ‪ ... ،‬ﺑﻪ ﺻﻮرت درﺳﺖ و ﺻﺤﯿﺢ ارﺗﺒﺎط‬
‫ﺑﺮﻗﺮار ﮐﻨﯿﻢ ) ﺑﻪ زﺑﺎن ﺧﻮد ﻣﺎﺷﯿﻦ ( اﺣﺘﯿﺎج ﺑﻪ راﺑﻂ ﻫﺎﯾﯽ دارﯾﻢ ﮐﻪ ﺑﺘﻮاﻧﻨﺪ اﯾﻦ ﮐﺎر را ﺑﻪ درﺳﺘﯽ اﻧﺠﺎم دﻫﻨﺪ ‪ ،‬ﻓﺮض ﮐﻨﯿﺪ ﯾﮏ ﻓﺎرﺳﯽ‬
‫زﺑﺎن ) ﮐﻪ زﺑﺎن دﯾﮕﺮي ﻫﻢ ﻧﻤﯽ داﻧﺪ ( ﺑﺎ ﯾﮏ اﻧﮕﻠﯿﺴﯽ زﺑﺎن ) ﮐﻪ او ﻫﻢ زﺑﺎن ﻓﺎرﺳﯽ را ﻧﻤﯽ داﻧﺪ ( ﺑﺮﺧﻮرد ﻣﯽ ﮐﻨﻨﺪ و ﻣﯽ ﺧﻮاﻫﻨﺪ ﺑﺎ ﻫﻢ‬
‫ﺻﺤﺒﺖ ﮐﻨﻨﺪ ‪ ،‬ﺑﻪ ﻧﻈﺮ ﺷﻤﺎ ﭼﺎره ﮐﺎر ﭼﯿﺴﺖ ؟ ﺧﻮب اوﻟﯿﻦ و ﺗﻨﻬﺎ ﮔﺰﯾﻨﻪ ﯾﮏ ﻣﺘﺮﺟﻢ ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ ﻫﻢ زﺑﺎن ﻓﺎرﺳﯽ ﺑﺪاﻧﺪ و ﻫﻢ زﺑﺎن‬

‫‪3‬‬
‫اﻧﮕﻠﯿﺴﯽ ‪ ،‬ﺣﺎل آن دو ﺑﻪ راﺣﺘﯽ ﻣﯽ ﺗﻮاﻧﻨﺪ ﺑﺎ ﻫﻢ ﻣﮑﺎﺗﺒﻪ داﺷﺘﻪ ﺑﺎﺷﻨﺪ ‪ .‬در ﻣﻮرد ﮐﺎﻣﭙﯿﻮﺗﺮ ﻫﻢ دﻗﯿﻘﺎ ﺑﻪ ﻫﻤﯿﻦ ﺻﻮرت اﺳﺖ ‪ ،‬ﻧﺮم اﻓﺰار و‬
‫ﺳﺨﺖ اﻓﺰار ﮐﺎﻣﭙﯿﻮﺗﺮ زﺑﺎن ﻫﻢ دﯾﮕﺮ را ﻧﻤﯽ داﻧﻨﺪ و اﺣﺘﯿﺎج ﺑﻪ ﯾﮏ ﺳﺮي ﻣﺘﺮﺟﻢ ﻫﺎﯾﯽ ﺑﻪ ﻧﺎم ‪ API‬دارﻧﺪ ‪.‬‬

‫‪ API‬ﻫﺎ راﺑﻂ ﻫﺎي ﻧﺮم اﻓﺰاري ﻫﺴﺘﻨﺪ ﮐﻪ زﺑﺎن ﺳﯿﺴﺘﻢ ) زﺑﺎن ﻣﺎﺷﯿﻦ ( و ﭼﮕﻮﻧﮕﯽ ارﺗﺒﺎط ﺑﺎ ﺳﺨﺖ اﻓﺰار را ﻣﯽ داﻧﻨﺪ ‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‬
‫ﻣﻦ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ اﮔﺮ ﺑﺨﻮاﻫﻢ ﯾﮏ ﭘﯿﮑﺴﻞ از ﻣﺎﻧﯿﺘﻮر را روﺷﻦ ﮐﻨﻢ ﺑﻪ ‪ API‬ﻣﺮﺑﻮﻃﻪ ﻓﺮﻣﺎن ﻣﯽ دﻫﻢ ﮐﻪ اﯾﻦ ﮐﺎر را ) ﺑﺎ زﺑﺎﻧﯽ ﮐﻪ ﺑﻠﺪ‬
‫ﻫﺴﺘﯽ ( ﺑﺮاي ﻣﻦ اﻧﺠﺎم ﺑﺪه و ﻣﺴﺘﻘﯿﻢ ﺑﺎ ﺳﺨﺖ اﻓﺰار ﺻﺤﺒﺖ ﻧﺨﻮاﻫﻢ ﮐﺮد ‪ API ،‬ﻣﺮﺑﻮﻃﻪ دﺳﺘﻮر را ﮔﺮﻓﺘﻪ و ﺑﻪ ﺳﺨﺖ اﻓﺰار ﻣﯽ رﺳﺎﻧﺪ‬
‫‪ ،‬ﺑﻪ ﻫﻤﯿﻦ راﺣﺘﯽ ‪...‬‬

‫‪ API‬ﻫﺎي ﻣﺨﺘﻠﻔﯽ ﺑﺮاي ﺑﺨﺶ ﻫﺎي ﻣﺨﺘﻠﻒ ﺳﺨﺖ اﻓﺰار وﺟﻮد دارد ‪ ،‬اﻣﺎ در اﯾﻨﺠﺎ و اﯾﻦ ﻣﻘﺎﻟﻪ ‪ API‬ﻫﺎي ﮔﺮاﻓﯿﮑﯽ ﻣﺪ ﻧﻈﺮ ﻣﺎ ﻣﯽ‬
‫ﺑﺎﺷﺪ ‪ ،‬ﮐﻪ ﻣﻌﺮوﻓﺘﺮﯾﻦ آﻧﻬﺎ ‪ OpenGl‬و ‪ DirectX‬ﻣﯽ ﺑﺎﺷﻨﺪ ‪.‬‬

‫اﻟﺒﺘﻪ ﺳﺨﺖ اﻓﺰار ﻫﺎي ﻣﻮﺟﻮد ﻧﯿﺰ ﺑﺎﯾﺪ از ‪ API‬ﻫﺎ ﭘﺸﺘﯿﺒﺎﻧﯽ ﮐﻨﻨﺪ ‪ ،‬ﮐﻪ ﺑﻌﻀﯽ ﺷﺮﮐﺖ ﻫﺎي ﺳﺎزﻧﺪه ﺳﺨﺖ اﻓﺰار و ﮐﺎرت ﻫﺎي ﮔﺮاﻓﯿﮑﯽ از‬
‫‪ API‬ﻫﺎي ‪ OpenGL‬ﭘﺸﺘﯿﺒﺎﻧﯽ و ﻫﻤﺎﯾﺖ ﻣﯽ ﮐﻨﻨﺪ و ﺑﻌﻀﯽ ﻫﻢ از ‪ DirectX‬ﮐﻪ ﻣﺤﺼﻮل ﺷﺮﮐﺖ ﻣﺎﮐﺮوﺳﺎﻓﺖ اﺳﺖ ‪ .‬ﻫﺮ ﯾﮏ از‬
‫اﯾﻦ واﺳﻂ ﻫﺎي ﻧﺮم اﻓﺰاري ‪ OpenGl‬و ‪ DirectX‬ﻣﻌﺎﯾﺐ و ﻣﺰاﯾﺎي ﺧﻮاص ﺧﻮد را دارﻧﺪ ﮐﻪ در اﯾﻨﺠﺎ ﻗﺼﺪ ﻣﻘﺎﯾﺴﻪ اﯾﻦ دو را ﻧﺪارم ‪.‬‬

‫ﺗﺎرﯾﺨﭽﻪ و ﻧﺤﻮه ﺗﮑﺎﻣﻞ ‪: OpenGl‬‬

‫ﺳﺎزﻧﺪه ‪ OpenGL‬ﯾﺎ ﺑﻬﺘﺮ ﺑﮕﻮﯾﯿﻢ ﺗﻮﺳﻌﻪ دﻫﻨﺪه و ﺑﻬﯿﻨﻪ ﮐﻨﻨﺪه آن ﺷﺮﮐﺖ ‪ Silicon Graphics‬ﻣﯽ ﺑﺎﺷﺪ ) ﮐﻪ ﺑﻪ اﺧﺘﺼﺎر ‪SGI‬‬
‫ﻧﯿﺰ ﻧﺎﻣﯿﺪه ﻣﯽ ﺷﻮد و ﯾﮑﯽ از ﺑﺰرﮔﺎن ﺻﻨﻌﺖ ﮔﺮاﻓﯿﮏ ﮐﺎﻣﭙﯿﻮﺗﺮي ﻣﯽ ﺑﺎﺷﺪ ( ‪ ،‬ﺧﻮد ‪ OpenGL‬ﺗﻮﺳﻌﻪ ﯾﺎﻓﺘﻪ ﮐﺘﺎﺑﺨﺎﻧﻪ دوﺑﻌﺪي ‪IRIS‬‬
‫‪ GL‬ﮐﻪ آن ﻫﻢ ﻣﺤﺼﻮل ﺷﺮﮐﺖ ‪ SGL‬ﺑﻮد ‪ ،‬ﻣﯽ ﺑﺎﺷﺪ ‪ .‬ﺷﺮﮐﺖ ﻫﺎي دﯾﮕﺮي ﻧﯿﺰ ﺑﻪ ﺗﻮﺳﻌﻪ اﯾﻦ ﻣﺤﺼﻮل ﻣﺘﻦ ﺑﺎز ﮐﻤﮏ ﮐﺮده اﻧﺪ از‬
‫ﺟﻤﻠﻪ ﺷﺮﮐﺖ ‪ D Labs3‬ﮐﻪ ﺗﮑﻨﯿﮏ و ﻗﺎﺑﻠﯿﺖ ﺳﺎﯾﻪ زﻧﯽ را ﺑﻪ ‪ OpenGL‬اﺿﺎﻓﻪ ﻧﻤﻮد ‪ .‬در ﺳﺎﻟﻬﺎي اﺧﯿﺮ ﮐﺘﺎﺑﺨﺎﻧﻪ ﻫﺎي‬
‫‪ OpenAL‬و ‪ OpenIL‬ﻧﯿﺰ ﺑﻪ ﻣﻮازات ‪ OpenGL‬در ﺣﺎل ﭘﯿﺸﺮوي و ﮐﺴﺘﺮش ﻫﺴﺘﻨﺪ ﮐﻪ اوﻟﯽ ﺑﺮاي ﮐﻨﺘﺮل و ﻣﺪﯾﺮﯾﺖ ﺳﺨﺖ‬
‫اﻓﺰار ﻫﺎي ﺻﻮﺗﯽ )‪ (Audio‬و اﯾﺠﺎد ﺻﺪا ﻫﺎي ﺳﻪ ﺑﻌﺪي و دوﻣﯽ ﺑﺮاي ﻣﺪﯾﺮﯾﺖ و ﮐﻨﺘﺮل دﺳﺘﮕﺎه ﻫﺎي ورودي ) ‪ ( Input‬ﻫﺎ اﯾﺠﺎد‬
‫ﺷﺪه اﻧﺪ ‪.‬‬

‫رﻗﯿﺐ اﺻﻠﯽ ‪ OpenGL‬ﻫﻤﺎن ‪ DirectX‬ﻣﺤﺼﻮل ﺷﺮﮐﺖ ‪ Microsoft‬ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ در ﺳﺎل ‪ 1995‬وارد ﻋﺮﺻﻪ رﻗﺎﺑﺖ ‪API‬‬
‫ﻫﺎ ﺷﺪ ‪ ،‬در اواﯾﻞ رﻗﺎﺑﺖ ﺑﯿﻦ اﯾﻦ دو اﭘﻦ ﺟﯽ ال ﮐﺎﻣﻼ ﯾﮏ ﺳﺮ و ﮔﺮدن از ﺣﺮﯾﻒ ﺧﻮد ﺟﻠﻮ ﺑﻮد ‪ ،‬اﻣﺎ ﮐﺎر ﺑﻪ ﻫﻤﯿﻦ روال ﭘﯿﺶ ﻧﺮﻓﺖ و‬
‫ﺷﺮك ﻣﺎﮐﺮوﺳﺎﻓﺖ ﯾﺎ اﺳﺘﻔﺎده از ﻗﺪرت ﺗﺠﺎري ﺧﻮد ﺗﻮاﻧﺴﺖ از رﻗﯿﺐ ﺧﻮد ﺟﻠﻮ ﺑﺰﻧﺪ ‪ ،‬اﻟﺒﺘﻪ ﻣﺘﻦ ﺑﺎز ﺑﻮدن ‪ OpenGL‬ﻫﻢ ﺑﯽ ﺗﻘﺼﯿﺮ ﻧﺒﻮد‬
‫ﺑﻪ ﮔﻮﻧﻪ اي ﮐﻪ ﻣﺎﮐﺮوﺳﺎﻓﺖ از اﯾﻦ وﯾﮋﮔﯽ اﺳﺘﻔﺎده ﻣﯽ ﮐﺮد و ﻣﺤﺼﻮﻻت ﺧﻮد را ﺗﻘﺮﯾﺒﺎ ﻣﺸﺎﺑﻪ ﺑﺎ ﻣﺤﺼﻮﻻت ‪ OpenGL‬اراﺋﻪ ﻣﯽ داد ﺗﺎ‬
‫اﯾﻨﮑﻪ در ﺗﺎرﯾﺦ ‪ 2000‬ﻣﯿﻼدي ‪ DirectX 8‬ﻣﻨﺘﺸﺮ ﺷﺪ ﮐﻪ اﻣﮑﺎﻧﺎت ﺑﯿﺸﺘﺮ و ﺑﻬﺘﺮي ﻧﺴﺒﺖ ﺑﻪ ‪ OpenGL‬داﺷﺖ ‪ ،‬در اﯾﻦ ﺑﺮﻫﻪ‬
‫زﻣﺎﻧﯽ ﺑﻮد ﮐﻪ ‪ OpenGL‬از رﻗﯿﺐ ﺧﻮد ﻋﻘﺐ اﻓﺘﺎد وﻟﯽ ﻫﻤﭽﻨﺎن رﻗﺎﺑﺖ ﺑﯿﻦ اﯾﻦ دو اداﻣﻪ دارد ‪.‬‬

‫‪4‬‬
 ‫‪1‬‬
‫اﻧﻮاع ﮔﺮاﻓﯿﮏ راﯾﺎﻧﻪ اي ‪:‬‬

‫دو ﻧﻮع ﮔﺮاﻓﯿﮏ راﯾﺎﻧﻪ اي وﺟﻮد دارد‪ :‬ﻧﻮع اول ﮔﺮاﻓﯿﮏ رﺳﺘﺮي)‪ (Raster‬ﮐﻪ ﺑﻪ ﮔﺮاﻓﯿﮏ ‪ Bitmap‬ﻧﯿﺰ ﺷﻬﺮت دارد‪ .‬ﮔﺎﻫﯽ ﻧﯿﺰ ﺑﻪ‬
‫ﮔﺮاﻓﯿﮏ رﺳﺘﺮي ﮔﺮاﻓﯿﮏ ﭘﯿﮑﺴﻠﯽ ﻫﻢ ﻣﯽ ﮔﻮﯾﻨﺪ‪ .‬ﻧﻮع دوم آن ﮔﺮاﻓﯿﮏ وﮐﺘﻮر)‪ (Vector‬ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ ﺑﻪ ﻧﻮع ”ﺑﺮداري“ ﻧﯿﺰ ﺷﻬﺮت دارد‪.‬‬

‫ﮔﺮاﻓﯿﮏ ﭘﯿﮑﺴﻠﯽ ﯾﺎ رﺳﺘﺮي ‪:‬‬

‫اﯾﻦ ﻧﻮع ﮔﺮاﻓﯿﮏ ﺗﺸﮑﯿﻞ ﺷﺪه اﺳﺖ از ﺧﺎﻧﻪ ﻫﺎي ﭘﯿﮑﺴﻠﯽ ﮐﻪ داراي درﺟﻪ ﻣﺸﺨﺼﯽ از ﯾﮏ رﻧﮓ ﻣﯽ ﺑﺎﺷﻨﺪ و وﻗﺘﯽ اﯾﻦ ﭘﯿﮑﺴﻞ ﻫﺎ در‬
‫ﮐﻨﺎر ﯾﮑﺪﯾﮕﺮ ﺑﺎ درﺟﻪ رﻧﮕﻬﺎﯾﯽ ﻣﺨﺘﻠﻒ از ﻫﻢ‪ ،‬ﻗﺮار ﻣﯽ ﮔﯿﺮﻧﺪ‪ ،‬ﺗﺼﺎوﯾﺮ را ﺗﺸﮑﯿﻞ ﻣﯽ دﻫﻨﺪ‪ .‬در ﮔﺮاﻓﯿﮏ ﭘﯿﮑﺴﻠﯽ ﺑﻪ دﻟﯿﻞ اﯾﻨﮑﻪ ﺷﻤﺎ ﺑﺎ‬
‫رﻧﮓ ﭘﯿﮑﺴﻞ ﻫﺎ ﺳﺮو ﮐﺎر دارﯾﺪ‪ ،‬ﻗﺎدر ﺑﻪ وﯾﺮاﯾﺶ‪ ،‬ﺣﺬف ﯾﺎ اﯾﺠﺎد ﺗﺼﻮﯾﺮ ﯾﺎ ﻋﮑﺲ ﻧﯿﺴﺘﯿﺪ‪ .‬ﺗﻨﻬﺎ ﻣﯽ ﺗﻮاﻧﯿﺪ ﻋﮑﺲ ﯾﺎ ﺗﺼﺎوﯾﺮ دﯾﺠﯿﺘﺎل را‬
‫ﺗﻮﺳﻂ دﺳﺘﺮﺳﯽ ﺑﻪ ﭘﯿﺴﻠﻬﺎي رﻧﮕﯽ آن‪ ،‬وﯾﺮاﯾﺶ ﻧﻤﺎﯾﯿﺪ‪ .‬آﻧﭽﻪ در ﮔﺮاﻓﯿﮏ رﺳﺘﺮي اﻫﻤﯿﺖ دارد‪ ،‬ﺗﻌﺪاد ﭘﯿﮑﺴﻞ ﻫﺎي رﻧﮕﯽ در اﯾﻨﭻ ﻣﯽ‬
‫ﺑﺎﺷﺪ‪ ،‬زﯾﺮا اﯾﻦ ﺗﻌﺪاد‪ ،‬ﮐﯿﻔﯿﺖ رﻧﮕﯽ و وﺿﻮع ﺗﺼﻮﯾﺮي ﻋﮑﺲ دﯾﺠﯿﺘﺎل را ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ‪ .‬ﺑﻪ ﺗﻌﺪاد ﭘﯿﮑﺴﻞ ﻫﺎي رﻧﮕﯽ در اﯾﻨﭻ‪،‬‬
‫رزوﻟﻮﺷﻦ ﻣﯽ ﮔﻮﯾﻨﺪ‪ .‬و ﻣﻘﺪار رزوﻟﻮﺷﻦ‪ ،‬ﻫﻤﺎن ﻣﻘﺪار ﭘﯿﮑﺴﻞ ﻫﺎ را در واﺣﺪ اﯾﻨﭻ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ﮐﻪ اﺻﻄﻼﺣﺎ ﺑﻪ آن واﺣﺪ ‪ dpi‬ﻣﯽ‬
‫ﮔﻮﯾﻨﺪ )ﯾﻌﻨﯽ ‪ Dot Per Inch‬ﯾﺎ ﺗﻌﺪاد ﻧﻘﺎط در اﯾﻨﭻ(‪.‬ﻫﻤﯿﻦ واﺣﺪ ‪ dpi‬اﺳﺖ ﮐﻪ ﺑﺎﻋﺚ ﻣﯽ ﺷﻮد وﻗﺘﯽ ﺷﻤﺎ ﯾﮏ ﺗﺼﻮﯾﺮ رﺳﺘﺮي را ﺑﺰرگ‬
‫ﻧﻤﺎﯾﯽ ﻣﯽ ﮐﻨﯿﺪ‪ ،‬ﮐﯿﻔﯿﺖ ﺗﺼﻮﯾﺮ ﭘﺎﯾﯿﻦ ﺗﺮ ﻣﯽ آﯾﺪ‪ .‬زﯾﺮا ﻫﺮﭼﻪ ﻫﻢ ﮐﻪ آﻧﺮا ﺑﺰرگ ﺗﺮ ﮐﻨﯿﺪ ﻧﻤﯽ ﺗﻮاﻧﯿﺪ رزوﻟﻮﺷﻦ ﯾﺎ ﺗﻌﺪاد ﭘﯿﮑﺴﻞ ﻫﺎي آن را‬
‫در واﺣﺪ اﯾﻨﭻ اﻓﺰاﯾﺶ دﻫﯿﺪ‪ .‬ﮐﯿﻔﯿﺖ اﯾﻦ ﺗﺼﺎوﯾﺮ ﺑﺎ ﺳﺎﯾﺰ ارﺗﺒﺎط ﻣﺴﺘﻘﯿﻢ دارد‪.‬‬

‫ﮔﺮاﻓﯿﮏ وﮐﺘﻮر ﯾﺎ ﺑﺮداري ‪:‬‬

‫اﯾﻦ ﻧﻮع ﮔﺮاﻓﯿﮏ‪ ،‬ﮔﺮاﻓﯿﮑﯽ راﯾﺎﻧﻪ اي اﺳﺖ ﮐﻪ ﺑﺎ ﻓﺮﻣﻮﻟﻬﺎي رﯾﺎﺿﯽ ﺳﺮ و ﮐﺎر دارد‪ .‬از ﺧﻂ ﻫﺎ‪ ،‬ﻣﻨﺤﻨﯽ ﻫﺎ و اﺷﮑﺎﻟﯽ ﮐﻪ داراي ﺑﻌﺪ و‬
‫ﻣﺨﺘﺼﺎت رﯾﺎﺿﯽ ﻣﯽ ﺑﺎﺷﻨﺪ و ﻣﮑﺎن آﻧﻬﺎ ﺑﺎ ‪ x‬و ‪ y‬ﺗﻌﺮﯾﻒ ﻣﯽ ﮔﺮدد‪ .‬داراي ﻃﻮل و ﻋﺮض رﯾﺎﺿﯽ ﻣﯽ ﺑﺎﺷﻨﺪ و رزوﻟﻮﺷﻦ آﻧﻬﺎ ﺑﺎ ﺗﻐﯿﯿﺮ‬
‫ﺳﺎﯾﺰ‪ ،‬ﺗﻐﯿﯿﺮ ﻧﻤﯽ ﯾﺎﺑﺪ‪ .‬ﺑﻨﺎﺑﺮاﯾﻦ ﮐﯿﻔﯿﺖ ﺗﺼﺎوﯾﺮ در ﻫﺮ ﺳﺎﯾﺰي ﯾﮑﺴﺎن ﻣﯽ ﻣﺎﻧﺪ و اﯾﻦ ﮐﺎر از ﻃﺮﯾﻖ ﻣﺤﺎﺳﺒﺎت رﯾﺎﺿﯽ اﻧﺠﺎم ﻣﯽ ﺷﻮد‪.‬اﯾﻦ‬
‫ﮔﺮاﻓﯿﮏ ﯾﮑﯽ از ﺑﻬﺘﺮﯾﻦ و ﭘﺮﮐﺎرﺑﺮدﺗﺮﯾﻦ اﻧﻮاع ﮔﺮاﻓﯿﮏ راﯾﺎﻧﻪ اﺳﺖ‪ ،‬ﺑﺮاي ﮐﺎر ﺗﺼﻮﯾﺮ ﺳﺎزي اﺳﺘﻔﺎده ﻣﯽ ﺷﻮد و ﻃﺮاﺣﯽ آرم ﻫﺎ و ﮔﺎﻫﯽ‬
‫ﺗﺼﻮﯾﺮ ﺳﺎزي ﮐﺘﺎب ﻫﺎي ﮐﻮدك و … ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﻫﺎي وﮐﺘﻮري اﻧﺠﺎم ﻣﯽ ﺷﻮد‬

‫در ﺗﺼﻮﯾﺮ زﯾﺮ ﺑﻪ ﺻﺮاﺣﺖ ﻣﯿﺘﻮاﻧﯿﺪ ﺗﻔﺎوت ﻣﺎﺑﯿﻦ اﯾﻦ دو ﻧﻮع ﮔﺮاﻓﯿﮏ را ﻣﺸﺎﻫﺪه ﻓﺮﻣﺎﺋﯿﺪ ‪:‬‬

‫‪1‬‬
‫‪http://www.howtogeek.com/howto/32597/whats-the-difference-between-pixels-and-vectors/‬‬

‫‪5‬‬
 ‫ﻗﻮاﻧﯿﻦ ﻧﻮﺷﺘﺎري در ‪: opengl‬‬

‫· دﺳﺘﻮرات ‪ opengl‬ﺑﺎ ﭘﯿﺸﻮﻧﺪ ‪ gl‬ﺷﺮوع ﻣﯿﺸﻮد و ﺑﺎ ﯾﮏ ﺣﺮف ﺑﺰرگ اداﻣﻪ ﻣﯽ ﯾﺎﺑﻨﺪ ﻣﺎﻧﻨﺪ دﺳﺘﻮرﻫﺎي‬
‫)(‪ glBegin‬و ﯾﺎ ) (‪glutDisplayFunc‬‬
‫‪GL_COLOR_BUFFER_BIT‬‬ ‫· ﺛﻮاﺑﺖ ﺑﺎ ﭘﯿﺸﻮﻧﺪ _‪ GL‬ﺷﺮوع ﻣﯿﺸﻮد و ﺗﻤﺎم ﺣﺮوف ﺑﻌﺪ از آن ﺣﺮوف ﺑﺰرگ اﺳﺖ ﻣﺎﻧﻨﺪ‪:‬‬
‫· ﺑﻌﻀﯽ از دﺳﺘﻮرات ﻧﯿﺰ ﺑﺎ ﯾﮏ ﻋﺪد وﭼﻨﺪﯾﻦ ﺣﺮف در اﻧﺘﻬﺎ ﺑﺮاي ﯾﺎدآوري ﺗﻌﺪاد و ﻧﻮع آرﮔﻮﻣﺎﻧﻬﺎي ورودي‪,‬ﺧﺎﺗﻤﻪ‬
‫ﻣﯽ ﯾﺎﺑﻨﺪ ‪ .‬ﺑﺮاي ﻣﺜﺎل در دﺳﺘﻮر )(‪ ‘3’ glVertex3fv‬ﺑﻪ ﻣﻌﻨﺎي وﺟﻮد ‪ 3‬آرﮔﻮﻣﺎن ورودي و ’‪ ‘f‬ﺑﻪ ﻣﻌﻨﺎي‬
‫اﻋﺸﺎري ﺑﻮدن ورودي ﻫﺎ و ’‪ ‘v‬ﺑﻪ ﻣﻌﻨﺎي ﺑﺮداري‪ 2‬ﺑﻮدن ورودي ﻫﺎ اﺳﺖ ‪.‬‬

‫‪2. Vector‬‬
‫‪6‬‬
‫اﻧﻮاع داده ﻫﺎ ﺑﻪ ﻫﻤﺮاه ﻧﺤﻮه ﺗﻌﺮﯾﻒ در ‪: opengl‬‬

‫‪7‬‬
 ‫ﻗﺎﻟﺐ ﮐﻠﯽ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ﻫﺎ در ‪ opengl‬ﺑﻪ زﺑﺎن ‪: Visual C++‬‬

‫>‪#include <GL/glut.h‬‬

‫‪.‬‬

‫‪.‬‬

‫‪.‬‬

‫ﺗﻌﺮﯾﻒ ﻣﺘﻐﯿﯿﺮﻫﺎ و ﺛﻮاﺑﺖ‬

‫)(‪Void init‬‬

‫{‬

‫ﻣﻘﺪاردﻫﯽ اوﻟﯿﻪ‬

‫}‬

‫ﺗﻌﺮﯾﻒ ﺳﺎﯾﺮ ﺗﻮاﺑﻊ در ﺻﻮرت ﻧﯿﺎز‪//‬‬

‫)‪int main(int argc,char **argv‬‬

‫{‬

‫ﻓﺮاﺧﻮاﻧﯽ ﺗﻮاﺑﻊ رﺳﻢ و ارﺳﺎل ﭘﺎراﻣﺘﺮ ورودي ﺑﻪ ﺗﻮاﺑﻊ‪//‬‬

‫;)(‪Init‬‬

‫;)(‪glutMainLoop‬‬

‫;‪return 0‬‬

‫}‬

‫‪8‬‬
 ‫ﻧﺤﻮه ﺗﻨﻈﯿﻢ ‪ Microsoft Visual C++ 2010‬ﺑﺮاي ﮐﺎرﮐﺮدن ﺑﺎ ‪: opengl‬‬

‫اﺑﺘﺪا ﻓﺎﯾﻠﻬﺎي ﻣﻮرد ﻧﯿﺎز را داﻧﻠﻮد ﮐﻨﯿﺪ ‪:‬‬

‫‪http://s1.picofile.com/file/7323794515/freeglut_MSVC.zip.html‬‬

‫‪http://www.opengl.org/resources/libraries/glut‬‬

‫در زﯾﺮ ﻣﺤﺘﻮﯾﺎت ﻓﺎﯾﻞ داﻧﻠﻮد ﺷﺪه را ﻣﺸﺎﻫﺪه ﻣﯿﮑﻨﯿﺪ ‪:‬‬

‫ﺑﻌﺪ از ﺧﺎرج ﮐﺮدن ﻓﺎﯾﻞ از ﺣﺎﻟﺖ ﻓﺸﺮده ‪ 3‬ﻓﻮﻟﺪر وﺟﻮد دارد ﮐﻪ ﻃﺒﻖ زﯾﺮ ﺑﺎﯾﺪ ﮐﭙﯽ ﺷﻮد ‪:‬‬

‫‪ .1‬در درون ﻓﻮﻟﺪر ‪ bin‬ﻓﺎﯾﻞ ‪ freeglut.dll‬را ﺑﻪ اﯾﻦ آدرس ﮐﭙﯽ ﮐﻨﯿﺪ ‪:‬‬
‫‪C:\windows\system32‬‬
‫و در ﺳﯿﺴﺘﻤﻬﺎي ‪ 64‬ﺑﯿﺘﯽ ﻓﺎﯾﻞ ‪ freeglut.dll‬ﻣﻮﺟﻮد در ﻓﻮﻟﺪر ‪ x64‬را ﺑﻪ اﯾﻦ آدرس ﮐﭙﯽ ﮐﻨﯿﺪ ‪:‬‬
‫‪C:\windows\SysWOW64‬‬

‫‪ .2‬در درون ﻓﻮﻟﺪر ‪ include‬ﻓﻮﻟﺪري ﺑﻪ ﻧﺎم ‪ GL‬وﺟﻮد دارد ‪ .‬ﻣﺤﺘﻮﯾﺎت اﯾﻦ ﻓﻮﻟﺪر را ﮐﻪ ﺷﺎﻣﻞ ‪ 4‬ﻓﺎﯾﻞ ﺑﺎ ﭘﺴﻮﻧﺪ‬
‫‪ .h‬اﺳﺖ را ﺑﻪ آدرس زﯾﺮ ﮐﭙﯽ ﮐﻨﯿﺪ ‪:‬‬
‫‪C:\Program Files\Microsoft SDKs\Windows\v7.0A\Include\gl‬‬
‫و در ﺳﯿﺴﺘﻤﻬﺎي ‪ 64‬ﺑﯿﺘﯽ ﻧﯿﺰ ﺑﻪ اﯾﻦ آدرس ‪:‬‬
‫‪C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Include\gl‬‬

‫‪9‬‬
 ‫‪ .3‬در درون ﻓﻮﻟﺪر ‪ lib‬ﻓﺎﯾﻠﯽ ﺑﻪ ﻧﺎم ‪ freeglut.lib‬وﺟﻮد دارد ﮐﻪ آن را ﺑﺎﯾﺪ ﺑﻪ آدرس زﯾﺮ ﮐﭙﯽ ﮐﻨﯿﺪ ‪:‬‬
‫‪C:\Program Files\Microsoft SDKs\Windows\v7.0A\Lib‬‬

‫و درﺳﯿﺴﺘﻤﻬﺎي ‪ 64‬ﺑﯿﺘﯽ ﻧﯿﺰ ﻓﺎﯾﻞ ‪ freeglut.lib‬ﻣﻮﺟﻮد در ﻓﻮﻟﺪر ‪ x64‬را ﺑﻪ اﯾﻦ آدرس ﮐﭙﯽ ﮐﻨﯿﺪ ‪:‬‬

‫‪C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Lib\x64‬‬

‫‪ .4‬ﺑﺮﻧﺎﻣﻪ ‪ visual studio 2010‬را اﺟﺮا ﮐﻨﯿﺪ و ﻣﺮاﺣﻞ زﯾﺮ را دﻧﺒﺎل ﮐﻨﯿﺪ ‪:‬‬

‫‪10‬‬
11
12
 ‫ﺑﻌﺪ از اﯾﺠﺎد ﻓﺎﯾﻞ ‪ ,‬ﺳﻮرس ﮐﺪ ﺧﻮد را درون آن ﻣﯿﻨﻮﯾﺴﯿﻢ ‪.‬‬

‫‪13‬‬
‫ﺣﺎل ﺑﺎﯾﺪ ﻓﺎﯾﻞ ﮐﺘﺎﺑﺨﺎﻧﻪ اي ‪ opengl‬را ﺑﻪ ﭘﺮوژه ﺧﻮد ﻟﯿﻨﮏ ﮐﻨﯿﻢ ﺑﺮاي اﯾﻨﮑﺎر ﻣﺮاﺣﻞ زﯾﺮ را دﻧﺒﺎل ﮐﻨﯿﺪ ‪:‬‬

‫‪14‬‬
‫ﻣﻘﺪار ‪ freeglut.lib‬را در ﮐﺎدر زﯾﺮ وارد ﮐﺮده و در ﺗﻤﺎﻣﯽ ﭘﻨﺠﺮه ﻫﺎ ‪ ok‬ﮐﻨﯿﺪ ‪.‬‬

‫‪15‬‬
‫ﺣﺎل ﮐﺎر ﺑﺮاي وﯾﻨﺪوزﻫﺎي ‪ 32‬ﺑﯿﺘﯽ ﺗﻤﺎم ﺷﺪه و ﺷﻤﺎ ﻓﻘﻂ ﮐﺎﻓﯽ اﺳﺖ ﮐﻪ ﺑﺮﻧﺎﻣﻪ ﺗﺎن را ﻧﻮﺷﺘﻪ و اﺟﺮا ﮐﻨﯿﺪ وﻟﯽ ﺑﺮاي‬
‫وﯾﻨﺪوزﻫﺎي ‪ 64‬ﺑﯿﺘﯽ ﺑﺎﯾﺪ ﯾﮏ ﮐﺎر دﯾﮕﺮ ﻧﯿﺰ ﺑﮑﻨﯿﺪ ‪:‬‬

‫‪16‬‬
17
 ‫راﻫﻨﻤﺎي ﺑﺮﺧﯽ از دﺳﺘﻮرات ‪: opengl‬‬

‫)‪ : glClearColor (R,G,B,A‬رﻧﮓ ﭘﺎك ﮐﻨﻨﺪه ﺟﺎري ﺻﻔﺤﻪ را ﺑﻪ ﻣﻘﺪار ‪ RGBA‬داده ﺷﺪه ﺗﻨﻈﯿﻢ ﻣﯿﮑﻨﺪ ‪ .‬ﮐﻪ‬ ‫‪o‬‬
‫‪)R‬ﻗﺮﻣﺰ( و ‪)G‬ﺳﺒﺰ( و ‪)B‬آﺑﯽ( و ‪)A‬آﻟﻔﺎ ﯾﺎ ﺷﻔﺎﻓﯿﺖ( اﺳﺖ ‪.‬‬
‫رﻧﮓ ﭘﯿﺸﻔﺮض )‪ (0,0,0,0‬اﺳﺖ ﮐﻪ رﻧﮓ ﺳﯿﺎه اﺳﺖ ‪ .‬ﻣﻘﺎدﯾﺮ ﻣﻮرد ﻧﻈﺮ ﻣﺎ ﺑﯿﻦ ‪ 0‬و ‪ 1‬اﺳﺖ ‪.‬‬

‫) ‪ : glClear( GLbitfield mask‬ﺑﺎﻓﺮ ﻫﻤﻮاره ﺑﺎﯾﺪ ﻗﺒﻞ از ﺗﺮﺳﯿﻢ ﺻﻔﺤﻪ ﭘﺎك ﺷﻮد زﯾﺮا ﻣﻘﺎدﯾﺮ رﻧﮓ ﻫﺮ ﭘﯿﮑﺴﻞ در ﺑﺎﻓﺮ‬ ‫‪o‬‬
‫ﻗﺮار داده ﻣﯿﺸﻮد و اﯾﻦ دﺳﺘﻮر ﻧﯿﺰ ﻫﻤﯿﻦ ﮐﺎر را ﻣﯿﮑﻨﺪ ﻣﻘﺎدﯾﺮ ‪ GLbitfield mask‬ﻣﯿﺘﻮاﻧﺪ ﺷﺎﻣﻞ ﻣﻘﺎدﯾﺮ زﯾﺮ ﺑﺎﺷﺪ ‪:‬‬

‫‪GL_COLOR_BUFFER_BIT‬‬ ‫ﺑﺎﻓﺮ رﻧﮕﯽ‬

‫‪GL_DEPTH_BUFFER_BIT‬‬ ‫ﺑﺎﻓﺮ ﻋﻤﻖ‬
‫‪GL_ACCUM_BUFFER_BIT‬‬ ‫ﺑﺎﻓﺮ اﻧﺒﺎﺷﺘﮕﯽ‬
‫‪GL_STENCIL_BUFFER_BIT‬‬ ‫ﺑﺎﻓﺮ اﺳﺘﻨﺴﯿﻞ‬

‫ﺑﺎ ﻓﺮاﺧﻮاﻧﯽ اﯾﻦ ﺗﺎﺑﻊ ﻓﻘﻂ ﺑﺎﻓﺮﻫﺎﯾﯽ ﮐﻪ در آرﮔﻮﻣﺎن ﻣﻌﺮﻓﯽ ﺷﺪه اﻧﺪ ﭘﺎك ﻣﯽ ﺷﻮﻧﺪ و ﺑﻘﯿﻪ ﺑﺎﻓﺮﻫﺎ ﻫﻤﭽﻨﺎن ﺣﺎﻟﺖ ﻗﺒﻠﯽ ﺧﻮد رو ﺣﻔﻆ ﻣﯽ‬
‫ﮐﻨﻨﺪ‪.‬‬

‫)‪ : glColor{3,4}{b,s,f,i,d,ub,us,ui}( red,green, blue,alpha‬اﯾﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺗﻌﯿﯿﻦ رﻧﮓ اﺷﯿﺎئ روي ﺻﻔﺤﻪ ﺑﻪ ﮐﺎر‬ ‫‪o‬‬
‫ﻣﯿﺮود و در ﺻﻮرت ﺳﻪ آرﮔﻮﻣﺎﻧﻪ ﺑﻮدن ﻣﻘﺎدﯾﺮ ‪ RGB‬را ﻣﯿﮕﯿﺮﻧﺪ و در ﺻﻮرت ﭼﻬﺎر آرﮔﻮﻣﺎﻧﻪ ﺑﻮدن ﻣﻘﺎدﯾﺮ ‪ RGBA‬را ﻣﯿﮕﯿﺮد ‪ .‬ﺑﺮاي‬
‫ﻣﺜﺎل ‪:‬‬

‫‪glColor3f(0.0,‬‬ ‫‪0.0,‬‬ ‫;)‪0.0‬‬ ‫ﺳﯿﺎه‬

‫‪glColor3f(1.0,‬‬ ‫‪0.0,‬‬ ‫;)‪0.0‬‬ ‫ﻗﺮﻣﺰ‬
‫‪glColor3f(0.0,‬‬ ‫‪1.0,‬‬ ‫;)‪0.0‬‬ ‫ﺳﺒﺰ‬
‫‪glColor3f(1.0,‬‬ ‫‪1.0,‬‬ ‫;)‪0.0‬‬ ‫زرد‬
‫‪glColor3f(0.0,‬‬ ‫‪0.0,‬‬ ‫;)‪1.0‬‬ ‫آﺑﯽ‬
‫‪glColor3f(1.0,‬‬ ‫‪0.0,‬‬ ‫;)‪1.0‬‬ ‫ﺳﺮخ آﺑﯽ‬
‫‪glColor3f(0.0,‬‬ ‫‪1.0,‬‬ ‫;)‪1.0‬‬ ‫ﻓﯿﺮوزه اي‬
‫‪glColor3f(1.0,‬‬ ‫‪1.0,‬‬ ‫;)‪1.0‬‬ ‫ﺳﻔﯿﺪ‬

‫ﻧﻮع دﯾﮕﺮ ارﺳﺎل ﭘﺎراﻣﺘﺮ ورودي اﯾﻦ ﺗﺎﺑﻊ ﺑﻪ ﺻﻮرت ﺑﺮداري اﺳﺖ ﮐﻪ در اﯾﻦ ﺣﺎﻟﺖ ﺑﺎﯾﺪ ورودي ﻫﺎ آراﯾﻪ ﺑﺎﺷﻨﺪ ﺑﻪ ﺻﻮرت زﯾﺮ ‪:‬‬
‫;}‪GLfloat color_array[] = {1.0, 0.0, 0.0‬‬
‫;)‪glColor3fv(color_array‬‬

‫‪18‬‬
‫)‪: glOrtho(GLdouble left, GLdouble right,GLdouble bottom, GLdouble top,GLdouble zNear, GLdouble zFar‬‬ ‫‪o‬‬

‫دﺳﺘﻮري ﮐﻪ دﯾﺪ اورﺗﻮﮔﺮاﻓﯿﮏ ﺣﺠﻢ را ﺑﻪ وﺟﻮد ﻣﯽ آورد در اﯾﻦ ﺣﺎﻟﺖ ﺣﺠﻢ درﺣﺎل ﻣﺸﺎﻫﺪه ﺑﻪ ﺷﮑﻞ ﯾﮏ ﺟﻌﺒﻪ دﯾﺪه ﻣﯿﺸﻮد‬
‫)ﺷﮑﻞ زﯾﺮ( ‪:‬‬

‫آرﮔﻮﻣﺎﻧﻬﺎي ‪ left‬و ‪ right‬ﻣﺨﺘﺼﺎت ﺻﻔﺤﺎت ﻋﻤﻮدي ﺑﺮش ﭼﭗ و راﺳﺖ را ﻣﻌﯿﻦ ﻣﯿﺴﺎزد ‪ top .‬و ‪ bottom‬ﻣﺨﺘﺼﺎت‬
‫ﺻﻔﺤﺎت اﻓﻘﯽ ﺑﺮش ﺑﺎﻻ و ﭘﺎﺋﯿﻦ را ﻣﺸﺨﺺ ﻣﯿﮑﻨﺪ ‪.‬و آرﮔﻮﻣﺎﻧﻬﺎي ‪ near‬و ‪ far‬ﻓﺎﺻﻠﻪ ﺑﺎ ﺻﻔﺤﺎت ﺑﺮش ﻧﺰدﯾﮑﺘﺮ و دورﺗﺮ ﻫﺴﺘﻨﺪ ‪.‬‬
‫دﺳﺘﻮر )‪ gluOrtho2D(left,right,bottom,top‬ﺑﺎ دﺳﺘﻮر )‪ glOrtho(left,right,bottom,top,-1,1‬ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ اﯾﻦ ﺗﻔﺎوت‬
‫ﮐﻪ دﺳﺘﻮر اول ﺑﺮاي اﯾﺠﺎد ﺳﯿﺴﺘﻢ دﺳﺘﮕﺎه ﻣﺨﺘﺼﺎت دوﺑﻌﺪي ﺑﻪ ﮐﺎر ﻣﯿﺮود ‪.‬‬

‫‪19‬‬
 ‫‪o‬‬
‫;) ‪glBegin( GLenum mode‬‬
‫‪.‬‬
‫‪.‬‬
‫‪:‬‬ ‫;)(‪glEnd‬‬

‫ﺑﺮاي ﺷﺮوع و ﭘﺎﯾﺎن دﺳﺘﻮرات ﺗﺮﺳﯿﻤﯽ)اﺷﮑﺎل اوﻟﯿﻪ( ﮐﻪ ﺑﺎ رﺋﻮﺳﺸﺎن ﻣﺸﺨﺺ ﻣﯿﺸﻮﻧﺪ ﺑﮑﺎر ﻣﯿﺮوﻧﺪ ‪ .‬آرﮔﻮﻣﺎن ‪ GLenum mode‬ﻧﻮع‬
‫ﺗﺮﺳﯿﻤﯽ ﮐﻪ ﺑﺎﯾﺪ ﺷﺮوع ﺷﻮد را ﻣﻌﯿﻦ ﻣﯿﺴﺎزد ﺑﺮاي ﻣﺜﺎل ‪ glBegin(GL_TRIANGLES) :‬ﺑﻪ ﻣﻌﻨﺎي اﯾﻦ اﺳﺖ ﮐﻪ ﻣﯿﺨﻮاﻫﯿﻢ رﺳﻢ ﯾﮏ‬
‫ﻣﺜﻠﺚ را ﺷﺮوع ﮐﻨﯿﻢ و )(‪ glEnd‬ﺑﻪ ‪ opengl‬ﻣﯿﮕﻮﯾﺪ ﮐﻪ رﺳﻢ ﻣﺜﻠﺚ ﺑﻪ ﭘﺎﯾﺎن رﺳﯿﺪه اﺳﺖ ‪ .‬و ﻣﺎ ﺑﯿﻦ اﯾﻦ دو دﺳﺘﻮر رﺋﻮس ﻣﻮرد ﻧﯿﺎز‬
‫ﺑﺮاي رﺳﻢ را وارد ﻣﯿﮑﻨﯿﻢ ‪.‬ﻣﻘﺎدﯾﺮ ﻣﺠﺎز ﺑﺮاي ‪ GLenum mode‬در دﺳﺘﻮر ‪ glBegin‬ﺑﻪ ﺻﻮرت زﯾﺮ اﺳﺖ ‪.‬‬

‫‪20‬‬
 ‫)‪: glVertex{2,3,4}{d,f,I,s}{v}(input parameters‬‬ ‫‪o‬‬
‫ﯾﮏ رأس از ﺷﮑﻠﯽ را ﮐﻪ ﺑﺎﯾﺪ ﺑﯿﻦ )(‪ glBegin‬و )(‪ glEnd‬رﺳﻢ ﺷﻮد را اﯾﺠﺎد ﻣﯿﮑﻨﺪ در ‪ opengl‬ﺗﻤﺎﻣﯽ اﺷﮑﺎل ﻫﻨﺪﺳﯽ ﺑﺎ ﻣﺠﻤﻮﻋﻪ‬
‫اي از رﺋﻮس ﺑﯿﺎن ﻣﯿﺸﻮﻧﺪ ‪ .‬ﺑﺎﯾﺪ ﺑﺪاﻧﯿﺪ ﮐﻪ ﺗﺮﺗﯿﺐ اراﺋﻪ رﺋﻮس ﺑﺴﯿﺎر ﻣﻬﻢ اﺳﺖ ‪.‬‬

‫ﺑﺮاي ﻣﺜﺎل دﺳﺘﻮر زﯾﺮ ﺑﺮاي ﺗﺮﺳﯿﻢ ﯾﮏ ﺧﻂ اﺳﺖ ‪:‬‬

‫;)‪glBegin(GL_LINES‬‬
‫;)‪glVertex2i(10,10‬‬
‫;)‪glVertex2i(90,120‬‬
‫;)(‪glEnd‬‬

‫‪21‬‬
‫ﺑﺮاي اﻃﻤﯿﻨﺎن ﺣﺎﺻﻞ ﮐﺮدن از ﺗﺮﺳﯿﻢ ﺗﻤﺎم ﻣﻮاردي ﮐﻪ رﺳﻢ ﺷﻮﻧﺪ در ﭘﺎﯾﺎن دﺳﺘﻮرات ﺗﺮﺳﯿﻤﯽ از اﯾﻦ ﺗﺎﺑﻊ اﺳﺘﻔﺎده‬ ‫)(‪: glFlush‬‬ ‫‪o‬‬
‫ﻣﯿﺸﻮد ‪ .‬در واﻗﻊ اﯾﻦ ﺗﺎﺑﻊ ﺑﺎﻓﺮ را ﺧﺎﻟﯽ ﻣﯿﮑﻨﺪ و ﺗﻤﺎﻣﯽ دﺳﺘﻮرات در ﺣﺎل اﻧﺘﻈﺎر را ﺑﻪ ﻃﻮر ﺳﺮﯾﻊ اﺟﺮا ﻣﯿﮑﻨﺪ‬

‫ﺑﺮاي ﺗﻐﯿﯿﺮ ﻣﮑﺎن ﺷﺊ و ﻫﻤﭽﻨﯿﻦ ﻣﮑﺎن دورﺑﯿﻨﻬﺎ از ﻣﺎﺗﺮﯾﺲ ﻫﺎ اﺳﺘﻔﺎده ﻣﯿﺸﻮد و اﯾﻦ‬ ‫‪: glMatrixMode(GLenum‬‬
‫)‪(GLenum mode‬‬
‫‪mode‬‬ ‫‪o‬‬
‫ﻣﯿﺘﻮاﻧﺪ ﺷﺎﻣﻞ ﻣﻘﺎدﯾﺮ زﯾﺮ ﺑﺎﺷﺪ ‪:‬‬ ‫‪GLenum mode‬‬ ‫ﺗﺎﺑﻊ ﻧﯿﺰ ﻣﺎﺗﺮﯾﺲ ﺟﺎري را ﺗﻌﯿﯿﻦ ﻣﯿﮑﻨﺪ ﻣﻘﺪار‬

‫‪3‬‬
‫‪GL_MODELVIEW‬‬ ‫ﺑﺮاي اﻧﺘﻘﺎل و ﺗﻐﯿﯿﺮ ﻣﮑﺎن و دوران و ‪ ...‬اﺷﯿﺎئ اﺳﺘﻔﺎده ﻣﯿﺸﻮد و ﺑﺼﻮرت ﭘﯿﺸﻔﺮض اﯾﻦ ﺣﺎﻟﺖ اﺳﺖ‬
‫‪4‬‬
‫‪GL_PROJECTION‬‬ ‫ﺑﺮاي ﺣﺎﻟﺖ دوﺑﻌﺪي اﺳﺘﻔﺎده ﻣﯿﺸﻮد‬
‫‪GL_TEXTURE‬‬ ‫ﺑﺮاي ﺣﺎﻟﺘﯽ ﮐﻪ ﻣﯿﺨﻮاﻫﯿﻢ از ﺗﮑﺴﺘﭽﺮ)ﺗﺼﻮﯾﺮ ﺑﻪ ﺟﺎري رﻧﮓ( اﺳﺘﻔﺎده ﻣﯿﺸﻮد‬

‫ﺗﺼﻮﯾﺮ زﯾﺮ ﯾﮏ ﮐﺮه ﺳﺎده اﺳﺖ ﺑﺎ اﯾﻦ ﺗﻔﺎوت ﮐﻪ دز آن از ﺑﺎﻓﺖ ﺗﮑﺴﺘﭽﺮ ﺑﻪ ﺟﺎي رﻧﮓ اﺳﺘﻔﺎده ﺷﺪه ‪:‬‬

‫‪lLoadIdentity() o‬‬
‫‪ : glLoadIdentity‬ﻣﺎﺗﺮﯾﺲ ﻗﺎﺑﻞ ﺗﻐﯿﯿﺮ ﺟﺎري را ﺑﻪ ﻣﺎﺗﺮﯾﺲ واﺣﺪﺗﺒﺪﯾﻞ ﻣﯿﮑﻨﺪ‪ ).‬ﻣﺎﺗﺮﯾﺲ واﺣﺪ ﻣﺎﺗﺮﯾﺴﯽ اﺳﺖ ﮐﻪ ﻣﻮﻟﻔﻪ‬
‫ﻫﺎي روي ﻗﻄﺮ اﺻﻠﯽ ‪ 1‬وﻣﺎﺑﻘﯽ ‪ 0‬ﻫﺴﺘﻨﺪ‪(.‬‬

‫‪ : glEnable(GLenum‬ﺑﺮاي ﻓﻌﺎل ﻧﻤﻮدن ﯾﮏ ﻗﺎﺑﻠﯿﺖ اﺳﺘﻔﺎده ﻣﯿﺸﻮد ﻣﺎﻧﻨﺪ‪glEnable(GL_POINT_SMOOTH) :‬‬

‫)‪(GLenum cap‬‬ ‫‪o‬‬
‫ﻏﯿﺮﻓﻌﺎل ﻧﻤﻮدن ﯾﮏ ﻗﺎﺑﻠﯿﺖ اﺳﺘﻔﺎده ﻣﯿﺸﻮد ﻣﺎﻧﻨﺪ‪glDisable(GL_POINT_SMOOTH) :‬‬ ‫‪ : glDisable(GLenum‬ﺑﺮاي‬
‫)‪(GLenum cap‬‬ ‫‪o‬‬
‫ﺑﺮرﺳﯽ ﻣﯿﮑﻨﺪ ﮐﻪ آﯾﺎ ﯾﮏ ﻗﺎﺑﻠﯿﺖ ﻓﻌﺎل اﺳﺖ ﯾﺎ ﻧﻪ و درﺻﻮرت ﻓﻌﺎل ﺑﻮدن ﻣﻘﺪار‬ ‫‪: glIsEnabled(GLenum‬‬
‫)‪(GLenum cap‬‬ ‫‪o‬‬
‫‪ GL_TRUE‬و در ﺻﻮرت ﻏﯿﺮ ﻓﻌﺎل ﺑﻮدن ﻣﻘﺪار ‪ GL_FALSE‬را ﺑﺮﻣﯿﮕﺮداﻧﺪ ‪.‬‬

‫‪3‬‬
‫‪http://www.songho.ca/opengl/files/matrixModelView.zip‬‬
‫‪4‬‬
‫‪http://www.songho.ca/opengl/files/matrixProjection.zip‬‬

‫‪22‬‬
 : ‫ ﻣﯽ ﺗﻮاﻧﺪ ﺛﺎﺑﺖ ﻫﺎي زﯾﺮ را ﺑﻪ ﻋﻨﻮان ﭘﺎرﻣﺘﺮﻫﺎي ﺧﻮد ﺑﮕﯿﺮد‬GLenum cap ‫در ﺗﻮاﺑﻊ ﺑﺎﻻ ﻣﻘﺪار‬

GL_ALPHA_TEST GL_MAP2_COLOR_4
GL_AUTO_NORMAL GL_MAP2_INDEX
GL_BLEND GL_MAP2_NORMAL
GL_CLIP_PLANEi GL_MAP2_TEXTURE_COORD_1
GL_COLOR_LOGIC_OP GL_MAP2_TEXTURE_COORD_2
GL_COLOR_MATERIAL GL_MAP2_TEXTURE_COORD_3
GL_CULL_FACE GL_MAP2_TEXTURE_COORD_4
GL_DEPTH_TEST GL_MAP2_VERTEX_3
GL_DITHER GL_MAP2_VERTEX_4
GL_FOG GL_NORMALIZE
GL_INDEX_LOGIC_OP GL_POINT_SMOOTH
GL_LIGHTi GL_POLYGON_OFFSET_FILL
GL_LIGHTING GL_POLYGON_OFFSET_LINE
GL_LINE_SMOOTH GL_POLYGON_OFFSET_POINT
GL_LINE_STIPPLE GL_POLYGON_SMOOTH
GL_LOGIC_OP GL_POLYGON_STIPPLE
GL_MAP1_COLOR_4 GL_SCISSOR_TEST
GL_MAP1_INDEX GL_STENCIL_TEST
GL_MAP1_NORMAL GL_TEXTURE_1D
GL_MAP1_TEXTURE_COORD_1 GL_TEXTURE_2D
GL_MAP1_TEXTURE_COORD_2 GL_TEXTURE_GEN_Q
GL_MAP1_TEXTURE_COORD_3 GL_TEXTURE_GEN_R
GL_MAP1_TEXTURE_COORD_4 GL_TEXTURE_GEN_S
GL_MAP1_VERTEX_3 GL_TEXTURE_GEN_T
GL_MAP1_VERTEX_4

‫ اﺳﺘﻔﺎده ﻣﯽ ﮐﻨﺪ و ﯾﮏ‬glut ‫ ﮐﻪ از ﮐﺘﺎﺑﺨﺎﻧﻪ‬openGL ‫ اﯾﻦ ﺗﺎﺑﻊ در ﺑﺮﻧﺎﻣﻪ ﻫﺎي‬: glutInit(int *argc, char **argv) o
.‫ رو ﻣﻌﺮﻓﯽ ﻣﯽ ﮐﻨﻪ‬glut ‫در واﻗﻊ اﯾﻦ ﺗﺎﺑﻊ ﮐﺘﺎﺑﺨﺎﻧﻪ‬. ‫ﺑﺎر ﻣﻘﺪاردﻫﯽ اوﻟﯿﻪ ﻣﯽ ﺷﻮد‬
: ‫ آرﮔﻮﻣﺎن ﻫﺴﺖ‬2 ‫اﯾﻦ ﺗﺎﺑﻊ داراي‬
.‫ ﺗﻌﺪاد آرﮔﻮﻣﺎﻧﻬﺎي ارﺳﺎﻟﯽ رو ذﺧﯿﺮه ﻣﯽ ﮐﻨﺪ‬argc . ‫ اﺳﺖ‬main ‫ ﺗﺎﺑﻊ‬argc ‫ ﮐﻪ اﺷﺎره ﮔﺮي ﺑﻪ ﻣﺘﻐﯿﺮ‬:argc
. ‫ ﻣﻘﺪار آرﮔﻮﻣﺎﻧﻬﺎ رو ذﺧﯿﺮ ه ﻣﯽ ﮐﻨﺪ‬argv ‫ اﺳﺖ و‬main ‫ ﺗﺎﺑﻊ‬argv ‫ اﺷﺎره ﮔﺮي ﺑﻪ ﻣﺘﻐﯿﺮ‬:argv

‫ ﻫﻤﺎﻧﻄﻮر ﮐﻪ از اﺳﻢ اﯾﻦ ﺗﺎﺑﻊ ﭘﯿﺪاﺳﺖ ﺑﺮاي ﻣﺸﺨﺺ ﮐﺮدن ﻣﻮﻗﻌﯿﺖ ﭘﻨﺠﺮه ﺑﮑﺎر‬: glutInitWindowPosition(int x,int y) o
. ‫ اﺳﺖ‬y‫ و‬x ‫ﻣﯿﺮود و داراي دو آرﮔﻮﻣﺎن‬

‫ ﻫﻤﺎﻧﻄﻮر ﮐﻪ از اﺳﻢ اﯾﻦ ﺗﺎﺑﻊ ﭘﯿﺪاﺳﺖ ﺑﺮاي ﻣﺸﺨﺺ ﮐﺮدن اﻧﺪازه ﭘﻨﺠﺮه‬: glutInitWindowSize(int width,int heigth) o
. ‫ﺑﮑﺎر ﻣﯿﺮود و داراي دو آرﮔﻮﻣﺎن ﻃﻮل وﻋﺮض اﺳﺖ‬

Test ‫ﺑﺎ ﻓﺮاﺧﻮاﻧﯽ اﯾﻦ ﺗﺎﺑﻊ ﭘﻨﺠﺮه ﻣﺎ ﺳﺎﺧﺘﻪ ﻣﯿﺸﻮد و در ﻋﻨﻮان آن ﻋﺒﺎرت‬ : glutCreateWindow("Test Windows”) o
.‫ را ﻗﺮار ﻣﯽ ﮔﯿﺮد‬Windows

23
‫‪ :‬اﯾﻦ ﺗﺎﺑﻊ ﯾﮏ ﺗﺎﺑﻊ دﯾﮕﺮ را ﻓﺮاﺧﻮاﻧﯽ ﻣﯽ ﮐﻨﺪ ‪،‬ﮐﻪ ﻣﺎ ﻧﻮﺷﺘﯿﻢ در واﻗﻊ آرﮔﻮﻣﺎن آن‬ ‫)‪glutDisplayFunc(Display Function‬‬ ‫‪o‬‬
‫ﯾﮏ ﺗﺎﺑﻊ اﺳﺖ‪.‬ﺑﻪ اﯾﻨﮕﻮﻧﻪ ﺗﻮاﺑﻊ ‪ CallBack‬ﮔﻔﺘﻪ ﻣﯿﺸﻮد ‪.‬‬

‫ﺑﺎﻋﺚ ﺷﺮوع رﺧﺪادﻫﺎي ‪ glut‬ﻣﯿﺸﻮد و ﺑﻪ ﻣﺤﺾ رﺳﯿﺪن ﺑﺮﻧﺎﻣﻪ ﺑﻪ اﯾﻦ ﺧﻂ ﺗﻤﺎم ﺗﻌﺎرﯾﻔﯽ ﮐﻪ ﺑﺮاي‬ ‫)(‪: glutMainLoop‬‬ ‫‪o‬‬
‫اﯾﺠﺎد ﭘﻨﺠﺮه ﮐﺮده اﯾﻢ را ﺑﻪ ﮐﺎر ﻣﯽ اﻧﺪازد و ﺑﺎﻋﺚ ﻧﻤﺎﯾﺶ ﭘﻨﺠﺮه ﻣﺎ ﻣﯿﺸﻮد ‪.‬اﯾﻦ ﭘﻨﺠﺮه ﯾﮏ ﺣﻠﻘﻪ ﭘﺮدازﺷﯽ ﺑﯽ ﻧﻬﺎﯾﺖ اﯾﺠﺎد ﻣﯽ‬
‫ﮐﻨﺪ و ﺗﺎ زﻣﺎن ﺑﺴﺘﻦ ﭘﻨﺠﺮه ﺑﻪ ﮐﺎر ﺧﻮدش اداﻣﻪ ﻣﯿﺪﻫﺪ و ﺑﺎرﻫﺎ و ﺑﺎرﻫﺎ ﺗﻤﺎم دﺳﺘﻮراﺗﯽ ﮐﻪ ﺑﺎ ‪ glut‬ﻧﻮﺷﺘﻪ اﯾﻢ را اﺟﺮا ﻣﯽ ﮐﻨﺪ‬
‫اﯾﻦ ﺣﻠﻘﻪ ﺗﻤﺎم ﺣﺮﮐﺎت ﻣﺎﻧﻨﺪ ﻣﻮس ‪،‬ﮐﯿﺒﻮرد رو ﻟﺤﻈﻪ ﺑﻪ ﻟﺤﻈﻪ ﭘﺮدازش و ﺑﺎﻋﺚ ﻣﯿﺸﻮد ﻣﺎ ﺗﻐﯿﯿﺮات را در ﺻﻔﺤﻪ ﻣﺸﺎﻫﺪه ﮐﻨﯿﻢ‪.‬‬

‫اﯾﻦ ﺗﺎﺑﻊ ‪ mode‬ﻧﻤﺎﯾﺸﯽ را ﺑﺮاي ﻣﺎ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ‪.‬‬ ‫)‪: glutInitDisplayMode(unsigned int display mode‬‬ ‫‪o‬‬

‫آرﮔﻮﻣﺎﻧﻬﺎي آن ﻣﯽ ﺗﻮاﻧﺪ ﻫﺮ ﯾﮏ ﯾﺎ ﺗﺮﮐﯿﺒﯽ از ﻣﻘﺎدﯾﺮ زﯾﺮ ﺑﺎﺷﺪ‪.‬‬

‫‪GLUT_RGBA‬‬ ‫‪GLUT_ALPHA‬‬
‫‪GLUT_RGB‬‬ ‫‪GLUT_DEPTH‬‬
‫‪GLUT_INDEX‬‬ ‫‪GLUT_STENCIL‬‬
‫‪GLUT_SINGLE‬‬ ‫‪GLUT_MULTISAMPLE‬‬
‫‪GLUT_DOUBLE‬‬ ‫‪GLUT_STEREO‬‬
‫‪GLUT_ACCUM‬‬ ‫‪GLUT_LUMINANCE‬‬

‫ﻣﺎﻧﻨﺪ ‪:‬‬
‫;)‪glutInitDisplayMode(GLUT_SINGLE,GLUT_RGB‬‬

‫دﺳﺘﻮر ﺑﺎﻻ ‪ mode‬ﭘﻨﺠﺮه ﺗﮏ ﺑﺎﻓﺮي در ‪ mode‬رﻧﮕﯽ ‪ RGB‬رو ﻣﺸﺨﺺ ﮐﺮده اﺳﺖ ‪.‬‬

‫‪24‬‬
 : ‫ ﺑﺮﻧﺎﻣﻪ رﺳﻢ ﯾﮏ ﺧﻂ در ﺻﻔﺤﻪ‬: ‫ﻣﺜﺎل‬
#include<gl/glut.h>
void init()
{
glClearColor(0,0,0,0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0,100,0,200);

}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2i(30,100);
glVertex2i(50,10);
glEnd();
glFlush();
}
int main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200,200);
on(200,200);
glutCreateWindow("Line");
);
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

. ‫ ﻣﺸﺨﺺ ﻧﻤﻮد‬glLineWidth(glfloat linewidth) ‫ﺑﻪ وﺳﯿﻠﻪ ﺗﺎﺑﻊ‬ ‫ ﻋﺮض ﺧﻂ را ﻣﯿﺘﻮان‬: ‫ﻧﮑﺘﻪ‬

25
 : ‫ ﺑﺮﻧﺎﻣﻪ رﺳﻢ ﭼﻬﺎر ﻧﻘﻄﻪ ﺑﺎ ﮔﻮﺷﻪ ﻫﺎي ﺻﺎف در ﺻﻔﺤﻪ‬: ‫ﻣﺜﺎل‬

#include<gl/glut.h>
void init()
{
glClearColor(0,0,0,0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0,100,0,200);

}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_POINT_SMOOTH);
glPointSize(10);
glBegin(GL_POINTS);
glColor3f(1.0,0.0,0.4);
glVertex2i(20,65);
glColor3f(0.0,0.3,0.0);
glVertex2i(33,56);
glColor3f(0.3,0.1,0.3);
glVertex2i(10,12);
glEnd();
glFlush();
}
int main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200,200);
glutCreateWindow("Points"
"Points");
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

. ‫ ﻣﯿﺘﻮان ﻣﺸﺨﺺ ﻧﻤﻮد‬glPointSize(glfloat glPointSize) ‫ ﺑﺰرﮔﯽ ﻧﻘﻄﻪ ﻫﺎ را ﺑﻪ وﺳﯿﻠﻪ ﺗﺎﺑﻊ‬: ‫ﻧﮑﺘﻪ‬

26
 : ‫ ﺑﺮﻧﺎﻣﻪ رﺳﻢ ﺧﻂ ﺑﻪ وﺳﯿﻠﻪ ﭘﯿﺪاﮐﺮدن ﺷﯿﺐ‬: ‫ﻣﺜﺎل‬

#include<gl/glut.h>
#include<math.h>
double round(double x)
{
return floor(x + 0.5);
}
void DDALine( GLint X1, GLint Y1, GLint X2, GLint Y2)
{
GLint iX, iY, Temp;
float m, X, Y;
if( (X2-X1) > (Y2-Y1))
{
if( X1 > X2)
{
Temp=X1; X1=X2; X2=Temp;
Temp=Y1; Y1=Y2; Y2=Temp;
}
Y=Y1;
m = (GLfloat) (Y2-Y1)/(X2-X1);
for( iX = X1; iX <= X2; iX ++)
{
glBegin(GL_POINTS);
glColor3f(1.0,0.2,0.0);
glVertex2i(iX,round(Y));
glEnd();
Y += m;
}
}
else
{
if( Y1 > Y2)
{
Temp=X1; X1=X2; X2=Temp;
Temp=Y1; Y1=Y2; Y2=Temp;
}
X = X1;
m = (float) (X2-X1)/(Y2-Y1);
for( iY = Y1; iY <= Y2; iY ++)
{
glBegin(GL_POINTS);
glColor3f(1.0,0.2,0.0);
glVertex2i(round(X),iY);
glEnd();
X += m;
}
}
}
void init()
{
glClearColor(0,0,0,0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0,100,0,200);

}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_POINT_SMOOTH);
glPointSize(10);
DDALine(10,50,50,50);
glFlush();
}

27
int main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200,200);
glutCreateWindow("Line
"Line With Slope"
Slope");
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

28
 : ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﭼﻨﺪﯾﻦ ﻣﺜﻠﺚ ﺟﺪا از ﻫﻢ رﺳﻢ ﮐﻨﺪ‬: ‫ﻣﺜﺎل‬
#include<gl/glut.h>
void init()
{
glClearColor(0,0,0,0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(100,100,0,200);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLES);
glColor3f(0,0,1.0);
glVertex2f(-0.8, -0.8);
glVertex2f(-0.6, -0.4);
glVertex2f(-0.3, -0.8);
glColor3f(0,1,0);
glVertex2f(0.8, 0.8);
glVertex2f(0.6, 0.4);
glVertex2f(0.3, 0.8);
glColor3f(1,0,0);
glVertex2f(-0.4, 0.0);
glVertex2f(0.0, 0.5);
glVertex2f(0.4, 0.0);
glEnd();
glFlush();
}
int main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200,200);

"Triangels");
glutCreateWindow("Triangels"
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

29
 : ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ دو ﻣﺜﻠﺚ ﺑﻪ ﻫﻢ ﭼﺴﺒﯿﺪه)ﻣﺸﺘﺮك در ﯾﮏ ﺿﻠﻊ( رﺳﻢ ﮐﻨﺪ‬: ‫ﻣﺜﺎل‬

#include<gl/glut.h>
void init()
{
glClearColor(0,0,0,0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(100,100,0,200);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLE_STRIP);
glColor3f(0,0,1.0);
glVertex2f(0.4, 0.0);
glVertex2f(0.0, -0.5);
glVertex2f(-0.4, 0.0);
glColor3f(1,0,0);
glVertex2f(-0.4, 0.0);
glVertex2f(0.0, 0.5);
glVertex2f(0.4, 0.0);
glEnd();
glFlush();
}
int main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200,200);
osition(200,200);

Strip Triangels"
glutCreateWindow(Strip Triangels");
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

30
 : ‫ ﻣﺜﻠﺜﻬﺎﯾﯽ رﺳﻢ ﮐﻨﯿﺪ ﮐﻪ در ﯾﮏ راس ﻣﺸﺘﺮك ﺑﺎﺷﻨﺪ‬: ‫ﻣﺜﺎل‬

#include<gl/glut.h>
void init()
{
glClearColor(0,0,0,0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(100,100,0,200);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glBegin(GL_TRIANGLE_FAN);
glVertex2f(-0.0, 0.0);
glVertex2f(-0.7, 0.0);
glVertex2f(-0.7, 0.7);
glVertex2f(0.0, 0.7);
glVertex2f(0.7, 0.7);
glVertex2f(0.7, 0.0);
glVertex2f(0.7, -0.7);
glVertex2f(0.0, -0.7);
glVertex2f(-0.7, -0.7);
glEnd();
glFlush();
}
int main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200,200);

glutCreateWindow("FAN Triangels");
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

31
 : ‫ ﺿﻠﻌﯽ رﺳﻢ ﮐﻨﺪ‬8 ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ‬: ‫ﻣﺜﺎل‬
#include<gl/glut.h>
void init()
{
glClearColor(0,0,0,0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(100,100,0,200);

}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glPolygonMode(GL_FRONT_AND_BACK,
GL_FRONT_AND_BACK, GL_LINE);
glBegin(GL_POLYGON);
glVertex2f(-0.7, -0.4);
glVertex2f(-0.7, 0.4);
glVertex2f(-0.4, 0.7);
glVertex2f(0.4, 0.7);
glVertex2f(0.7, 0.4);
glVertex2f(0.7, -0.4);
glVertex2f(0.4, -0.7);
glVertex2f(-0.4, -0.7);
glEnd();
glFlush();
}
int main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200,200);
glutCreateWindow("Polygon"
"Polygon");
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

‫ اﺳﺘﻔﺎده ﻣﯿﺸﻮد ﮐﻪ ﺗﻌﺪاد اﺿﻼع آن ﺗﻮﺳﻂ رﺋﻮس ﺗﻌﺮﯾﻒ‬GL_POLYGON ‫ ﺑﺮاي رﺳﻢ ﭼﻨﺪ ﺿﻠﻌﯽ از دﺳﺘﻮر‬: ‫ﻧﮑﺘﻪ‬
. ‫ﺷﺪه ﻣﺸﺨﺺ ﻣﯿﺸﻮد‬

32
‫ ﻧﻮع ﺗﺮﺳﯿﻢ ﺷﮑﻞ را ﻣﺸﺨﺺ ﻣﯿﮑﻨﺪ ﮐﻪ آﯾﺎ ﺗﻮﭘﺮ ﺑﺎﺷﺪ ﯾﺎ ﺗﻮﺧﺎﻟﯽ و ﭘﺎراﻣﺘﺮ‬glPolygonMode(face, mode) ‫ دﺳﺘﻮر‬: ‫ﻧﮑﺘﻪ‬
‫ را ﺑﻪ ﺧﻮد‬GL_BACK ‫ ﯾﺎ‬GL_FRONT ‫ ﯾﺎ‬GL_FRONT_AND_BACK ‫ ﻣﯿﺘﻮاﻧﺪ ﻣﻘﺎدﯾﺮ‬face
‫ را ﻣﯿﺘﻮاﻧﺪ ﺑﮕﯿﺮد ﮐﻪ‬GL_LINE ‫ ﯾﺎ‬GL_POINT ‫ ﯾﺎ‬GL_FILL ‫ ﻧﯿﺰ ﻣﻘﺎدﯾﺮ‬mode ‫اﺧﺘﺼﺎص دﻫﺪ و ﭘﺎراﻣﺘﺮ‬
. ‫ اﺳﺖ‬GL_FILL ‫ﭘﯿﺸﻔﺮض آن‬

: ‫ﺿﻠﻌﯽ رﺳﻢ ﮐﻨﺪ‬4 ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ ﻟﻮزي و ﻣﺘﻮازي اﻻﺿﻼع را ﺑﻪ وﺳﯿﻠﻪ‬: ‫ﻣﺜﺎل‬
#include<gl/glut.h>
void init()
{
glClearColor(0,0,0,0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(100,100,0,200);

}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glPolygonMode(GL_FRONT_AND_BACK,
_AND_BACK, GL_LINE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glBegin(GL_QUADS);
glVertex2f(-0.8, 0);
glVertex2f(-0.4, 0.4);
glVertex2f(0.0, 0.0);
glVertex2f(-0.4, -0.4);
glVertex2f(0.9, 0.5);
glVertex2f(0.2, 0.5);
glVertex2f(0.1, 0.0);
glVertex2f(0.8, 0.0);
glEnd();
glFlush();
}
int main(int argc,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200,200);
glutCreateWindow("QUADS");
);
init();
glutDisplayFunc(display);
isplayFunc(display);
glutMainLoop();
return 0;
} : ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

33
‫ و ﺑﺎ رﻧﮓ زرد رﺳﻢ‬4 ‫ ﮐﻪ ﺑﺎ رﻧﮓ آﺑﯽ ﭘﺮ ﺷﺪه و در وﺳﻂ آن ﻣﺮﺑﻌﯽ ﺑﻪ ﺿﻠﻊ‬9 ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ داﯾﺮه اي ﺗﻮﭘﺮ ﺑﻪ ﺷﻌﺎع‬: ‫ﻣﺜﺎل‬
:‫ﮐﻨﺪ‬

#include <GL/glut.h>
#include <math.h>
int Height=400, Width=400;
#define edgeOnly 0
void DrawCircle(double radius, int numberOfSides)
{

// if edge only, use line strips; otherwise , use polygons

if(edgeOnly)
glBegin(GL_LINE_STRIP);
else
glBegin(GL_POLYGON);
// calculate each vertex on the circle
for ( int vertex = 0; vertex < numberOfSides; vertex++ )
{
// calculate the angle of current vertex
// ( vertex # * 2 * PI ) / # of sides
float angle_c = (float)) vertex * 2.0 * 3.14159 / numberOfSides;
glColor3f(0,0,1); // Blue Color
// draw the current vertex at the correct radius
glVertex2f(cosf(angle_c)*radius, sinf(angle_c)*radius);
}
// if drawing edge only, then need to complete the loop with first vertex
if(edgeOnly)
glVertex2f(radius, 0.0);
glEnd();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
DrawCircle(0.8, 100);
glColor3f(1, 1, 0);
glBegin(GL_QUADS);
glVertex2f(-0.2, 0.2);
glVertex2f(-0.2, -0.2);
glVertex2f(0.2, -0.2);
glVertex2f(0.2, 0.2);
glEnd();
glutSwapBuffers();
}
int main(int argc, char **argv)
{ : ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬
glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE);
glutInitWindowSize(Width, Height);
glutCreateWindow("Circle Example");
glutDisplayFunc(display);

glutMainLoop();
}

34
 : ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ ﻣﺜﻠﺚ ﺑﺎ ﻃﯿﻒ رﻧﮕﯽ اﯾﺠﺎد ﮐﻨﺪ‬: ‫ﻣﺜﺎل‬

#include <GL/glut.h>

void Init(void)
{
glClearColor(1.0,1.0,1.0,0.0);
};
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glRotatef(0,0.0,0.0,1.0);
glBegin(GL_POLYGON);
glColor3f(1.0, 0.0, 0.0);
glVertex2f(-0.5, -0.5);
glColor3f(0.0, 1.0, 0.0);
glVertex2f(0.5, -0.5);
glColor3f(0.0, 0.0, 1.0);
glVertex2f(0.0, 0.5);
glEnd();
glPopMatrix();
glutSwapBuffers();
}

int main(int argc, char **argv)

{glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(100,100);
glutInitWindowSize(400,400);
glutCreateWindow("Gradiant Triangle");
Init();
glutDisplayFunc(display);
: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬
glutMainLoop();
return 0;
}

35
 : 5‫ رﺳﻢ ﺧﻂ ﺑﻪ وﺳﯿﻠﻪ اﻟﮕﻮرﯾﺘﻢ ﺑﺮزﻧﻬﺎم‬: ‫ﻣﺜﺎل‬

#include<GL/glut.h>
#include <stdlib.h>
#include <math.h>
void init(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,300.0,0.0,300.0);
}
void setPixel(GLint xCoordinate, GLint yCoordinate)
{
glBegin(GL_POINTS);
glVertex2i(xCoordinate,yCoordinate);
glEnd();
glFlush(); //executes all OpenGL functions as quickly as possible
}
//Bresenham line-drawing procedure for |m| < 1.0
void lineBres(GLint x0, GLint y0, GLint xEnd, GLint yEnd)
{
GLint dx = abs(xEnd - x0);
GLint dy = abs(yEnd - y0);
GLint p = 2 * dy - dx;
GLint twoDy = 2 * dy;
GLint twoDyMinusDx = 2 * (dy-dx);
GLint x,y;
// determine which endpoint to use as start position
if (x0 > xEnd){
x = xEnd;
y = yEnd;
xEnd = x;
}else{
x = x0;
y = y0;
}
setPixel(x,y);
while(x<xEnd){
x++;
if(p<0)
p += twoDy;
else{
y++;
p += twoDyMinusDx;
}
setPixel(x,y);
}
}
void drawMyLine(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glPointSize(4.0);
GLint x0 = 100;
GLint y0 = 150;
GLint xEnd = 200;
GLint yEnd = 200;
lineBres(x0,y0,xEnd,yEnd);
}
void main(int argc, char**argv)
{

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

36
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(400,400);
glutInitWindowPosition(0,0);
glutCreateWindow("Bresenham");

init();
glutDisplayFunc(drawMyLine);
glutMainLoop();
}

: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

37
 : ‫ رﺳﻢ داﯾﺮه ﺑﻪ وﺳﯿﻠﻪ اﻟﮕﻮرﯾﺘﻢ ﻧﻘﻄﻪ ﻣﯿﺎﻧﯽ‬: ‫ﻣﺜﺎل‬

#include<GL/glut.h>
class screenPoint
{
private:
GLint x,y;
public:
/* Defult constructor: initializes coordinates position to (0,0) */
screenPoint()
{
x = 0;
y = 0;
}
//Methods
void setCoordinates(GLint xCoordinateValue, GLint yCoordinateValue)
{
x = xCoordinateValue;
y = yCoordinateValue;
}
GLint getx () const
{
return x;
}
GLint gety () const
{
return y;
}
void incrementx ()
{
x++;
}
void decrementy ()
{
y--;
}
};
void setPixel(GLint xCoordinate, GLint yCoordinate)
{
glBegin(GL_POINTS);
glVertex2i(xCoordinate, yCoordinate);
glEnd();
glFlush(); //process all OpenGL functions as quickly as possible
}
void circleMidPoint(GLint xc, GLint yc, GLint raduis)
{
screenPoint circlePoint;
//initialize value for midpoint parameter
GLint p = 1-raduis;
//set coordinates for top point of circle
circlePoint.setCoordinates(0,raduis);
//function prototype
void circlePlotPoints(GLint, GLint, screenPoint);
//plot the initial point in each quadrant
circlePlotPoints(xc, yc, circlePoint);
//calculate the next point and plot in each octant
while(circlePoint.getx() < circlePoint.gety())
{
circlePoint.incrementx();
if(p<0)
p += 2 * circlePoint.getx() + 1;
else{
circlePoint.decrementy ();
p += 2 * (circlePoint.getx () - circlePoint.gety ()) + 1;

38
}
circlePlotPoints(xc, yc, circlePoint);
}
}
void circlePlotPoints(GLint
(GLint xc, GLint yc, screenPoint circPoint)
{
setPixel(xc + circPoint.getx () , yc + circPoint.gety ());
setPixel(xc - circPoint.getx () , yc + circPoint.gety ());
setPixel(xc + circPoint.getx () , yc - circPoint.gety ());
setPixel(xc - circPoint.getx () , yc - circPoint.gety ());
setPixel(xc + circPoint.gety () , yc + circPoint.getx ());
setPixel(xc - circPoint.gety () , yc + circPoint.getx ());
setPixel(xc + circPoint.gety () , yc - circPoint.getx ());
setPixel(xc - circPoint.gety () , yc - circPoint.getx ());
}
//Initialize OpenGL
void init(void)
{
glClearColor(0.0,0.0,0.0,0.0); //set display
display-window color to black
glMatrixMode(GL_PROJECTION); //set projection parameters
gluOrtho2D(0.0,300.0,0.0,300.0);
}
void drawMyCircle(void)
{
glClear(GL_COLOR_BUFFER_BIT); //clear display
display-window
glColor3f(1.0,0.0,0.0); //set pixel color to red
glPointSize(3.0);
GLint xCenter = 150;
GLint yCenter = 150;
GLint raduis = 100;
circleMidPoint(xCenter, yCenter, raduis);
}
void main(int argc, char**argv)
{
glutInit(&argc, argv); //initialize GLUT
glutInitWindowPosition(10,10); //set top
top-left display-window position
glutInitWindowSize(500,500); //set display
display-window width and height to 500
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); //set display mode
//Now display the window with a title
glutCreateWindow("Circle Mid Point ");
);
init(); //execute initialization procedure of OpenGL
glutDisplayFunc(drawMyCircle); //send graphics to display window
glutMainLoop(); //display everything and wait
}
: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

39
 : ‫ ﺑﺮﻧﺎﻣﻪ رﺳﻢ داﯾﺮه ﺑﻪ وﺳﯿﻠﻪ اﻟﮕﻮرﯾﺘﻢ ﺑﺮزﻧﻬﺎم‬: ‫ﻣﺜﺎل‬
#include<GL/glut.h>
#include<stdlib.h>
#include<math.h>
GLfloat x=10.0 ;
GLfloat y=0.0;
GLfloat x1;
void init()
{
glClearColor(0,0,0,0);
gluOrtho2D(-20,20,-20,20);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
x=15;
y=0;
x1=0;

glColor3f(1,0,0);
while(x>y)
{

glBegin(GL_POINTS);
{
glVertex2f(x,y);
glVertex2f(-x,y);
glVertex2f(x,-y);
glVertex2f(-x,-y);
glVertex2f(y,x);
glVertex2f(-y,x);
glVertex2f(-y,-x);
glVertex2f(y,-x);
}

glEnd();
y++;
x1=sqrt((x*x)-2*y-1); : ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬
x=x1;
}
glFlush();
}

int main(int argc,char **argv)

{
glutInit(&argc,argv);
glutInitWindowSize(300,300);
glutInitWindowPosition(200,200);
glutCreateWindow("test");
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

40
 : ‫ رﺳﻢ داﯾﺮه ﺑﻪ روش دﮐﺎرﺗﯽ‬: ‫ﻣﺜﺎل‬

#include<GL/glut.h>
#include <stdlib.h>
#include <math.h>
void init(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,300.0,0.0,300.0);
}
void setPixel(GLint xCoordinate, GLint yCoordinate)
{
glBegin(GL_POINTS);
glVertex2i(xCoordinate,yCoordinate);
glEnd();
glFlush(); //executes all OpenGL functions as quickly as possible
}

double round(double x)
{
return floor(x + 0.5);
}

void floatCircle(GLint XCenter, GLint YCenter, GLint r)

{
GLint x, y;
GLfloat yr;
GLdouble s;
for( x = -r; x <= r ; x ++)
{
s=r*r -x*x;
yr = sqrt(s);
y = round(yr);
setPixel(x+XCenter, y+YCenter);
setPixel(x+XCenter, -y+YCenter); : ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬
}
}

void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1,0,0);
floatCircle(150,150,100);
glFlush();
}

void main(int argc, char**argv)

{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(400,400);
glutInitWindowPosition(0,0);
glutCreateWindow("Dekarti");

init();
glutDisplayFunc(display);
glutMainLoop();
}

41
 : ‫ رﺳﻢ داﯾﺮه ﺑﻪ روش ﻗﻄﺒﯽ‬: ‫ﻣﺜﺎل‬

#include<GL/glut.h>
#include <stdlib.h>
#include <math.h>
const float PI=3.14;
int circle_points=100;
void init(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,300.0,0.0,300.0);
}
void setPixel(GLint xCoordinate, GLint yCoordinate)
{
glBegin(GL_POINTS);
glVertex2i(xCoordinate,yCoordinate);
glEnd();
glFlush(); //executes all OpenGL functions as quickly as possible
}

double round(double x)
{
return floor(x + 0.5);
}

void MyCircle(GLfloat centerx, GLfloat centery, GLfloat radius)

{
GLint i;
GLdouble angle;
glBegin(GL_POLYGON);
for (i = 0; i < circle_points; i++) {
angle = 2*PI*i/circle_points;
glVertex2f(centerx+radius*cos(angle),
centery+radius*sin(angle));
}
glEnd();
} : ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1,0,0);
MyCircle(150,150,100);
glFlush();
}

void main(int argc, char**argv)

{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(400,400);
glutInitWindowPosition(0,0);
glutCreateWindow("Gotbi");

init();
glutDisplayFunc(display);
glutMainLoop();
}

42
 :‫ ﺑﺮﻧﺎﻣﻪ رﺳﻢ ﺧﻂ ﺑﺎ ﻧﻘﻄﻪ‬: ‫ﻣﺜﺎل‬
#include<GL/glut.h>

void init()
{
glClearColor(0.1,0.2,0.1,0);
glutInitWindowPosition(200,60);
glutInitWindowSize(800,400);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0,100,0,200);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
for(int i=1; i<2000 ;i++)
{
glBegin(GL_POINTS);
glVertex2i(i,i*2);
glEnd();

}
glFlush();
}
int main(int argc,char**argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutCreateWindow("Test");
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

43
 ‫ﮔﺮاﻓﯿﮏ ﺳﻪ ﺑﻌﺪي در ‪: opengl‬‬

‫ﺑﺮاي رﺳﻢ اﺷﯿﺎي ﺳﻪ ﺑﻌﺪي ﻫﻤﺎﻧﻨﺪ رﺳﻢ اﺷﯿﺎي دو ﺑﻌﺪي ﻋﻤﻞ ﻣﯿﮑﻨﯿﻢ ‪ .‬رﺳﻢ اﺷﯿﺎي ﺳﻪ ﺑﻌﺪي ﺑﺴﯿﺎر ﺑﺴﯿﺎر ﺳﺎده و آﺳﺎن اﺳﺖ و ﺑﺮاي‬
‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن ‪ OpenGL‬ﻟﺬت ﺑﺨﺶ ﺗﺮﯾﻦ ﺑﺨﺶ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ اﺳﺖ‪.‬‬

‫ﺗﺮﺳﯿﻢ اﺷﮑﺎل ﺳﻪ ﺑﻌﺪي ‪:‬‬

‫ﻗﺎب ﺳﯿﻤﯽ)‪ : (Wire frame‬ﺷﯽ را ﺑﺎ اﺳﺘﻔﺎده از ﺧﻄﻮط رﺳﻢ ﻣﯽ ﻧﻤﺎﯾﺪ ﺗﺎ ﻟﺒﻪ ﻫﺎي ﻣﺮﺋﯽ ﭼﻨﺪ ﺿﻠﻌﯽ ﻫﺎ را ﻧﻤﺎﯾﺶ دﻫﺪ ‪.‬‬
‫‪ :‬ﺳﻄﺢ ﺷﯽ را ﺑﻪ ﺻﻮرت ﻫﻤﺮاه رﻧﮓ و ﺑﻪ ﺻﻮرت ﻫﻤﻮار ﻧﻤﺎﯾﺶ ﻣﯿﺪﻫﺪ‪.‬و اﯾﻦ ﺣﺎﻟﺖ ﺑﺎﻻﺗﺮﯾﻦ ﺳﻄﺢ‬ ‫ﻫﻤﻮار ) ‪(Smooth‬‬
‫واﻗﻊ ﮔﺮاﯾﯽ را داراﺳﺖ‪.‬‬

‫‪44‬‬
‫اﯾﻦ دﺳﺘﻮر ﺑﺮاي رﺳﻢ ﻣﮑﻌﺐ ﺑﻪ ﺻﻮرت ﺳﯿﻤﯽ اﺳﺖ‬ glutWireCube(GLdouble size)

‫اﯾﻦ دﺳﺘﻮر ﺑﺮاي رﺳﻢ ﻣﮑﻌﺐ ﺑﻪ ﺻﻮرت ﻫﻤﻮار اﺳﺖ‬ glutSolidCube(GLdouble size)

glutWireCone(GLdouble base,
‫اﯾﻦ دﺳﺘﻮر ﺑﺮاي رﺳﻢ ﻣﺨﺮوط ﺑﻪ ﺻﻮرت ﺳﯿﻤﯽ اﺳﺖ‬ GLdouble height,GLint slices, GLint
(stacks

‫اﯾﻦ دﺳﺘﻮر ﺑﺮاي رﺳﻢ ﻣﺨﺮوط ﺑﻪ ﺻﻮرت ﻫﻤﻮار اﺳﺖ‬ glutSolidCone(GLdouble base,
GLdouble height,GLint slices, GLint
(stacks

‫اﯾﻦ دﺳﺘﻮر ﺑﺮاي رﺳﻢ ﮐﺮه ﺑﻪ ﺻﻮرت ﺳﯿﻤﯽ اﺳﺖ‬ glutWireSphere(GLdouble

radius,GLint slices, GLint stacks)

‫اﯾﻦ دﺳﺘﻮر ﺑﺮاي رﺳﻢ ﮐﺮه ﺑﻪ ﺻﻮرت ﻫﻤﻮار اﺳﺖ‬ glutSolidSphere(GLdouble

radius,GLint slices, GLint stacks)

45
 glutWireTorus(GLdouble
‫اﯾﻦ دﺳﺘﻮر ﺑﺮاي رﺳﻢ ﺗﯿﻮب ﺑﻪ ﺻﻮرت ﺳﯿﻤﯽ اﺳﺖ‬ innerRadius,GLdouble
outerRadius,GLint nsides, GLint
rings)

glutSolidTorus(GLdouble
‫اﯾﻦ دﺳﺘﻮر ﺑﺮاي رﺳﻢ ﺗﯿﻮب ﺑﻪ ﺻﻮرت ﻫﻤﻮار اﺳﺖ‬ innerRadius,GLdouble
outerRadius,GLint nsides, GLint
rings)

‫اﯾﻦ دﺳﺘﻮر ﺑﺮاي رﺳﻢ ﻗﻮري ﺑﻪ ﺻﻮرت ﺳﯿﻤﯽ اﺳﺖ‬ glutWireTeapot(GLdouble size)

‫اﯾﻦ دﺳﺘﻮر ﺑﺮاي رﺳﻢ ﻗﻮري ﺑﻪ ﺻﻮرت ﻫﻤﻮار اﺳﺖ‬ glutSolidTeapot(GLdouble size)

46
 ‫راﻫﻨﻤﺎي ﺑﺮﺧﯽ از دﺳﺘﻮرات ‪:‬‬

‫)‪ : glShadeModel(GLenum Mode‬ﯾﮑﯽ از ﻗﺎﺑﻠﯿﺖ ﻫﺎي ﻣﻬﻢ ‪ OpenGL‬ﺗﺮﮐﯿﺐ رﻧﮓ ﻫﺎي ﻣﺨﺘﻠﻒ در ﯾﮏ ﺷﺊ‬ ‫‪o‬‬
‫اﺳﺖ‪ .‬ﮐﻪ در اﯾﻦ ﮐﺎر ﻫﺮ راس از ﺷﺊ رﻧﮓ ﻣﺘﻔﺎوﺗﯽ ﻣﯿﮕﯿﺮد‪ .‬اﯾﻦ ﺗﺎﺑﻊ ﺑﻪ ‪ OpenGL‬ﻣﯿﮕﻮﯾﺪ ﮐﻪ اﺷﯿﺎي ﻣﺎ ﻓﻘﻂ ﯾﮏ رﻧﮓ ﺑﮕﯿﺮﻧﺪ ﯾﺎ ﺑﺎ‬
‫ﭼﻨﺪ رﻧﮓ ﻣﺨﺘﻠﻒ رﻧﮓ آﻣﯿﺰي ﺷﻮﻧﺪ‪ .‬اﯾﻦ ﺗﺎﺑﻊ ﺑﻪ ﺟﺎي ‪ GLenum Mode‬ﻣﯿﺘﻮاﻧﺪ ﻣﻘﺎدﯾﺮ زﯾﺮ را ﺑﮕﯿﺮد ‪:‬‬

‫‪ :‬ﻓﻘﻂ ﯾﮏ رﻧﮓ ﻣﯿﺘﻮاﻧﯿﻢ ﺑﻪ ﺷﺊ اﺧﺘﺼﺎص دﻫﯿﻢ‪.‬‬ ‫‪GL_FLAT -1‬‬

‫‪ : GL_SMOOTH -2‬ﻣﯽ ﺗﻮاﻧﯿﻢ ﺗﺮﮐﯿﺒﯽ از رﻧﮕﻬﺎ را ﺑﻪ ﺷﯽ اﺧﺘﺼﺎص دﻫﯿﻢ‪.‬‬

‫در ﺣﺎﻟﺖ ﭘﯿﺶ ﻓﺮض ﻣﻘﺪار ﺗﺎﺑﻊ ‪ glShadeModel‬ﺑﺮاﺑﺮ ‪ GL_FLAT‬اﺳﺖ ﮐﻪ ﻣﺎ در اﯾﻦ ﺻﻮرت ﻓﻘﻂ ﯾﮏ رﻧﮓ ﻣﯿﺘﻮاﻧﯿﻢ ﺑﻪ ﺷﺊ‬
‫ﻣﺎن اﺧﺘﺼﺎص دﻫﯿﻢ‪.‬‬

‫ﺑﺎﯾﺪ ﻫﻤﯿﺸﻪ اﯾﻦ ﻧﮑﺘﻪ را ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﯿﺪ ﮐﻪ ﺗﺎﺑﻊ ‪ glShadeModel‬ﻗﺒﻞ از ﺑﻠﻮك ‪ glBegin / glEnd‬ﺑﯿﺎﯾﺪ ﮐﻪ در ﻏﯿﺮ اﯾﻦ‬
‫ﺻﻮرت ﺧﻄﺎ رخ ﻣﯿﺪﻫﺪ‪.‬‬

‫)‪ : glViewport(GLint x,GLint y,GLsizei width,GLsizei height‬ﺑﺮاي اﻧﺘﺨﺎب ﻧﺎﺣﯿﻪ دﯾﺪ اﺳﺘﻔﺎده ﻣﯿﺸﻮد ‪.‬‬ ‫‪o‬‬

‫ﮐﻪ در آن )‪ (x,y‬ﻣﺨﺘﺼﺎت ﭘﯿﮑﺴﻠﯽ ﮔﻮﺷﻪ ﺳﻤﺖ ﭼﭗ ﭘﺎﯾﯿﻦ درﯾﭽﻪ دﯾﺪ ﻧﺴﺒﺖ ﺑﻪ ﮔﻮﺷﻪ ﺳﻤﺖ ﭼﭗ ﭘﺎﯾﯿﻦ ﭘﻨﺠﺮه ﻣﯽ ﺑﺎﺷﺪ‪.‬‬
‫‪ height‬و ‪ Width‬ﻋﺮض و ارﺗﻔﺎع درﯾﭽﻪ دﯾﺪ ﺑﺮ ﺣﺴﺐ ﭘﯿﮑﺴﻞ ﻣﯽ ﺑﺎﺷﺪ ‪.‬‬

‫ﻓﺮض ‪ OpenGL‬اﯾﻦ ﻧﯿﺴﺖ ﮐﻪ ﺷﮑﻞ را ﺑﺮ روي ﺗﻤﺎم ﭘﻨﭽﺮه ﺑﻨﮕﺎرد‪.‬‬ ‫‪ü‬‬

‫ﭘﻨﺠﺮه ﮔﺮاﻓﯿﮑﯽ را ﻣﯽ ﺗﻮان ﺑﻪ ﭼﻨﺪ درﯾﭽﻪ ﮐﻮﭼﮏ ﺗﻘﺴﯿﻢ ﮐﺮد‪.‬‬ ‫‪ü‬‬
‫ﻫﺮ ﺗﺼﻮﯾﺮ ﻣﺠﺰا ﺑﺮ روي ﯾﮏ درﯾﭽﻪ ﻗﺎﺑﻞ رﺳﻢ اﺳﺖ‪.‬‬ ‫‪ü‬‬
‫درﯾﭽﻪ اي ﮐﻪ رﺳﻢ اﺷﮑﺎل در آن اﻧﺠﺎم ﻣﯽ ﺷﻮد‪ ،‬درﯾﭽﻪ دﯾﺪ ﻧﺎم دارد‪.‬‬ ‫‪ü‬‬
‫درﯾﭽﻪ دﯾﺪ ﻣﯽ ﺗﻮاﻧﺪ ﮐﻞ ﭘﻨﭽﺮه ﺑﺎﺷﺪ و ﯾﺎ ﻫﺮ ﻧﺎﺣﯿﻪ ﻣﺴﺘﻄﯿﻞ ﺷﮑﻞ از آن ﺑﺎﺷﺪ‪.‬‬ ‫‪ü‬‬

‫‪ : glutSwapBuffers() o‬در ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺑﺎ ‪ opengl‬ﻣﯿﺘﻮان از دو ﺑﺎﻓﺮ اﺳﺘﻔﺎده ﮐﺮد ﮐﻪ اﯾﻦ دﺳﺘﻮر ﺑﺎﻓﺮ ﭘﺸﺘﯽ را ﺑﺎ ﺑﺎﻓﺮ‬
‫ﺟﻠﻮﯾﯽ ﺟﺎﺑﺠﺎ ﻣﯿﮑﻨﺪ ‪ .‬ﺗﻤﺎم رﺳﻤﻬﺎ در ﺑﺎﻓﺮ ﭘﺸﺘﯽ اﺗﻔﺎق ﻣﯽ اﻓﺘﺪ و ﻫﻨﮕﺎﻣﯽ ﮐﻪ آﻣﺎده ﺷﺪ ﺟﺎي دو ﺑﺎﻓﺮ ﺑﺎ ﻫﻢ ﻋﻮض ﻣﯿﺸﻮداﯾﻦ‬
‫ﮐﺎر از ﭘﺮﭘﺮ زدن ﺗﺼﻮﯾﺮ ﺟﻠﻮﮔﯿﺮي ﻣﯿﮑﻨﺪ )ﺑﻪ ﻧﻤﺎﯾﺶ ﺑﺪون ﭘﺮﭘﺮ ﺗﺼﻮﯾﺮ ﻓﻠﯿﮑﺮ ﻧﯿﺰ ﻣﯿﮕﻮﯾﻨﺪ( ‪.‬‬

‫اﮔﺮ ﭘﻨﺠﺮه ﺗﮏ ﺑﺎﻓﺮ ﺑﺎﺷﺪ از ‪ glFlush‬اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ ‪.‬‬

‫اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ ‪.‬‬ ‫‪glutInitDisplayMode‬‬ ‫ﯾﺎدآوري ‪ :‬ﻫﻤﺎﻧﻄﻮر ﮐﻪ ﻗﺒﻼ ﮔﻔﺘﯿﻢ ﺑﺮاي ﻣﺸﺨﺺ ﮐﺮدن ﺗﻌﺪاد ﺑﺎﻓﺮﻫﺎ از دﺳﺘﻮر‬

‫‪47‬‬
 ‫)(‪ : glutPostRedisplay‬ﺑﺎ اﺳﺘﻔﺎده از اﯾﻦ ﺗﺎﺑﻊ ﺑﻪ ﺻﻮرت ﻣﺠﺎزي رﺧﺪاد ‪ refresh‬را ﺑﺮاي ﭘﻨﺠﺮه ﻓﻌﺎل ﻣﯽ ﺷﻮد‪.‬‬ ‫‪o‬‬

‫زﻣﺎﻧﯽ از اﯾﻦ ﺗﺎﺑﻊ اﺳﺘﻔﺎده ﻣﯽ ﮐﻨﯿﻢ ﮐﻪ ﻣﯽ ﺧﻮاﻫﯿﻢ ﺑﯿﻦ ﯾﮏ ﺗﺎﺑﻊ و ﺗﺎﺑﻊ ‪ display‬ارﺗﺒﺎط ﺑﺮﻗﺮار ﮐﻨﯿﻢ‪.‬‬

‫))‪ : glutIdleFunc(void (*func)(void‬اﯾﻦ ﺗﺎﺑﻊ ‪ ,‬ﺗﺎﺑﻊ ﻧﻤﺎﯾﺶ را ﻣﮑﺮرا ﺗﮑﺮار ﻣﯿﮑﻨﺪ ﺗﺎزﻣﺎﻧﯽ ﮐﻪ دﯾﮕﺮ ﻫﯿﭻ رﺧﺪادي‬ ‫‪o‬‬
‫درﯾﺎﻓﺖ ﻧﺸﻮد ‪.‬‬

‫))‪ : glutMouseFunc(void (*func)(int button, int state,int x, int y‬ﺗﺎﺑﻊ ‪ callback‬ﺑﺮاي ﻣﺎوس در ﭘﻨﺠﺮه‬ ‫‪o‬‬
‫ﺟﺎري را ﻣﺸﺨﺺ ﻣﯿﮑﻨﺪ‪.‬ﺗﺎﺑﻌﯽ ﮐﻪ ﺑﻌﻨﻮان ﺗﺎﺑﻊ ﭘﺮدازش ﻣﺎوس ﺑﻪ ﺗﺎﺑﻊ ﻓﻮق ﻣﻌﺮﻓﯽ ﻣﯽ ﺷﻮد ﺑﺎﯾﺪ ﭼﻬﺎر ورودي داﺷﺘﻪ ﺑﺎﺷﺪ‪:‬‬
‫ﭘﺎراﻣﺘﺮ اول ﻣﻌﯿﻦ ﻣﯽ ﮐﻨﺪ ﮐﻪ ﮐﺪام دﮐﻤﻪ ﻣﺎوس ﻓﺸﺮده ﯾﺎ رﻫﺎ ﺷﺪه اﺳﺖ ﮐﻪ ﺳﻪ ﺣﺎﻟﺖ دارد ‪:‬‬
‫‪GLUT_LEFT_BUTTON‬‬
‫‪GLUT_MIDDLE_BUTTON‬‬
‫‪GLUT_RIGHT_BUTTON‬‬

‫ﭘﺎراﻣﺘﺮ دوم وﺿﻌﯿﺖ دﮐﻤﻪ ﻣﺮﺑﻮﻃﻪ‪ ،‬ﯾﻌﻨﯽ ﻓﺸﺮده ﺷﺪن ﯾﺎ رﻫﺎ ﺷﺪن آن اﺳﺖ ﮐﻪ دو ﺣﺎﻟﺖ زﯾﺮ را دارد‪:‬‬
‫‪GLUT_DOWN‬‬
‫‪GLUT_UP‬‬
‫ﭘﺎراﻣﺘﺮ ﺳﻮم و ﭼﻬﺎرم ﻧﯿﺰ ﻣﻮﻗﻌﯿﺖ ﻣﺎوس در ﻣﺨﺘﺼﺎت ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫))‪ : glutKeyboardFunc(void (*func)(unsigned char key,int x, int y‬ﺗﺎﺑﻊ ‪ callback‬ﺑﺮاي ﮐﯽ ﺑﻮرد در‬ ‫‪o‬‬
‫ﭘﻨﺠﺮه ﺟﺎري را ﻣﺸﺨﺺ ﻣﯿﮑﻨﺪ‪ .‬ﺑﺮاي ﭘﺮدازش ﻓﺸﺮده ﺷﺪن ﮐﻠﯿﺪﻫﺎي ﻣﻌﻤﻮﻟﯽ ﺑﻪ ﮐﺎر ﺑﺮده ﻣﯽ ﺷﻮد‪.‬ﮐﻠﯿﺪﻫﺎي ﻣﻌﻤﻮﻟﯽ ﻣﺜﻞ ﺣﺮوف‬
‫اﻟﻔﺒﺎ و اﻋﺪاد و ﻫﻤﻪ ﮐﺎراﮐﺘﺮﻫﺎﯾﯽ ﮐﻪ داراي ﮐﺪ اﺳﮑﯽ ﻫﺴﺘﻨﺪ‪.‬ﺑﺎﺷﺪ در ﺻﻮرﺗﯿﮑﻪ ﭘﺎراﻣﺘﺮ ﺗﺎﺑﻊ ﻓﻮق‪ NULL‬از ﮐﻠﯿﺪﻫﺎي ﻣﻌﻤﻮﻟﯽ‬
‫ﺻﺮﻓﻨﻈﺮ ﻣﯽ ﺷﻮد‪.‬‬

‫ﺗﺎﺑﻌﯽ ﮐﻪ ﺑﻌﻨﻮان ﭘﺎراﻣﺘﺮ ﺗﺎﺑﻊ ﻓﻮق ﻣﻌﺮﻓﯽ ﻣﯽ ﺷﻮد ﺑﺎﯾﺴﺘﯽ ﺳﻪ ﭘﺎراﻣﺘﺮ ورودي داﺷﺘﻪ ﺑﺎﺷﺪ ‪:‬‬

‫‪ ü‬ﮐﺪ اﺳﮑﯽ ﮐﻠﯿﺪ ﻓﺸﺮده ﺷﺪه‬

‫‪ ü‬ﻣﺨﺘﺼﺎت ﻣﺎوس در ﻫﻨﮕﺎم ﻓﺸﺮده ﺷﺪن ﮐﻠﯿﺪ ﻧﺴﺒﺖ ﺑﻪ ﮔﻮﺷﻪ ﺳﻤﺖ ﭼﭗ ﺑﺎﻻ ﭘﻨﺠﺮه )‪ (x,y‬ﺑﺮ ﺣﺴﺐ ﭘﯿﮑﺴﻞ‬

‫‪48‬‬
 ‫)‪: glutReshapeFunc(reshape‬‬ ‫‪o‬‬
‫ﺑﻪ ﻫﻨﮕﺎم ﺗﻐﯿﯿﺮ اﻧﺪازه ﭘﻨﺠﺮه ﺗﺎﺑﻊ ‪ reshape‬ﻓﺮاﺧﻮاﻧﯽ ﺧﻮاﻫﺪ ﺷﺪ ‪.‬‬ ‫‪ü‬‬
‫ﺷﺎﻣﻞ اوﻟﯿﻦ رﺳﻢ ﭘﻨﺠﺮه ﻧﯿﺰ ﻣﯽ ﺑﺎﺷﺪ ‪.‬‬ ‫‪ü‬‬
‫ﺗﺎﺑﻊ‪ ،‬ﻋﺮض و ارﺗﻔﺎع ﭘﻨﺠﺮه ﺟﺪﯾﺪ را ﺑﻪ ﺑﻌﻨﻮان ﭘﺎراﻣﺘﺮ درﯾﺎﻓﺖ ﻣﯽ ﮐﻨﺪ‪.‬‬ ‫‪ü‬‬

‫)‪void reshape (int width, int height‬‬

‫{‬
‫;)‪glViewport (0, 0, width, height‬‬
‫}‬

‫‪ : glPopMatrix() o‬ﻣﺎﺗﺮﯾﺲ ﺑﺎﻻي ﭘﺸﺘﻪ را ﺑﺮداﺷﺘﻪ و ﺑﻌﻨﻮان ﻣﺎﺗﺮﯾﺲ ﻓﻌﻠﯽ ﻗﺮار ﻣﯽ دﻫﺪ‪.‬‬

‫‪ : glPushMatrix() o‬ﺗﻤﺎم ﺗﻮاﺑﻊ دﯾﮕﺮ ﻣﺎﺗﺮﯾﺲ ﻓﻌﻠﯽ ﺑﻪ ﻏﯿﺮ از ﺑﺎﻻي ﭘﺸﺘﻪ را ﺗﺨﺮﯾﺐ ﻣﯽ ﮐﻨﺪ‪.‬‬

‫‪ : glTranslate{f,d}( TYPE x, TYPE, y, TYPE z ) o‬ﺑﺮاي اﻧﺘﻘﺎل ﯾﮏ ﺟﺴﻢ از ﻧﻘﻄﻪ اي ﺑﻪ ﻧﻘﻄﻪ دﯾﮕﺮ اﺳﺘﻔﺎده ﻣﯿﺸﻮد و‬
‫ﻣﺎﺗﺮﯾﺲ ﺟﺎري را در ﻣﺎﺗﺮﯾﺲ ﺗﺒﺪﯾﻞ ﺿﺮب ﻣﯽ ﮐﻨﺪ ‪.‬‬

‫‪49‬‬
‫) ‪ : glRotate{f,d}( TYPE angle, TYPE x, TYPE y, TYPE z‬ﺑﺮاي دوران ﯾﮏ ﺟﺴﻢ اﺳﺘﻔﺎده ﻣﯿﺸﻮد ‪.‬‬ ‫‪o‬‬
‫دوران ﺣﻮل ﻣﺤﻮر دﻟﺨﻮاه ﺑﺎ زاوﯾﻪ اي ﺑﻪ اﻧﺪازه ‪angle‬‬ ‫‪ü‬‬
‫دوران ﺣﻮل ﻣﺤﻮر ‪(angle,1.0,0.0,0.0) x‬‬ ‫‪ü‬‬
‫دوران ﺣﻮل ﻣﺤﻮر ‪(angle,o.0,1.0,0.0) y‬‬ ‫‪ü‬‬
‫دوران ﺣﻮل ﻣﺤﻮر ‪(angle,0.0,0.0,1.0) z‬‬ ‫‪ü‬‬

‫‪ : glScale{f,d}( TYPE x, TYPE y, TYPE z) o‬ﺑﺮاي ﻣﻘﯿﺎس ﯾﮏ ﺟﺴﻢ اﺳﺘﻔﺎده ﻣﯿﺸﻮد ‪.‬‬

‫‪50‬‬
 ‫)‪: glLight{f,i}{v}(GLenum light,GLenum pname,const GLfloat *params‬‬ ‫⃝‬

‫ﻧﻮر ﭘﺮدازي در ‪ OpenGL‬ﺑﺎﻋﺚ ﻣﯿﺸﻮد ﮐﻪ ﺻﺤﻨﻪ ﻫﺎﯾﯽ ﮐﻪ ﺧﻠﻖ ﻣﯿﺸﻮﻧﺪ ﻃﺒﯿﻌﯽ ﺑﻪ ﻧﻈﺮ ﺑﺮﺳﻨﺪ‪ .‬در ‪ opengl‬ﻣﺎ ﭼﻬﺎر ﻧﻮع ﻧﻮر ﭘﺮدازي‬
‫دارﯾﻢ ‪ Ambient‬و ‪ Diffuse‬و ‪ Specular‬و ‪. Emmisive‬‬

‫در ﺗﺎﺑﻊ ﺑﺎﻻ آرﮔﻮﻣﺎن ‪ GLenum light‬ﻧﺎم ﻣﻨﺒﻊ ﻧﻮر اﺳﺖ و ‪ GLenum pname‬ﻧﻮع دﺳﺘﺮﺳﯽ ﺑﻪ ﻧﻮر اﺳﺖ ﮐﻪ اﮔﺮ ﯾﮑﯽ از‬
‫ﻣﻘﺎدﯾﺮ)‪ (GL_DIFFUSE, GL_ AMBIENT, GL_ SPECULAR, GL_ EMMISIVE‬ﺑﺎﺷﺪ ﺑﯿﺎﻧﮕﺮ اﯾﻦ اﺳﺖ ﮐﻪ آرﮔﻮﻣﺎن‬
‫ﺑﻌﺪي رﻧﮓ ﻧﻮر را ﭘﺮدازش ﺧﻮاﻫﺪ ﮐﺮد ﮐﻪ اﯾﻦ آراﯾﻪ داراي ‪ 4‬اﻧﺪﯾﺲ ﯾﺎ ﻋﻀﻮ اﺳﺖ ‪ .‬ﺳﻪ ﻋﻀﻮ اول آراﯾﻪ ﻣﺸﺨﺺ ﮐﻨﻨﺪه ي رﻧﮓ ‪R,G,B‬‬
‫اﺳﺖ و ﻋﻀﻮ آﺧﺮ ﻣﻘﺪار ‪ Alpha‬اﺳﺖ ﮐﻪ ﺷﺪت ﻧﻮر رو ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ‪ .‬اﻣﺎ اﮔﺮ آرﮔﻮﻣﺎن دوم ﺑﺮاﺑﺮ ﻣﻘﺪار ‪ GL_POSITION‬ﺑﺎﺷﺪ‬
‫ﺑﯿﺎﻧﮕﺮ اﯾﻦ اﺳﺖ ﮐﻪ آرﮔﻮﻣﺎن ﺳﻮم ﻣﺤﻞ ﻧﻮر را ﭘﺮدازش ﺧﻮاﻫﺪ ﮐﺮد و اﯾﻦ آراﯾﻪ ﺑﺎﯾﺪ ﺳﻪ ﻋﻨﺼﺮي ﺑﺎﺷﺪ ﮐﻪ ﻣﺸﺨﺺ ﮐﻨﻨﺪه ي ‪X,Y,Z‬‬
‫ﻫﺴﺘﻨﺪ ‪ .‬ﺑﻪ ﻣﻘﺎدﯾﺮ زﯾﺮ ﺗﻮﺟﻪ ﮐﻨﯿﺪ ‪:‬‬
‫;}‪GLfloat A[4]={1,1,1,1‬‬
‫;}‪GLfloat Pos1[4]={9,5,1,0‬‬
‫;)‪glLightfv(GL_LIGHT0,GL_DIFFUSE,A‬‬
‫;)‪glLightfv(GL_LIGHT0,GL_POSITION,Pos1‬‬

‫ﻻزم ﺑﻪ ذﮐﺮ اﺳﺖ ﮐﻪ ﺑﺮاي اﺳﺘﻔﺎده از ﻣﻨﺒﻊ ﻧﻮر ﺑﺎﯾﺪ آن را ﻓﻌﺎل ﮐﻨﯿﻢ و ﻫﻤﭽﻨﯿﻦ ﻣﻘﺎدﯾﺮ ‪ GL_LIGHTING‬و ‪GL_DEPTH_TEST‬‬
‫و ‪ GL_COLOR_MATERIAL‬ﻧﯿﺰ ﺑﺎﯾﺪ ﻓﻌﺎل ﮔﺮدﻧﺪ ‪.‬‬
‫;)‪glEnable(GL_LIGHTING‬‬
‫;)‪glEnable(GL_DEPTH_TEST‬‬
‫;)‪glEnable(GL_COLOR_MATERIAL‬‬
‫;)‪glEnable(GL_LIGHT0‬‬

‫)‪: glMaterialf{v}(GLenum face, GLenum pname, GLfloat param‬‬ ‫‪o‬‬

‫‪: glMaterialf‬‬
‫اﯾﻦ ﺗﻮاﺑﻊ ﭘﺎراﻣﺘﺮﻫﺎي ﻣﺎده را ﺑﺮاي ﻣﺪل ﻧﻮر ﭘﺮدازي ﺗﻌﯿﯿﻦ ﻣﯽ ﮐﻨﻨﺪ‪.‬‬
‫‪ : Face‬وﺟﻪ ﯾﺎ وﺟﻮﻫﯽ اﺳﺖ ﮐﻪ ﺑﺎﯾﺪ ﺑﻪ روز در آورده ﺷﻮﻧﺪ و ﯾﮑﯽ از ﺳﻪ ﻣﻘﺪار ‪, GL_FRONT GL_FRONT_AND_BACK ,‬‬
‫‪ GL_BACK‬ﻣﯽ ﺗﻮاﻧﺪ ﺑﺎﺷﺪ ‪.‬‬
‫‪ : Pname‬در اﯾﻦ ﺣﺎﻟﺖ ﻓﻘﻂ ‪ GL_SHININESS‬ﻣﯽ ﺗﻮاﻧﺪ ﺑﺎﺷﺪ و ‪ param‬ﻣﻘﺪاري اﺳﺖ ﮐﻪ ﭘﺎراﻣﺘﺮ ﯾﺎد‬
‫ﺷﺪه ﺑﻪ آن ﺗﻨﻈﯿﻢ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫‪: glMaterialfv‬‬
‫آرﮔﻮﻣﺎن ‪ face‬در آن ﻫﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ ﻗﺒﻠﯽ اﺳﺖ و ‪ pname‬ﻣﻘﺎدﯾﺮ زﯾﺮ را ﻣﯽ ﺗﻮاﻧﺪ داﺷﺘﻪ ﺑﺎﺷﺪ ‪:‬‬
‫‪ GL_AMBIENT‬و ‪ GL_DIFFUSE‬و ‪ : GL_SPECULAR‬ﻫﻤﺎﻧﻨﺪ آﻧﭽﻪ ﮐﻪ در ﻗﺴﻤﺖ ﻗﺒﻞ ﮔﻔﺘﻪ ﺷﺪ ﻣﯽ ﺑﺎﺷﻨﺪ ‪.‬‬
‫‪ : GL_EMISSION‬در اﯾﻦ ﺣﺎﻟﺖ ﭘﺎراﻣﺘﺮ ‪ param‬ﺣﺎوي ﭼﻬﺎر ﻋﺪد ﺧﻮاﻫﺪ ﺑﻮد ﮐﻪ ﺷﺪت ‪ RGBA‬ﻧﻮر ﺳﺎﺗﻊ ﺷﺪه را ﻣﻌﯿﻦ ﻣﯽ‬
‫ﮐﻨﻨﺪ‬
‫‪ : GL_SHININESS‬در اﯾﻦ ﺣﺎﻟﺖ ﭘﺎراﻣﺘﺮ ‪ param‬ﺣﺎوي ﭼﻬﺎر ﻋﺪد ﺧﻮاﻫﺪ ﺑﻮد ﮐﻪ ﺟﺰء آﯾﻨﻪ اي ‪ RGBA‬را ﻣﻌﯿﻦ ﻣﯽ ﮐﻨﻨﺪ و در‬
‫ﺑﺎزه ‪ 0‬و ‪ 128‬ﻗﺮار دارﻧﺪ‪.‬‬
‫‪ : GL_AMBIENT_AND_DIFFUSE‬ﮐﻪ ﮐﺎﻣﻼ واﺿﺢ اﺳﺖ ‪.‬‬

‫‪51‬‬
‫‪ : GL_COLOR_INDEXES‬در اﯾﻦ‪ param‬ﺣﺎوي ﺳﻪ ﻋﺪد ﺧﻮاﻫﺪ ﺑﻮد ﮐﻪ اﻧﺪﯾﺲ ﻫﺎي رﻧﮕﯽ ﻣﺤﯿﻄﯽ اﻧﺘﺸﺎري و آﯾﻨﻪ اي را‬
‫ﻣﻌﯿﻦ ﻣﯽ ﮐﻨﻨﺪ‪ .‬اﯾﻦ ﺳﻪ ﻣﻘﺪار و ‪ GL_SHININESS‬ﺗﻨﻬﺎ ﻣﻘﺎدﯾﺮ ﻣﻮاد ﺑﮑﺎر ﮔﺮﻓﺘﻪ ﺷﺪه در اﯾﻦ ﺣﺎﻟﺖ ﻧﻮر ﭘﺮدازي ﻣﯽ ﺑﺎﺷﻨﺪ‪.‬‬

‫)‪: glutTimerFunc(unsigned int msecs, void (*func)(int value), value‬‬ ‫‪o‬‬

‫ﺑﺮاي داﺷﺘﻦ ﺣﺮﮐﺖ در ﺑﺮﻧﺎﻣﻪ ﻫﺎ )اﻧﯿﻤﯿﺸﻦ( ﻣﺎ ﻧﯿﺎز ﺑﻪ رﺧﺪادي دارﯾﻢ ﮐﻪ در ﻓﻮاﺻﻞ زﻣﺎﻧﯽ ﻣﺸﺨﺺ ﺑﯿﺎﯾﺪ ﺑﺮاي اﯾﻦ از رﺧﺪاد ﺗﺎﯾﻤﺮ‬
‫اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬رﺟﯿﺴﺘﺮ ﮐﺮدن اﯾﻦ رﺧﺪاد ﺑﺎ ﺗﺎﺑﻊ ‪ glutTimerFunc‬اﺳﺖ وﻟﯽ اﯾﻦ ﺗﺎﺑﻊ ﺑﺎ ﺗﻮاﺑﻊ ﻣﺸﺎﺑﻪ ‪ 3‬ﺗﻔﺎوت دارد ‪:‬‬

‫‪ -1‬ﻓﺮاﺧﻮاﻧﯽ اﯾﻦ رﺧﺪاد در دﺳﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ اﺳﺖ )ﭘﺎراﻣﺘﺮ اول زﻣﺎن آن را ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ(‬

‫‪-2‬اﯾﻦ ﺗﺎﺑﻊ ﯾﮏ ﻣﻘﺪار ﺑﻪ ‪ event handler‬ﭘﺎس ﻣﯽ ﮐﻨﺪ ‪).‬ﭘﺎراﻣﺘﺮ دوم(‬

‫‪ -3‬اﯾﻦ دﺳﺘﻮر را ﻫﻢ در ‪ main‬ﻣﯽ ﻧﻮﯾﺴﯿﻢ و ﻫﻢ در آﺧﺮ ﺗﺎﺑﻊ ‪) event handler‬ﺗﺎﺑﻊ ﺗﺎﯾﻤﺮ(‬

‫ﺗﻮﺟﻪ ‪ :‬در آﺧﺮ ﺗﻤﺎﻣﯽ ﺗﻮاﺑﻊ ﺑﺎﻻ ﺑﺎﯾﺪ دﺳﺘﻮر ‪ glutPostRedisplay‬را ﻧﻮﺷﺖ ﺗﺎ ﺗﻐﯿﯿﺮات ﺑﻪ ﺗﺎﺑﻊ ‪ display‬رود ‪.‬‬

‫;)‪glutTimerFunc(2000,timerFunc,0‬‬

‫)‪: glFog{f,i}{v}(GLenum pname,GLfloat param‬‬ ‫‪o‬‬

‫ﺗﮑﻨﯿﮏ ﻣﻪ در اﮐﺜﺮ ﺗﺼﺎوﯾﺮ ﺳﻪ ﺑﻌﺪي ﺑﻪ ﺧﺼﻮص ﺑﺎزي ﻫﺎي ﮐﺎﻣﭙﯿﻮﺗﺮي ﻣﻮرد اﺳﺘﻔﺎده ﻗﺮار ﻣﯽ ﮔﯿﺮد‪ .‬ﭘﺎراﻣﺘﺮ ‪GLenum‬‬
‫‪ pname‬ﻣﯿﺘﻮاﻧﺪ ﻣﻘﺎدﯾﺮ ‪GL_FOG_MODE, GL_FOG_DENSITY, GL_FOG_START, GL_FOG_END,‬‬
‫‪ GL_FOG_INDEX, GL_FOG_COORD_SRC‬را ﺑﮕﯿﺮد و ﭘﺎراﻣﺘﺮ ‪ GLfloat param‬ﻣﻘﺪار ﺳﺖ ﺷﺪه ﻧﺴﺒﺖ ﺑﻪ‬
‫آرﮔﻮﻣﺎن ﻗﺒﻠﯽ را ﻣﺸﺨﺺ ﻣﯿﮑﻨﺪ ‪.‬‬
‫ﺗﮑﻨﯿﮏ ‪ fog‬ﺑﻪ ﻃﻮر ﭘﯿﺸﻔﺮض ﻏﯿﺮ ﻓﻌﺎل اﺳﺖ ﺷﻤﺎ ﺑﺮاي اﺳﺘﻔﺎده اول ﺑﺎﯾﺪ آن را ﻓﻌﺎل ﮐﻨﯿﺪﺑﻪ وﺳﯿﻠﻪ ﺗﺎﺑﻊ )‪. glEnable(GL_FOG‬‬
‫ﺑﻪ اﯾﻦ ﻣﺜﺎﻟﻬﺎ دﻗﺖ ﮐﻨﯿﺪ ‪:‬‬
‫;}‪GLfloat fogColor[4] = {0, 01, 0, 1.0‬‬
‫;)‪glFogfv (GL_FOG_COLOR, fogColor‬‬
‫ﯾﺎ‬
‫;)‪glFogf (GL_FOG_DENSITY, 0.1‬‬

‫‪52‬‬
 ‫)‪: glLineStipple(GLint factor, GLushort pattern‬‬ ‫‪o‬‬

‫اﻟﮕﻮي ﻧﻘﺶ ﯾﮏ ﺧﻂ را ﻣﻌﯿﻦ ﻣﯽ ﮐﻨﺪ ‪ .‬ﭘﺎراﻣﺘﺮ ‪ GLint factor‬در ﻫﺮ ﺑﯿﺖ اﻟﮕﻮي ﻧﻘﺶ زدن ﺿﺮب ﻣﯽ ﺷﻮد‬
‫‪ : Pattern‬ﻋﺪد ‪ 16‬ﺑﯿﺘﯽ ﺻﺤﯿﺢ ‪ ،‬ﺑﻄﻮرﯾﮑﻪ اﻟﮕﻮي ﺑﯿﺘﯽ آن ) ﺳﺮي ﺻﻔﺮ و ﯾﮏ ﻫﺎ ( ﻣﻌﯿﻦ ﻣﯽ ﺳﺎزد‬
‫ﮐﻪ ﮐﺪام اﺟﺰاء از ﺧﻂ رﺳﻢ ﺧﻮاﻫﻨﺪ ﺷﺪ ) ﻋﺪد ﯾﮏ ﺑﻪ ﻣﻌﻨﺎي ﺗﺮﺳﯿﻢ و ﺻﻔﺮ ﺑﻪ ﻣﻌﻨﺎي ﻋﺪم ﺗﺮﺳﯿﻢ ﻣﯽ ﺑﺎﺷﺪ(‪.‬‬
‫ﺑﯿﺖ ﺻﻔﺮ در اﺑﺘﺪا ﺑﮑﺎر ﻣﯽ رود و ﺗﻤﺎم اﻟﮕﻮي ﭘﯿﺶ ﻓﺮض از ﯾﮏ ﺗﺸﮑﯿﻞ ﺷﺪه اﺳﺖ‪.‬‬
‫ﻗﺒﻞ از ﺑﮑﺎ ر ﺑﺮدن اﯾﻦ ﺗﺎﺑﻊ ﺑﺎﯾﺪ از دﺳﺘﻮر )‪ glEnable(GL_LINE_STIPPLE‬ﺑﺮاي ﻓﻌﺎل ﺳﺎزي اﯾﻦ ﺣﺎﻟﺖ اﺳﺘﻔﺎده ﮐﺮد‬
‫ﺑﺮاي ﻣﺜﺎل ﺑﺎ اﻟﮕﻮي ‪ $3F07‬ﮐﻪ در ﻣﺒﻨﺎي دو ﻣﻌﺎدل ‪ 0011111100000111‬ﻣﯽ ﺑﺎﺷﺪ ‪ ،‬ﺧﻄﯽ رﺳﻢ ﺧﻮاﻫﺪ ﺷﺪ ﺑﺎ ﺳﻪ‬
‫ﻧﻘﻄﻪ روﺷﻦ ‪ 5 ،‬ﻧﻘﻄﻪ ﺧﺎﻣﻮش ‪ 6 ،‬ﻧﻘﻄﻪ روﺷﻦ و ‪ 2‬ﻧﻘﻄﻪ ﺧﺎﻣﻮش‪ .‬اﮔﺮ ‪ factor‬ﻣﺴﺎوي ‪ 2‬ﺑﺎﺷﺪ ‪ ،‬اﻟﮕﻮ ﮐﺸﯿﺪه ﻣﯽ ﺷﻮد ‪6 :‬‬
‫ﻧﻘﻄﻪ روﺷﻦ ‪ 10 ،‬ﻧﻘﻄﻪ ﺧﺎﻣﻮش ‪ 12 ،‬ﻧﻘﻄﻪ روﺷﻦ و ‪4‬ﻧﻘﻄﻪ ﺧﺎﻣﻮش ‪ .‬در ﺗﺼﻮﯾﺮ زﯾﺮ ﻣﺜﺎﻟﻬﺎي ﯾﺒﺸﺘﺮي اراﺋﻪ ﺷﺪه اﻧﺪ ‪ .‬ﺑﺎﯾﺪ ﺧﺎﻃﺮ‬
‫ﻧﺸﺎ ن ﮐﺮد ﮐﻪ اﻋﺪاد ﻣﺒﻨﺎي ‪ 16‬در زﺑﺎن ‪ C‬ﺑﺎ ‪ 0X‬آﻏﺎز ﻣﯽ ﺷﻮﻧﺪ ‪.‬‬

‫)‪: glPolygonStipple(const GLubyte *mask‬‬ ‫‪o‬‬

‫اﻟﮕﻮي ﻧﻘﺶ ﯾﮏ ﭼﻨﺪﺿﻠﻌﯽ را ﻣﻌﯿﻦ ﻣﯽ ﮐﻨﺪ ‪ mask .‬اﺷﺎره ﮔﺮي اﺳﺖ ﺑﻪ ﯾﮏ اﻟﮕﻮي‪32‬در‪ 32‬ﺑﯿﺘﯽ ‪ .‬ﻗﺒﻞ از ﺑﮑﺎر ﮔﯿﺮي‬
‫ﺗﺎﺑﻊ ﺑﺎﯾﺪ اﯾﻦ ﺣﺎﻟﺖ را ﺑﻮﺳﯿﻠﻪ دﺳﺘﻮر )‪ glEnable(GL_POLYGON_STIPPLE‬ﻓﻌﺎل ﻧﻤﻮد ‪ .‬ﺑﺼﻮرت ﭘﯿﺶ ﻓﺮض ﺗﻤﺎم ﭼﻨﺪ ﺿﻠﻌﯽ ﻫﺎ ﺑﺎ‬
‫ﯾﮏ اﻟﮕﻮي ﺗﻮﭘﺮ ﺗﺮﺳﯿﻢ ﻣﯽ ﺷﻮﻧﺪ‪.‬‬

‫)‪: glBitmap(GLsizei width, GLsizei height,GLfloat xorig, GLfloat yorig,GLfloat xmove, GLfloat ymove,const GLubyte *bitmap‬‬ ‫‪o‬‬

‫ﺑﯿﺖ ﻣﭗ ﻫﺎ آراﯾﻪ اي ﻣﺴﺘﻄﯿﻠﯽ از ﻧﻘﺎط ﻣﯽ ﺑﺎﺷﻨﺪ ﮐﻪ در ﻫﺮ ﻧﻘﻄﻪ آن ﯾﮏ ﺗﮏ ﺑﯿﺖ ﻗﺮار دارد دﺳﺘﻮرات ‪ glBitmap‬و‬
‫‪ glRasterPos‬ﺑﺮاي ﻗﺮار دادن و ﻧﻤﺎﯾﺶ ﯾﮏ ﺑﯿﺖ ﻣﭗ ﺑﺮ روي ﺻﻔﺤﻪ ﺑﮑﺎر ﻣﯽ روﻧﺪ ‪ .‬ﻋﻤﻮﻣﺎ ﺑﯿﺖ ﻣﭗ ﻫﺎ ﺑﺮاي ﻧﻤﺎﯾﺶ‬
‫ﻓﻮﻧﺖ ﻫﺎ ك ارﺑﺮد دارﻧﺪ‪ .‬ﺑﺮاي ﻣﺜﺎل ﮐﺎراﮐﺘﺮ ‪ F‬را ﺑﺼﻮرت زﯾﺮ ﻣﯽ ﺗﻮان ﻃﺮاﺣﯽ ﮐﺮد‪.‬‬

‫‪53‬‬
‫داده ﻫﺎي ﺑﯿﺖ ﻣﭗ ﻫﺎ ﻫﻤﻮاره در ﻗﻄﻌﺎﺗﯽ ﮐﻪ ﻣﻀﺮﺑﯽ از ‪ 8‬ﺑﯿﺖ ﻫﺴﺘﻨﺪ ذﺧﯿﺮه ﻣﯽ ﺷﻮﻧﺪ ‪ .‬ﺑﯿﺖ ﻫﺎﯾﯽ ﮐﻪ ﺑﯿﺖ ﻣﭗ ﻫﺎ را ﺗﺸﮑﯿﻞ‬
‫ﻣﯽ دﻫﻨﺪ از ﮔﻮﺷﻪ ﺳﻤﺖ ﭼﭗ ﭘﺎﯾﯿﻦ ﺷﺮوع ﻣﯽ ﺷﻮﻧﺪ ‪ ،‬ﺳﭙﺲ ردﯾﻒ ﭘﺎﯾﯿﻦ رﺳﻢ ﻣﯽ ﺷﻮد در اداﻣﻪ ردﯾﻒ ﺑﺎﻻﯾﯽ و ﺑﻪ ﻫﻤﯿﻦ‬
‫ﺗﺮﺗﯿﺐ‪.‬‬
‫در دﺳﺘﻮر ﺑﺎﻻ ﺑﯿﺖ ﻣﭙﯽ را ﮐﻪ ﺗﻮﺳﻂ آرﮔﻮﻣﺎن ‪ const GLubyte *bitmap‬ﻣﻌﯿﻦ ﮔﺸﺘﻪ ﺗﺮﺳﯿﻢ ﻣﯽ ﮐﻨﺪ ‪ .‬اﮔﺮ ﻣﺤﻞ ﻗﺮار‬
‫ﮔﯿﺮي آن در ﺻﻔﺤﻪ ﻣﺠﺎز ﻧﺒﺎﺷﺪ ‪ ،‬ﭼﯿﺰي رﺳﻢ ﻧﺨﻮاﻫﺪ ﺷﺪ‪.‬‬
‫‪ : GLsizei height , GLsizei width‬ﻃﻮل و ﻋﺮض ﺑﯿﺖ ﻣﭗ را ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﻨﺪ‪.‬‬
‫‪ : GLfloat yorig, GLfloat xorig‬ﻣﻮﻗﻌﯿﺖ ﻣﺒﺪا را در ﺑﯿﺖ ﻣﭗ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﻨﺪ ‪ .‬ﻣﺒﺪا از ﮔﻮﺷﻪ ﭘﺎﯾﯿﻦ ‪ ،‬ﺳﻤﺖ ﭼﭗ اﻧﺪازه‬
‫ﮔﯿﺮي ﻣﯽ ﺷﻮد‪.‬‬
‫‪ x : GLfloat ymove, GLfloat xmove‬و ‪ y‬اﯾﯽ ﻫﺴﺘﻨﺪ ﮐﻪ ﺑﻪ ﻣﻮﻗﻌﯿﺖ ‪ raster‬ﺟﺎري ﭘﺲ از اﯾﻨﮑﻪ ﺑﯿﺖ ﻣﭗ رﺳﻢ ﻣﯽ‬
‫ﺷﻮد ‪ ،‬اﺿﺎﻓﻪ ﻣﯽ ﮔﺮدﻧﺪ‪.‬‬

‫)…‪ :glRasterPos{2,3,4}{i,d,f,s}{v}(Glint x,Glint y,‬ﺑﺮاي ﺗﻌﯿﯿﻦ ﻣﻮﻗﻌﯿﺖ ﺷﻄﺮﻧﺠﯽ ﺑﺮاي ﻋﻤﻠﯿﺎت ﭘﯿﮑﺴﻠﯽ اﺳﺖ ‪.‬‬ ‫‪o‬‬

‫)‪ : glPixelStore{f,i}(GLenum pname,GLfloat param‬ﺣﺎﻟﺖ ذﺧﯿﺮه ﺳﺎزي ﭘﯿﮑﺴﻞ را ﺗﻨﻈﯿﻢ ﻣﯿﮑﻨﺪ ﭘﺎراﻣﺘﺮ‬ ‫‪o‬‬
‫‪ GLenum pname‬ﻣﯿﺘﻮاﻧﺪ ﺷﺎﻣﻞ ﯾﮑﯽ از ﻣﻘﺎدﯾﺮ ‪:‬‬

‫‪GL_PACK_SWAP_BYTES, GL_PACK_LSB_FIRST, GL_PACK_ROW_LENGTH, GL_PACK_IMAGE_HEIGHT, GLenum pname‬‬

‫‪GL_PACK_SKIP_PIXELS, GL_PACK_SKIP_ROWS, GL_PACK_SKIP_IMAGES,GL_PACK_ALIGNMENT‬‬
‫‪GL_UNPACK_SWAP_BYTES, GL_UNPACK_LSB_FIRST, GL_UNPACK_ROW_LENGTH, GL_UNPACK_IMAGE_HEIGHT,‬‬
‫‪GL_UNPACK_SKIP_PIXELS, GL_UNPACK_SKIP_ROWS, GL_UNPACK_SKIP_IMAGES,GL_UNPACK_ALIGNMENT‬‬
‫ﺑﺎﺷﺪ و ﭘﺎراﻣﺘﺮ ‪ GLfloat param‬ﻧﯿﺰ ﻣﻘﺪار ﻣﺮﺑﻮط ﺑﻪ ﭘﺎراﻣﺘﺮ اول را ﻣﺸﺨﺺ ﻣﯿﮑﻨﺪ ‪.‬‬

‫‪54‬‬
 : ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﯾﮏ ﻣﺜﻠﺚ ﺑﺎ ﺧﻄﻮط ﺧﻄﭽﯿﻦ رﺳﻢ ﮐﻨﺪ‬: ‫ﻣﺜﺎل‬
#include<GL/glut.h>

void init()
{
glClearColor(0.1,0.1,0.4,0);
glutInitWindowPosition(200,600);
glutInitWindowSize(800,800);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0,100,0,200);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.2,0.8);
glEnable (GL_LINE_STIPPLE);

glLineStipple (1, 0x00FF);

glBegin(GL_LINES);
glVertex2i(20,70);
glVertex2i(40,120);

glVertex2i(60,70);
glVertex2i(40,120);

glVertex2i(20,70);
glVertex2i(60,70);
: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬
glEnd();

glFlush();
}
int main(int argc,char**argv)
{
glutInit(&argc,argv);
glutCreateWindow("Test");
glutDisplayFunc(display);
glutInitDisplayMode(GLUT_SINGLE|GLU
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

init();

glutMainLoop();
return 0;
}

55
 : ‫ رﺳﻢ ﮐﻨﺪ‬bitmap ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﺷﮑﻞ زﯾﺮ را ﺑﺎ اﺳﺘﻔﺎده از ﻣﻔﻬﻮم‬: ‫ﻣﺜﺎل‬

#include<GL/glut.h>

void init()
{
glutInitWindowPosition(100,200);
glutInitWindowSize(900,900);
glClearColor(1,1,1,0);
glMatrixMode(GL_PROJECTION );
glOrtho (0,100,0,150,0,1);

GLubyte bitShape[128]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x03, 0x80, 0x01, 0xC0, 0x06, 0xC0, 0x03, 0x60,
0x04, 0x60, 0x06, 0x20, 0x04, 0x30, 0x0C, 0x20,
0x04, 0x18, 0x18, 0x20, 0x04, 0x0C, 0x30, 0x20,
0x04, 0x06, 0x60, 0x20, 0x44, 0x03, 0xC0, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x66,0x01, 0x80, 0x66, 0x33,0x01, 0x80, 0xCC,
0x19,0x81, 0x81, 0x98, 0x0C, 0xC1, 0x83,0x30,
0x07,0xe1,0x87, 0xe0, 0x03, 0x3f, 0xfc,0xc0,
0x03,0x31,0x8c, 0xc0,0x03, 0x33, 0xcc, 0xc0,
0x06,0x64, 0x26, 0x60, 0x0c, 0xcc, 0x33, 0x30,
0x18, 0xcc, 0x33, 0x18,0x10,0xc4, 0x23, 0x08,
0x10,0x63,0xC6,0x08, 0x10, 0x30, 0x0c, 0x08,
0x10, 0x18,0x18, 0x08,0x10, 0x00, 0x00, 0x08};

void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0,0,0);
glRotatef(0,1,2,3);
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
glRasterPos2i(40,80);

glBitmap(31,30,0,0,0,0,bitShape);
glutSwapBuffers ();
////////////////

56
 glRasterPos2i(20,60);
glBitmap(31,30,0,0,0,0,bitShape);
////////////////
glRasterPos2i(60,60);
glBitmap(31,30,0,0,0,0,bitShape);
}
int main(int argc,char**argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE |GLUT_RGB);
glutCreateWindow("bitmap");
init();

glutDisplayFunc(display);

glutMainLoop();
return 0;
}

: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

57
 ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ دو ﮐﺮه را رﺳﻢ ﮐﻨﺪ و اﯾﻦ ﮐﺮه ﻫﺎ ﺑﻪ ﻃﺮف ﻫﻢ ﺣﺮﮐﺖ ﮐﻨﻨﺪ و اﮔﺮ روي ﻫﻢ اﻓﺘﺎدﻧﺪ ﺗﺮﮐﯿﺐ‬: ‫ﻣﺜﺎل‬
: ‫رﻧﮕﺸﺎن ﻣﺸﺨﺺ ﺷﻮد‬

#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>
#include <math.h>

// Rotation amounts
static GLfloat xRot = 0.0f;
static GLfloat yRot = 0.0f;

// Called to draw scene

void RenderScene(void)
{
glClearColor(1,1,1,0);
// Angle of revolution around the nucleus
static float fElect1 = 0.0f;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -100.0f);
glClear(GL_COLOR_BUFFER_BIT);

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

glColor4f(0.0,0.0,1,0.50);
glPushMatrix();
glRotatef(fElect1, 0.0f, 1.0f, 0.0f);
glTranslatef(90.0f, 0.0f, 0.0f);
glutSolidSphere(10.0f, 15, 15);
glPopMatrix();

glColor4f(1,0,0,0.20);
glPushMatrix();
glRotatef(fElect1, 0.0f, 1.0f, 0.0f);
glTranslatef(0.0f - 90, 0.0f, 0.0f);
glutSolidSphere(10.0f, 15, 15);
glPopMatrix();

// Increment the angle of revolution

fElect1 += 10.0f;
if(fElect1 > 360.0f)
fElect1 = 0.0f;

// Show the image

glutSwapBuffers();

// This function does any needed initialization on the rendering

// context.
void SetupRC()
{
glEnable(GL_DEPTH_TEST); // Hidden surface removal
glFrontFace(GL_CCW); // Counter clock-wise polygons face out

58
 glEnable(GL_CULL_FACE); // Do not calculate inside of jet

void TimerFunc(int value)

{
glutPostRedisplay();
glutTimerFunc(500, TimerFunc, 1);
}

void ChangeSize(int w, int h)

{
GLfloat nRange = 100.0f;

// Prevent a divide by zero

if(h == 0)
h = 1;

// Set Viewport to window dimensions

glViewport(0, 0, w, h);

// Reset coordinate system

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

// Establish clipping volume (left, right, bottom, top, near, far)

if (w <= h)
glOrtho (-nRange, nRange, nRange*h/w, -nRange*h/w, -nRange*2.0f, nRange*2.0f);
else
glOrtho (-nRange*w/h, nRange*w/h, nRange, -nRange, -nRange*2.0f, nRange*2.0f);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

int main(int argc, char* argv[])

{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("Guy ha");
glutReshapeFunc(ChangeSize); : ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬
glutDisplayFunc(RenderScene);
glutTimerFunc(500, TimerFunc, 1);
SetupRC();
glutMainLoop();

return 0;
}

59
 ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﻣﮑﻌﺒﯽ در ﺻﻔﺤﻪ اﯾﺠﺎد ﮐﻨﺪ و ﺑﺎ ﮐﻠﯿﮏ ﭼﭗ اﯾﻦ ﻣﮑﻌﺐ ﭼﺮﺧﺶ ﮐﻨﺪ و ﺑﺎ ﮐﻠﯿﮏ دﮐﻤﻪ وﺳﻂ‬: ‫ﻣﺜﺎل‬
: ‫ﻣﺎوس ﭼﺮﺧﺶ ﻣﺘﻮﻗﻒ ﺷﻮد‬

#include <GL/glut.h>
#include <stdlib.h>

static GLfloat spin = 0.0;

void init(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glRotatef(spin, 0.3, 0.2, 1.0);
glColor3f(1.0, 1.0, 1.0);
glutWireCube(50);
glPopMatrix();
glutSwapBuffers();
}

void spinDisplay(void)
{
spin = spin + 2.0;
if (spin > 360.0)
spin = spin - 360.0;
glutPostRedisplay();
}

void reshape(int w, int h)

{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-100,100,-150,150,-100,100);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

void mouse(int button, int state, int x, int y)

{
switch (button) {
case GLUT_LEFT_BUTTON:
if (state == GLUT_DOWN)
glutIdleFunc(spinDisplay);
break;
case GLUT_MIDDLE_BUTTON :
if (state == GLUT_UP)
glutIdleFunc(NULL);
break;
default:
break;
}
}

60
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow ("test");
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMainLoop();
return 0;
}

: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

61
 : ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﻣﮑﻌﺒﯽ در ﺻﻔﺤﻪ اﯾﺠﺎد ﮐﻨﺪ و ﺑﺎ ﺣﺮﮐﺖ ﻣﺎوس ﻣﮑﻌﺐ ﻧﯿﺰ ﭼﺮﺧﺶ ﮐﻨﺪ‬: ‫ﻣﺜﺎل‬

#include <gl/glut.h>

bool fullscreen = false;

bool mouseDown = false;

float xrot = 0.0f;

float yrot = 0.0f;

float xdiff = 0.0f;

float ydiff = 0.0f;

void drawBox()
{
glBegin(GL_QUADS);

glColor3f(1.0f, 0.0f, 0.0f);

// FRONT
glVertex3f(-0.5f, -0.5f, 0.5f);
glVertex3f( 0.5f, -0.5f, 0.5f);
glVertex3f( 0.5f, 0.5f, 0.5f);
glVertex3f(-0.5f, 0.5f, 0.5f);
// BACK
glVertex3f(-0.5f, -0.5f, -0.5f);
glVertex3f(-0.5f, 0.5f, -0.5f);
glVertex3f( 0.5f, 0.5f, -0.5f);
glVertex3f( 0.5f, -0.5f, -0.5f);

glColor3f(0.0f, 1.0f, 0.0f);

// LEFT
glVertex3f(-0.5f, -0.5f, 0.5f);
glVertex3f(-0.5f, 0.5f, 0.5f);
glVertex3f(-0.5f, 0.5f, -0.5f);
glVertex3f(-0.5f, -0.5f, -0.5f);
// RIGHT
glVertex3f( 0.5f, -0.5f, -0.5f);
glVertex3f( 0.5f, 0.5f, -0.5f);
glVertex3f( 0.5f, 0.5f, 0.5f);
glVertex3f( 0.5f, -0.5f, 0.5f);

glColor3f(0.0f, 0.0f, 1.0f);

// TOP
glVertex3f(-0.5f, 0.5f, 0.5f);
glVertex3f( 0.5f, 0.5f, 0.5f);
glVertex3f( 0.5f, 0.5f, -0.5f);
glVertex3f(-0.5f, 0.5f, -0.5f);
// BOTTOM
glVertex3f(-0.5f, -0.5f, 0.5f);
glVertex3f(-0.5f, -0.5f, -0.5f);
glVertex3f( 0.5f, -0.5f, -0.5f);
glVertex3f( 0.5f, -0.5f, 0.5f);
glEnd();
}

bool init()
{
glClearColor(0.93f, 0.93f, 0.93f, 0.0f);

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearDepth(1.0f);

return true;

62
}

void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();

gluLookAt(
0.0f, 0.0f, 3.0f,
0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f);

glRotatef(xrot, 1.0f, 0.0f, 0.0f);

glRotatef(yrot, 0.0f, 1.0f, 0.0f);

drawBox();

glFlush();
glutSwapBuffers();
}

void resize(int w, int h)

{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

glViewport(0, 0, w, h);

gluPerspective(45.0f, 1.0f * w / h, 1.0f, 100.0f);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

void idle()
{
if (!mouseDown)
{
xrot += 0.3f;
yrot += 0.4f;
}

glutPostRedisplay();
}

void keyboard(unsigned char key, int x, int y)

{
switch(key)
{
case 27 :
exit(1); break;
}
}

void specialKeyboard(int key, int x, int y)

{
if (key == GLUT_KEY_F1)
{
fullscreen = !fullscreen;

if (fullscreen)
glutFullScreen();
else
{
glutReshapeWindow(500, 500);

63
glutPositionWindow(50, 50);
}
}
}

void mouse(int button, int state, int x, int y)

{
if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
mouseDown = true;

xdiff = x - yrot;
ydiff = -y + xrot;
}
else
mouseDown = false;
}

void mouseMotion(int x, int y)

{
if (mouseDown)
{
yrot = x - xdiff;
xrot = y + ydiff;

glutPostRedisplay();
}
}

int main(int argc, char *argv[])

{
glutInit(&argc, argv);

glutInitWindowPosition(50, 50);
glutInitWindowSize(500, 500);

glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

glutCreateWindow("13 - Solid Shapes");

glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutSpecialFunc(specialKeyboard);
glutMouseFunc(mouse); : ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬
glutMotionFunc(mouseMotion);
glutReshapeFunc(resize);
//glutIdleFunc(idle);

if (!init())
return 1;

glutMainLoop();

return 0;
}

64
 ‫ ﻧﻮر دوم روﺷﻦ ﺷﻮد‬2 ‫ ﻧﻮر اول روﺷﻦ ﺷﻮد و ﺑﺎ زدن ﮐﻠﯿﺪ‬1 ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ دوﻋﺪد ﻧﻮر اﯾﺠﺎد ﮐﻨﺪ و ﺑﺎ زدن ﮐﻠﯿﺪ‬: ‫ﻣﺜﺎل‬
: ‫ ﻫﺮ دو ﻧﻮر ﻫﻤﺰﻣﺎن روﺷﻦ ﺷﻮﻧﺪ‬3 ‫و ﺑﺎ زدن ﮐﻠﯿﺪ‬

#include <GL/glut.h>

void init(void)
{
GLfloat ambient[]={1,1,1,1};
GLfloat diff[]={0,1,1,1};
GLfloat mat_specular[] = { 1.0, 0.0, 0.0, 1.0 };
GLfloat mat_shininess[] = { 2.0 };
GLfloat light1_position[] = { 1.0, 1.0, -.2, 0.0 };
GLfloat light0_position[] = { -1.0, -1.0, 1.0, 0.0 };
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_SMOOTH);

glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);

glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
glLightfv(GL_LIGHT1,GL_AMBIENT,ambient);
glLightfv(GL_LIGHT1,GL_DIFFUSE ,diff);
glEnable(GL_LIGHTING);

glEnable(GL_DEPTH_TEST);
}

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutSolidSphere (1.0, 200, 50);
glFlush ();
}

void reshape (int w, int h)

{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w,
1.5*(GLfloat)h/(GLfloat)w, -10.0, 10.0);
else
glOrtho (-1.5*(GLfloat)w/(GLfloat)h,
1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

void key(unsigned char k,int x,int y)

{
switch(k)
{
case '1': glEnable(GL_LIGHT1);
glDisable(GL_LIGHT0);
glutPostRedisplay();
break;
case '2':

65
 glEnable(GL_LIGHT0);
glDisable(GL_LIGHT1);
glutPostRedisplay();
y();
break;
case '3':
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glutPostRedisplay();
break;
}
}

int main(int argc, char** argv)

{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutKeyboardFunc(key);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}
: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

66
 ‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﮐﺮه اي در وﺳﻂ ﺻﻔﺤﻪ رﺳﻢ ﮐﻨﺪ ﺳﭙﺲ ﻧﻮري ﺑﻪ رﻧﮓ ﺳﻔﯿﺪ از ﯾﮏ ﻃﺮف ﺗﺎﺑﯿﺪه ﺷﺪه و ﺑﺎ‬: ‫ﻣﺜﺎل‬
: ‫ﮔﺬﺷﺖ زﻣﺎن ﻫﻢ ﻣﮑﺎن و ﻫﻢ رﻧﮓ ﻧﻮر ﺗﻐﯿﯿﺮ ﯾﺎﺑﺪ‬

#include<gl/glut.h>

GLfloat A[4]={1,1,1,1};
GLfloat Pos1[4]={9,5,1,0};
GLfloat D=0;
int i=0;
int j=1;
int k=0;
int cheaker=0;
void init()
{
glClearColor(0,0,0,0);
glShadeModel(GL_SMOOTH);
glLightfv(GL_LIGHT0,GL_DIFFUSE,A);

glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
}

void display()
{

glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glPushMatrix();

glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT);
glColor3f(0,1,0);
glEnable(GL_LIGHT0);
glutSolidSphere(0.4,100,100);

glPushMatrix();

glRotatef(D,i,j,k);
glLightfv(GL_LIGHT0,GL_POSITION,Pos1);

glPopMatrix();

glutSwapBuffers();
D+=.3;
A[1]-=.001;
glLightfv(GL_LIGHT0,GL_DIFFUSE,A);
}

void main (int argc, char **argv)

{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE);
glutInitWindowSize(800,600);
glutInitWindowPosition(100,100);
glutCreateWindow("kore noor rang");
init();

67
 glutDisplayFunc(display);
glutIdleFunc(display);
glutMainLoop();

}
: ‫ﮐﻪ ﺧﺮوﺟﯽ زﯾﺮ را ﺗﻮﻟﯿﺪ ﻣﯿﮑﻨﺪ‬

68
 ‫ﻣﻨﺎﺑﻊ‬
Addison Wesley OpenGL SuperBible 5 th Edition

OpenGL Programming Guide: The Official Guide to Learning OpenGL (7 th Edition)(Red Book)

‫ ﻣﻬﻨﺪس ﺑﻬﺮام ﺑﻬﺮام ﺑﯿﮕﯽ‬C++ ‫ در‬OpenGL‫ﻣﻘﺪﻣﻪ اي ﺑﺮ‬

‫ ﻣﻬﻨﺪس وﺣﯿﺪ ﻧﺼﯿﺮي‬OpenGL ‫راﻫﻨﻤﺎي ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺳﻪ ﺑﻌﺪي‬

‫ ﻣﻬﻨﺪس ﺟﻮاد ﻣﻬﺮي‬1 ‫اﺻﻮل ﮔﺮاﻓﯿﮏ ﮐﺎﻣﭙﯿﻮﺗﺮي‬

www.opengl.org

www.lighthouse3d.com

www.songho.ca/opengl

www.fly.cc.fer.hr/~unreal/theredbook

www3.ntu.edu.sg/home/ehchua/programming/index.html#OpenGL

www.nurani.ir

www.s1390.mihanblog.com

www.irnt.blogfa.com

69
70