UI פוסט 3: OpenGL vs. DirectX

8 בדצמבר 2007

 זהו פוסט המשך לפוסט הקודם "Swing vs GDI" שעסק בסקירה של מנועים גראפיים של מערכות הפעלה. כמו כן הראתי טבלת השוואה קטנה בין שני המנועיים.
(אפשר לקרוא את הפוסט הזה גם ללא קשר לפוסטים הקודמים)



UI פוסט 3: OpenGL vs. DirectX


בהמשך לנושא הקודם שנגע במנועים גראפיים כמו GDI ו-Swing, אגע במנועים גראפיים נוספים, שעובדים בטכנולוגיות DirectX ו-OpenGL.


כפי שמנועי GDI או Swing נועדו ל"ציור" של אובייקטים גראפיים דו-ממדיים (בעיקר פקדים של טפסים וכו'), DirectX ו-OpenGL נועדו ל"ציור" אובייקטים גראפיים דו-ממדיים ותלת-ממדיים (מדמים אפקט של תלת מימד בעזרת טרנספורמציות גראפיות של צורות דו-ממדיות על המסך, על כך יפורט בהמשך).



קצת היסטוריה:


בעולם האנושי התקשרות החזותית מתבצעת ע"י פירוש (אינטרפרטציה) של צורות, לרוב הצורות הנם אובייקטים תלת-ממדיים מוחשיים, כגון: חפצים, אנשים ובעלי חיים; בעלי ממדים בעולם האמיתי. המוח האנושי מתרגם אותות שהוא מקבל מהעיניים לתמונות בהתייחסות למיקום החפץ במרחב, פרמטרים נוספים: חוזק האור (תאורה), צבעים, צללים ועוד רבים אחרים. האדם המודרני מבטא את המחשבה החזותית בצורת תמונות ועל מנת להציג חפצים תלת-ממדיים הוא המציא שיטות שונות כמו ציור בפרספקטיבה, הצללות, שינוי צבעים ועוד.


עם ההתפתחות של המחשבים, התפתחו גם התקנים שמסוגלים להציג מידע חזותי כמו: טקסטים ותמונות. בחלק מן ההתקנים האלה נכללים כרטיסים גראפיים (כרטיסי מסך); כרטיסים אלקטרוניים משוכללים אשר מותקנים במארז המחשב, כרטיסים אלה מספקים יכולת "ציור" של מידע חזותי על גבי המסך. בשנים האחרונות חלה התפתחות גדולה בהתקנים אלה וכיום הם מציידים ברכיבי זיכרון עצמאיים, מעבדים מתמטיים ורכיבים מיוחדים נוספים. אם בעבר חלק גדול מהחישובים של המידע חזותי נעשה ע"י ה-CPU (מעבד ראשי של המחשב), אז היום זה מתבצע בכרטיס גראפי, רוב הכרטיסים החדשים מציידים במעבד ייחודי אשר "מתמחה" ביכולות חישוב של תצוגות תלת-ממדיות. כרטיס מכיל מעבד גראפי, אשר נשלט ע"י התוכנה (דרייבר), תוכנה מקבלת פקודות על מנת להציג אובייקטים תלת-ממדיים על גבי המסך, לכל אובייקט ישנם פרמטרים כמו: גודל, צורה, צבע, גוון, טקסטורה ועוד.


מפתחי תוכנה משתמשים בדרייבר על מנת להפעיל את הכרטיס. עבודה עם דרייבר של חומרה אינה קלה, לכל יצרן יש דרייבר עם ממשק API שונה (לאחרונה נעשים מאמצים לקבוע סטנדרטים קבועים לכל היצרנים הגדולים), יש להכיר את מגוון הפקודות של הממשק, הפקודות יחסית מסובכות לשימוש, בד"כ מפתח שמגיע מתחום של תכנות בשפות-העל והעולם של תכנות מונחה עצמים לא "יאהב" את ה-API של החומרה. – כאן בא לעזרה מנוע גראפי תלת-ממדי, ש"מתווך" בין מפתח תוכנה לבין הדרייבר של החומרה.


מנוע גראפי – מהווה שכבה לוגית (שכבה של תוכנה) מעל דרייבר של החומרה (במקרה שלנו – כרטיס גראפי). שכבה של מנוע גראפי מכילה ממשק עם פקודות, שבעזרתן ניתן לשלוט בדרייבר של רכיב החומרה. מנוע גראפי הנו מתווך (Proxy) בין הממשק של הדרייבר לבין השכבת התצוגה של היישום. מנוע גראפי "מכיר" פקודות ספציפיות של כל יצרן החומרה, מספק ממשק נוח ואחיד לכל פלטפורמה שעליה הוא מותקן.


לדוגמא: אני מעוניין לפתח מחשק מחשב תלת-ממדי. לשם כך אני זקוק לכרטיס גראפי בעל יכולות עיבוד מסוימות, בשוק המחשבים קיימים מגוון כרטיסים גראפיים ולכל כרטיס יש ממשק ומאפיינים ייחודיים. אני מעוניין שהמשחק יוכל לעבוד עם כל הסוגים הנפוצים של כרטיסים גראפיים – בעיקר שהוא יספק לי יכולות גראפיות נחוצות. המטרה היא לפתח משחק מחשב ללא קשר לסוג החומרה שעליה המשתמש ירצה להפעיל את המשחק. מנוע גראפי יהווה ממשק API שמולו אני אעבוד, עליו אפתח את הצד הגראפי של המשחק, ומנוע יתרגם את הפקודות לאלו המובנות לדרייבר החומרה.


לסיכום: מנוע גראפי מהווה חוצץ לוגי בין המפתח לדרייבר חומרה, מפתח לא צריך להכיר את הממשקים ואת הפקודות שמפעילות את החומרה, למעשה הוא תמיד עובד מול אותו ממשק שמוכר לו. היצרן של כרטיס גראפי מתאים את הממשק של הדרייבר לדרישות של מנוע גראפי, או לחילופין היצרן של המנוע הגראפי מתאים את המנוע לסוג החומרה עליה הוא אמור לשלוט.



מנוע גראפי לתלת-ממד


תיאור חזותי של אובייקטים תלת ממדיים מתבצע בעזרת חומרה מיוחדת ו/או בעזרת תוכנה מיוחדת.


בעבר הלא רחוק החלו להתפתח תוכנות עם יכולת תצוגה של אובייקטים תלת-ממדים, חלק גדול מהתוכנות הללו שייך למשחקי מחשב. חברות תוכנה שייצרו משחקים פיתחו מנועים גראפיים משלהם ועם השנים חלק מהן עברו לפיתוח של מנועיים גראפיים בלבד, כמוצר עיקרי; אותו הן משווקות לחברות אחרות המפתחות תוכנות בעלות יכולת תצוגה תלת-ממדית.


כיום ישנם שני מנועים גראפיים דומיננטיים בשוק התוכנה:



OpenGL


מתוך האתר ויקיפדיה:


– OpenGL‏ (Open Graphics Library) הוא ממשק תכנות יישומים ליצירת תוכנות שמייצרות גרפיקה תלת ממדית ממוחשבת (וגם דו-ממדית). הממשק מורכב מיותר מ-250 קריאות פונקציות שונות שיכולות לשמש לציור של סצנות תלת-ממדיות מורכבות מפרימיטיבים (אובייקטים) פשוטים. OpenGL פותחה ע"י חברת סיליקון גרפיקס (Silicon Graphics Inc.) בשנת 1992 והיא פופולארית בתעשיית משחקי הוידיאו, שם היא מתחרה בפלטפורמות של חברת מיקרוסופט המשתמשות ב־Direct3D. שימוש נרחב ב-OpenGL ניתן למצוא בסביבות מציאות מדומה, סימולציות מדעיות, הצגת מידע, סימולאטורים מדמי טיסה ופיתוח משחקי מחשב.


– בנוסף ניתן לציין כי ממשק OpenGL שייך לחבילת פיתוח (SDK – Software development kit) אשר מופצת בחינם ויש גרסאות שונות להתקנה במערכות הפעלה שונות, ניתן לומר שזהו מנוע גראפי רב-תחליטי עבור פלטפורמות (מע' הפעלה) שונות.





DirectX


מתוך האתר ויקיפדיה:


– DirectX היא ספרייה (DLL – Dynamic link library) שפותחה על ידי מיקרוסופט לסביבת Windows, מטרתה לתת גישה ישירה לחומרת המחשב, ובכך להאיץ ביצועים. מטרה נוספת של ספרייה זו היא להנגיש למתכנתים פונקציות לגרפיקה דו ממדית ותלת ממדית, מבלי שיעברו התמחות מיוחדת בכך. הוספת ספרייה זו גרמה לכך שפיתוח משחקי מחשב למשל יהיה קל ומהיר מאשר קודם.


בחלק מן המקורות DirectX מוזכר יחד עם Direct3D:


Direct3D


 – מהווה רכיב מרכזי של DirectX האחראי על רינדור (עיבוד והצגה נכונה) של תלת-מימד. הטכנולוגיה משתמשת בהאצת חומרה (כרטיס הגראפי).


– כמו OpenGL, DirectX הנה חבילת פיתוח (SDK) שמופצת בחינם, לעומת OpenGL חבילה זו יכולה "לרוץ" רק במערכות הפעלה של מיקרוסופט (ללא קשר לניסיונות של קהילות מפתחים בקוד-פתוח, להתאים חבילה למערכות הפעלה אחרות כמו לינוקס. הרצה של משחק הבנוי על חבילה הנ"ל דרך אימולטור כלשהו הנה איטית ומלווה בבעיות ברוב המקרים).




OpenGL vs. DirectX


לשני מנועיים יש מאפיינים משותפים וייחודיים, ולשניהם יש חסרונות ויתרונות:








































פרמטר השוואה


DirectX


OpenGL




  • תאימות




  • שייך למערכת הפעלה ספציפית




  • ניתן להתקנה ברוב מע' הפעלה נפוצות




  • "רץ" במערכת הפעלה ספציפית




  • "רץ" בכל מערכת הפעלה שבה ניתן היה להתקין את החבילה




  • מודל השכבות




  • מהווה שכבה מעל הדרייבר של כרטיס הגראפי




  • מהווה שכבה מעל הדרייבר של כרטיס הגראפי




  • רכיבים חיוניים




  • מכיל מאיץ גראפי בנוסף למאיץ שיש בחומרה




  • מכיל מאיץ גראפי בנוסף למאיץ שיש בחומרה




  • תפוצה




  • מותקן ברוב קונסולות משחק של מיקרוסופט




  • מותקן בקונסולות משחק נפוצות




  • פיתוח




  • לפני התאמה לדוט-נט נחשב לממשק יותר מסובך בפיתוח מאשר OpenGL




  • נחשב לממשק יותר קל בפתוח מ-DirectX




  • ביצועי (חומרה)




  • מאיצים גראפיים: משתמש במאיץ גראפי של כרטיס חומרה בנוסף למאיץ גראפי לוגי ששייך לחבילה.




  • מאיצים גראפיים: לוקה בחסר בעבודה מול מאיצים של חומרה (רק לאחרונה נעשה עבודה גדולה לשיפור הממשק בעבודה מול חומרה). מכיל מאיץ גראפי כרכיב תוכנה עיקרי, מלכתחילה נועד לשמש כמאיץ גראפי במקום כרטיס חומרה – כיום חסרון על פני מאיצי חומרה.




  • ביצועיים (כללי)




  • מצטיין בתחום משחקי מחשב. מסקנה: תנצלו משאבי חומרה ותזכו בכל הקופה.




  • מצטיין בתחום מקצועי: תוכנות תלת-ממדי לתעשייה, מדע ואקדמיה. מפסיד בעבודה מול חומרה.


 


טבלת השוואות נוספת בתחום הרינדור התלת-ממדי:


Feature                                                   OpenGL                                   DirectX


Vertex Blending                                                  N/A                                            Yes


Multiple Operating Systems                                  Yes                                             No


Extension Mechanism                                          Yes                                           Yes


Development                                                Multiple member Board               Microsoft


Thorough Specification                                          Yes                                            No


Two-sided lighting                                                 Yes                                            No


Volume Textures                                                  Yes                                            No


Hardware independent Z-buffers                              Yes                                            No


Accumulation buffers                                             Yes                                            No


Full-screen Ant-aliasing                                         Yes                                          Yes


Motion Blur                                                          Yes                                          Yes


Depth of field                                                        Yes                                          Yes


Stereo Rendering                                                  Yes                                           No


Point-size/line-width attributes                               Yes                                           No


Picking                                                                Yes                                           No


Parametric curves and surfaces                              Yes                                           No


Cache geometry                                                 Display                        Vertex Buffers


System emulation                                    Hardware not present        Let app. determine


Interface                                                        Procedure calls                             COM


Updates                                                              Yearly                                  Yearly


Source Code                                                    Examples                                   SDK


 


את הטבלה המקורית אפשר למצוא כאן: http://www.cprogramming.com/tutorial/openglvs.html



ראו בהמשך פוסט על ה"מהפכה ב-UI", אשמח לקבל הערות/תיקונים לגבי הפוסט. לרשימת הפוסטים של הסדרה לחצו כאן.

Add comment
facebook linkedin twitter email

Leave a Reply

Your email address will not be published.

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

*

10 comments

  1. שניר דוד8 בדצמבר 2007 ב 17:23

    נראה שOpenGL מנצח ברוב החזיתות.. הפיתוח קל יותר, הוא פתוח לחלוטין וניתן לעבוד מולו בכל מערכת הפעלה, וכו וכו…
    אבל לא הבנתי מפה למה עדיין DirectX הוא המועדף לפיתוח משחקים.. גם בטבלת השוואה שנתת רואים שלOpenGL יש יותר פיצ'רים ואפשרויות מDirectX, אז מה עושה את DirectX לפייבוריטית בפיתוח משחקים? (באופן פרופורציונלי.. יש המון משחקים בOpenGL גם…)

    Reply
  2. OhadAston8 בדצמבר 2007 ב 17:26

    יפה, מעניין מאוד!

    Reply
  3. Maxim8 בדצמבר 2007 ב 18:07

    החסרון של OpenGL הוא מתמיכה של חומרה, זהו תנאי מאוד הכרחי/חשוב.
    הטבלה האחרונה לא כ"כ מעודכנת, אעדכן אותה בהמשך ואוסיף פרמטרים נוספים שיותר מובנים לאנשים שלא מפתחים בתלת-מימד.
    כל חברה שמכבדת את עצמה ורוצה למכור יותר, בונה על שני המנועים. קונסולות שונות תומכות ב-DirectX ו-OpenGL; אם חברה רוצה שהמשחק יעבוד חלק בWindows ובקונסולות של מיקרוסופט היא תבחר ב-DirectX.
    בד"כ כותבים שכבה פנימית של החברה האחראית לגראפיקה ואליה מצרפים מנוע מסוג כלשהו, כך שמפתחים יכולים להתקדם בבניית אובייקטים וסצינות ללא קשר לסוג מנוע, אח"כ עושים התאמות למגבלות המנועים ולתמיכה באפקטים שונים, זהו פתרון שיינתן ע"י אנשי ה-API של החברה. כמובן שזה נושא מאוד גדול ואפשר לכתוב על זה ספרים שלמים.

    Reply
  4. צביקה פאר 8 בדצמבר 2007 ב 21:36

    Direct3D10 חושף ממשק חדש בהרבה יותר קל ופשוט מ Direct3D9 וקודמיו .
    יותר מיבני לכל Stage בPipline יש את אוסף הפקודות הלוגיות שלו .
    HLSL 4.0 הינה שפה עשירה עם הרבה פחות מוגבלויות מ3.0
    (אין הגבלה על הגודל של הshader למשל)

    Reply
  5. Maxim9 בדצמבר 2007 ב 0:45

    עדיין לא בדקתי את DirectX10, אבל לפי דוגמאות קוד שיש ברשת ולפי ביקורות, החבילה עדיין רחוקה מלהיות קלה בשימוש.
    אומר שאם היה אפשר לבנות סצינה גראפית עם אובייקטים פרימיטיביים בקלות יחסית, כמו להשתמש ב-StreamWriter של חבילת System.IO של דוט-נט אז העסק היה הרבה יותר טוב. יכול להיות שאין כוונה לבנות API שכל מפתח דוט-נט יוכל להשתלט עליה.
    עדיין יש שימוש בטיפוסי מבנים מסובכים ומיוחדים, שימוש במצביעים (pointers = unsafe code) ועוד דברים שאני לא אוהב להתעסק איתם, אבל נאלץ כי אין ברירה. כמובן שאם מישהו ירצה לכתוב עבור תלת – צריך לדעת אלגברה לינארית בסיסית, ואם ירצה להיות ממש טוב אז גם חדו"א 2 ואנליזה הרמונית.
    לכן WPF הולך להיות הדבר הבא, כשכבה לוגית מעל DirectDraw. מפתחים לא יצטרכו להכיר את ה-API של DirectX.

    Reply
  6. Eran Kampf9 בדצמבר 2007 ב 5:38

    DirectDraw לא קיים יותר ו-WPF לא יושב מעליו
    WPF לא נועד להתחרות או להחליף את DirectX כ-API לפיתוח משחקים/תוכנות שדורשות גרפיקה אינטנסיבית בזמן אמת

    Reply
  7. Eran Kampf9 בדצמבר 2007 ב 5:43

    ואגב לגבי פשטות,
    ל-OpenGL עקומת התחלה פשוטה יותר אבל ברגע שאתה רוצה להתחיל לנצל את כל הפיצ'רים החדשים של ה-GPU וכו' וצריך להתעסק עם כל מיני הרחבות של OpenGL (מצד ATI ומצד NVidia) זה כבר נהיה סיפור לא פשוט בכלל.
    במקרה הזה, DirectX שמציע סטנדרט אחיד מעל ATI, NVIDIA וכו' מפשט קצת את העניינים.

    Reply
  8. Maxim9 בדצמבר 2007 ב 12:50

    סליחה, תיקון טעות כתיב: כוונתי הייתה ש-WPF מעל Direct3D (כנראה הושפעתי ממאמר אחר שכתבתי על רינדור של דו-מימד ב-DirectDraw).

    WPF לא מתיימר להחליף את DirectX, כוונתי הייתה שיבוא הזמן ו-API של DirectX, ברובו יישלט ע"י WPF או כל חבילה אחרת, חדירה של טכנולוגיה תלויה בנגישותה ואין שום סיבה שמפתחי דוט-נט לא ישתמשו ב-DirectX באותה קלות כמו שהם שולטים בספריות תקניות של דוט-נט.

    Reply
  9. ekampf9 בדצמבר 2007 ב 21:58

    ובשביל זה יש XNA….

    Reply
  10. ekampf9 בדצמבר 2007 ב 22:01

    אגב קהל היעד של DirectX היה ונשאר מפתחי C++.
    XNA מפשט קצת את העניינים וחושף ממשק דוטנט (בעיקר עבור hobbyist developers)

    Reply