download.game-dev.ir].pdf · M 8&+) PPU (Physics Processing Unit) ˜7 g >+ / Ageia W 7 & ? !KG & !...

PhysX 1آموزش مدل سازی فيزيک بازی های کامپيوتری با استفاده از موتور فيزيک

آموزش مدل سازي فيزيك بازي هاي كامپيوتري

PhysXبا استفاده از موتور فيزيك

نويسنده : كريشنا كومار

به كوشش : عباسعلي طهماسبي

1393دي - بازي ساز

dev.ir-www.bazi

@bazi_dev


درباره نويسنده

اخذ كرده است . 2010مار ، يك برنامه نويس گرافيك و بازي است . او مهندسي علوم كامپيوتر را در سال كريشنا كو

از آن به بعد ، در حوزه گرافيك ، برنامه نويسي بازي ، برنامه هاي تعاملي سه بعدي و دنياي مجازي كار كرده است . در

ياد گرفته است . او همچنين CODيسيس ، فار كراي و درخصوص بازي هائي مثل كرا يوقت آزادش ، چيزهاي جديد

دارد كه در خصوص گرافيك و برنامه نويسي بازي است . www.gfxguru.orgوب سايتي در آدرس

مقدمه

ش آمديد . بازي هاي خو PhysXبه آموزش مدل سازي فيزيك در بازي هاي كامپيوتري با استفاده از موتور فيزيك

ويدويي به عنوان يك شكل جديد سرگرمي پديدار شده اند و براي انواع مختلفي از پلتفرم ها مثل كامپيوترهاي شخصي

، تلفن هاي همراه و ديگر دستگاه هاي قابل حمل توليد مي شوند . نسل امروزي بازي Tablet PC، كنسول ها ،

ورهاي فيزيك در بسياري از بازي ها به عنوان يك ميان افزار استفاده مي شوند تا ها پيچيده تر از هميشه هستند . موت

Nvidiaشتاب ، تصادم و برخورد ، نيرو ، اصطكاك و ... شبيه سازي شود . به ، ذرفتار فيزيكي دنياي واقعي مثل جا

PhysX هاي بازي سازي معروف و يك موتور فيزيك پيشرفته و مستقل از پلتفرم است كه بسيار زياد توسط استاديو

توسعه دهنده گان ، مورد استفاده قرار مي گيرد . اين موتور به طور مجازي محتوي همه اجزاي مربوط به فيزيك است

از توانائي پردازش PhysXكه يك توسعه دهنده ممكن است بخواهد در داخل بازيش استفاده كند . موتور فيزيك

ته اي استفاده مي كند تا هرچقدر كه امكان باشد ، بازي را از نظر فيزيكي چندهس CPUپيشرفته و GPUموازي يك

، واقعي تر كند .

برنامه هاي فقط براي توسعه دهنده هاي بازي ها مفيد نيست بلكه براي هر كسي كه قصد دارد PhysXموتور فيزيك

فاده قرار مي گيرد .سه بعدي توليد كند كه نياز به شبيه سازي بالدرنگ فيزيك دارد ، مورد است

براي مطالعه اين كتاب به چه ابزاري نياز است ؟

Microsoft Visual C++ 2010يا باالتر ) همراه با كامپايلر 7با ويندوز ( ترجيحا ويندوز PCشما به يك سيستم

Express نياز داريد . مي توانيد اين كامپايلر را به صورا رايگان درhttp://www.microsoft.com . دانلود كنيد

downloads-https://developer.nvidia.com/physxرا از 3.3.0Nvidia PhysX SDKهمچنين بايد

نام نمائيد . هرچند نويسنده ، در بعضي از مثال هاي كتاب از كتابخانه دانلود كنيد كه براي دانلود ، ابتدا بايد در سايت ثبت

freeglut به آدرسhttp://freeglut.sourceforge.net براي نمايش و رندر اشياء فيزيكيPhysX استفاده ،

استفاده كند . به همين دليل يك فصل كمكي راهنما Ogre3Dكرده است اما مترجم سعي مي كند از موتور رندر

براي اين كار ، به كتاب اضافه شده است .


اين كتاب براي چه كسي مناسب است ؟

را ياد PhysXعالقه مندان و تمام افرادي است كه قصد دارند موتور فيزيك اين كتاب مخصوص برنامه نويسان بازي ،

اب الزم نيست دانش و تجربه قبلي در زمينه اين موتور فيزيكي داشته باشيد يا اينكه يك بگيرند . براي مطالعه اين كت

كارگشا خواهد بود. Ogre3D، رياضيات سه بعدي و موتور ++Cبرنامه نويس كاركشته باشيد . فهم مقدماتي از

مطالب فهرست

PhysX 3 SDK ........................................................................................................................ 8 با كار شروع : 1 فصل

8 ........................................................................................................................................................ مختصر يا خچهيتار

PhysX ........................................................................................................................................................ 8 اتيخصوص

PhysX 3 .......................................................................................................................................... 9 ديجد اتيخصوص

10 ...................................................................................................................................... ابزارها و PhysX SDK دانلود

PhysX SDK .................................................................................................................................... 11 از استفاده مجوز

PhysX ...................................................................................................................................... 11 يبرا ازيموردن ستميس

VC++ Express 2010 ........................................................................................................................... 11 ماتيتنظ

14 ........................................................................................................................................................................... خالصه

16 .............................................................................................................................................. يمقدمات ميمفاه: 2 فصل

16 ........................................................................................................................................................... گرهايباز و صحنه

17 ............................................................................................................................................................................ اليمتر

17 ......................................................................................................................................................................... ها لشك

PhysX 3 ................................................................................................................................. 18 برنامه نياول ساختن

PhysX ............................................................................................................................................. 19 هياول يمقدارده

20 ................................................................................................................................................................... صحنه جاديا

21 ................................................................................................................................................................ گرهايباز جاديا

PhysX .................................................................................................................................................. 22 يساز هيشب

PhysX................................................................................................................................................ 23 كردن متوقف

23 ........................................................................................................................................................................... خالصه


Ogre3D ............... 24 موتور از استفاده با يكيزيف اءياش يكيگراف يساز هيشب: مترجم توسط شده اضافه يكمك فصل

33 ............................................................................................................................ جامد اجسام يشناس حركت: 3 فصل

33 .................................................................................................................................................. جامد جسم كي يبررس

33 ................................................................................................................................................................................ جرم

33 ............................................................................................................................................................................ يچگال

34 .............................................................................................................................................................................. جاذبه

34 ............................................................................................................................................................................ سرعت

34 ................................................................................................................................................................. گشتاور و روين

36 ............................................................................................................................................................................ ييرايم

36 .................................................................................................................................................... كينماتيس يگرهايباز

37 ................................................................................................................................................................ خواب تيوضع

Solver............................................................................................................................................................... 37 درجه

38 ........................................................................................................................................................................... خالصه

39 ............................................................................................................................................. برخورد صيتشخ: 4 فصل

39 ..........................................................................................................................................................برخورد يها شكل

39 ................................................................................................................................................................. يهندس شكل

39 ................................................................................................................................................................................. كره

40 ............................................................................................................................................................................... بهجع

40 ........................................................................................................................................................................... كپسول

40 ............................................................................................................................................................................ صفحه

Trigger .................................................................................................................................................. 41 يها شكل

41 ...................................................................................................................................................يساز هيشب يدادهايرو

Trigger ........................................................................................................................................................... 42 داديرو

43 ................................................................................................................................................................. برخورد داديرو

Broad-Phase ............................................................................................................................. 44 برخورد صيتشخ


Sweep-and-prune (SAP) .............................................................................................................................. 45

Multi box pruning (MBP) ............................................................................................................................ 45

Narrow-Phase ......................................................................................................................... 46 برخورد صيتشخ

46 .................................................................................................................................................. مداوم برخورد صيتشخ

47 ........................................................................................................................................................................... خالصه

48 ........................................................................................................................................................ ها مفصل: 5 فصل

PhysX ................................................................................................................................................... 48 در ها مفصل

49 ........................................................................................................................................................... ثابت يها مفصل

50 ..................................................................................................................................................... يچرخش يها مفصل

52 ......................................................................................................................................................... يكرو يها مفصل

53 .................................................................................................................................................... دار فاصله يها مفصل

54 .......................................................................................................................................................... يخط يها مفصل

D6 ............................................................................................................................................................ 55 يها مفصل

57 ........................................................................................................................................................................... خالصه

58 ........................................................................................................................................ صحنه يسارهااستف: 6 فصل

58 ......................................................................................................................... )اشعه انتشار( Raycast ياستفسارها

Sweep .................................................................................................................................................. 60 ياستفسارها

Overlap ............................................................................................................................................... 62 ياستفسارها

63 ........................................................................................................................................................................... خالصه

64 ....................................................................................................................................... كاراكتر كننده كنترل: 7 فصل

64 ............................................................................................................................ كاراكتر كننده كنترل يمقدمات ميمفاه

64 ................................................................................................................................... كاراكتر كننده كنترل به ازين لزوم

65 ...................................................................................................................................... كاراكتر كننده كنترل كي ديتول

66 .......................................................................................................................... كاراكتر كننده كنترل كي دادن حركت

67 ............................................................................................................................................. ديمف يمتدها و مشخصات


67 ..................................................................................................................................................... تيموقع كردن روز به

67 ............................................................................................................................. كاراكتر كننده كنترل كي يها شكل

68 ......................................................................................................................................................... اندازه كردن روز به

68 ....................................................................................................................................................... خودكار برداشتن گام

69 ......................................................................................................................................................................... بيش حد

69 ........................................................................................................................................................................... خالصه

70 ............................................................................................................................................................... ذرات: 8 فصل

70 ................................................................................................................................................................... ذرات يبررس

70 .............................................................................................................................................. يا ذره ستميس كي جاديا

70 .............................................................................................................................................. يدرون برخورد بدون ذرات

71 .................................................................................................................................................... يدرون برخورد با ذرات

72 .............................................................................................................................................. يا ذره ستميس مشخصات

74 ...................................................................................................................................................................... ذرات ديتول

76 ......................................................................................................................................................... ذرات كردن روز به

77 ..................................................................................................................................................................... ذرات حذف

77 .......................................................................................................................................................... ذرات كننده هيتخل

77 ............................................................................................................................................................ برخورد نگيلتريف

78 ........................................................................................................................................................................... خالصه

79 .............................................................................................................................................................. پارچه: 9 فصل

79 ........................................................................................................................................................... چهپار كي يبررس

79 ...................................................................................................................................................... پارچه fabric ديتول

81 ..................................................................................................................................................................... پارچه ديتول

81 .................................................................................................................................................. پارچه مشخصات ميتنظ

81 .................................................................................................................................................................. پارچه برخورد

83 ........................................................................................................................................ پارچه ذرات حركت تيمحدود


83 ....................................................................................................................................... پارچه ذرات كيتفك تيمحدود

84 ....................................................................................................................................................... پارچه يدرون برخورد

84 ................................................................................................................................................. پارچه نوع هم با برخورد

84 ........................................................................................................................................... رچهپا GPU دهنده شتاب

85 ........................................................................................................................................................................... خالصه

PhysX ....................................................................................................... 86 يريتصو يابي اشكال برنامه: 10 فصل

PhysX Visual Debugger (PVD) ....................................................................................... 86 يقدماتم ميمفاه

87 .................................................................................................................................... شبكه از استفاده با PVD ارتباط

88 ................................................................................................................... ليفا كي عنوان به PVD يها داده رهيذخ

89 ............................................................................................................................................. ارتباط يبرقرار يها نهيگز

89 ........................................................................................................................................................................... خالصه


PhysX 3 SDKشروع كار با : 1فصل

بيان مي كند . در اين PhysXاصطالحات مجوز و سيستم الزم مطالبي را درخصوص تاريخچه ، خصوصيات ، اين فصل

به منظور كامپايل MS Visual C++ 2010را دانلود كنيم و آن را با PhysX SDKفصل ياد مي گيريم كه چطور

برنامه ها ، پيكربندي كنيم .

تاريخچه اي مختصر

PhysX SDK ه بوده است و توسط در دست توسع 2004يك موتور فيزيك كامل است كه از سالAgeia با خريد

ETH Zurich spin-off NovodeX بودتوسعه داده شده .Ageia يك شركت توليدي ريزتراشه هاي نيمه رسانا

هاي معمولي CPUبود و اولين شركتي بود كه پرادزشگري با توانائي انجام محاسبات فيزيكي را ساخت كه در آن زمان از

موجود سريع تر بود .

(واحد پردازش فيزيك) بود كه شبيه به PPU (Physics Processing Unit)فروش كارت هاي Ageiaف هد

(واحد پردازش گرافيكي) بود كه امروزه مورد استفاده قرار مي GPU (Graphics Processing Unit)كارتهاي

قدرت پردازش يك كارت بود تا نام داشت ) را هم ساخته NovodeX SDK( قبال PhysXگيرد . اين شركت نرم افزار

PPU ، را تحت كنترل درآورد . اين شركتPhysX SDK را به عنوان يك كتابخانه ميان افزار فيزيكي براي توليد بازي

Nvidia، 2008در بازار خيلي خوب به فروش نرفت . در چهارم فبريه PPUها ، مجوز داده بود . متاسفانه كارت هاي

، حاال با PhysXتكميل شد . موتور دو شركت ، ادغام 2008فبريه 13را بخرد . در Ageiaاهد اعالم كرد كه مي خو

را بر روي ساختار PhysXاين بود كه Nvidiaتوسط Ageiaشناخته مي شود . علت اصلي خريد Nvidia PhysXنام

CUDA انجام شود . كارت هاي گرافيك كارت هاي گرافيك پياده سازي كند تا پردازش فيزيك به صورت سخت افزاري

PhysX در انحصارNvidia GPU است كه يك پيروزي در مقايسه با رقيبشATI/AMD . است

، ساختاري جديد را ارائه مي كند و PhysX 3.xآخرين ورژن است . PhysX SDK 3.3.0 ،در زمان نوشتن اين كتاب

اين موتور طوري نوشته شده رائي و بازدهي ترقي كرده است . كامال بازنويسي شده است كه در زمينه كا PhysXموتور

كه از چندين پلتفرم پشتيباني مي كند اما يك كد پايه دارد . پلتفرم هائي كه پشتيباني مي شوند عبارتند از : ويندوز ،

PhysXو حتي دستگاه هاي دستي آندرويدي . PS3و XBOX 360كنسول هاي بازي مثل ، Mac OS Xلينوكس ،

را هم دارد . Windows RTو PS Vitaاپل ، Wii U ،iOS، تينتندو Xbox One ،PS 4پشتيباني از 3.3.0

PhysX خصوصيات

Nvidia PhysX : يك موتور فيزيك پيشرفته است كه داراي خصوصيات زير است

سازي فيزيك است و از مفاهيم ضروري ترين جنبه شبيه جامد: ديناميك اجسام جامدديناميك (حركت شناسي) اجسام

فيزيكي مثل موقعيت (مكان) ، سرعت ، شتاب ، نيروها ، اندازه حركت ، تكانه ، اصطكاك ، تصادم و برخورد و گرانش

اين مشخصات به ما قدرت شبيه سازي يا تقليد سناريوهاي فيزيك دنياي واقعي را مي دهد .(جاذبه ) استفاده مي كند .


تر : كنترل كننده كاراكتر يك نوع خاص از برخوردكننده فيزيكي است كه در اصل براي كنترل بازيكن كنترل كننده كاراك

نماتيك كه ممكن است بخواهد از مشخصات مربوط به كنترل كننده يس جسميا هر نوع سوم شخص يا اول شخص

كاراكتر استفاده كند ، مورد استفاده قرار مي گيرد .

له نقليه : ديناميك وسيله نقليه به شما امكان شبيه سازي فيزيك وسيله نقليه را با استفاده ديناميك (حركت شناسي) وسي

از اشكال كروي چرخان كه مي تواند مدل اصطكاك تاير را شبيه سازي كند ، مي دهد . يك سيستم تعليق برپايه مفصل

براي تعليق وسيله نقليه مورد استفاده قرار مي گيرد .

، شبيه سازي ذرات و مايع است . از اين خصوصيات PhysXمايع : دو مورد از خصوصيات مهيج شبيه سازي ذرات و

براي دستيابي به انواع متنوعي از افكت هاي سينماتيك(حركت شناسي) استفاده مي شود . از ذرات مي توان براي توليد

SPH (Smoothed Particleكه به استفاده كرد و از ذرات مايعافكت هائي مثل آتش ، جرقه و ذرات خاك و شن

Hydrodynamics) ر نوع افكت ذرات برپايه ههم معروف هستند مي توان براي شبيه سازي مايعات ، گازها ، دود يا

SPH . استفاده مي شود

شبيه سازي پارچه : اين خصوصيت به شما اجازه مي دهد پارچه هاي واقعي را شبيه سازي كنيد كه مي تواند براي شبيه

سازي لباس كاراكترهاي بازي يا هر نوع شئ پارچه اي مثل پرچم ها و پرده ها مورد استفاده قرار گيرد . اين اشياء پارچه

فيزيكي بسته شوند .اجسام اي مي توانند كشيده شوند ، پاره شوند يا به ديگر

را شبيه سازي كنيد . يرپذ دگرديسشبيه سازي بدن نرم : اين خصوصيت به شما اجازه مي دهد اشياء حجمي

PhysX 3خصوصيات جديد

به شرح زير هستند : PhysX 3خصوصيات قابل توجه

چندنخي اتوماتيك و با بازدهي باال و يك كد پايه براي همه پلتفرم هائي كه از آنها پشتيباني مي شود .

ازش پردازنده هاي چند هسته اي در مدير وظايف بهبوديافته و مخزن مديريت شده نخ ها براي مهاركردن توانائي پرد

همه پلتفرم ها .

مي توانند در يك موجود تركيب شوند كه يك حدود PhysXكه در آن چندين بازيگر و تراكم يك مفهوم جديد توده

دارد كه در هنگامي كه تعداد زيادي از اشياء ، به كار گيري مي شوند ، پردازش را آسان مي كند معمولي و تصادم برخورد

.

را با كمترين كپي داده و PhysXجديد و باينري كه توسط آن مي توان با بازدهي باال بازيگران serializationيك

بدون تخصيص اضافه حافظه ، به داخل يك صحنه اضافه كرد . حاال ، توليد و تخريب بازيگران ، از اضافه و حذف شدن

پذير براي مديريت منابع فراهم مي كند . از صحنه ، جدا شده است كه يك استراتژي انعطاف

يك فيزيك زمان اجرا كه بسيار زياد بهينه شده است و زمان واكنش بهتري دارد و حافظه كمتري مي خواهد .


( نرم افزار اشكال يابي تصويري اجسام فيزيكي ) كه PhysX Visual Debugger (PVD)يك ورژن جديد از

را بهبود بخشيده است . PhysXري همه اشياء ديدن تصويكارائي بهتري دارد و

يك مدل كامل وسيله نقليه كه شامل اجزائي مثل موتور ، كالج ، دنده ، ديفرانسيل ، چرخ ها ، الستيك ها و شاسي

است .

و ابزارها PhysX SDKدانلود

اين كار را به صورت رايگان در دثبت نام كنيد كه مي تواني Nvidiaبايد به عنوان يك كاربر PhysX SDKبراي دانلود

https://developer.nvidia.com . بعد از ايجاد يك حساب كاربري ، بايد انجام دهيدMy Account را از

APEX/PhysX Registered Developerكليك كرده و گزينه Nvidiaسمت راست و باالي سايت

Program ا انتخاب كنيد . درخواست موافقت با مجوز ممكن است يك تا سه روز كاري طول بكشد . ر

، بر روي APEX/PhysX Registered Developer Programبعد از موافقت با درخواست مجوز

PhysX/Tools Download كليك كرده ، پلتفرم خود را انتخاب كنيد و سپسPhysX SDK را دانلود كنيد . توجه

) دانلود كرده ايم . PC (Windows)را براي پلتفرم ويندوز كامپيوترهاي شخصي ( SDKكنيد كه براي اين كتاب ما

كه در اين فصل بررسي مي شوند هم براي پلتفرم ويندوز است . PhysX SDKفايل هاي هدر و كتابخانه اي


PhysX SDKمجوز استفاده از

Nvidia PhysX SDK فرم ويندوز ، هم استفاده تجاري و هم استفاده غيرتجاري ، رايگان است . براي پلتفرم كامال براي پلت

و ابزارهايش براي استفاده هاي غيرتجاري و آموزشي Nvidia binary PhysX SDKو آندرويد ، OS Xهاي لينوكس ،

رايگان است .

PhysXسيستم موردنياز براي

جديدتر همراه با حداقل GPUيا يك Nvidia GeForce 8، سري PhysXي كمترين نياز براي پشتيباني سخت افزار

يك كارت گرافيك و حافظه مخصوص PhysXمگابايت حافظه گرافيكي است . اما هر برنامه 256و CUDAهسته 32

مخصوص مگابايت ، حافظه گرافيكي توصيه مي شود مگر اينكه كارت گرافيك 512به خود را توصيه مي كند . معموال ،

PhysX داشته باشيد . درايورهاي گرافيكيNvidia طوري ساخته شده اند كه مي توانند از چندين كارت گرافيك در

يك سيستم ، استفاده كنند . براي اين كار بايد از يك كارت گرافيك براي رندر گرافيكي استفاده شود و از كارت ديگر

. PhysXفقط براي پردازش فيزيكي

VC++ Express 2010 تنظيمات

استفاده مي كنيم . اين ابزار به PhysXبراي كامپايل برنامه هاي Microsoft Visual C++ 2010 Expressما از

و در Property Pages| Viewبايد از منوي در دسترس است . www.microsoft.comصورت رايگان در

را داخل پروژه كنيم . PhysXفايل هاي هدر و كتابخانه اي VC++ Directoriesقسمت

در مراحل زير انجام مي شود : VC++ 2010 Expressپيكربندي

مي ايد ، بايد آن را روي هارد ZIPبراي پلتفرم ويندوز ، كه در يك فايل فشرده PhysX 3.x SDK. بعد از دانلود 1

استخراج مي كنيم . در نهايت آدرس C:\devاي اين كتاب ، ما اين فايل را در مسير كامپيوترتان استخراج كنيد . بر

PhysX SDK به شكلC:\dev\PhysX-3.3.0_PC_SDK_Core . خواهد بود


ايجاد كنيم . Win32 Console، بايد يك برنامه جديد PhysX. قبل از داخل كردن فايل هاي هدر و كتابخانه اي 2

، گزينه New Projectو پنجره File | New | Projectرا اجرا و از منوي ++MS VCامپايلر براي اين كار ، ك

Win32 Console Application را انتخاب و يك نام و مسير هم براي پروژه انتخاب كنيد . در نهايت دكمهOK

را كليك كنيد تا تصويري مثل زير داشته باشد :

را كليك كنيد تا صفحه Nextباز مي شود كه در آن دكمه Win32 Application Wizard. بعد از اين پنجره 3

Application Settings باز شود . در آنجا گزينهEmpty project را تيك زده و مثل شكل زير دكمهFinish

را كليك كنيد :


كه براي كامپايل برنامه PhysX SDKرا طوري تنظيم كنيم كه بتواند فايل هاي هدر و كتابخانه اي ++VCسپس بايد

| Debugبه شكل زير View | Property Managerها ، الزم هستند را پيدا كند . براي اين كار از منوي

Win32 ياRelease | Win32 : را دوباركليك كنيد

5 .VC++ Directories : را انتخاب كنيد و مسيرهاي زير را وارد كنيد

كليك كنيد و آدرس زير را وارد كنيد : <...Edit>روي را انتخاب كرده ، Include Directoriesالف )

C:\dev\PhysX-3.3.0_PC_SDK_Core\Include


كليك كنيد و آدرس زير را وارد كنيد : <...Edit>را انتخاب كرده ، روي Library Directoriesب )

بيتي : 32براي پلتفرم هاي

C:\dev\PhysX-3.3.0_PC_SDK_Core\Lib\win32

بيتي : 64براي پلتفرم هاي

C:\dev\PhysX-3.3.0_PC_SDK_Core\Lib\win64

bit-32بيتي را اضافه مي كنيم چون هم بر روي سيستم 32توجه : براي اين كتاب ما كتابخانه هاي مخصوص پلتفرم

bit-64بيتي اجرا مي شوند هم بر روي سيستم

اي ذخيره تغييرات و بستن پنجه كليك كنيد .را بر OK. در نهايت دكمه 6

را توليد مي كنيم . PhysXتكميل شد . در فصل بعد اولين برنامه VC++ 2010 Expressدر PhysXكار تنظيم

خالصه

را به ما ياد داد كه براي مطالعه ادامه كتاب ، مورد نياز خواهند بود PhysXاين فصل تمام اطالعات مقدماتي مربوط به

را از وب سايت PhysX SDKثبت نام كنيم و Nvidiaما ياد گرفتيم كه چطور به عنوان يك توسعه دهنده .


Nvidia دانلود كنيم . همچنين ياد گرفتيم كه چطور فايل هايPhysX SDK را بهVisual C++ 2010 داخل

را كامپايل نمائيم . PhysXكنيم تا بتوانيم برنامه هاي


مقدماتي: مفاهيم 2فصل

شما را با مورد استفاده قرار خواهيم داد ، فراهم مي آورد و PhysXاين فصل مقدمه اي در خصوص مفاهيمي كه در

) و ... آشنا مي كند .shape، شكل ( )material) ، متريال ( actor) ، بازيگر ( sceneاصطالحاتي مثل صحنه (

مطالب زير در اين فصل مود بررسي قرار مي گيرند :

و توليد صحنه و بازيگرها PhysXمقداردهي اوليه

بازيگراني آنها به راذتوليد شكل ها و متريال ها و واگ

PhysXشبيه سازي و سپس متوقف كردن

صحنه و بازيگرها

است را شنيده ايد : "ويليام شكسپير"احتماال جمالت زير كه نقل قولي از

و زنان فقط هنرپيشه اند : آنان ورود و خروج خودشان را دارند و يك همه دنيا يك صحنه نمايش است و همه مردان "

"نفر در زمان خودش ، نقش هاي زيادي را بازي مي كند

، اين جهان مثل يك صحنه نمايش است و انسان ها شبيه هنرپيشه ها يا بازيگراني به نظر من او مي خواسته بگويد

. هر بازيگري ممكن است شخصيت و توانائي مجزا و مخصوص به ا در آن اجرا مي كنندرهستند كه نقش خودشان

خود را داشته باشد اما فقط يك صحنه نمايش با يك فضاي محدود ، دكوراسيون و نورپردازي از پيش تعريف شده

وجود دارد .

ود را به ) شناخته مي شود و هنرپيشه ها ، نقش خsceneبه عنوان يك صحنه ( PhysXبه همين شكل ، يك دنيا در

بيه سازي اتفاق مي افتد ، تعريف ش) ايفا مي كنند . يك صحنه ، مشخصات دنيائي را كه در آن ، actorعنوان بازيگر (

يك مي كند و مشخصات آن توسط همه بازيگراني كه در اين صحنه ايجاد شده اند ، به اشتراك گذاشته مي شود .

است كه بر روي همه بازيگراني كه در صحنه ، شبيه سازي مي ) gravityمثال خوب از مشخصات صحنه ، جاذبه (

، مستقل از صحنه اند . شوند ، تاثير مي گذارد . هرچند بازيگران مختلف ، مي توانند مشخصات متفاوتي داشته باشند

توليد شود . PxSceneيك نمونه از صحنه مي تواند با استفاده از كالس

، شبيه سازي شود . آن مي تواند مشخصاتي مثل يك PhysXاند در يك صحنه يك بازيگر ، شئ اي است كه مي تو

) dynamic) يا متحرك ( staticشكل ، متريال ، تبديل و ... داشته باشد . يك بازيگر مي تواند در دو نوع ساكن (

شه در يك دسته بندي شود . اگر از نوع ساكن باشد ، مثال يك پايه يا شئ بي حركت روي صحنه نمايش كه همي

موقعيت ثابت قرار دارد ، توسط شبيه سازي غير قابل حركت خواهد بود . اگر بازيگر متحرك باشد ، مثل يك انسان يا


هر نوع شئ متحرك ديگر بر روي صحنه نمايش ، مي تواند توسط شبيه سازي ، موقعيتش به روز و تازه شود .

مربوط به اجسام ديگر ، خصه شب حركت ، سرعت يا هر مبازيگران متحرك مي توانند مشخصاتي مثل جرم ، شتا

()PxPhysics::createRigidStaticيك نمونه از بازيگر ساكن مي تواند با فراخوان تابع جامد را داشته باشند .

توليد شود و يك نمونه از بازيگر متحرك مي تواند به وسيله فراخوان تابع

PxPhysics::createRigidDynamic() شود . هر دو تابع ، يك پارامتر از نوع توليدPxTransform نياز دارند

كه موقعيت و جهت بازيگر ايجاد شده را تعريف مي كند .

بازيگران ساكن : موقعيت ساكن دارند / نمي توانند مشخصاتي مثل جرم ، سرعت و نيرو داشته باشند .

باشند . / مشخصاتي مثل جرم ، سرعت و نيرو دارند .بازيگران متحرك : مي توانند موقعيت و چرخش متغيير داشته

متريال

، يك متريال ، مشخصه يك شئ فيزيكي است كه اصطكاك و ارتجاع يك بازيگر را تعريف مي كند و PhysXدر

براي تعيين برخورد و تصادم با اشياء ديگر ، مورد استفاده قرار مي گيرد . براي توليد يك متريال ،

PxPhysics::createMaterial() را فرابخوانيد كه سه آرگومان نوعPxReal به ترتيب ، احتياج دارد . اينها

اصطكاك ساكن ، اصطكاك جنبشي و ارتجاع را تعريف مي كنند .

: PhysXيك مثال از ايجاد يك متريال

PxMaterial* mMaterial = gPhysicsSDK->createMaterial(0.5,0.5,0.5);

ن دهنده اصطكاكي است كه در هنگامي كه يك جسم جامد در حال سكون است ، بر روي آن اصطكاك ساكن نشا

تا بي نهايت باشد . از طرف ديگر ، اصطكاك جنبشي ، تنها هنگامي بر روي 0اعمال مي شود و مقدار آن مي تواند از

باشد . ارتجاع ، فنريت يك 1و 0يك جسم جامد قابل اجراست كه در حال حركت باشد و مقدار آن هميشه بايد بين

نزديك تر باشد ، بدن ، فنري 1مقداري كه به باشد . 1و 0جسم جامد را تعريف مي كند و مقدار آن بايد هميشه بين

تر مي شود . تمام اين مقادير را مي توان دستكاري كرد تا باعث شويم يك شئ هنگامي كه با اشياء ديگر فعل و انفعال

پينگ پونگ ، رفتاري ارتعاشي داشته باشد يا مثل يخ ، لغزنده باشد .دارد ، مثل يك توپ

شكل ها

، يك بازيگر ايجاد مي كنيم ، مشخصات ديگري مثل شكل و متريال آن وجود دارند كه بايد PhysXهنگامي كه در

، PhysXيك شكل در د . تعريف شوند و بعدا به عنوان پارامترهاي تابع براي توليد بازيگر ، مورد استفاده قرار بگيرن

يك يك شكل هندسي است كه حدود برخورد و تصادم را براي يك بازيگر ، تعريف مي كند . يك بازيگر مي تواند

براي تعريف حدود تصادم خود ، بيش از يك شكل داشته باشد . شكل ها مي توانند توسط فراخوان


PxRigidActor::createShape() ، حداقل به يك پارامتر از نوع ايجاد شوند كه اين تابعPxGeometry و

PxMaterial . احتياج دارد

مثالي از ايجاد يك شكل از يك بازيگر :

PxMaterial* mMaterial = gPhysicsSDK->createMaterial(0.5,0.5,0.5);

PxRigidDynamic* sphere = gPhysicsSDK->createRigidDynamic(spherePos);

sphere->createShape(PxSphereGeometry(0.5f), *mMaterial);

) sphereكه نشان دهنده بازيگران ساكن است ، مي تواند شكل هائي مثل كره ( PxRigidStaticيك بازيگر نوع

height) يا plane، صفحه box ، (convex mesh ،triangular mesh )) ، جعبه (capsuleكپسول (،

field براي بازيگران نوع داشته باشد . شكل هاي مجازPxRigidDynamic كه نشان دهنده بازيگران متحرك است

) است يا خير . ( بازيگر سينماتيك در kinematicبه عنوان يك سينماتيك ( ، ، بسته به اين است كه آيا بازيگر

ر نوع فصل بعدي توضيح داده مي شود ) اگر بازيگر ، سينماتيك باشد ، مي تواند همه شكل هاي يك بازيگ

PxRigidStatic ، را داشته باشد در غير اين صورت مي تواند شكل هائي مثل كره ، كپسول ، جعبهconvex

mesh داشته باشد اما نمي تواند شكل هايtriangle mesh صفحه يا ،height field . داشته باشد

PhysX 3ساختن اولين برنامه

را PhysX SDKخودمان را داريم . در اين برنامه ، ما PhysXه حاال اطالعات كافي براي توليد اولين برنام

مقداردهي اوليه مي كنيم ، يك صحنه ايجاد مي كنيم و سپس دو بازيگر اضافه مي كنيم . اولين بازيگر يك صفحه

ساكن است كه به عنوان يك زمين ثابت عمل مي كند و دومين بازيگر ، يك مكعب متحرك است كه چند واحد باالتر

از صفحه قرار گرفته است . وقتي كه شبيه سازي شروع مي شود ، مكعب بايد تحت تاثير جاذبه ، بر روي صفحه بيافتد

.

ماست ، براي اينكه ساده باشد ، قصد نداريم بازيگري را به صورت تصويري بر روي PhysXچون اين اولين كد

بر روي خط فرمان چاپ مي كنيم تا اينكه ساكن ده را صفحه نمايش ترسيم كنيم . ما فقط موقعيت مكعب سقوط كنن

شود .

فايل هدر اصلي براي PxPhysicsAPI.hما كدنويسي را با داخل كردن فايل هاي هدر مورد نياز شروع مي كنيم .

PhysX است و شامل همهPhysX API در يك فايل هدر است .در آينده ممكن است فقط فايل هاي هدر مورد

انتخاب و داخل برنامه كنيد كه اين كار به كوچك شدن اندازه برنامه كمك مي كند . ما همچنين سه فايل نيازتان را

را هم VC++ 2010 Expressكامپايلر Releaseو Debugبراي هردو پيكربندي PhysXكتابخانه اي

بارگذاري مي كنيم .

نياز داريم : physxهم به فضاي نام PhysX است ، براي ++C كه بخشي از استاندارد stdعالوه بر فضاي نام


#include <iostream>

#include <PxPhysicsAPI.h> //PhysX main header file

//-------Loading PhysX libraries----------]

#ifdef _DEBUG

#pragma comment(lib, "PhysX3DEBUG_x86.lib")

#pragma comment(lib, "PhysX3CommonDEBUG_x86.lib")

#pragma comment(lib, "PhysX3ExtensionsDEBUG.lib")

#else

#pragma comment(lib, "PhysX3_x86.lib")

#pragma comment(lib, "PhysX3Common_x86.lib")

#pragma comment(lib, "PhysX3Extensions.lib")

#endif

using namespace std;

using namespace physx;

PhysXي اوليه مقدارده

يك شئ نوع ، ()PxCreateFoundation، ابتدا بايد توسط فراخوان تابع PhysX SDKبراي مقداردهي اوليه

PxFoundation : ايجاد كنيم . اين تابع سه پارامتر مي خواهدID ورژن ، يكallocator callback و يك

error callback ن هدرها و فايل هاي . اولين پارامتر ، از عدم مطابقت بيDLL . متناظر ، جلوگيري مي كند

allocator callback وerror callback برنامه هستند اما هر به صمخصوSDK يك پياده سازي پيش فرض

هم فراهم كرده كه در برنامه ما مورد استفاده قرار مي گيرد .

به شكل زير است : PhysX SDKكد توليد فونداسيون

static PxDefaultErrorCallback gDefaultErrorCallback; static PxDefaultAllocator gDefaultAllocatorCallback; static PxFoundation* gFoundation = NULL; //Creating foundation for PhysX gFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gDefaultAllocatorCallback,gDefaultErrorCallback);

PhysX، يك نمونه از ()PxCreatePhysicsبعد از ايجاد يك نمونه از كالس فونداسيون ، با فراخوان تابع

SDK : را توليد مي كنيم . اين تابه به سه پارامتر نياز داردID ورژن ، ارجاع شئPxFoundation كه قبال ايجاد

PxTolerancesScaleو كرده ايم


ما يك شئ پيش فرض از اين نوع را پاس مي دهيم . با مقايسه دستگاه PxTolerancesScaleپارامتر براي

PhysX باNULL مطمئن مي شويم كه اين دستگاه به درستي توليد شده است . اگر شئ برابر با ،NULL ، نباشد

دستگاه با موفقيت توليد شده است .

به شكل زير است : PhysX SDKكد توليد يك نمونه از

static PxPhysics* gPhysicsSDK = NULL;

//Creating instance of PhysX SDK

gPhysicsSDK = PxCreatePhysics(PX_PHYSICS_VERSION, *gFoundation, PxTolerancesScale() );

if(gPhysicsSDK == NULL)

{

cerr<<"Error creating PhysX3 device, Exiting..."<<endl;

exit(1);

}

صحنهايجاد

و سپس اضافه كردن بازيگران به آن است . PhysXتوليد شد ، وقت توليد يك صحنه PhysXبعد از اينكه دستگاه

مي توانيد يك صحنه توليد كنيد كه به يك نمونه از كالس ()PxPhysics::createSceneبا فراخوان

PxSceneDesc به عنوان پارامتر ، نياز دارد . شئPxSceneDesc توصيفي از مشخصات الزم براي ايجاد محتوي

صحنه است مثال جاذبه .

: PhysXكد ايجاد يك نمونه از صحنه

PxScene* gScene = NULL;

//Creating scene

PxSceneDesc sceneDesc(gPhysicsSDK->getTolerancesScale());

sceneDesc.gravity = PxVec3(0.0f, -9.8f, 0.0f);

sceneDesc.cpuDispatcher = PxDefaultCpuDispatcherCreate(1);

sceneDesc.filterShader = PxDefaultSimulationFilterShader;

gScene = gPhysicsSDK->createScene(sceneDesc);

توليد مي شود كه به عنوان پارامتر براي توليد بازيگران استفاده خواهد شد : PxMaterialسپس ، يك نمونه از


//Creating material

PxMaterial* mMaterial =

//static friction, dynamic friction, restitution

gPhysicsSDK->createMaterial(0.5,0.5,0.5);

ايجاد بازيگرها

حاال وقت ايجاد بازيگرهاست ، اولين بازيگر ما يك صفحه است كه به عنوان زمين عمل مي كند . هنگامي كه در

PhysX ايجاد مي كنيم ، جهت پيش فرضش ، عمودي است مثل يك ديوار اما ما مي خواهيم صفحه يك صفحه

درجه بچرخانيم تا بردار عمودش به صرف باال شود . اين كار با استفاده از 90مثل زمين عمل كند . بنابراين بايد آن را

دي ، انجام مي شود . چون مي براي قرار دادن و چرخاندن بازيگر در فضاي دنياي سه بع PxTransformكالس

قرار PxVec3(0.0f,0.0f,0.0f)را مقدار PxTransformخواهيم صفحه را در مبدا قرار دهيم ، اولين پارامتر

بچرخانيم ، Zدرجه در امتداد محور 90مي دهيم . اين مقدار ، صفحه را در مبدا قرار مي دهد . هچنين بايد صفحه را

به عنوان دومين پارامتر استفاده مي كنيم . PxQuat(PxHalfPi,PxVec3(0.0f,0.0f,1.0f))بنابراين از

حاال ما يك بازيگر ساكن جامد ايجاد كرده ايم اما هنوز شكلي برايش تعريف نشده است . بنابراين با فراخوان تابع

createShape() و قرار دادنPxPlaneGeometry() و يك ارجاع به به عنوان اولين پارامترmMaterial كه

شكل صفحه ()PxPlaneGeometryاين كار را انجام مي دهيم . قبال توليد كرده بوديم ، به عنوان دومين پارامتر ،

، بازيگر را اضافه مي planeو قرار دادن ارجاع PxScene::addActorرا تعريف مي كند . در نهايت با فراخوان

كنيم :

//1-Creating static plane

PxTransform planePos = PxTransform(PxVec3(0.0f, 0, 0.0f),PxQuat(PxHalfPi, PxVec3(0.0f, 0.0f, 1.0f)));

PxRigidStatic* plane = gPhysicsSDK->createRigidStatic(planePos);

plane->createShape(PxPlaneGeometry(), *mMaterial);

gScene->addActor(*plane);

واحد باالي صفحه 10اضافه مي كنيم ، يك بازيگر متحرك است كه شكل هندسي جعبه دارد و دومين بازيگري كه

ايجاد ()PxCreateDynamicساكن ما قرار گرفته است . يك بازيگر متحرك جامد مي تواند به وسيله فراخوان تابع

و PxPhysics ،PxTransform ،PxGeometry ،PxMaterialپارامتر از نوع هاي 5 به ترتيب شود كه

PxReal واحد باالتر از مبداء قرار دهيم ، اولين پارامتر 10نياز دارد . چون مي خواهيم آن راPxTransform مقدار

PxVec3(0.0f,10.0f,0.0f) واحد باالي 10است كه آن را 10خواهد بود . توجه كنيد كه يك جزء از بردار

چرخش پيش فرض اصليش را داشته باشد بنابراين دومين پارامتر كالس همچنين مي خواهيم كهمبداء قرار مي دهد .

PxTransform . يك نمونه از كالس را ناديده مي گيريمPxBoxGeometry بايد ايجاد شود كه همPxVec3 را

ا استفاده از به عنوان پارامتر مي خواهد كه اين پارامتر ابعاد يك مكعب را به اندازه نصف ، توصيف مي كند . در نهايت ب

بازيگر ايجاد شده را به به عنوان پارامتر تابع ، gBox و فراهم كردن ارجاع ()PxScene::addActorفراخوان

صحنه اضافه مي كنيم :


PxRigidDynamic*gBox; //2) Create cube PxTransform boxPos(PxVec3(0.0f, 10.0f, 0.0f)); PxBoxGeometry boxGeometry(PxVec3(0.5f,0.5f,0.5f)); gBox = PxCreateDynamic(*gPhysicsSDK, boxPos,boxGeometry,*mMaterial,1.0f); gScene->addActor(*gBox);

PhysXشبيه سازي

دارد كه PhysX، براي فريم بعدي ، احتياج به محاسبه موقعيت جديد همه بازيگران PhysXشبيه سازي يك برنامه

به يك مقدار زمان نياز دارد كه به گام زمان PhysXيوتون قرار دارند . شبيه سازي يك برنامه تحت تاثير قانون ن

)time step هم معروف است و زمان را در دنياي (PhysX پيش مي برد . ما از متدPxScene::simulate()

نياز PxRealارامتر نوع استفاده مي كنيم . ساده ترين شكل آن به يك پ PhysXپيش بردن زمان در دنياي براي

باشد ، در غير اين صورت نتيجه حاصل ، تعريف نشده 0دارد كه زمان را به ثانيه نشان مي دهد و هميشه بايد بيشتر از

را فرابخوانيد كه اجازه مي دهد شبيه سازي تكميل ()PxScene::fetchResultsخواهد بود . بعد از اين بايد

نشان true. اين متد به يك پارامتر بولي اختياري نياز دارد و نصب اين پارامتر با مقدار شده و نتيجه بازگشت داده شود

شبيه سازي بايد منتظر بماند تا اينكه كامل شود بطوريكه در هنگام بازگشت ، ضمانت مي شود كه نتايج در مي دهد كه

. خواهد بوددسترس

//Stepping PhysX

PxReal myTimestep = 1.0f/60.0f;

void StepPhysX()

{

gScene->simulate(myTimestep);

gScene->fetchResults(true);

}

واحد باالي زمين 10خودمان را در يك حلقه شبيه سازي كرديم تا اينكه بازيگر متحرك ( جعبه ) ، PhysXما برنامه

، موقعيت جعبه بر PhysXاز زمان شبيه سازي توليد شده و به زمين بيافتد و به وضعيت سكون برسد . براي هر گام

yبوده اما جزء (0 ,10 ,0)روي خط فرمان چاپ مي شود . با مشاهده خط فرمان ، مي بينيد كه در ابتدا موقعيت جعبه

كه نشان دهنده موقعيت عمودي جعبه است ، تحت تاثير نيروي جاذبه و در مدت شبيه سازي ، كاهش يافته است . در

لقه ، مشاهده مي شود كه موقعيت جعبه يكسان است . اين يعني جعبه با زمين برخورد كرده و حاال در وضعيت پايان ح

سكون قرار گرفته است .

//Simulate PhysX 300 times

for(int i=0; i<=300; i++)

{

//Step PhysX simulation


if(gScene)

StepPhysX();

//Get current position of actor (box) and print it

PxVec3 boxPos = gBox->getGlobalPose().p;

cout<<"Box current Position ("<<boxPos.x <<" "<<boxPos.y <<" "<<boxPos.z<<")\n";

}

PhysXمتوقف كردن

ده و حافظه را آزاد را نابود كر PhysXانجام شده است ، بايد اشياء مربوط به PhysXحاال كه شبيه سازي برنامه

نمائيم .

. ، همه بازيگرها ، سيستم هاي ذره اي و شيدرها را از صحنه حذف مي كند ()PxScene::releaseفراخوان متد

شئ ()PxFoundation::releaseفيزيك را متوقف مي كند . فراخوان ()PxPhysics::releaseفراخوان

فونداسيون را آزاد مي كند :

void ShutdownPhysX()

{

gScene->release();

gPhysicsSDK->release();

gFoundation->release();

}

خالصه

خودمان را ساختيم و مراحل آن را از ابتدا تا انتها ياد گرفتيم . براي اينكه اين برنامه PhysXما در نهايت اولين برنامه

ايش موقعيت بازيگر در مدت شبيه سازي استفاده كرديم كه زياد ا كوتاه و ساده نگه داريم ، فقط از خط فرمان براي نمر

، OpenGLاست . در فصل هاي بعدي ، با استفاده از كتابخانه PhysXمهيج نيست اما ساده ترين راه شروع كار با

بيه سازي را انجام خواهيم داد .شبه صورت تصويري ،


يكي اشياء فيزيكي با استفاده از موتور فصل كمكي اضافه شده توسط مترجم : شبيه سازي گراف

Ogre3D

اين فصل در متن اصلي كتاب وجود ندارد و توسط مترجم اضافه شده است . نويسنده در مثال ها و برنامه هاي نمونه و

دانلود كنيد ، براي نمايش گرافيكي اشيائي كه با www.gfxguru.orgكمكي كتاب كه مي توانيد آنها را در لينك

استفاده كرده است . اما من در اينجا قصد OpenGLايجاد مي شوند ، از كتابخانه گرافيكي PhysXفاده از موتور است

را به صورت گرافيكي رندر كنم . PhysXاستفاده كنم و بازيگران جامد متحرك Ogre3Dدارم از موتور گرافيكي

هت اشياء فيزيكي را با استفاده از اعمال قوانين فيزيك درواقع با پيشرفت زمان ، جديدترين موقعيت و ج PhysXموتور

، محاسبه مي كند و تنها كاري كه ما بايد انجام دهيم اين است كه در هر فريم ، اشياء گرافيكي را با اشياء فيزيكي

يكي هماهنگ كنيم يعني موقعيت و جهت اشياء گرافيكي را در هر فريم برطبق موقعيت و جهت محاسبه شده اشياء فيز

يد مي خواهيم سقوط آزاد يك جعبه را شبيه نبه روز كنيم تا شبيه سازي فيزيك دنياي واقعي انجام شود . مثال فرض ك

PhysX واحدي باالي زمين قرار گرفته است . ابتدا بايد با استفاده از موتور 10سازي كنيم . براي مثال جعبه در ارتفاع

كنيم كه هم اندازه ايجادهم بايد يك جعبه را Ogre3Dنيم . سپس در موتور ، اين جعبه را به صورت فيزيكي تعريف ك

جعبه فيزيكي باشد . آنگاه در هر فريم ، موقعيت و جهت اين جعبه گرافيكي را برطبق موقعيت و جهت جعبه فيزيكي

جعبه از باال به پائين ، به روز نمائيم . با اين كار خواهيد ديد كه شده استبراي ما محاسبه PhysXكه توسط موتور

البته براي فهميدن ي اين امر اتفاق مي افتد . خوب با من همراه باشد .عمي افتد درست همانطوري كه در دنياي واق

آموزش "مي كنم به كتاب آشنا باشيد . پيشنهاد Ogre3Dكدهاي اين مثال بايد از قبل با كدنويسي براي موتور

كه قبال ترجمه شده " Ogre 3D 1.7ي كامپيوتري با استفاده از موتور گرافيكي مقدماتي برنامه نويسي بازي ها

است ، مراجعه كنيد .

PhysXو Ogre3D، موتور استفاده مي كنم . در سيستم من 2008و ويژوال استاديو 1.8.1ورژن Ogre3Dمن از

:در مسيرهاي زير نصب شده است

J:\OGRE 3D\SDK\Ogre_SDK\OgreSDK_vc9_v1-8-1

D:\PhysX SDK\PhysX-3.3.0_PC_SDK_Core

را به ويژوال استاديو معرفي كنيم تا بتواند آنها را پيدا كرده و مسير فايل هاي هدر و كتابخانه اي اين دو موتور بايد

: استفاده كند


ايجاد كنيد و يك Win32 Console Applicationيك پروژه جديد برنامه را بسازم . Debugمن قصد دارم ورژن

خوب با داخل كردن فايل هاي هدر و كتابخانه اي هردو به پروژه خود اضافه كنيد . main.cppفايل كد جديد به نام

موتور شروع مي كنيم :

#include "Ogre\ExampleApplication.h" #include <PxPhysicsAPI.h> #pragma comment(lib, "PhysX3DEBUG_x86.lib") //Always be needed #pragma comment(lib, "PhysX3CommonDEBUG_x86.lib") //Always be needed #pragma comment(lib, "PhysX3ExtensionsDEBUG.lib") //PhysX extended library


#pragma comment(lib, "PhysXVisualDebuggerSDKDEBUG.lib") //For PVD only #pragma comment(lib, "OgreMain_d.lib") #pragma comment(lib, "OIS_d.lib") using namespace Ogre; using namespace physx;

حاال نمونه اوليه تابع هاي مورد استفاده در برنامه را اضافه مي كنيم :

//-----------PhysX function prototypes------------// void InitPhysX(); //Initialize the PhysX SDK and create actors. void StepPhysX(); //Step PhysX simulation. void ShutdownPhysX(); //Shutdown PhysX SDK void CreatePhyisicalCube(PxVec3 cubePos , PxReal scale); //Function for the visualization of PhysX simulation (Optional and 'Debug' mode only) void ConnectPVD(); void synsPhysx(); void setupPhysicsGraphic();

) است . تابع PhysX( نرم افزار اشكال يابي تصويري اشياء PVD براي اتصال به نرم افزار ()ConnectPVDتابع

synsPhysx() در هر فريم فراخوانده مي شود و اشياء گرافيكيOgre3D را با اجسام فيزيكيPhysX . هماهنگ مي كند

را Ogre3Dود در صحنه ، اشياء گرافيكي موج PhysXنيز براساس تعداد اشياء فيزيكي ()setupPhysicsGraphicتابع

ايجاد مكعبهم به صورت فيزيكي براساس موقعيت داده شده ، يك ()CreatePhyisicalCubeتابع توليد مي كند .

مي كند .

حاال متغييرهاي جهاني را اضافه مي كنيم ://--------------Global variables--------------// static PxPhysics* gPhysicsSDK = NULL; //Instance of PhysX SDK static PxFoundation* gFoundation = NULL; //Instance of singleton foundation SDK class //Instance of default implementation of the error callback static PxDefaultErrorCallback gDefaultErrorCallback; //Instance of default implementation of the allocator interface required by the SDK static PxDefaultAllocator gDefaultAllocatorCallback; PxScene* gScene = NULL; //Instance of PhysX Scene PxReal gTimeStep = 1.0f/60.0f; //Time-step value for PhysX simulation PxRigidDynamic *gBox = NULL; //Instance of box actor SceneManager* mSceneMgrGlobal = NULL; PxRigidActor** actors ; Ogre::SceneNode ** graphicNodes; PxTransform * t = NULL;

actors وgraphicNodes . آرايه اي از اشاره گرها هستندactors گرهاي اجسام جامد است و آرايه اي از اشاره

graphicNodes گره صحنه است .آرايه اي از اشاره گرهاي

را به روز كرده و اشياء PhysXايجاد مي كنيم تا بتوانيم در هر فريم ، موتور FrameListenerحاال يك كالس

گرافيكي را نيز با اجسام فيزيكي هماهنگ نمائيم :

class TestFrameListener : public FrameListener {

private : RenderWindow* window;


public :

TestFrameListener(RenderWindow* win): window(win){} bool frameEnded (const FrameEvent &evt)

{ StepPhysX(); if (window->isClosed()) { return false; } return true;

} bool frameStarted(const FrameEvent& evt)

{ synsPhysx(); return true;

} };

ارث مي برد : ExampleApplicationحاال وقت اضافه كردن كالس اصلي برنامه است كه از كالس

class Example1 : public ExampleApplication { public: void createFrameListener()

{

TestFrameListener * mListener= new TestFrameListener(mWindow); mRoot->addFrameListener(mListener);

}

void createScene()

{

mSceneMgrGlobal = mSceneMgr; InitPhysX(); //Initialize PhysX then create scene and actors ConnectPVD(); mSceneMgr->setAmbientLight(ColourValue(1.0,1.0,1.0,1.0)); mCamera->setPosition(10,10,-30); mCamera->lookAt(0,0,0); CreatePhyisicalCube(PxVec3(0.0,10.0,0.0),1.0); CreatePhyisicalCube(PxVec3(3.0,20.0,0.0),1.0); CreatePhyisicalCube(PxVec3(1.0,50.0,0.0),1.0); CreatePhyisicalCube(PxVec3(0.0,40.0,0.0),1.0);

setupPhysicsGraphic();

Ogre::Plane plane(Vector3::UNIT_Y, -10); Ogre::MeshManager::getSingleton().createPlane("plane", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane, 1500,1500,20,20,true,1,5,5,Vector3::UNIT_Z);


Ogre::Entity* entPlane = mSceneMgr->createEntity("LightPlaneEntity", "plane"); mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(entPlane); entPlane->setMaterialName("Examples/BeachStones");

} };

، و راه اندازي موتور mSceneMgrGlobalبعد از ذخيره آدرس مديرصحنه در اشاره گر جهاني ()createSceneدر تابع

PhysX و ارتباط با نرم افزارPVD ،4 ايجاد مي كنيم و سپس با فراخوان تابع مكعببازيگر فيزيكي

setupPhysicsGraphic() ،فيزيكي ساخته مي شوند . مكعب 4متناظر با اين هاي گرافيكي مكعب

را اضافه مي كنيم : ()mainحاال تابع

int main (void) { Example1 app;

app.go();

return 0;

}

را راه اندازي مي كند و يك صحنه ، متريال و يك بازيگر صفحه را اضافه مي PhysXموتور ()InitPhysXتابع

كند :

void InitPhysX() { //Creating foundation for PhysX

gFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gDefaultAllocatorCallback, gDefaultErrorCallback);

//Creating instance of PhysX SDK gPhysicsSDK = PxCreatePhysics(PX_PHYSICS_VERSION, *gFoundation, PxTolerancesScale() ); if(gPhysicsSDK == NULL) { std::cerr<<"Error creating PhysX3 device, Exiting..."<<std::endl; exit(1); } //Creating scene //Descriptor class for scenes PxSceneDesc sceneDesc(gPhysicsSDK->getTolerancesScale()); sceneDesc.gravity = PxVec3(0.0f, -9.8f, 0.0f); //Setting gravity //Creates default CPU dispatcher for the scene sceneDesc.cpuDispatcher = PxDefaultCpuDispatcherCreate(1); //Creates default collision filter shader for the scene sceneDesc.filterShader = PxDefaultSimulationFilterShader; gScene = gPhysicsSDK->createScene(sceneDesc); //Creates a scene //Creating PhysX material PxMaterial* material = gPhysicsSDK->createMaterial(0.5,0.5,0.5); //---------Creating actors-----------]


//1-Creating static plane //Position and orientation(transform) for plane actor PxTransform planePos = PxTransform(PxVec3(0.0f),PxQuat(PxHalfPi, PxVec3(0.0f, 0.0f,

1.0f))); //Creating rigid static actor PxRigidStatic* plane = gPhysicsSDK->createRigidStatic(planePos); //Defining geometry for plane actor plane->createShape(PxPlaneGeometry(), *material); //Adding plane actor to PhysX scene gScene->addActor(*plane);

}

به صورت فيزيكي يك مكعب تعريف مي كند : ()CreatePhyisicalCube تابع

void CreatePhyisicalCube(PxVec3 cubePos , PxReal scale) { //Creating PhysX material //Creating a PhysX material PxMaterial* material = gPhysicsSDK->createMaterial(0.5,0.5,0.5); //2-Creating dynamic cube //Position and orientation(transform) for box actor PxTransform boxPos(cubePos); //Defining geometry for box actor PxBoxGeometry boxGeometry(PxVec3(scale,scale,scale)); //Creating rigid static actor gBox = PxCreateDynamic(*gPhysicsSDK, boxPos, boxGeometry, *material, 1.0f);

//Adding box actor to PhysX scene gScene->addActor(*gBox);

}

//Stepping PhysX void StepPhysX() { //Advances the simulation by 'gTimeStep' time gScene->simulate(gTimeStep); //Block until the simulation run is completed gScene->fetchResults(true); } //Shutdown PhysX void ShutdownPhysX() {

//Removes any actors, particle systems, and constraint shaders from this scene gPhysicsSDK->release(); //Destroys the instance of foundation SDK

gFoundation->release(); } //Function for the visualization of PhysX simulation (Optional and 'Debug' mode only) void ConnectPVD() { // check if PvdConnection manager is available on this platform if(gPhysicsSDK->getPvdConnectionManager() == NULL) return; // setup connection parameters // IP of the PC which is running PVD const char* pvd_host_ip = "127.0.0.1"; // TCP port to connect to, where PVD is listening int port = 5425; // timeout in milliseconds to wait for PVD to respond,


unsigned int timeout = 100; // consoles and remote PCs need a higher timeout.

PxVisualDebuggerConnectionFlags connectionFlags = PxVisualDebuggerExt::getAllConnectionFlags();

// and now try to connect

debugger::comm::PvdConnection* theConnection = PxVisualDebuggerExt::createConnection(gPhysicsSDK->getPvdConnectionManager(),

pvd_host_ip, port, timeout, connectionFlags);

}

"cube.mesh"اساس تعداد اشياء فيزيكي موجود در صحنه ، گره هاي صحنه و مش بر ()setupPhysicsGraphicتابع

ايجاد مي كند :

void setupPhysicsGraphic() { int numActors = gScene->getNbActors(physx::PxActorTypeFlag::eRIGID_DYNAMIC); actors = new PxRigidActor*[numActors]; graphicNodes = new Ogre::SceneNode *[numActors]; Ogre::Entity ** entS = new Ogre::Entity *[numActors];

gScene->getActors(physx::PxActorTypeFlag::eRIGID_DYNAMIC,reinterpret_cast <PxActor**> (actors) ,numActors);

for (int i=0 ; i<numActors ; i++) { entS[i] = mSceneMgrGlobal->createEntity("cube.mesh"); entS[i]->setMaterialName("Examples/BumpyMetal"); graphicNodes[i] = mSceneMgrGlobal->getRootSceneNode()->createChildSceneNode(); graphicNodes[i]->setScale(0.02f,0.02f,0.02f); graphicNodes[i]->attachObject(entS[i]); } }

، براساس تعداد اشياء فيزيكي موجود در صحنه ، موقعيت و جهت جهاني هر بازيگر فيزيكي را گرفته ()synsPhysxتابع

و به گره هاي گرافيكي صحنه اعمال مي كند تا مكعب هاي گرافيكي با مكعب هاي فيزيكي هماهنگ شوند :

void synsPhysx() { int numActors = gScene->getNbActors(physx::PxActorTypeFlag::eRIGID_DYNAMIC); if( t == NULL ) t = new PxTransform[numActors]; for (int i=0 ; i<numActors ; i++) { PxRigidActor * actor = actors[i]; t[i] = actor->getGlobalPose(); graphicNodes[i]->setPosition(t[i].p.x,t[i].p.y,t[i].p.z); graphicNodes[i]->setOrientation(t[i].q.w,t[i].q.x,t[i].q.y,t[i].q.z); }

}


حاال اگر همه كارها به درستي انجام شده باشد ، برنامه به درستي كامپايل و لينك مي شود . برنامه ايجاد شده را در

در مسير زير كپي كنيد : Ogre3Dپوشه فايل هاي اجرائي موتور

J:\OGRE 3D\SDK\Ogre_SDK\OgreSDK_vc9_v1-8-1\bin\Debug

باال كپي كنيد تا برنامه اجرا شود: در ضمن بايد فايل هاي زير را هم در مسير

nvToolsExt32_1.dll

PhysX3CHECKED_x86.dll

PhysX3CommonCHECKED_x86.dll

به آدرس زير پيداكنيد : PhysXرا مي توانيد در مسير نصب موتور dllاين فايل هاي

D:\PhysX SDK\PhysX-3.3.0_PC_SDK_Core\Bin\win32

فيزيكي در هنگام سقوط آزاد آنها ، مكعب از باال به پائين سقوط مي كنند و شبيه سازي 4با اجراي برنامه مي بينيد كه

، انجام مي شود :اثر نيروي جاذبه بر روي آنها برخوردشان با هم و

را هم اجرا كرده باشيد ، اشياء PVD (PhysX Visual Debugger)در ضمن اگر قبل از اجراي برنامه ، نرم افزار

را براي شما به نمايش خواهد گذاشت :فيزيكي


: حركت شناسي اجسام جامد 3فصل

مباحث زير در اين فصل توضيح داده مي شود :

ركت شناسي اجسام جامدحمفاهيم پايه

تغيير مشخصات جسم جامد مثل جرم ، چگالي ، سرعت ، شتاب و حركت زاويه اي

solver درجه واب جسم جامد ووضعيت خ

ك جسم جامدبررسي ي

يك جسم جامد يك جسم فيزيكي است كه يك جرم معين و يك شكل ثابت دارد . يك مشخصه مهم جسم جامد اين

نيروي بيروني را به آن اعمال مي كنيم ، هميشه شكل اصليش را حفظ مي كند . اين است كه هنگامي كه ما

د را آسان مي كند . يك جسم جامد مي تواند خصوصيت محاسبات فيزيكي كه بر روي يك جسم (بازيگر) انجام مي شو

از چندين جسم جامد متصل به هم ساخته شود و مي تواند مشخصاتي مثل سرعت ، نيرو ، گشتاور ، گرانيگاه (مركز

ثقل ) ، حركت زاويه اي و ... داشته باشد . در اين فصل ، متدها و پارامترهائي را براي تغيير مشخصات اجسام جامد

د مي گيريم .متحرك ، يا

جرم

جرم يكي از خصوصيات حياتي يك جسم جامد است . مشخصات ديگر مثل گشتاور اينرسي و تكانه بسته به اين

است كه ()PxRigidBody::setMassسم جامد فراخوان ، آسانترين راه تنظيم جرم يك ج PhysXهستند . در

()PxRigidBody::getMassهمچنين تابع مي خواهد كه نشان دهنده جرم است . PxRealيك پارامتر نوع

براي گرفتن جرم يك جسم جامد استفاده مي شود .

چگالي

متحرك ، جرم در واحد اندازه شكل تصادمش است . جرم يك بازيگر جامد متحرك به نسبت جامد بازيگرچگالي يك

زياد مي شود . چگالي يك جسم جامد اندازه شكلش است . اين يعني اگر شما اندازه شكلش را زياد كنيد ، جرم شئ هم

نصب شود كه دو پارامتر مي گيرد . PxRigidBodyExt::updateMassAndInertiaمي تواند توسط فراخوان

است و ارجاعي به جسم جامدي است كه چگاليش بايد به روز شود . دومين PxRigidBodyاولين پارامتر از نوع

م را تعيين مي كند .است و چگالي جس PxRealپارامتر از نوع


جاذبه

PxActor::setActorFlag(PxActorFlag::eDISABLE_GRAVITY, true);

خودمان ، از اين PhysXك واقعي است . ما قبال در اولين برنامه ييك مشخصه حياتي براي شبيه سازي فيز، جاذبه

را فرابخوانيد ()PxScene::setGravityمشخصه استفاده كرده ايم . براي تعيين جاذبه براي يك صحنه ، متد

در مي خواهد و شامل سه عدد حقيقي است . اين سه عدد ، نشان دهنده شتاب ثقل PxVec3كه يك پارامتر نوع

هستند . در اينجا ، فاصله به متر نشان داده مي شود و زمان به ثانيه . Zو X ،Yمحورهاي

كه تعيين مي شود PxVec3(0.0f, -9.8f, 0.0f)مقدار در يك شبيه سازي فيزيك معمولي ، جاذبه معموال با

توليد شده ، فعال يا غير فعال كند . براي جامدمي تواند جاذبه را براي هر جسم PhysXبرابر با جاذبه زمين است .

قرار دهيد : trueانجام اين كار ، گزينه زير را

PxActor::setActorFlag(PxActorFlag::eDISABLE_GRAVITY, true);

سرعت

، مي توانيم سرعت خطي ( سرعت در جهت يك خط مستقيم ) يك جسم جامد متحرك را در هر نقطه از PhysXدر

تعيين كنيم . در ساده ترين شكلش ، اين تابع ()PxRigidBody::setLinearVelocityزمان ، با فراخوان

، Xكه نشان دهنده سرعت بر روي محورهاي مي خواهد كه شامل سه عدد حقيقي است 'PxVec3'يك پارامتر نوع

Y وZ هستند . همچنين مي توانيم سرعت زاويه اي يك جسم جامد متحرك را با فراخوان

PxRigidBody::setAngularVelocity() و فراهم كردن يك پارامتر نوعPxVec3 كه نشان دهنده اندازه

كنيم . است ، تعيين Zو X ،Yسرعت زاويه اي بر روي محورهاي

نيرو و گشتاور

جرم آن است كه باعث مي يك راه براي حركت دادن يك بازيگر متحرك جامد ، اعمال يك نيرو بر مركز PhysXدر

شود ، در يك حركت خطي ، حركت كند . همچنين با اعمال يك گشتاور به يك بازيگر متحرك ، مي توانيم آن را

حول محورهايش بچرخانيم .

توان با استفاده از دو تابع زير انجام داد : اين كارها را مي

void PxRigidBody::addForce(const PxVec3& force, PxForceMode::Enum mode, bool autowake); void PxRigidBody::addTorque(const PxVec3& torque, PxForceMode::Enum mode, bool autowake);

به يك بردار سه بعدي نياز دارد كه نشان دهنده بزگي نيرو و ()PxRigidBody::addForceساده ترين شكل

دنياي سه بعدي است . دومين و سومين پارامتر ، اختياري هستند . دومين پارامتر Zو X ،Yجهت آن در محورهاي

گزينه ممكن است . PxForceMode::eFORCEاست كه به صورت پيش فرض PxForceMode از نوع enumيك


است كه يك نيروي ضربه اي را اعمال مي كند و گزينه PxForceMode::eIMPULSEديگر

PxForceMode::eVELOCITY_CHANGE سم جامد ، به جسم اعمال مي كند . نيرو را بدون مالحظه جرم جكه

ند است كه اگر بازيگر خواب باشد ، بيدارش مي ك trueسومين پارامتر يك مقدار بولي است كه به صورت پيش فرض

.

نيرو بر اجسام لوجود دارند كه راه هاي ظريف تري را براي اعما PxRigidBodyExtتوابع عضو ديگري از كالس

جامد متحرك فراهم مي كنند :

void PxRigidBodyExt::addForceAtPos(PxRigidBody& body, const PxVec3& force, const PxVec3& pos, PxForceMode::Enum mode, bool wakeup); void PxRigidBodyExt::addForceAtLocalPos(PxRigidBody& body, const PxVec3& force, const PxVec3& pos, PxForceMode::Enum mode, bool wakeup); void PxRigidBodyExt::addLocalForceAtPos(PxRigidBody& body, const PxVec3& force, const PxVec3& pos, PxForceMode::Enum mode, bool wakeup); void PxRigidBodyExt::addLocalForceAtLocalPos(PxRigidBody& body, const PxVec3& force, const PxVec3& pos, PxForceMode::Enum mode, bool wakeup);

PxRigidBodyExt::addForceAtPos() يك نيروي تعريف شده در سيستم مختصات جهاني را كه بر روي

در سيستم مختصات جهاني عمل مي كند را به بازيگر اعمال مي كند .يك نقطه خاص

PxRigidBodyExt::addForceAtLocalPos() يك نيروي تعريف شده در سيستم مختصات محلي را كه بر

ي كند را به بازيگر اعمال مي كند .روي يك نقطه خاص در سيستم مختصات جهاني عمل م

PxRigidBodyExt::addLocalForceAtPos() يك نيروي تعريف شده در سيستم مختصات محلي بازيگر را

كه بر روي يك نقطه خاص در سيستم مختصات جهاني عمل مي كند را به بازيگر اعمال مي كند .

PxRigidBodyExt::addLocalForceAtLocalPos()يف شده در سيستم مختصات محلي يك نيروي تعر

بازيگر را كه بر روي يك نقطه خاص در سيستم مختصات محلي عمل مي كند را به بازيگر اعمال مي كند .

است . از طرف ديگر ، مختصات محلي ، هميشه به PhysXتوجه كنيد كه مختصات جهاني در اينجا مختصات صحنه

اع دارد . اين موضوع در شكل زير توضيح داده شده است :، ارج PhysXسيستم مختصات محلي بازيگرهاي


يميراي

ميرايي مشخصه ايست كه اندازه حركت خطي و زاويه اي يك بازيگر جامد متحرك را كاهش مي دهد تا اينكه به

يه اي سكون برسد با فرض اينكه هيچ نيروي بيروني اعمال نشده باشد . تابعي كه براي تعيين اندازه حركت خطي و زاو

زير است : ليك بازيگر جامد ، استفاده مي شود به شك

void PxRigidDynamic::setLinearDamping(PxReal linDamp);

void PxRigidDynamic::setAngularDamping(PxReal angDamp);

PxRigidDynamic::setLinearDamping() ميرايي خطي را براي يك جسم جامد تعيين مي كند و يك

برابر سرعت است . linDampكه برابر با مي خواهد كه نشان دهنده اندازه نيروي ميرايي است PxRealمتر نوع پارا

يك پارامتر ميرايي زاويه اي را تعيين مي كند و ()PxRigidDynamic::setAngularDampingبه همين شكل

برابر سرعت زاويه اي است . angDampيك گشتاور ميرايي برابر با نشان دهنده مي خواهد كه PxRealنوع

بازيگرهاي سينماتيك

) ، بازيگرهاي متحرك جامد هستند كه توسط فراخوان يك تابع به Kinematic actorبازيگرهاي سينماتيك (

روزرساني صريح ، در دنياي فيزيكي حركت مي كنند و مستقيما قانون حركت نيوتون را دنبال نمي كنند .

ك مي تواند بر ديگر اجسام جامد متحرك موجود در صحنه تاثير بگذارد اما برعكس اين موضوع يك بازيگر سينماتي

درست نيست . بازيگرهاي سينماتيك اغلب براي كنترل كننده هاي كاراكتر در يك موتور فيزيك استفاده مي شوند كه

ك جامد و اختن يك بازيگر سينماتيموقعيت كاراكتر بازي و حدود تصادم آنها را به روز و تازه مي كنند . براي س

متحرك ، تابع زير فراخوانده مي شود :

PxRigidDynamic::setRigidDynamicFlag(PxRigidDynamicFlag::eKINEMATIC, true


نصب مي كند . trueرا با مقدار PxRigidDynamicFlag::eKINEMATICاين تابع در اصل گزينه

اخته شد ، موقعيت آن توسط فراخوان بعد از اينكه يك بازيگر سينماتيك س

PxRigidDynamic::setKinematicTarget() به روز مي شود كه يك پارامتر نوعPxTransform مي

در هر مرحله شبيه سازي فراخوانده ()setKinematicTargetخواهد كه محتوي مقصد بعدي حركت است . تابع

و تصادم بر روي جسم ، جسم سينماتيك را در انجام برخورد مي شود و صرف نظر از نيروهاي بيروني ، گرانش يا

دنياي فيزيك حركت مي دهد . با يك جسم سينماتيك هميشه طوري برخورد مي شود كه انگار جرم نامحدود دارد و

هر بازيگر متحرك كه در مسيرش باشد را با فشار هل مي دهد .

وضعيت خواب

ند وضعيت خواب داشته باشد كه تصميم مي گيرد آيا جسم شبيه سازي يك بازيگر جامد متحرك مي توا PhysXدر

به وسيله دوري از انجام محاسبات غير الزم ، انجام PhysXشود يا خير . اين كار براي باالبردن كارائي شبيه سازي

د ، بازيگر به وقتي كه انرژي جنبشي يك بازيگر براي يك دوره زماني مشخص ، كمتر از مقدار آستانه باشمي شود .

وضعيت خواب مي رود . هنگامي كه يك جسم جامد در وضعيت خواب باشد ، تنها زماني كه با يك شئ بيدار ديگر

برخورد كند ، بيدار مي شود يا اگر درخواست جسم جامد ، موقعيت يا سرعتش را تغيير دهد ، بيدار مي شود . ما مي

. همچنين مي توانيم با ، صريحا يك بازيگر را بيدار كنيم ()PxRigidDynamic::wakeUpتوانيم توسط فراخوان

، صريحا يك بازيگر را به وضعيت خواب ببريم . براي بررسي ()PxRigidDynamic::putToSleepفراخوان

()PxRigidDynamic::isSleeping، خواب است يا خير ، مي توان PhysXاينكه يك بازيگر در يك صحنه

بازگشت مي دهد . trueر بازيگر خواب باشد ، فراخواند كه اگ را

Solverدرجه

) در موتور فيزيك تشخيص داده شود ، براساس مشخصات اشيائي كه به collisionوقتي كه يك برخورد و تصادم (

رفع واكنش برخورد به كار مي آيد . براي ها Solverهم برخورد كرده اند ، يك واكنش مناسب بايد محاسبه شود .

Solver ها سعي مي كنند نيروهاي اعمال شده به يك جسم را فرونشانده و توسط چرخش بر روي همه نيروهاي

باعث يك شبيه سازي دقيق تر مي شود . به جسم ، حركت جسم را محدود كنند . افزايش تعداد اين چرخش ها ،

است . براي هر بازيگر 1مقدار و براي سرعت 4براي موقعيت ، مقدار PhysX solverصورت پيش فرض ، چرخش

با استفاده از تابع زير ، اين چرخش ها مي تواند به صورت اختصاصي تنظيم شود :

void PxRigidDynamic::setSolverIterationCounts(PxU32 minPositionIters, PxU32 minVelocityIters);

زم است كه داراي تعداد زيادي از مفاصل هستند .نها براي بازيگراني الر كلي ، افزايش تعداد چرخش ها ، تبه طو


خالصه

درباره مشخصات مربوط به اجسام جامد متحرك ، مطالب زيادي ياد گرفتيم . اين مشخصات شامل در اين فصل

هستند . ياد گرفتيم كه چطور جرم ، چگالي و جاذبه را براي يك جسم جامد متحرك solverدرجه وضعيت خواب و

همچنين درباره اجسام سينماتيك و جائي كه و چطور نيرو ، گشتاور و ميرايي را بر روي آن اعمال نمائيم . تعين كنيم

مورد استفاده قرار مي گيرند ، مطالبي را آموختيم .


: تشخيص برخورد 4فصل

مطالب مطرح شده در اين فصل عبارتند از :

PhysXشكل هاي برخورد و انواع اشكال هندسي موجود در

filter shader(محرك) ، رويدادهاي شبيه سازي و Triggerشكل هاي

Narrow-Phaseو تشخيص برخورد Broad-Phaseتشخيص برخورد

تشخيص برخورد مداوم

شكل هاي برخورد

ديگر مباحث مهم مربوط به آن را بررسي مي كند . ) و collision detectionاين فصل موضوع تشخيص برخورد (

رد ، تنها مي تواند زماني اتفاق بيافتد كه دو يا چند جسم داراي شكل مشخص ، با هم ديگر برخورد كنند . يك برخو

را تعريف فضائيش، يك شكل هميشه الزم است براي اينكه ، حجم PhysXبنابراين ، براي يك بازيگر جسم جامد

كند .

به يك PhysXياد گرفتيم و ديديم كه توليد يك شكل در ، درباره شكل ها و متريال ها مطالبي را 2ما قبال در فصل

(شكل PhysXيك بازيگر فضائي در اينجا ، حجم نياز دارد . PxMaterialو يك ارجاع به PxGeometryشئ

ف يچند شكل هندسي رايج را براي تعر PhysX SDKتعريف مي شود . PxGeometryهندسي) به وسيله كالس

رده است كه در بخش هاي زير توضيح داده مي شوند :شكل يك بازيگر ، فراهم ك

شكل هندسي

، يك نمونه از شكل هندسي الزم است كه حدود برخورد ( PhysXهمانطور كه مي دانيم ، براي توليد يك شكل در

به شكل زير است : PhysXرا تعريف مي كند . انواع اشكال هندسي موجود در PhysXحجم فضائي) يك بازيگر

كره

يك شكل هندسي براي شكل يك بازيگر تعريف مي كند و يك پارامتر نوع ()PxSphereGeometryتابع

PxReal . مي خواهد كه نشان دهنده شعاع كره است

كد توليد يك كره كه شكل هندسي كره را مدل سازي مي كند به صورت زير است :

PxReal radius = 2.0f;

gPhysicsSDK->createShape(PxSphereGeometry(radius),gMaterial);


ل توليد ايك نمونه از متري gMaterialتوليد شده است و PhysX SDKيك نمونه از gPhysicsSDKدر اينجا ،

شده مي باشد .

جعبه

PxRealيك شكل هندسي جعبه را براي شكل يك بازيگر ، تعريف مي كند و سه پارامتر ()PxBoxGeometryتابع

بخواهيد ، بايد مقدارش aدهنده اضالع جعبه در اندازه نصفه هستند . اين يعني اگر ضلعي با اندازه مي خواهد كه نشان

قرار دهيد . a/2را در داخل اين پارامترها به اندازه

كد توليد يك جعبه براي طراحي شكل هندسي جعبه :

PxReal hx = 0.5f; //half-extent x

PxReal hy = 0.5f; //half-extent y

PxReal hz = 0.5f; //half-extent z

gPhysicsSDK->createShape(PxBoxGeometry(hx,hy,hz),gMaterial);

كپسول

نياز دارد PxRealيك شكل هندسي كپسول را تعريف مي كند و به دو پارامتر نوع ()PxCapsuleGeometryتابع

تر نشان دهنده ارتفاع به اندازه نصفه است .اولين پارامتر نشان دهنده شعاع كپسول است و دومين پارام.

كد توليد يك كپسول :

PxReal r = 0.5f; // capsule radius

PxReal h = 1.0f; // capsule half-extent height

gPhysicsSDK->createShape(PxCapsuleGeometry(r,h),gMaterial);

صفحه

صفحه ، با آن ، پائين تقسيم مي كند . هر چيزي در پائين را به باال و PhysXفضاي ()PxPlaneGeometryتابع

. تابع پارامتري نمي خواهد و حجم برخورد صفحه كامال بسته به موقعيتش است . مي كندبرخورد

كد توليد صفحه :

gPhysicsSDK->createShape(PxPlaneGeometry(),gMaterial);


Trigger شكل هاي

باشند . يك شكل triggerتوليد شوند ، مي توانند به عنوان يك شكل PhysXر همه شكل هائي كه مي توانند د

trigger ) در شبيه سازي شركت نمي كند اما مي تواند طوري تنظيم شود كه در استفسارهاي صحنهscene

queries شركت كند . شكل آن هيچ برخورد فيزيكي را شامل نمي شود . يك شكل (trigger در اصل براي

اين استفاده مي شود كه آيا يك جسم جامد ، روي حجم فضائي آن افتاده است يا خير . اگر بله ، آن يك تابع تشخيص

callback را اجرا مي كند . اين خصوصيت ، خيلي زياد در بازي ها استفاده مي شود . براي مثال ، فرض كنيد شما در

به جلو دري مي آيد ، در به صورت اتوماتيك بازيكن يك حال ساخت يك بازي تخيلي هستيد كه در آن ، هروقت كه

گر با شكل مكعب در جلوي در قرار دهيد و آن را يبراي بازيكن باز مي شود . براي انجام اين كار ، يك باز

triggerShape كنيد . سپس يك منطق بازي بنويسيد كه هروقت كه بازيگر مكعب ، يك تماس و روي هم

شكل خودش ، تشخيص داد ، انيميشن بازشدن در نمايش داده شود . افتادگي بين شكل بازيكن و

قرار مي دهد : triggerكد زير شكل يك بازيگر را

//Setting trigger flag true for 'triggerShape'

PxShape* triggerShape;

triggerActor->getShapes(&triggerShape, 1);

triggerShape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, false);

triggerShape->setFlag(PxShapeFlag::eTRIGGER_SHAPE, true);

كرده ايم كه falseرا PxShapeFlag::eSIMULATION_SHAPEموضوع مهم در كد باال اين است كه ما

true اآن ر PxShapeFlag::eTRIGGER_SHAPEمشاركتش را در شبيه سازي فيزيكي غيرفعال مي كند و گزينه

عمل كند . triggerكرده ايم كه باعث مي شود به عنوان يك شكل

با ديگر اجسام سخت متحرك ، از طريق پياده سازي triggerهمپوشاني و تماس شكل

PxSimulationEventCallback::onTrigger گزارش مي شود . بنابراين بايد كالس برنامه تان را از كالس

PxSimulationEventCallback . به ارث ببريد

رويدادهاي شبيه سازي

همپوشاني و تماسي پيدا كند يا هرزمان كه دو جسم سخت با triggerهروقت كه يك جسم سخت با يك شكل

الزم را فراهم كرده است . با ارث filter shaderفراخوانده مي شود كه callbackهمديگر برخورد كنند ، يك تابع

، اين رويدادهاي شبيه سازي مي توانند دريافت شوند . اين در PxSimulationEventCallbackبردن از كالس


اصل كالس واسطي است كه به ما كمك مي كند به رويدادهاي شبيه سازي ، گوش كنيم . وقتي كه يك كالس

داشتيد ، يك نمونه از آن براي ثبت شبيه سازي تابع PxSimulationEventCallbackاستخراج شده از كالس

callback درPhysX . استفاده مي شود

براي رويدادهاي شبيه سازي : callbackكد ثبت تابع

// sceneDesc is an instance of 'PxSceneDesc'

sceneDesc.simulationEventCallback = &gContactReportCallback;

، gContactReportCallbackتابع است و PxSceneDescيك نمونه از كالس sceneDescدر اين مثال ،

است . PxSimulationEventCallback يك نمونه از كالس استخراج شده از

دو تابع براي استفسار برخورد فراهم كرده است كه در بخش هاي زير PxSimulationEventCallbackكالس

توضيح داده مي شوند :

Triggerرويداد

روي هم افتاده و همپوشاني داشته باشند ، تابع ، جامدتوسط هر شكل جسم triggerهروقت كه يك شكل

PxSimulationEventCallback::onTrigger() اولين پارامتر .فراخوانده مي شود . اين تابع دو پارامتر دارد

فراهم مي كند . PhysXدر شبيه سازي triggerرايه از همه جفت هاي آاست و يك PxTriggerPairاز نوع

است . كالس PhysXدر شبيه سازي triggerاست و مجموع تعداد جفت هاي PxU32از نوع دومين پارامتر

PxTriggerPair يك جفت محتوي اطالعاتي براي دو بازيگري است كهtrigger را شكل داده اند مثال شكلي كه

كه باعث رويداد به آن الصاق شده است و شكل ديگر triggerبوده است و بازيگري كه شكل triggerبه عنوان

trigger . شده است

، مي توانيم از بين همه جفت هاي ()PxSimulationEventCallback::onTriggerبا استفاده از تابع

trigger موجود در صحنهPhysX بچرخيم و هر كار مربوط به رويداد trigger . را انجام دهيم

و بازيگري كه روي آن افتاده : triggerدرباره بازيگر triggerكد گرفتن اطالعات از جفت

void onTrigger(PxTriggerPair* pairs, PxU32 nbPairs)

{

//loop through all trigger-pairs of PhysX simulation

for(PxU32 i=0; i < nbPairs; i++)

{


//get current trigger actor & other actor info

//from current trigger-pair

const PxTriggerPair& curTriggerPair = pairs[i];

PxRigidActor* triggerActor = curTriggerPair.triggerActor;

PxRigidActor* otherActor = curTriggerPair.otherActor;

}

}

رويداد برخورد

()PxSimulationEventCallback::onContactع هروقت كه دو جسم جامد با همديگر برخورد كنند ، تاب

است و محتوي PxContactPairHeaderپارامتر دارد . اولين پارامتر از نوع 3فراخوانده مي شود . اين تابع

PxContactPairاطالعاتي درباره دو بازيگري است كه يك جفت برخورد را تشكيل داده اند . دومين پارامتر از نوع

PxU32را فراهم كرده است . سومين پارامتر از نوع PhysXت هاي برخورد موجود در شبيه سازي و همه جفاست

است . PhysXاست و مجموع تعداد جفت هاي برخورد در شبيه سازي

كد زير موقعيت هاي برخورد همه جفت هاي برخورد داده شده را چاپ مي كند :

void ContactReportCallback::onContact(const PxContactPairHeader& pairHeader,const PxContactPair* pairs, PxU32 nbPairs)

{

const PxU32 buff = 64; //buffer size

PxContactPairPoint contacts[buff];

//loop through all contact pairs of PhysX simulation

for(PxU32 i=0; i < nbPairs; i++)

{

//extract contant info from current contact-pair

const PxContactPair& curContactPair = pairs[i];

PxU32 nbContacts = curContactPair.extractContacts(contacts, buff);

for(PxU32 j=0; j < nbContacts; j++)

{

//print all positions of contact.


PxVec3 point = contacts[j].position;

cout<<"Contact point ("<<point.x <<" "<< point.y<<" "<<point.x<<")\n";

}

}

}

Broad-Phaseتشخيص برخورد

بتواند آن ، كوچكترين جعبه اي است كه PhysXبراي يك شئ axis aligned bounding box (AABB)يك

يك شئ AABBدرميان قرار دهد به شرط آنكه لبه هاي جعبه هميشه موازي با محورهاي مختصات باشند . شئ را

هرگز نمي چرخد ، اگرچه خود شئ مي تواند در هر محوري بچرخد .

AABB (axis aligned bounding box) يك شئ قلبي شكل

نمي AABBي اشياء طنكرده باشند ، تحت هيچ شراي دو شئ روي هم نيافتاده باشند يا با يكديگر برخورد AABBاگر

هم افتاده يا با همديگر برخورد روي، هر دو شئ AABBتوانند با يكديگر برخورد داشته باشند . از طرف ديگر ، اگر

و تصادم كرده باشند ، مي تواند بين اشياء واقعي ، برخورد و تصادم اتفاق بيافتد اما ضمانتي وجود ندارد . بررسي برخورد

كم هزينه تر از بررسي برخورد اشياء واقعي است چون آن فقط يك جعبه است اما خود شئ ممكن AABBبا استفاده از

گران تمام مي شود . CPUاست از تعداد بسيار زيادي از مثلث ها ساخته شده باشد كه براي پردازش


AABB دو شئ با يك تماس و بدون تماس

آنها منفي بوده است ، از AABB، مي توانيم براي اشيائي كه تست برخورد Broad-Phaseدر تشخيص برخورد

محاسبات غيرضروري تست برخورد شئ با شئ ، دوري كنيم . جفت اشيائي كه تستشان مثبت بوده است ، براي

ا اشياء ، تست مجدد مي شوند كه پرهزينه تر است اما براي تشخيص اينكه آي Narrow-Phaseتشخيص برخورد

واقعا با همديگر برخورد كرده اند يا خير ، ضروري است .

پشتيباني مي شوند ، عبارتند از : PhysX 3.3.0كه در Broad-Phaseالگوريتم هاي

Sweep-and-prune (SAP)

Multi box pruning (MBP)

Sweep-and-prune (SAP)

-Broadگوريتم خيلي محبوب در تشخيص برخورد يك الهم معروف است و sort-and-sweepاين به الگوريتم

Phase ، است . معموال ، عملكرد و كارائي آن هنگامي كه تعداد زيادي از اشياء در وضعيت خواب به سر مي برند

خيلي خوب است . هنگامي كه اكثريت اشياء موجود در صحنه يا در حال حركت هستند يا در حال اضافه و حذف شدن

كارائي ، كاهش پيدا مي كند . اين الگوريتم نيازي به تعريف حدود دنيا براي كاركردن ندارد .از صحنه هستند ،

Multi box pruning (MBP)

اضافه شده است . هنگامي PhysX (3.3.0)جديد است و در PhysX SDKدر Multi-box-pruningالگوريتم

ال اضافه و حذف شدن از صحنه هستند ، اين الگوريتم مي كه اكثريت اشياء موجود در صحنه يا در حال حركتند يا در ح

اما هنگامي كه اكثريت اشياء موجود در صحنه در وضعيت عمل كند . sweep-and-pruneتواند بهتر از الگوريتم


ود باشد . اين الگوريتم براي كاركردن به تعريف حد SAPخواب به سر مي برند ، كارائي اين الگوريتم مي تواند بدتر از

دنيا نياز دارد .

، الگوريتم PxSceneDesc، در داخل ساختار PxBroadPhaseType enumبنابرنيازمان مي توانيم با استفاده از

Broad-Phase . را انتخاب كنيم

Narrow-Phaseتشخيص برخورد

برخورد ، مثبت باشند ، براي تشخيص Broad-Phaseجفت اشيائي كه در تست الگوريتم تشخيص برخورد

Narrow-Phase مجددا تست مي شوند . در اين مرحله ، به جاي ،AABB اشياء ، اشياء واقعي براي تشخيص

راس باشد . nتا 3برخورد ، تست مي شوند كه مي تواند پرهزينه باشد چون تعداد چندضلعي هاي اشياء مي تواند از

از : نقطه تقاطع ، بردار عمود برخورد و عمق نفوذ . اين اطالعات ديگري كه در اين مرحله محاسبه مي شوند عبارتست

واكنش به برخورد ، مهم هستند .مشخصات براي

تشخيص برخورد مداوم

دو تكنيك تشخيص برخورد وجود دارد كه معموال در موتورهاي فيزيك مورد استفاده قرار مي گيرد . اولي ، تشخيص

) است و دومي تشخيص برخورد مداوم Discrete Collision Detection (DCD)برخورد گسسته (

)Continuous Collision Detection (CCD) (

DCD كارائي بهتري دارد چون بين دو مرحله زماني ، براي تشخيص برخورد ، تست مي كند . پس از چند مرحله از

ما مستعد گم كردن برخورد اشيائي تقاطع اشيائي كه با هم برخورد كرده اند ، برخورد و تصادم تشخيص داده مي شود . ا

CDDاست كه با سرعت در حال حركتند . علت اين ، تكنيك تشخيص برخورد ناپيوسته اش است . از طرف ديگر ،

حركت پيوسته اشياء در حال حركت را بررسي كرده و هيچ برخوردي را در طول حركت بين دو مرحله زماني ، از دست

مشتاق كارائي بيشتر است . DCDنسبت به CCDبه علت طبيعت پيوسته بودنش ، نمي دهد .

، به كارائي ضربه كمتري مي زند . اما CCDفعال است چون نسبت به DCDبه صورت پيش فرض ، PhysXدر

، است تا اينكه از دقت و اطمينان تشخيص برخوردش CCDموقيت هاي زيادي وجود دارد كه نياز به فعال كردن

بهره ببريم .

اقدامات زير انجام مي شود : ، PhysXدر CCDبراي فعال كردن

را فعال كنيد : CCD. به شكل زير در توصيف كننده صحنه ، 1

PxPhysics* physx; ... PxSceneDesc desc; desc.flags |= PxSceneFlag::eENABLE_CCD;


2 . CCD : را در فيلتر فعال كنيد

static PxFilterFlags testCCDFilterShader( PxFilterObjectAttributes attributes0, PxFilterData filterData0, PxFilterObjectAttributes attributes1, PxFilterData filterData1, PxPairFlags& pairFlags, const void* constantBlock, PxU32 constantBlockSize) { pairFlags = PxPairFlag::eRESOLVE_CONTACTS; pairFlags |= PxPairFlag::eCCD_LINEAR; return PxFilterFlags(); } desc.filterShader = testCCDFilterShader; physx->createScene(desc);

بايد براي اجسام جامد متحرك ، فعال شود : CCD . در نهايت ، 3

PxRigidBody* body; body->setRigidBodyFlag(PxRigidBodyFlag::eENABLE_CCD, true);

CDD تنها بين اشيائي فعال مي شود كه سرعت نسبيشان بزرگتر از مجموع آستانه سرعتشان باشد . اين آستانه سرعت

به صورت اتوماتيك بسته به مشخصات شكل ، محاسبه مي شود و مقياس گذاري هاي غيريكنواخت را پشتيباني مي

ند .ك

خالصه

آموزش ديديم . درباره شكل هاي PhysXورد موجود در رباره تشخيص برخورد و شكل هاي برخدر اين فصل د

trigger رويدادهاي شبيه سازي و ،filter shader آموزش ديديم . همچنين از بين تشخيص برخوردBroad-

Phase وNarrow-Phase . گسسته و مداوم ، عبور كرديم ،


: مفصل ها 5فصل

موجود است و نيز درباره مشخصات و تنظيمات آنها آموزش PhysXدر اين فصل درباره انواع مختلف مفاصلي كه در

مي بينيم . مباحث زير در اين فصل بررسي مي شوند :

مفصل هاي ثابت

مفصل هاي چرخشي

مفصل هاي كروي

مفصل هاي فاصله دار

مفصل هاي خطي

D6مفصل هاي

PhysXدر مفصل ها

با شانمحدوديت هائي هستند كه مشخصات دو بازيگر متصل به هم و فعل و انفعال، PhysX) در Jointمفصل ها (

را تنظيم مي كنند . در شبيه سازي فيزيك ، مفاصل در زمينه هاي زيادي مورد استفاده قرار مي گيرد ، براي هم ديگر

صل براي كاراكتر بازي ، اتصال درها و پنجره ها با يك مفصل لوالئي و با استفاده از مفا ragdollمثال ، ساختن يك

ساختن زنجير يا طناب به وسيله اتصال يك سري از مفصل ها . مفاصل هميشه بين دو بازيگر ايجاد مي شوند اما

ع باشد يا از نو PxRigidDynamicحداقل يكي از آنها بايد قابل حركت باشد . اين يعني بايد يا از نوع

PxArticulationLink و بازيگران ديگر آن مفصل مي توانند هر نوعي از اينها و نيز نوعPxRigidStatic

براي توليد مفاصل بندبند استفاده مي شود و در حال حاضر در مرحله PxArticulationLinkكالس باشند .

متحرك مورد استفاده قرار مي گيرد . كاركترهاي آزمايشي قرار دارد . مفاصل بندبند مخصوصا براي توليد مفاصل

براي توليد بازيگران ساكني كه حجم فضائي دارند ، استفاده مي شود اما آنها در صحنه PxRigidStaticكالس

PhysX . به عنوان تكيه گاه در فضاي جهاني مورد استفاده قرار گيرند و بازيگران ثابت مي توانند ، ثابت باقي مي مانند

د توسط مفاصل ، به يك بازيگر جامد متحرك متصل شوند .نيز مي توانن

، شش نوع مختلف مفصل در دسترس است كه عبارتند از : PhysX 3در


جهت و حركت ثابت در امتداد اجسام متصل به هم دارد . اين مفصل ، اجازه انجام : مفصل ثابت ، يك مفصل ثابت

براي ساختن يك PxFixedJointمي دهد . كالس هيچ حركت خطي يا چرخش در امتداد محورهاي مفصل ن

مفصل ثابت مورد استفاده قرار مي گيرد .

: اين را مفصل لوالئي هم مي گويند . اين مفصل اجازه حركت خطي در امتدادش را نمي دهد اما اجازه چرخشيمفصل

ر دو طرف آن را هل داد و به چرخش آزاد حول يكي از محورها را مي دهد . دري كه براي بازكردنش مي توان از ه

براي توليد اين PxRevoluteJointيك ديوار وصل شده است ، مثال خوبي از يك مفصل لوالئي است . كالس

نوع مفصل استفاده مي شود .

: اين مفصل اجازه حركت خطي در امتداد مفصل را نمي دهد اما تغيير جهت آزادانه انجام مي شود . يك مفصل كروي

ل تنظيم كه به يك خودرو متصل است ، مثال خوبي از يك مفصل كروي است . كالس آينه قاب

PxSphericalJoint . براي ساختن يك مفصل كروي استفاده مي شود

اين نوع مفصل ، هميشه مبدا اجسام متصل شده را در داخل يك محدوده مشخص نگه مي دارد . : مفصل فاصله دار

يد اين نوع مفصل مورد استفاده قرار مي گيرد .براي تول PxDistanceJointكالس

: اين را مفصل لغزنده هم مي گويند . اين نوع مفصل هميشه يك جهت ثابت دارد اما اجازه انجام حركت مفصل خطي

براي ساختن اين نوع مفصل استفاده مي شود . PxPrismaticJointمي دهد . كالس xخطي در امتداد محور

مفصل خيلي قابليت انعطاف پذيري و تنظيم شدن دارد طوري كه هر شش درجه از آزادي را اين نوع : D6مفصل

D6براي سفارشي كردن فراهم كرده است . با توجه به نياز شما ، انواع زيادي از مفاصل مي تواند از يك مفصل

براي ساختن اين نوع مفصل استفاده مي شود . PxD6Jointاستخراج شود . كالس

اي ثابتمفصل ه

دو بازيگر را طوري به هم متصل مي كند كه نمي توانند حركت كنند يا جهتشات را PhysXيك مفصل ثابت در

نسبت به همديگر ، تغيير دهند .


در يك شرايط مطلوب ، اجسام متصل به هم ، رابطه فضائي خود را حفظ مي كنند . اما ممكن است شرايطي پيش آيد

ابت را به هم بزند و باعث حركت شود . در جائي كه مي خواهيم شكسته شدن دو بازيگر كه پايداري يك مفصل ث

متصل به هم را توسط نيروهاي بيروني ، نشان دهيم ، مفصل ثابت مفيد خواهد بود .

پارامتر 5براي توليد يك مفصل ثابت بين دو بازيگر استفاده مي شود . اين تابع ()PxFixedJointCreateتابع

توليد شده است . دومين پارامتر PhysX SDKاست كه يك نمونه از PxPhysicsخواهد . اولين پارامتر از نوع مي

است و ارجاعي به اولين بازيگري است كه مفصل به آن متصل شده است . سومين پارامتر ، PxRigidActorاز نوع

به همين شكل ، نشان مي دهد . رازيگر است و موقعيت و جهت مفصل نسبت به اولين با PxTransformاز نوع

تابع يك چهارمين و پنجمين پارامتر ، ارجاعي به بازيگر دوم و موقعيت و جهت مفصل نسبت به بازيگر دوم ، هستند .

، بعضي از اين پارامترها هم استفاده PhysXنمونه از مفصل توليد شده را بازگشت مي دهد . براي ديگر مفصل هاي

مي شوند .

نمونه براي ساختن يك مفصل ثابت : كد

PxVec3 pos = PxVec3(0,10,3); //position of static actor PxVec3 offset = PxVec3(0,2,0); // offset of connected actor from joint //creating actors PxRigidActor* staticActor = PxCreateStatic(*gPhysicsSDK, PxTransform(pos), PxSphereGeometry(0.5f), *mMaterial); PxRigidDynamic* connectedActor = PxCreateDynamic(*gPhysicsSDK, PxTransform(PxVec3(0)), PxBoxGeometry(0.5,0.5,2), *mMaterial, 1.0f); //creating fixed joint between actors PxFixedJoint* fixedJoint = PxFixedJointCreate (*gPhysicsSDK, staticActor, PxTransform(offset), connectedActor, PxTransform(-offset)); //adding actors to scene gScene->addActor(*staticActor); gScene->addActor(*connectedActor);

يك نمونه از mMaterialتوليد شده از قبل است و PhysX SDKيك نمونه از gPhysicsSDKدر اينجا ،

است . PhysXمتريال

مفصل هاي چرخشي

يك مفصل چرخشي ، از انجام همه حركت ها به جز چرخش ، جلوگيري مي كند .


كد توليد يك مفصل چرخشي :

//creating actors

PxRigidActor* staticActor = ...

PxRigidDynamic* connectedActor = ...

PxVec3 offset = PxVec3(0,2,0); // offset of connected actor from joint

//creating Revolute joint between actors

PxRevoluteJoint* revoluteJoint =

PxRevoluteJointCreate (*gPhysicsSDK, staticActor, PxTransform(offset), connectedActor, PxTransform(-offset));

براي ()setLimit و پائين چرخش را براي يك مفصل چرخشي تعيين كرد . تابع همچنين مي توان محدوده باال

مي خواهد . PxJointLimitPairتفاده مي شود . اين تابع يك پارامتر نوع ستنظيم محدوده يك مفصل چرخشي ا

ئيني را مقدار محدوده پا lowerLimitمي خواهد كه PxRealپارامتر نوع PxJointLimitPair ،3خود پارامتر

فاصله از limitContactDistanceمقدار محدوده باالئي را تعيين مي كند و upperLimitتعيين مي كند ،

محدوده باال يا پائيني كه در آن نيروي محدود كننده فعال مي شود را تعيين مي كند . مقدار محدوده پائيني بايد هميشه

و نصب گزينه ()setRevoluteJointFlagستفاده از فراخوان كوچكتر از مقدار محدوده باالئي باشد . ما با ا

PxRevoluteJointFlag::eLIMIT_ENABLED باtrue محدوده تعريف شده يك مفصل چرخشي را فعال ،

مي كنيم .

كد تنظيم محدوده باال و پائين چرخش براي يك مفصل چرخشي :

revoluteJoint->setLimit(PxJointLimitPair(lowerLimit, upperLimit, limitContactDistance));


revoluteJoint ->setRevoluteJointFlag(PxRevoluteJointFlag::

eLIMIT_ENABLED, true);

مفصل هاي كروي

يك مفصل كروي ، از حركت خطي در امتداد اجسام متصل به هم ، جلوگيري مي كند اما چرخيدن و تابيدن مفصل

مجاز است .

مفصل كروي :كد توليد يك

//creating actors

PxRigidActor* actor1 = ...

PxRigidDynamic* actor2 = ...


//creating Spherical joint between actors

PxSphericalJoint* sphericalJoint =

PxSphericalJointCreate (*gPhysicsSDK, actor1, PxTransform(offset), actor2,PxTransform(-offset));


مفصل كروي از يك محدوده مخروطي پشتيباني مي كند كه تعيين مي كند كه اجسام متصل چقدر مي توانند از يك

ان را محدود محور مشخص ، نوسان داشته باشند و يك محدوده پيچيدن كه پيچيدن اجسام متصل حول محورهايش

مي كند .

كد تنظيم محدوده هاي يك مفصل كروي :

sphericalJoint->setLimitCone(PxJointLimitCone(yLimitAngle, zLimitAngle, limitContactDistance));

sphericalJoint->

setSphericalJointFlag(PxSphericalJointFlag::eLIMIT_ENABLED, true);

مي خواهد كه سازنده اين PxJointLimitConeيك پارامتر نوع ()SetLimitConeتابع

PxJointLimitCone سه پارامتر نوع ،PxReal نياز دارد كهyLimitAngle نشان دهنده اندازه زاويه از محور

y ، نيرو استzLimitAngle نشان دهنده زاويه از محورz نيرو است وlimitContactDistance نشان دهنده

از محدوده باالئي يا پائيني كه در آن نيروي محدود كننده فعال مي شود . با فراخوان فاصله

setSphericalJointFlag() و نصب گزينهPxSphericalJointFlag::eLIMIT_ENABLED با مقدار

true . حدود تعريف شده يك مفصل كروي را فعال مي كنيم ،

مفصل هاي فاصله دار

دا بازيگرهاي متصل را در داخل يك محدوده مشخص فاصله ، نگه مي دارد .يك مفصل فاصله دار ، مب


كد توليد يك مفصل فاصله دار :

//creating actors




//creating Spherical joint between actors

PxDistanceJoint* distanceJoint = PxDistanceJointCreate (*gPhysicsSDK, actor1, PxTransform(offset), actor2,PxTransform(-offset));

مي توانيم به شكل زير محدوده باالئي و پائيني را براي يك مفصل فاصله دار اعمال كنيم :

distanceJoint->setMinDistance(2.0f); distanceJoint->setMaxDistance(10.0f); distanceJoint->setDistanceJointFlag(eMAX_DISTANCE_ENABLED, true); distanceJoint->setDistanceJointFlag(eMIN_DISTANCE_ENABLED, true);

مترين و بيشترين فاصله مجاز براي ك ، به ترتيب ، ()setMaxDistanceو ()setMinDistanceتابع هاي

مفصل را تنظيم مي كنند .

مفصل هاي خطي

خطي ، هميشه يك جهت نسبي ثابت بين دو جسم متصل دارد اما اجازه انجام حركت خطي در امتداد يك مفصل

محورهاي رايج را مي دهد .


كد ساختن يك مفصل خطي :

//creating actors



PxVec3 offset = PxVec3(0,2,0); // offset of connected actor from oint

//creating Prismatic joint between actors

PxPrismaticJoint* prismaticJoint =

PxPrismaticJointCreate (*gPhysicsSDK, actor1, PxTransform(offset), actor2,PxTransform(-offset));

حركت مي تواند محدود شود :به شكل زير ، با تنظيم محدوده باالئي و پائيني بر روي فاصله بين مبدا اجسام متصل ،

prismaticJoint->setLimit(PxJointLimitPair(-10.0f, 20.0f, 0.01f);

prismaticJoint ->

setPrismaticJointFlag(PxPrismaticJointFlag::eLIMIT_ENABLED, true);

محدوده يك مفصل خطي استفاده مي شود و يك پارامتر نوع براي تنظيم ()setLimitتابع

PxJointLimitPair اين پارامتر به سه پارامتر نوع دمي خواهد كه خوPxReal نياز دارد كهlowerLimit

محدوده را تعيين مي كند و مقدار باالئي upperLimitمقدار پائيني محدوده را تعيين مي كند ،

limitContactDistance فاصله از محدوده باالئي يا پائيني كه در آن نيروي محدودكننده فعال مي شود را تعيين

يشه كوچكتر از مقدار محدوده باالئي باشد . با فراخوان ممي كند . مقدار محدوده پائيني بايد ه

setPrismaticJointFlag() و نصب گزينهPxPrismaticJointFlag::eLIMIT_ENABLED به مقدار

true . محدوده تعريف شده براي يك مفصل خطي را فعال مي كنيم ،

D6مفصل هاي

لي با انعطاف پذيري و قابليت تنظيم باال است كه هر شش درجه از ص، مف D6همانطور كه قبال هم ذكر شد ، مفصل

و آزادي چرخش در zو x ،yديگر ، آزادي حركت در همه محورهاي آزادي را براي سفارشي شدن ، دارد . به عبارت

از مفاصل را مي توان ساخت . ي، انواع زياد D6هر سه محور . با تنظيم مفصل

: D6كد ساختن يك مفصل

//creating actors





//creating D6 joint between actors

PxD6Joint* d6Joint =

PxD6JointCreate (*gPhysicsSDK, actor1, PxTransform(offset), actor2,PxTransform(-offset));

مفصل ثابت رفتار مي كند . براي ، قفل هستند و مثل يك D6به صورت پيش فرض ، همه درجات آزادي در مفصل

و PxD6Axisنياز است كه دو نوع شمارنده ()setMotion، تابع D6تنظيم درجه آزادي يك مفصل

PxD6Motion مي خواهد . پارامترPxD6Axis تعيين كننده محوري است كه حركت بايد انجام شود . مقادير ممكن ،

آن عبارتند از :

PxD6Axis::eX متداد محور : حركت در اx

PxD6Axis::eY حركت در امتداد محور :y

PxD6Axis::eZ حركت در امتداد محور :z

PxD6Axis::eTWIST : حركت حول محورx

PxD6Axis::eSWING1 : حركت حول محورy

PxD6Axis::eSWING2 : حركت حول محورz

PxD6Motion ممكن عبارتند از : نوع حركت حول يك محور مشخص را تعريف مي كند . مقادير

PxD6Motion::eLOCKED . درجه آزادي قفل است . حركت نسبي مجاز نيست :

PxD6Motion::eLIMITED . درجه آزادي محدود است . فقط حركت در داخل يك محدوده مشخص مجاز است :

PxD6Motion::eFREE محدوده كاملي از حركت را دارد .: درجه آزادي آزاد است و

توليد شود عبارتست از : مفصل چرخشي ، مفصل D6ز مفاصلي كه مي تواند با استفاده از تنظيم كردن مفصل تعدادي ا

در دسترس نيستند مثل مفصل استوانه اي و مفصل نقطه به PhysX 3كروي ، مفصل خطي و مفاصل ديگري كه در

صفحه .


خالصه

نوع 6و تنظيمات آنها ، آموزش ديديم . در خصوص PhysX SDKدر اين فصل ، درباره انواع مفصل هاي موجود در

آموزش ديديم كه عباتند از : مفصل ثابت ، مفصل چرخشي ، مفصل كروي ، مفصل فاصله PhysXمفصل موجود در

. همچنين رفتار و مشخصات آنها را بررسي كرديم . D6دار ، مفصل خطي و مفصل


: استفسارهاي صحنه 6فصل

مباحث زير ش مي بينيم .زآمو و عملكردشان ،) scene query(انواع مختلف استفسارهاي صحنه در اين فصل درباره

در اين فصل بررسي خواهد شد :

و شيوه هاي عملكرد آن Raycastاستفسارهاي

و شيوه هاي عملكرد آن Sweepاستفسارهاي

و شيوه هاي عملكرد آن Overlapاستفسارهاي

ار اشعه)(انتش Raycast استفسارهاي

) است ، درست مثل rayدها به وسيله اشعه ها (رراهي براي تشخيص تصادم و برخو (انتشار اشعه ) ، raycastاستفسار

يك نقطه قرمز را روي اولين شيوه اي كه از دستگاه اشاره گر ليزري در زمان نمايش اساليدها ، استفاده مي كنيم كه

استفاده هاي زيادي دارند مثل Raycastشد ، ايجاد مي كند . استفسارهاي شئ اي كه اشعه اش با آن برخورد كرده با

تشخيص نقطه برخورد گلوله در بازي هاي اول شخص ، بررسي خط ديد كاراكترهاي دشمن و انتخاب اشياء داخل

بازي با استفاده از ماوس .

م مي شود و بسته به آرگومان انجا ()PxScene::raycastتوسط فراخوان تابع raycast، استفسار PhysXدر

هائي كه به تابع پاس مي دهيد ، مي تواند در شيوه هاي مختلفي مورد استفاده قرار گيرد كه عبارتند از :

raycast() باPxRaycastBuffer buf وPxQueryFlag::eANY_HIT

raycast() باPxRaycastBuffer buf و سازنده پيش فرض

raycast() باPxRaycastBuffer buf(PxRaycastBuffer, PxU32)

برخورد با هر شئ را در true، فقط PxQueryFlag::eANY_HIT با ()raycastهنگام استفاده از تابع

PhysX بازگشت مي دهد . اين فراخواني كم هزينه است چون محاسباتي در زمينه شكل برخورد و نقطه محل اصابت

هستند و مبداء و جهت اشعه را تعيين PxVec3متر مي خواهد . دو پارامتر اولي از نوع پارا 6، انجام نمي دهد . اين تابع

است و نشان دهنده بيشترين مسافت مجاز اشعه است . پارامتر چهارم ، از نوع PxRealمي كنند . پارامتر سوم از نوع

PxRaycastBuffer است و محتوي نتيجه برخورد است . پارامتر پنجم از نوع PxHitFlag است و مشخص مي

، مورد نياز است . براي تنظيمات پيش فرض ، PxQueryHitكند كه كدام گزينه هاي اختياري براي پركردن ساختار


استفاده كنيم و آخرين پارامتر از نوع PxHitFlags(PxHitFlag::eDEFAULT)مي توانيم از

PxRaycastBuffer است و براي استفاده از اين شيوه ، بايد PxQueryFlag::eANY_HIT . باشد

: PxQueryFlag::eANY_HITو PxRaycastBuffer bufبا ()raycastمثالي از

PxVec3 origin = PxVec3(0,3,0); //[in] Ray origin

PxVec3 unitDir = PxVec3(0,1,0); //[in] Normalized ray direction

PxReal maxDistance = 1000.0f; //[in] Raycast max distance

PxRaycastBuffer hit; //[out] Raycast results

PxQueryFilterData fd;

fd.flags |= PxQueryFlag::eANY_HIT;

bool status = gScene->raycast(origin, unitDir, maxDistance, hit, PxHitFlags(PxHitFlag::eDEFAULT),fd);

و سازنده پيش فرض است . در اين شيوه PxRaycastBuffer bufهمراه با ()raycastه از دومين شيوه استفاد

، اطالعات دقيقي درباره اولين شكلي كه مورد trueاگر اشعه ، شكلي را مورد اصابت قرار دهد ، عالوه بر بازگشت

چهار پارامتر ابتدائي مورد نياز است كه اصابت قرار گرفته و اطالعات اصابت آن ، داده مي شود . براي اين شيوه ، تنها

هستند كه محتوي اطالعات اصابت raycastتعيين كننده مبداء ، جهت و بيشترين مسافت اشعه و نيز بافر

raycast است . اگر اشعه با يك بازيگرPhysX كه داراي شكلي است ، برخورد كند ، اين تابعtrue بازگشت مي

بازگشت خواهد داد . falseدهد در غير اين صورت

مثالي از اين شيوه :

PxVec3 origin = PxVec3(0,3,0); //[in] Ray origin

PxVec3 unitDir = PxVec3(0,1,0); //[in] Normalized ray direction

PxReal maxDistance = 1000.0f; //[in] Raycast max distance

PxRaycastBuffer hit; //[out] Raycast results

bool status = gScene->raycast(origin, unitDir, maxDistance, hit);

كه مي تواند در استفاده كنيم كه يك اشعه را پرتاب و منتشر كند ()raycastدر سومين شيوه ، مي توانيم طوري از

ل هائي كه در آنها نفوذ كرده و نقاط فوذ كند و اطالعاتي را درباره همه شكنهمه اشكالي كه در مسيرش هستند ،

، در يك بافر قرار دهد . براي اين شيوه ؛ سه پارامتر اولي ، مثل قبل يكسان هستند كه تعيين كننده مبداء ، ن ابرخوردش

PxRaycastBufferجهت و بيشترين مسافت اشعه مي باشند . پارامتر چهارم و آخرين پارامتر با

buf(hitBuffer, bufferSize) جابه جا مي شود كه همه اشيائي كه توسط اشعه مورد اصابت قرار گرفته اند


محتوي يك اصابت انسداد hitBufferهمراه با اطالعاتي درباره برخوردشان ، نگه مي دارد . اگر پارامتر

)blocking hit . باشد يا نباشد ، تابع يك مقدار بولي بازگشت مي دهد (

يك مثال از اين شيوه :

const PxU32 bufferSize = 256; // [in] size of 'hitBuffer' PxRaycastHit hitBuffer[bufferSize]; // [out] User provided buffer for results

// [out] Blocking and touching hits will be stored here PxRaycastBuffer buf(hitBuffer, bufferSize); // Raycast against all static & dynamic objects (no filtering) // The main result from this call are all hits along the ray, //stored in 'hitBuffer' bool hadBlockingHit = gScene->raycast(origin, unitDir, maxDistance, buf);

Sweepاستفسارهاي

(انتشار اشعه) هستند اما تنها تفاوت موجود اين است كه استفسارهاي raycastرهاي استفسارهاي درست مثل استفسا

sweep به جاي اشعه ، يك شكل را پرتاب يا منتشر مي كنند . مثلraycast در ،PhysX تابع ،

PxScene::sweep() براي انجام استفسارهايsweep مورد استفاده قرار مي گيرد كه مي تواند به شيوه هاي

متفاوتي مثل زير ، مورد استفاده قرار گيرد :

sweep() باPxSweepBuffer buf وPxQueryFlag::eANY_HIT

sweep() باPxSweepBuffer buf و سازنده پيش فرض

sweep() باPxSweepBuffer buf(PxSweepBuffer, PxU32)

باشد . convex ، مي تواند جعبه ، كره ، كپسول يا sweepشكل هندسي مورد نياز تابع

، تمام اشياء هندسي تعيين شده را در ميان فضا ، پرتاب كرده و همه بازيگران جامدي را كه در طول sweep تابع

و بازيگران sweep هر برخورد و تصادم موفق بين يك شكلپرتاب ، اصابتي را دريافت كرده اند ، پيدا مي كند .

را توليد مي كند . PxSweepBufferيلد صحنه ، اطالعات اصابت تعيين شده توسط ف

و PxSweepBuffer buf با ()sweep، شيوه استفاده از تابع ()sweepدر ميان همه شيوه هاي فراخوان تابع

PxQueryFlag::eANY_HIT كم هزينه ترين است چون اين شيوه هيچ محاسباتي را براي پيداكردن شكل مورد

با اجسام ديگر موجود در sweepدهد . تابع در هنگام برخورد موفق بين شكل اصابت و نقطه اصابت ، انجام نمي

است كه PxGeometryبه هفت پارامتر نياز دارد . اولين پارامتر از نوع عبازگشت مي دهد . تاب trueصحنه ، فقط

ه مبداء ، جهت و نشان دهنده شكل هندسي است كه براي پرتاب استفاده مي شود . سه پارامتر بعدي ، تعيين كنند

است كه نتيجه PxSweepBufferبيشترين مسافت شكل هندسي پرتاب از نقطه مبداء است . پارامتر پنجم ، از نوع


است كه تعيين كننده فيلدهاي اختياري است كه براي PxHitFlagاصابت را ذخيره مي كند . پارامتر ششم ، از نوع

براي تنظيمات پيش فرض مي توانيم از ، نياز هستند . PxQueryHitپركردن ساختار

PxHitFlags(PxHitFlag::eDEFAULT) استفاده كنيم . آخرين پارامتر از نوعPxQueryFilterData است

باشد . PxQueryFlag::eANY_HITو براي اينكه اين شيوه مورد استفاده قرار گيرد بايد

: PxQueryFlag::eANY_HITو PxSweepBuffer buf همراه با ()sweepمثالي از شيوه

//[in] Sweep geometry PxGeometry sphereGeometry = PxSphereGeometry(0.5f); //[in] Geomery transform PxTransform initialPos = PxTransform(PxVec3(0,5,0)); PxVec3 unitDir = PxVec3(0,-1,0); //[in] Normalized sweep direction PxReal maxDistance = 1000.0f; //[in] Sweep max distance PxSweepBuffer sweepBuff; //[out] Sweep result PxQueryFilterData fd; fd.flags |= PxQueryFlag::eANY_HIT; bool status = gScene->sweep(sphereGeometry,initialPos,unitDir,maxDistance, sweepBuff,PxHitFlags(PxHitFlag::eDEFAULT),fd);

و سازنده پيش فرض ، نه تنها برخورد با شكل هندسي PxSweepBuffer bufهمراه با () sweepاستفاده از

پرتاب را تشخيص مي دهد بلكه اطالعات اصابت را درباره اولين شكلي كه مورد اصابت قرار گرفته است ، در اختيار مي

هستند . ()sweepد كه مثل استفاده قبلي از تابع گذارد . تابع پنج پارامتر مي خواه

و سازنده پيش فرض : PxSweepBuffer bufهمراه با ()sweepمثالي از

//[in] Sweep geometry PxGeometry sphereGeometry = PxSphereGeometry(0.5f); //[in] geomery transform PxTransform initialPos = PxTransform(PxVec3(0,5,0)); PxVec3 unitDir = PxVec3(0,-1,0); //[in] Normalized sweep direction PxReal maxDistance = 1000.0f; //[in] Sweep max distance PxSweepBuffer sweepBuff; //[out] Sweep result bool status = gScene->sweep(sphereGeometry,initialPos,unitDir,maxDistance,sweepBuff);

، مي PxSweepBuffer buf(PxSweepBuffer, PxU32)هراه با ()sweepدر سومين شيوه استفاده از تابع

كه درسر راهش هستند نفوذ كرده و اطالعاتي را PhysXتواند به شكلي مورد استفاده قرار گيرد كه در تمام بازيگران

قرار داده است (تا وقتي كه شكل هندسي پرتاب به آخرين مسافت درباره همه بازيگراني كه آنها را مورد اصابت

مجازش برسد ) ، در اختيار بگذارد .

: PxSweepBuffer buf(PxSweepBuffer, PxU32) همراه با ()sweepمثالي از تابع


PxGeometry sphereGeometry = PxSphereGeometry(0.5f); //[in] Sweep geometry PxTransform initialPos = PxTransform(PxVec3(0,5,0)); //[in] geomery transform PxVec3 unitDir = PxVec3(0,-1,0); //[in] Normalized sweep direction PxReal maxDistance = 1000.0f; //[in] Sweep max distance PxSweepBuffer buff; //[out] Sweep result const PxU32 bufferSize = 256; // [in] size of 'sweepBuffer' PxSweepHit sweepBuffer[bufferSize]; //[out] User provided buffer for results PxSweepBuffer buf(sweepBuffer, bufferSize); //[out] Hits stored here bool status = gScene->sweep(sphereGeometry,initialPos,unitDir,maxDistance,buff);

، شكل هاي ورودي كه قابل استفاده هستند عبارتند از : جعبه ، sweepدر حال حاضر براي همه انواع استفسارهاي

. convexكره ، كپسول و

Overlapاستفسارهاي

، برخورد يا PhysX ، ما تعيين مي كنيم كه آيا شكل هندسي با اجسام موجود ديگر در صحنه Overlapدر استفسار

تماس داشته است يا خير . اگر يك تماس گزارش شود ، مي توانيم اطالعاتي را درباره شئ تماس به دست آوريم . اين

را پشتيباني نمي كند ، چون هيچ نقطه خاص PxHitFlagsاست به جزاينكه ()sweepو ()raycastشيوه شبيه

ندارد . اشكالي كه پشتيباني مي شوند عبارتند از جعبه ، كره ، كپسول اوليه از جائي كه تماس اتفاق افتاده است ، وجود

. convexو

انجام مي شود كه مي تواند ()PxScene::overlapتوسط فراخوان تابع overlap، استفسارهاي PhysXدر

تفاده قرار گيرد :بسته به آرگومان هائي كه شما به تابع پاس مي دهيد ، به شيوه هاي مختلفي به شكل زير مورد اس

overlap() باPxOverlapBuffer buf وPxQueryFlag::eANY_HIT

overlap() باPxOverlapBuffer buf(PxOverlapBuffer, PxU32)

، اگر حجم شكل ، PxQueryFlag::eANY_HITو PxOverlapBuffer buf همراه با ()overlapتابع

بازگشت مي دهد . در اين شيوه ، تابع چهار trueرار گيرد ، فقط ، مورد تماس ق PhysXتوسط هر بازيگر ديگر

و نشان دهنده شكل هندسي شئ اي است كه براي بررسي تماس PxGeometryپارامتر مي خواهد . اولي از نوع

است كه PxOverlapBufferاستفاده مي شود . دومين پارامتر ، تبديل يك شئ است و سومين پارامتر ، از نوع

است و براي استفاده از اين شيوه بايد PxQueryFilterDataي نتيجه تماس مي باشد . آخرين پارامتر از نوع محتو

PxQueryFlag::eANY_HIT . باشد

: PxQueryFlag::eANY_HITو PxOverlapBuffer bufهمراه با ()overlapيك مثال از

//[in] Sweep geometry


PxGeometry sphereGeometry = PxSphereGeometry(0.5f);

//[in] geomery transform

PxTransform initialPos = PxTransform(PxVec3(0,5,0));

PxOverlapBuffer buf; //[out] Buffer for overlap results

PxQueryFilterData fd;

fd.flags |= PxQueryFlag::eANY_HIT;

bool status = gScene->overlap(sphereGeometry,initialPos,buf,fd);

، تعداد اشيائي را كه با PxOverlapBuffer buf(PxOverlapBuffer, PxU32)با ()overlapتابع

شكلش تماس داشته ، بازگشت مي دهد و سه پارامتر مي خواهد . دو پارامتر اول ، تعريف كننده شكل هندسي و تبديل

است كه محتوي اطالعاتي درباره همه PxOverlapBufferتر از نوع مين پارامهستند و سوشئ براي بررسي تماس

اشياء تماس است .

: PxOverlapBuffer buf(PxOverlapBuffer, PxU32)همراه با ()overlapمثالي از تابع

PxGeometry sphereGeometry = PxSphereGeometry(0.5f);

PxTransform initialPos = PxTransform(PxVec3(0,5,0));

const PxU32 bufferSize = 256

PxOverlapHit overlapBuffer[bufferSize];

PxOverlapBuffer buf(overlapBuffer, bufferSize);

bool status = gScene->overlap(sphereGeometry,initialPos,buf);

خالصه

(تماسي) آموزش overlapرتاب شكل ) و (پ sweep(انتشار اشعه) ، raycastدر اين فصل درخصوص استفسارهاي

ديديم . ديديم كه اين استفسارها مي توانند به شيوه هاي مختلفي انجام شوند البته بسته به تعداد و نوع آرگومان هائي

كه براي تابع ها فراهم مي شوند . همچنين ياد گرفتيم كه هر شيوه هزينه هاي كارائي و عملكرد متفاوتي دارد و ما مي

نيم بسته به نيازمان ، استفسارهار را سفارشي كنيم .توا


: كنترل كننده كاراكتر 7فصل

آشنا مي شويم . PhysXدر اين فصل با مفهوم كنترل كننده كاراكتر و چگونگي استفاده از آن در

مباحثي كه در اين فصل بررسي مي شود عبارتند از :

اكترمفاهيم پايه و علت نياز به كنترل كننده كار

توليد و حركت دادن يك كنترل كننده كاراكتر

به روز كردن موقعيت ، شكل و اندازه يك كنترل كننده كاراكتر

شيب حدو گام برداشتن خودكار

مفاهيم مقدماتي كنترل كننده كاراكتر

ازي ها براي يك كنترل كننده كاراكتر ، يك نوع بازيگر سينماتيك خاص با يك شكل برخورد است كه ما از آن در ب

ساختن برخورد كننده يك كاراكتر بازي استفاده مي كنيم . آن ، مشخصات و متدهاي مخصوصي همراه با كنترلي

. داردظريف بر روي حركتش و كنش و واكنش با محيط اطراف

مورد (هوش مصنوعي) در بازي ها AIيك كنترل كننده كاراكتر مي تواند براي شبيه سازي حركت هر كاراكتر يا

يا سوم شخص در بازي هاي تيراندازي اول شخص ن مي تواند براي ساختن كاراكترهاي بازياستفاده قرار گيرد . آ

در يك بازي استراتژيك استفاده شود . NPCمورد استفاده قرار گيرد و حتي براي ساختن

لزوم نياز به كنترل كننده كاراكتر

كاراكتر به منظور نمايش حدود برخورد و تصادم يك كاراكتر بازيكن يا در بازي هاي كامپيوتري ، يك كنترل كننده

هوش مصنوعي دشمن ، استفاده مي شود . اگر چه اين كار را مي توان با استفاده از يك جسم جامد سينماتيك انجام

را برطرف مي كند .داد ، دير يا زود ، با مشكالت زيادي روبه رو مي شويد كه استفاده از كنترل كننده كاراكتر آنها

مشكالت معمولي كه ممكن است در هنگام استفاده از اجسام جامد پيش فرض موجود در موتور فيزيك به جاي يك

كنترل كننده كاراكتر ، با آنها روبه رو شويد ، عبارت است از :


تصادم بين اشياء ) براي تشخيص برخورد و DCDموال اجسام موتور فيزيك از الگوريتم تشخيص برخورد گسسته (عم

استفاده مي كنند كه گاهي اوقات در تشخيص اشياء متحرك پرسرعت با شكست مواجه مي شود ، در نتيجه باعث مي

شود يك كاراكتر از ميان يك ديوار حركت كند .

كنترل يك جسم جامد متحرك ، مي تواند با استفاده از نيرو يا تكانه حركت كند اما موقعيت نهائيش نمي تواند دقيقا

شود . بنابراين استفاده از آن به جاي كنترل كننده كاراكتر ، ايده خوبي نيست .

يك جسم جامد متحرك از روي سطوح شيب دار ، به سمت پائين مي لغزد اما هر جسمي كه يك كاراكتر را نشان مي

دهد بايد بتواند بر روي سطوح ناهموار و شيب دار بايستد .

در موتور فيزيك مشخصات ارتجاعي دارند كه باعث مي شود اجسام هنگام برخورد با يك سطح معموال ، اجسام موجود

، به سمت باال پرش كنند . اين مشخصه خوبي براي شبيه سازي يك كاراكتر نيست .

توليد يك كنترل كننده كاراكتر

) ايجاد كنيد controller managerقبل از ساختن يك كنترل كننده كاراكتر ، الزم است يك مدير كنترل كننده (

را مديريت مي كند . PhysXكه همه كنترل كننده هاي كاراكتر و كنش و واكنش آنها با هم ديگر در صحنه

كد ايجاد يك مدير كنترل كننده :

PxScene* gScene; //Instance of PhysX scene

PxControllerManager* manager = PxCreateControllerManager(*gScene);

يك كنترل كننده كاراكتر توليد كنيم :به شكل زير بعد از اين ، مي توانيم براي هر كاراكتر موجود در بازيمان ،

PxCapsuleControllerDesc desc;

//initial position

desc.position = PxExtendedVec3(0.0f,0.0f,0.0f);

//controller skin within which contacts generated

desc.contactOffset = 0.05f;

//max obstacle height the character can climb

desc.stepOffset = 0.01;

desc.slopeLimit = 0.5f; // max slope the character can walk


desc.radius = 0.5f; //radius of the capsule

desc.height = 2; //height of the controller

desc.upDirection = PxVec3(0, 1, 0); // Specifies the 'up' direction

desc.material = NULL;

PxController* c = manager->createController(desc);

مش ساكني باشد كه وقتي كه يك كنترل كننده كاراكتر ساختيم ، حجم محدودكننده آن بايد هميشه بر روي سطح يا

آن راه مي رود . تماس شكل كنترل كننده كاراكتر با سطحي كه بر روي آن راه مي رود ، مي تواند باعث نتيجه روي

تعريف نشده اي مثل افتادن كنترل كننده كاراكتر در سوراخ سطح ، شود .

حركت دادن يك كنترل كننده كاراكتر

توضيح داده شد ) ، 3( اجسام سينماتيك در فصل از آنجائيكه يك كنترل كننده كاراكتر ، يك جسم سينماتيك است

به روز شود ( حركت كند ) نه به وسيله نيروهاي خارجي ()moveموقعيت آن مي تواند فقط از طريق فراخوان صريح

. حتي تاثير جاذبه هم برطبق يك برنامه ؛ ايجاد مي PhysXاعمال شده از طرف ديگر بازيگران موجود در صحنه

نمي تواند بر روي اجسام سينماتيك اثري بگذارد . PhysXه شود چون جاذب

تابع زير فراخوانده مي شود :عيتش در هر فريم ، كاراكتر به وسيله به روز كردن موقبراي حركت دادن يك كنترل كننده

collisionFlags =

PxController::move(disp, minDist, elapsedTime, filters, obstacles);

پارامتر مي خواهد : 5؛ ()PxController::moveتابع

براي فريم جاري است . z و x ،yاست و نشان دهنده اندازه تغيير مكان در محورهاي PxVec3 اولين پارامتر از نوع

آن براي شبيه سازي تاثير جاذبه ، و پرش كنترل كننده كاراكتر بر اساس يك طرح و برنامه ، به روز مي شود . yجزء

براي حركت هاي عرضي كنترل كننده كاراكتر ، به روز مي شوند . zو xي اجزا

است و نشان دهنده كوچكترين اندازه مورد استفاده براي متوقف كردن الگوريتم تغيير مكان Px32دومين پارامتر از نوع

يمانده حركت كمتر از اين حد مي شود . ازگشتي است ، هنگامي كه فاصله باقب

است . moveتابع است و نشان دهنده زمان سپري شده از آخرين فراخوان PxF32ر از نوع سومين پارامت

است و مي تواند براي فيلتر كردن بازيگراني مورد استفاده قرار PxControllerFiltersچارمين پارامتر ، از نوع

گيرد كه كنترل كننده كاراكتر با آنها برخورد مي كند .

مانع هاي اضافه اي هستند كه كنترل است و اختياري است . اينها PxObstacleContextآخرين پارامتر از نوع

كننده كاراكتر بايد با آنها برخورد كند .


بازگشت مي دهد كه از آن مي توان براي PxControllerFlag، مقدار ()PxController::moveتابع

ه ، به ديوار يا هر چيز ديگري ضربه زده است ، استفاده تشخيص اينكه آيا كنترل كننده كاراكتر ، زمين را لمس كرد

كرد .

مشخصات و متدهاي مفيد

ل كننده كاربر ، مشخصات و متدهاي زيادي دارد كه براي كنترل دقيق حركت و كنش و واكنش با محيط ريك كنت

.اطراف ، حيلي مفيد هستند . بعضي از مشخصات حياتي در ادامه مورد بحث قرار مي گيرند

به روز كردن موقعيت

مهم است كه موقعيت حال حاضر يك كنترل كننده كاربر را بدانيد تا بتوانيد مدل گرافيكي كاراكتر بازي را با آن

هماهنگ كنيد . به صورت زير مي توان موقعيت كنترل كننده كاراكتر را به دست آوريم :

const PxExtendedVec3& PxController::getPosition() const;

را بازگشت مي موقعيت حال حاضر مركز شكل كنترل كننده كاراكتر ()PxController::getPositionتابع

دهد . توجه كنيد كه يك كنترل كننده كاراكتر هرگز نمي چرخد بنابراين تابعي براي گرفتن چرخش و دوران حال حاضر

كنترل كننده كاراكتر نداريم .

ن به عبارت ديگر موقعيت پاي كنترل كننده كاراكتر را با استفاده از تابع هاي زير به همچنين مي توانيم موقعيت پائي

دست آورده و تنظيم نمائيم :

//get foot position of character controller

const PxExtendedVec3& PxController::getFootPosition() const;

//set foot position of character controller

bool PxController::setFootPosition(const PxExtendedVec3& position);

شكل هاي يك كنترل كننده كاراكتر

PhysX : در حال حاضر دو نوع شكل براي تعريف محدوده برخورد يك كنترل كننده كاراكتر ، دارد

AABB (Axis Aligned Bounding Box) :AABB قعيت و يك بردار شكل جعبه است كه به وسيله يك مو

نمي چرخد حتي اگر شكل گرافيكي بازيكن بچرخد . AABBاندازه ، تعريف مي شود .

، حجم برخورد يك AABBشكل كپسول : يك شكل كپسول به وسيله ارتفاع و شعاعش تعريف شده و بهتر از

، كمي پرهزينه تر است . CPUكاراكتر را نشان مي دهد اما در زمينه استفاده از


يك حجم راي اينكه حدود برخورد كنترل كننده كاراكتر ، در برابر ديگر شكل هاي برخورد ، قابل قبول تر باشد ، ب

پوستي ، گرداگرد حجم كنترل كننده كاراكتر نگه داري مي شود . عرض پوست مي تواند از طريق تابع

PxControllerDesc::contactOffset تنظيم شود و مي تواند توسط تابع

PxController::getContactOffset() خوانده شود . هنگامي كه با يك رندركننده ، كنترل كننده كاراكتر را

به صورت گرافيكي مي بينيم ، بايد عرض پوستش را براي تعيين حجم رندرشده كنترل كننده ، رسيدگي و مالحضه

كنيم .

به روز كردن اندازه

قوز كردن ( خم راند در زمان اجرا به صورت ديناميك ، دچار تغيير شود تا رفتااندازه شكل كنترل كننده كاراكتر مي تو

متر است ، شايد بخواهيد در 1,5شدن) كاراكتر بازي ، شبيه سازي شود . براي مثال ، اگر ارتفاع كاراكتر بازي شما

وجود در بازي ، جلوگيري شود .متر كاهش دهيد تا از برخورد با اشياء كم ارتفاع م 1هنگام خم شدن آن را به مقدار

تابعي كه مي تواند براي تغيير اندازه يك كنترل كننده كاراكتر ، استفاده شود ، به شكل زير است :

مي توانيد از تابع زير استفاده كنيد : AABBبراي شكل

bool PxBoxController::setHalfSideExtent(PxF32 halfSideExtent) = 0; bool PxBoxController::setHalfForwardExtent(PxF32halfForwardExtent) = 0;

براي شكل كپسول مي توانيد از تابع زير استفاده كنيد :

bool PxCapsuleController::setRadius(PxF32 radius) = 0; bool PxCapsuleController::setHeight(PxF32 height) = 0;

ع يك كنترل كننده كاراكتر را افزايش مي دهيم ، ممكن است كنتزل كننده كاراكتر هنگامي كه در زمان اجرا ، ارتفا

مدتي از زمين بلند شود تا اينكه دوباره زمين را لمس نمايد . علت اين اتفاق اين است كه ارتفاع آن از مركز كاهش پيدا

تحت تاثير قرار مي دهد . بنابراين مي كند كه اندازه باالئي سمت چپ و پائيني سمت راست كنترل كننده كاراكتر را

، زمين را لمس كند . اين كار مي الزم است به طور مناسب ، موقعيتش تنظيم شود تا اينكه پس از تغيير اندازه ارتفاعش

تواند به طور اتوماتيك با استفاده از تابع زير ، انجام شود :

void PxController::resize(PxF32 height) = 0;

تن خودكارگام برداش

خصوصيتي برا ي يك كنترل كننده كاراكتر است كه به كنترل كننده كاراكتر اجازه گام برداشتن خودكار، PhysXدر

ي وقتي كه يك شخص عاز ميان يك سطح ناصاف حركت كند . درست مثل دنياي واقمي دهد بدون مداخله كاربر ،


تي درباره آنها فكر كند . اين به كنترل كننده كاراكتر اجازه مانع هاي كوچك در سرراهش عبور مي كند بدون اينكه ح

ساكن راه مي رود ، مقداري تحمل و انحراف مجاز triangle meshمي دهد ؛ هنگامي كه بر روي زمين يا يك

دربرابر سطوح يكنواخت يا زمين داشته باشد . اين تحمل و انحراف مجاز مي تواند توسط تابع

PxControllerDesc::stepOffset() نياز دارد گام برداشتن خودكارتعريف شود . پياده سازي خصوصيت ،

تعريف شود . ()PxController::upDirection(باال) را بداند كه مي تواند توسط تابع upبردار SDKكه

حد شيب

ا روي يك زمين هنگامي كه يك كنترل كننده كاراكتر روي سطحي حركت مي كند كه چند درجه شيب دار است ، ي

()PxControllerDesc::SlopeLimitبه وسيله تابع ناهموار شامل سطوح شيب دار و باريك حركت مي كند ،

مي توان حركت كنترل كننده كاراكتر را محدود كرد . اين تابع به بيشترين حد مجاز شيب به راديان براي يك كنترل

اويه حد مورد نظر بيان مي شود .كننده كاراكتر نياز دارد . اين به شكل كسينوس ز

درجه شيب نداشته باشد : 30كد زير اجازه مي دهد كه يك كنترل كننده كاراكتر روي سطحي راه برود كه بيش از

slopeLimit = cosf(PxMath::degToRad(30.0f));

فعال مي كند . بايد توجه تنظيم حد شيب به صفر ، هر محدوديت مربوط به شيب را بر روي كنترل كننده كاراكتر ، غير

كرد كه اگر شكل لمس شده به يك جسم جامد سينماتيك يا متحرك ، الصاق شده باشد ، يا اينكه شكل لمس شده ،

گرفتن نقطه برخورد از يك كره يا كپسول الصاق شده به يك جسم ساكن باشد ، حد شيب ناديده گرفته مي شود .

heightfield ،triangle mesh ،convex meshe و جعبه ها بيشتر و آسانتر از كره ها و كپسول ها انجام مي

شود بنابراين اين نوع شكل ها در محاسبات حد شيب ناديده گرفته مي شوند البته به شرطي كه به يك جسم ساكن

الصاق شده باشند .

خالصه

ا ياد گرفتيم . ياد گرفتيم كه چطور ر PhysXدر اين فصل مفهوم كنترل كننده كاراكتر و چگونگي استفاده از آن در

ايجاد و به روز كنيم و يك شكل براي آن تعريف نمائيم . همچنين مشخصات ديگر مربوط به يك كنترل كننده كاراكتر

و حد شيب را ديديم . گام برداشتن خودكارآن مثل


: ذرات 8فصل

يم . مباحثي كه در اين فصل بررسي مي شوند آموزش مي بين PhysXدر اين فصل ، در زمينه شبيه سازي ذرات در

عبارتند از :

انواع سيستم هاي ذره اي و توليد آنها

مشخصات سيستم هاي ذره اي

ايجاد ، به روز كردن و حذف يك ذره

و فيلتر برخورد تخليه كننده ذرات

بررسي ذرات

هاي ذره اي نياز دارند ، مورد استفاده قرار ذرات ، خيلي زياد در بازي ها و برنامه هاي سه بعدي ديگري كه به افكت

غبار ، برف و ... استفاده مي گيرند . از آنها براي شبيه سازي افكت هاي ذره اي مثل انفجارها ، دود ، مايع ، ريزگردها ،

مي شود . آنها با توليد گرافيك ها شبه واقعي ، اصالت شبيه سازي دنيا را افزايش مي دهند .

م ذره ايايجاد يك سيست

، قبل از توليد ذرات وافعي ، الزم است يك سيستم ذره اي ايجاد كنيم . كالس سيستم ذره اي ، تنظيمات PhysXدر

ذرات توليد شده مي ذرات و مراحل سيكل زندگي آنها مثل ، توليد ، به روز شدن و حذف آنها را مديريت مي كند .

ذرات چه اشياء ساكن ، چه متحرك ، كنش و واكنش داشته باشند . ، PhysXتوانند با ديگر اشياء موجود در صحنه

همچنين مي توانند توسط جاذبه و نيروها ، تحت تاثير قرار گيرند .

PhysX : در اصل از دونوع سيستم ذره اي پشتيباني مي كند كه عبارتند از

ذرات بدون برخورد دروني

ذرات با برخورد دروني (ذرات هيدروديناميك)

ت بدون برخورد درونيذرا


(ساكن يا متحرك) PhysXمشخصه اصلي اين ذرات اين است كه آنها مي توانند با محيط اطراف يا با ديگر بازيگران

برخورد و تصادم داشته باشند اما نمي توانند با ذرات هم نوع خود ، برخوردي داشته باشند . اين نوع ذرات براي توليد

، غبار ، برف ، طوفان و ... مناسب هستند . افكت هاي ذره اي مثل جرقه

براي توليد يك سيستم ذره اي كه از برخورد دروني پشتيباني نمي كند ، تابع

PxPhysics::createParticleSystem() فراخوانده مي شود . ساده ترين شكل آن يك پارامتر نوع

PxReal مي توانند در سيستم ذره اي توليد شده ، قرار گيرند . نياز دارد كه تعيين كننده بيشترين تعداد ذراتي است كه

بازگشت داده مي PxParticleSystemبا فراخوان موفق اين تابع ، ارجاعي به سيستم ذره اي توليد شده از نوع

بازگشت داده مي شود . nullشود در غير اين صورت

: PxParticleSystemمثالي از توليد يك سيستم ذره اي نوع

// set immutable properties.

PxU32 maxParticles = 100;

// create particle system in PhysX SDKs

PxParticleSystem* ps =

mPhysics->createParticleSystem(maxParticles);

// add particle system to scene, in case creation was successful

if(ps)

mScene->addActor(*ps);

ذرات با برخورد دروني

( ساكن يا متحرك ) و برخورد با ذرات هم نوع خود ، پشتيباني PhysXذرات با برخورد دروني ، از برخورد با بازيگران

است و مي تواند با دقت SPH (Smoothed Particle Hydrodynamics)مي كنند . از نظر تكنيكي ، اين

را در آدرس زير بيابيد : SPHسازي كند . اطالعات بيشتر درباره زياد ، رفتار مايع هاي متحرك را شبيه

http://en.wikipedia.org/wiki/Smoothed_particle_hydrodynamics

ش روغن ، فواره آب ، دود حجمي و گازها مناسبند .اين نوع ذرات براي توليد افكت هاي مايع مثل جريان مايع ، ريز

()PxPhysics:: createFluidبراي ايجاد يك سيستم ذره اي كه از برخورد دروني پشتيباني كند ، تابع

نياز دارد كه تعيين كننده بيشترين تعداد ذرات PxRealفراخوانده مي شود . ساده ترين شكل آن ، به يك پارامتر نوع

تابع در صورت موفقيت ، ارجاعي به سيستم ذره اي توليد شده از نوع يستم ذره اي است . موجود در س

PxParticleFluid بازگشت مي دهد در غير اين صورتnull . بازگشت داده مي شود


: PxParticleFluidمثالي از توليد يك سيستم ذره اي نوع

// set immutable properties.

PxU32 maxParticles = 100;

// create particle system in PhysX SDK

PxParticleFluid* pf = mPhysics->createParticleFluid(maxParticles);

// add particle fluid to scene, in case creation was successful

if (pf)

mScene->addActor(*ps);

از كالس پايه اي PxParticleFluidو PxParticleSystemهر دو كالس هاي ذرات ، يعني كالس

PxParticleBase . استخراج شده اند كه شامل متدهائي است كه براي هردو سيستم ذره اي ، مشترك است

مشخصات سيستم ذره اي

شامل مشخصات بسيار زيادي است كه براي تعريف رفتار شبيه سازي يك ذره و PhysXيك سيستم ذره اي در

اشياء اطراف ، استفاده مي شوند . اين مشخصات مي توانند براساس تغييرپذيريشان در هنگامي كنش و واكنش آن با

كه براي يك سيستم ذره اي تعريف مي شوند ، دسته بندي شوند .

دسته بندي مشخصات براساس تغييرپذيري ، عبارتند از :

داده مي شوند : مشخصاتي كه پس از ايجاد ذره ، تغييرناپذير هستند ، به شكل زير توضيح

maxParticles :. تعيين كننده بيشترين تعداد ذرات مجاز براي يك سيستم ذره اي

particleBaseFlags, PxParticleBaseFlag::ePER_PARTICLE_REST_OFFSET گزينه اي براي :

فاصله سكون هر ذرهفعال كردن / غيرفعال كردن

تغييرناپذير هستند: ،است PhysXي از صحنه ، در هنگامي كه سيستم ذره اي بخش ي كهمشخصات

maxMotionDistance ، تعيين كننده بيشترين فاصله اي كه يك ذره مي تواند در يك گام زماني شبيه سازي :

حركت كند . افزايش اين مقدار به اندازه خيلي زياد ، ممكن است بر روي كارائي اثر بگذارد .

gridSize براي تقسيم ذرات تعيين مي كند تا در يك گروه خاص براي كارائي و بازدهي اي را: اين مشخصه اندازه

بهتر ، دسته بندي شوند .


restOffset اين مشخصه كمترين فاصله بين ذرات و سطح بازيگران جامد را تعريف مي كند كه توسط سيستم :

برخورد نگهداري مي شود .

contactOffset تعريف مي كند كه در آن تماس بين ذرات و بازيگران جامد ، : اين مشخصه كمترين فاصله اي را

توليد مي شود . اين مقدار به صورت دروني براي دوري از چسبيدن و پراكنده شدن استفاده مي شود . اين مقدار بايد

باشد . restOffsetبزرگتر از

particleReadDataFlags ، چند مشخصه مربوط به ذرات را پس : اين مشخصه به برنامه / كاربر اجازه مي دهد

از شبيه سازي ، بخواند .

particleBaseFlags, PxParticleBaseFlag::eGPU اين گزينه اي براي فعال / غيرفعال كردن شتاب :

است . GPUدهنده

particleBaseFlags, PxParticleBaseFlag::eCOLLISION_TWOWAY / اين گزينه اي براي فعال :

دو شيوه كنش و واكنش بين اجسام جامد و ذرات است . غيرفعال كردن

restParticleDistance تفكيك پذيري ذره مايع را تعيين مي كند ( فقط : اين مشخصه

PxParticleFluid (

ار تغيير شوند ) :چمشخصاتي كه تغيير پذير هستند ( مي توانند در هر زماني د

restitution ات را تعيين مي كند .: اين مشخصه ارتجاع برخورد ذر

dynamicFriction . اين مشخصه اصطكاك ديناميك برخورد ذرات را تعيين مي كند :

staticFriction . اين مشخصه اصطكاك ساكن برخورد ذرات را تعيين مي كند :

damping . اين مشخصه ميرايي سرعت اعمال شده بر ذرات را تعيين مي كند :

externalAcceleration ن مشخصه شتاب اعمال شده بر ذرات را در هر گام زماني شبيه سازي : ايPhysX

تعيين مي كند .

particleBaseFlags, PxParticleBaseFlag::eENABLED اين گزينه براي فعال / غيرفعال كردن :

شبيه سازي ذرات است .

particleBaseFlags, PxParticleBaseFlag::ePROJECT_TO_PLANE براي فعال / : اين گزينه

غيرفعال كردن شيوه پرتاب است كه ذرات را به يك صفحه محدود مي كند .


projectionPlaneNormal, projectionPlaneDistance اين گزينه يك صفحه را براي شيوه پرتاب :

تعريف مي كند .

particleMass . اين مشخصه ، جرم ذرات را تعين مي كند :

simulationFilterData ين مشخصه اطالعات فيلتر مورد استفاده براي فيلتر كردن برخورد بين ذرات و : ا

اجسام جامد را نصب مي كند .

اعمال مي شوند : PxParticleFluidمشخصات تغييرپذيري كه فقط به

stiffness اين مشخصه تراكم پذيري ذرات مايع را مشخص مي كند . كاهش اين مقدار ، تراكم پذيري ذره را :

فزايش مي دهد يعني مثل اسفنج رفتار خواهد كرد در حالي كه افزايش اين مقدار ، استحكام ذره را افزايش مي دهد . ا

200تا 1نصب اين مشخصه با يك مقدار بزرگ ، ممكن است باعث بي ثباتي شبيه سازي شود . بهترين مقدار از

متغيير است .

viscosity ذره مايع به تغيير شكل تدريجي توسط هر نيروي خارجي است . : اين ، اندازه استحكام و مقاومت

افزايش مقدار اين مشخصه ، سفتي مايع را افزايش مي دهد مثال عسل در حاليكه كاهش مقدار آن ، سفتي مايع را

متغيير است . 300تا 5كاهش مي دهد مثل آب . بهترين مقدار از

توليد ذرات

يجاد شد ، وقت توليد ذرات است . اگر سيستم ذره اي از نوع بعد از اينكه يك سيستم ذره اي ا

PxParticleSystem باشد ، براي توليد يك ذره معمولي ، تابع

PxParticleSystem::createParticle() را فرامي خوانيم . از طرف ديگر ، اگر سيستم ذره اي از نوع

PxParticleFluid باشد ، براي توليد ذرهSPH تابع ،PxParticleFluid::createParticle() را

نياز دارد كه در اصل مثل يك PxParticleCreationDataهردو تابع حداقل يك پارامتر نوع فرامي خوانيم .

توصيف ذره اي مثل كالس توصيف كننده است كه بافرها را براي توليد ذرات ، توصيف مي كند . آن شامل

numParticles ،indexBuffer ،positionBuffer ،velocityBuffer ،restOffsetBuffer و

flagBuffer . است . تعيين انديس و موقعيت ذره اجباري است هرچند اطالعات ديگر مي توانند ناديده گرفته شوند

قرار بعد از اينكه ذرات توليد شدند ، تا وقتي كه نابود نشده اند ، مي توانند از طريق انديس هاي آرايه ، مورد دستيابي

گيرند .


ذرات مايع كه از بازيگر كره ، رها مي شوند .

مثالي از توليد چند ذره :

//declare particle descriptor for creating new particles

PxParticleCreationData particleCreationData;

particleCreationData.numParticles = 3;

PxU32 myIndexBuffer[] = {0, 1, 2};

PxVec3 myPositionBuffer[] = { PxVec3(0,0.2,0), PxVec3(0.5,1,0), PxVec3(0,2,.7) };

PxVec3 myVelocityBuffer[] = { PxVec3(0.1,0,0), PxVec3(0,0.1,0), PxVec3(0,0,0.1) };

particleCreationData.indexBuffer =

PxStrideIterator<const PxU32>(myIndexBuffer);

particleCreationData.positionBuffer =

PxStrideIterator<const PxVec3>(myPositionBuffer);

particleCreationData.velocityBuffer =

PxStrideIterator<const PxVec3>(myVelocityBuffer);


// create particles in *PxParticleSystem* ps

bool success = ps->createParticles(particleCreationData);

ليد ، به روزكردن ، حذف و خواندن مشخصات ذره اي ، تنها زماني مي تواند توجه كنيد كه دسترسي به ذرات مثل تو

انديس ذرات نبايد از در حال شبيه سازي نيست . sceneانجام شود كه صحنه

PxParticleBase::getMaxParticles() . رات از نوع هنگام توليد ذ تجاوز كندPxParticleFluid ،

نزديك باشد در غير ()PxParticleFluid::getRestParticleDistance فاصله توليد بين ذرات بايد به

ممكن است فورا در همه جهات ، پراكنده شوند .اين صورت

به روز كردن ذرات

رعتش ، دسترسي پيدا كرد .به هر ذره مي توان بالفاصله به صورت صريح براي به روز كردن موقعيت و س

كد به روز كردن موقعيت ذرات :

PxVec3 particlePositions[] = {...};

PxU32 particleIndices[] = {...};

PxU32 numParticles = ...;

PxStrideIterator<const PxVec3> newPositionBuff (particlePositions);

PxStrideIterator<const PxU32> indexBuff (particleIndices);

//ps is the instance of PxParticleSystem or PxParticleFluid

ps->setPositions(numParticles, indexBuff, newPositionBuff);

: كنيم، به روز ()addForcesما همچنين مي توانيم نيروي بر روي ذرات را با استفاده از

PxU32 numParticles = ...;

PxStrideIterator<const PxVec3> forceBuffer = ...;

PxStrideIterator<const PxU32> indexBuffer = ...;



ps->addForces(numParticles, indexBuffer,forceBuffer, PxForceMode::eFORCE);

با PxParticleBaseFlag::ePER_PARTICLE_REST_OFFSETستم ذره اي ، تابع اگر در هنگام ايجاد سي

true ، ذره مي تواند به روز شود .فاصله سكون نصب شده باشد

: PxParticleBaseFlagكد تنظيم


ps->setParticleBaseFlag(PxParticleBaseFlag::

ePER_PARTICLE_REST_OFFSET, true);

حذف ذرات

حذف شوند كه دو پارامتر مي ()PxParticleBase::releaseParticlesذرات مي توانند با استفاده از تابع

است و تعداد ذراتي كه بايد حذف شوند را نگه مي دارد . دومين پارامتر از نوع Px32خواهد . اولين پارامتر از نوع

PxStrideIterator<PxU32> . انديس ها هميشه است و انديس ذراتي را كه بايد حذف شوند ، مشخص مي كند

بايد سازگار با تعداد ذرات باشند . همچنين مي توانيم از اين تابع بدون هيچ پارامتري استفاده كنيم كه تمام ذرات موجود

را حذف مي كند . PhysXدر صحنه


ps->releaseParticles(numParticles,indexBuffer);

تخليه كننده ذرات

هستند كه به عنوان حذف كننده ذره عمل مي كنند و هروقت كه ذرات PhysXتخليه كننده ذرات ، اشياء يا اشكال

PhysX د شد . براي اينكه يك شكل را تخليه كننده ذرات با آن شئ تماس پيدا كنند ، ذرات از صحنه حذف خواهن

را فرابخوانيد . PxShape::setFlag(PxShapeFlag::ePARTICLE_DRAIN, true)قرار دهيد ، تابع

فيلترينگ برخورد


برخورد داشته باشند . بسته به نياز ما ، PhysXذرات مي توانند به صورت انتخابي طوري تنظيم شوند كه با هر شئ

انيم برخورد ذرات با يك نوع خاص بازيگر ، چه ساكن و چه متحرك را ناديده بگيريم . اين كار مي تواند از مي تو

اتالف كارائي غيرضروري يا برخوردهاي ناخواسته جلوگيري كند .

براي فعال كردن فيلترينگ برخورد بر اساس ذرات ، تابع

PxParticleBase::setSimulationFilterData() ده مي شود كه يك پارامتر نوع فراخوان

PxFilterData كه يك اطالعات تعريف شده توسط كاربر است و به داخل شيدر فيلترينگ برخورد پاس مي خواهد

داده مي شود .

خالصه

در اين فصل درباره انواع سيستم هاي ذره اي ، تفاوت بين آنها و چگونگي استفاده از آنها ، آموزش ديديم . در خصوص

به روز شدن و نابود شدن ذرات آموزش ديديم . همچنين درباره استفاده از تخليه ،ات ذرات و چگونگي توليد مشخص

نيز آموزش ديديم . PhysXكننده ذرات و چگونگي سفارشي كردن برخورد ذرات با ديگر بازيگران


: پارچه 9فصل

يم . مباحث مطرح شده در اين فصل عبارت آموزش مي بين PhysXدر اين فصل در خصوص شبيه سازي پارچه در

است از :

بررسي يك پارچه

پارچه fabricتوليد

توليد يك پارچه

تنظيم مشخصات پارچه مثل برخورد پارچه ، محدوديت حركت ذرات پارچه ، محدوديت تفكيك ذرات پارچه ، برخورد

پارچه GPUشتاب دهنده برخورد با هم نوع و، دروني پارچه

ك پارچهبررسي ي

PhysX SDK شبيه سازي پارچه را هم فراهم كرده است . از آن مي توان براي مقاصدي مثل شبيه سازي رفتار

فتار واقعي يك پرچم و پرده در محيط بازي استفاده كرد .ه يك كاراكتر بازي يا شبيه سازي رمربوط به پارچ

پارچه fabricتوليد

پارچه داريم كه در اصل محدوديت هاي ذرات fabricا نياز به يك نمونه از ، ابتد PhysXبراي توليد يك پارچه در

است و براي PxClothFabricپارچه از نوع fabric، يك PhysXپارچه و مقادير ديگر را ذخيره مي كند . در

. اولين را فرابخوانيم كه سه پارامتر مي خواهد ()PxClothFabricCreateتوليد يك نمونه از آن ، بايد تابع

توليد شده است . دومين پارامتر از نوع PhysX SDKاست كه يك ارجاع به PxPhysicsپارامتر از نوع

PxClothMeshDesc است كه در اصل يك كالس توصيف كننده براي مش پارچه است . سومين پارامتر از نوع

PxVec3 ان مي دهد . ما بايد تمام توصيفات است و نشان دهنده بردار نرمال شده اي است كه جهت جاذبه را نش

PxClothMeshDesc و را پر كنيم كه محتوي اطالعاتي درباره مش پارچه از قبيل ذرات پارچه ، وزن معكوس آن

شكل اوليه اي كه ذرات پارچه ايجاد مي كنند ، مي باشد كه در نهايت مش پارچه را مي سازد .

پارچه : fabricمثالي از توليد يك

//Array of cloth particles containing position and inverse masses.


PxClothParticle vertices[] =

{

PxClothParticle(PxVec3(0.0f, 0.0f, 0.0f), 0.0f),



PxClothParticle(PxVec3(1.0f, 1.0f, 0.0f), 1.0f)

};

PxU32 primitives[] = { 0, 1, 3, 2 };

PxClothMeshDesc meshDesc;

meshDesc.points.data = vertices;

meshDesc.points.count = 4;

meshDesc.points.stride = sizeof(PxClothParticle);

meshDesc.invMasses.data = &vertices->invWeight;

meshDesc.invMasses.count = 4;

meshDesc.invMasses.stride = sizeof(PxClothParticle);

meshDesc.quads.data = primitives;

meshDesc.quads.count = 1;

meshDesc.quads.stride = sizeof(PxU32) * 4;

PxClothFabric* fabric = PxClothFabricCreate(physics, meshDesc, PxVec3(0, -1, 0));

مش پارچه اي كه در مثال قبل آمده است ، از يك چهارضلعي ساده ساخته شده است اما در عمل مي تواند هر چيزي

كه توصيف PxClothMeshDescباشد از يك چندضلعي ابتدائي ساده گرفته تا يك لباس كامل كاراكتر . كالس

رات پارچه نياز دارد كه محتوي موقعيت در مختصات محلي و جرم معكوس آنهاست . كننده مش است ، به اطالعات ذ

تنظيم جرم معكوس ذرات پارچه با صفر باعث سينماتيك شدنش مي شود كه يعني شبيه سازي نخواهد شد و موقعيتش

كالس تنها مي تواند با يك فراخوان صريح به روز شود . بعد از پر كردن توصيف كننده مش پارچه يعني

PxClothMeshDesc توسط فراخوان تابع ،PxClothFabricCreate() ما ،fabric . پارچه را توليد مي كنيم


توليد پارچه

، پارچه را توليد مي ()PxPhysics::createClothپارچه ، در نهايت توسط فراخوان تابع fabricبعد از توليد

و نشان دهنده موقعيت جهاني است PxTransformين پارامتر از نوع پارامتر مي خواهد . اول 4كنيم كه اين تابع

پارچه اي كه قبال توليد كرديم را fabricاست كه ما ارجاع PxClothFabricدومين پارامتر از نوع پارچه است .

مش را مي گيرد كه در كالس توصيف كننده PxClothParticleقرار مي دهيم . پارامتر سوم ، اولين عضو آرايه

است و از آن براي تنظيم فعال و غيرفعال كردن خصوصيات PxClothFlagsهم استفاده شد و آخرين پارامتر از نوع

و تشخيص برخورد مداوم ، مورد استفاده قرار مي گيرد . GPUمربوط به پارچه مثل شتابدهنده

يك پارچه : دمثالي از تولي

PxTransform pose = PxTransform(PxVec3(1.0f));

PxCloth* cloth = gPhysicsSDK->createCloth(pose, fabric, vertices, PxClothFlags());

gScene->addActor(cloth);

تنظيم مشخصات پارچه

؛ يك پارچه از تعدادي از ذرات پارچه به هم پيوسته ، ساخته شده است و هر ذره مي تواند توسط ديگر PhysXدر

اين كار باعث مي شود شبيه سازي پارچه ، خيلي به خطاهاي عددي حساس ثير قرار گيرد . ، تحت تا PhysXاشياء

د تا شبيه سازي دقيقي از پارچه انجام شود . ما مي در يك گام زماني چندين بار مي چرخپارچه solverباشد . بنابراين

تنظيم كنيم كه ()PxCloth::setSolverFrequencyرا با فراخوان تابع solverتوانيم تعداد چرخش هاي

solverاست به عبارت ديگر تعداد تكرارهاي solverمي خواهد و نشان دهنده فركانس PxRealيك پارامتر نوع

برابر است با دو تكرار در هر فريم البته اگر برنامه شما با 120با solverبراي مثال ، تنظيم فركانس در هر ثانيه .

افزايش اين مقدار ، دقت شبيه سازي پارچه را افزايش مي دهد اما نياز به محاسبات ي شود . فريم در ثانيه اجرا م 60

متغيير است . 300تا تا 120هم بيشتر مي شود . بهترين مقدار از

برخورد پارچه

trianglesو convexesمي توانند با ديگر بازيگران مثل كره ها ، كپسول ها ، صفحات ، PhysXپارچه ها در

اضافه شوند مثل *PxClothCollisionبرخورد كنند . اين بازيگران برخورد كننده بايد به وسيله كالس هاي

PxClothCollisionSphere


فعال شوند . برخورد پارچه با PxClothFlag::eSCENE_COLLISIONانها همچنين مي توانند با استفاده از گزينه

خيلي كم هزينه تر است . بنابراين اگر شما بر روي كاراكتر trianglesو convexesكره و كپسول در مقايسه با

بازيتان ، پارچه ايجاد مي كنيد ، توصيه مي كنم از تركيبي از كره و كپسول براي تعريف شكل كاراكتر بازيتان استفاده

كنيد .

ده مي شود . اين تابع يك پارامتر فراخوان ()addCollisionSphereبراي اضافه كردن كره برخورد پارچه ، تابع

كره مي 32تا مي خواهد كه مشخصات كره اضافه شده را تعريف مي كند . PxClothCollisionSphereنوع

اضافه شود . PhysXتواند به يك صحنه

كدي براي اضافه كردن يك كره جديد برخورد كننده پارچه :

PxVec3 pos = PxVec3(0,0,0);

PxReal radius = 1.0f;

cloth->addCollisionSphere(

PxClothCollisionSphere(pos,radius));

فراخوانده مي شود كه دو پارامتر ()addCollisionCapsuleه پارچه ، تابع دبراي اضافه كردن كپسول برخورد كنن

ا براي تعريف دود دو كره تعريف مي شود . در اينجيك كپسول برخورد به عنوان حجم مح مي خواهد . PxU32نوع

اولين پارامتر ، اولين انديس نياز داريم . PxClothCollisionSphereفضاي باال و پائين كپسول ، به دو كره نوع

PhysXكپسول مي تواند به يك صحنه 32تا اولين كره است و دومين پارامتر ، دومين انديس دومين كره است .

اضافه شود .

برخورد كننده جديد پارچه : كدي براي اضافه كردن يك كپسول

PxClothCollisionSphere spheres[2] =

{

PxClothCollisionSphere( PxVec3(1.0f, 0.0f, 0.0f), 0.5f ),

PxClothCollisionSphere( PxVec3(2.0f, 0.0f, 0.0f), 0.25f )

};

cloth->setCollisionSpheres(spheres, 2);

cloth->addCollisionCapsule(0, 1);


محدوديت حركت ذرات پارچه

از تعداد زيادي از ذرات پارچه به هم پيوسته ، ساخته شده است . ممكن PhysXهمانطور كه مي دانيم يك پارچه

است موقعيت هائي باشد كه بخواهيم حركت ذرات پارچه را ( نه چرخش آنها را ) محدود كنيم . در اين موقعيت ، اگرچه

سازي شود ، اما حركت ذراتش در حصار محدوديتي است كه توسط كاربر تعريف شده است . پارچه مي تواند شبيه

، مي تواينم حركت ذرات لباس را محدود كنيم PxClothParticleMotionConstraintsبا استفاده از ساختار

ك كره خيالي محدود حركت ذرات را در داخل ي. اين ساختار اطالعات محدوديت ذرات را نگه مي دارد . آن در اصل

مي كند كه ارتفاع و شعاع اين كره مي تواند توسط كاربر تعريف شود . تنظيم شعاع محدوديت به صفر ، حركت ذرات

باشد تا nullبايد يا PxClothParticleMotionConstraintsپارچه را به مركز كره ، قفل مي كند . آرايه

ندازه تعداد ذرات موجود در پارچه باشد .محدوديت حركت را غيرفعال كند يا بايد هم ا

كد محدود كردن حركت ذرات پارچه :

PxClothParticleMotionConstraints motionConstraints[] =

{

PxClothParticleMotionConstraints(PxVec3(0.0f, 0.0f, 0.0f), 0.0f),

PxClothParticleMotionConstraints(PxVec3(0.0f, 1.0f, 0.0f), 1.0f), PxClothParticleMotionConstraints(PxVec3(1.0f, 0.0f, 0.0f), 1.0f),

PxClothParticleMotionConstraints(PxVec3(1.0f, 1.0f, 0.0f), FLT_MAX)

};

cloth->setMotionConstraints(motionConstraints);

محدوديت تفكيك ذرات پارچه

حدوديت حركت ذرات پارچه است . آن به ذرات پارچه نيرو وارد مي محدوديت تفكيك ذرات پارچه درست برعكس م

فصل مشترك پارچه الزم كند تا خارج از يك كره خيالي باقي بمانند . از آن مي توان براي تعريف هر ناحيه اي كه

براي تعريف هر محدوديت تفكيك ()PxCloth::setSeparationConstraintsنسيت ، استفاده كرد . تابع

مي PxClothParticleSeperationConstraintاين تابع يك پارامتر نوع پارچه استفاده مي شود . براي

باشد تا محدوديت حركت را غيرفعال كند يا هم اندازه تعداد ذرات موجود در nullخواهد كه يك آرايه است كه يا بايد

پارچه باشد .


برخورد دروني پارچه

ا طوري تنظيم كنيم كه ذرات اين پارچه بتوانند با يكديگر برخورد داشته باشند . با ما مي توانيم مشخصه يك پارچه ر

و ()PxCloth:: setSelfCollisionDistanceقراردادن مقداري مثبت در تابع هاي

PxCloth::setSelfCollisionStiffness() اين رفتار مي تواند فعال شود . تابع ،

PxCloth::setSelfCollisionDistance() يك پارامتر نوعPxReal مي خواهد كه نشان دهنده قطر يك

هر يك از ذرات پارچه است . كره خيالي در اطراف

برخورد دروني ه، اطمينان حاصل مي شود كه اين كره ها با هم برخوردي نخواهند داشت . فاصلدر طول شبيه سازي

لت سكون باشد . مقادير بزرگتر ممكن است باعث بي ثباتي فاصله دروني ذرات پارچه در حاميشه بايد كمتر از پارچه ه

يك ()PxCloth::setSelfCollisionStiffnessشبيه سازي يا حركت نامنظم ذرات پارچه شود . تابه

مي خواهد كه نشان مي دهد ، كه هنگامي كه كره خيالي محدوديت ، با يكديگر برخورد مي كنند PxRealپارامتر نوع

و جداسازي چقدر بايد قوي باشد . ، نيروي تفكيك

برخورد با هم نوع پارچه

، دو يا چند بازيگر پارچه وجود داشته باشد ، توسط فراخوان تابع هاي PhysXاگر در يك صحنه

PxScene::setInterCollisionDistance() وPxScene::setInterCollisionStiffness()

مي PxRealپارچه را هم فعال كنيم . هر دو تابع يك پارامتر نوع هم نوع برخورد با پارچه ،برخورد دروني ، مثل

كه به ترتيب ، نشان دهنده قطر يك كره خيالي در اطراف هر يك از ذرات پارچه و نيروي جداسازي و تفكيك خواهند

هستند .

پارچه GPUشتاب دهنده

) فعال هستند ، شتاب داده شوند . CUDAودا (هائي كه در آنها هسته هاي ك GPUمي تواند توسط PhysXپارچه

GPU هائي مثل سريNVIDIA GeForce وQuadro براي فعال كردن شتاب دهنده .GPU الزم است تابع ،

PxCloth::setClothFlag(PxClothFlag::eGPU,true) را فرابخوانيم كه گزينه

PxClothFlag::eGPU راtrue . مي كند


خالصه

پارچه و ذرات پارچه هم توليد fabricيح داديم كه چطور يك پارچه را توليد كنيم كه نياز داشت ، در اين فصل توض

برخورد با پارچه و برخورد درونيشده باشند . در خصوص مشخصات پارچه مثل برخورد پارچه ، محدوديت ذرات پارچه ،

توابع و پارامترهاي مورد نياز براي توليد يك هم آموزش ديديم . همچنين درباره پارچه GPUو شتاب دهنده هم نوع

هم آموزش ديديم . PhysXپارچه در


PhysXبرنامه اشكال يابي تصويري : 10فصل

) آموزش مي بينيم كه PhysX )PhysX Visual Debuggerدر اين فصل درباره برنامه اشكال يابي تصويري

است . مباحث مطرح شده در PhysXايل كردن برنامه هاي نرم افزاري براي ديدن تصويري ، اشكال زدائي و پروف

اين فصل :

PhysX Visual Debugger (PVD)مفاهيم مقدماتي

PVDبا PhysXارتباط برنامه هاي

در كامپيوتر PVDذخيره داده هاي

PVDسفارشي كردن گزينه هاي

PhysX Visual Debugger (PVD)مفاهيم مقدماتي

PVD ه مي تواند روي سيستم شما نصب شود و براي ديدن تصويري و پروفايل كردن شبيه سازي نرم افزاري است ك

PhysX مورد استفاده قرار گيرد . اين برنامه مي تواند به صورت گرافيكي و تصويري ، شبيه سازي حال حاضر يك

سازي رندرينگ برنامه و بازيگران اين صحنه را در يك پنجره مجزا نمايش دهد كه مستقل از پياده PhysXصحنه

PhysX . شماستPVD همچنين مي تواند شبيه سازيPhysX برنامه شما را ضبط كند كه بعدا مي توانيد از آن

براي ديدن تصويري ، آناليز و پيدا كردن مشكالت بالقوه مربوط به شبيه سازي ، استفاده كنيد .

را مي توانيد دانلود كنيد . ( ممكن است الزم باشد در PVDرا دانلود كرديد ، PhysX SDKاز همان صفحه اي كه

https://developer.nvidia.com ثبت نام كنيد ) . اطالعات بيشتر دربارهPVD و لينك دانلود را مي توانيد در

آدرس زير پيدا كنيد :

debugger-visual-http://developer.nvidia.com/physx

را از لينك زير به دست آوريد : PVD انويديا در خصوصآموزش هاي ويدئويي

tutorials-https://developer.nvidia.com/pvd

در زمان نوشتن اين كتاب ، به دست آوريد . PVDپنجره در نوار منو Helpرا مي توانيد با كليك PVDراهنماي

PVD . تنها براي پلتفرم ويندوز كامپيوتر هاي شخصي در دسترس است


با استفاده از شبكه PVDارتباط

د توسط جريان دادن اطالعات و داده مي توان PVDبا استفاده از PhysXديدن تصويري و آناليز بالدرنگ يك برنامه

به PVDدر كامپيوتر شما ، انجام شود . در اينجا يك برنامه TCP/IPهاي مربوط به شبيه سازي بر روي شبكه

شما ، اجرا شده باشد . پورت پيش فرض PhysXكار مي كند و بايد قبل از اجراي برنامه TCP/IPعنوان يك سرور

است . 5425مورد استفاده

: TCP/IPتوسط شبكه PVDكد ارتباط با

// check if PvdConnection manager is available on this platform

if(gPhysicsSDK->getPvdConnectionManager() == NULL)

return;

// setup connection parameters

const char* pvd_host_ip = "127.0.0.1"; // IP of local PC machine PVD

int port = 5425; // TCP port to connect to, where PVD is listening

unsigned int timeout = 100; //time in milliseconds to wait for PVD to respond.




debugger::comm::PvdConnection* theConnection = PxVisualDebuggerExt::createConnection(gPhysicsSDK->getPvdConnectionManager(), pvd_host_ip, port, timeout, connectionFlags);

if(theConnection)

cout<<"PVD TCP/IP Connection Successful!\n";

به عنوان يك فايل PVDره داده هاي ذخي

مي تواند به يك فايل ذخيره شود تا در آينده براي آناليزهاي بعدي برنامه PhysXداده هاي مربوط به شبيه سازي

PhysX . هنگامي كه از طريق شبكه ارتباط با مورد استفاده قرار گيردPVD برقرار شد ، ممكن است سرعت آهسته

باعث محدوديتهاي شبكه اي شود . در اين مواقع ، جريان دادن داده PhysXحنه وسيع ديدن تصويري يا يك ص

ذخيره pxd2.، بايد با پسوند PVDبه يك فايل يك راه جايگزين است . در هنگام ذخيره سازي فايل PVDهاي

ي آن ، مستقيما باز شود . مورد شناسائي قرار مي گيرد و مي تواند با دابل كليك بر رو PVDشود كه توسط نرم افزار

خير . علت هم \:Cذخيره كنيد اما در \:Dمي تواني اين فايل ها را در پارتيشنهاي ديسك سخت خود مثل

مجوزهاي محدودكننده نوشتن است .

در فايل : PVDخيره داده هاي ذكد

// check if PvdConnection manager is available on this platform

if(gPhysicsSDK->getPvdConnectionManager() == NULL)

return;

// setup connection parameters

const char* filename = "D:\\PvdCapture.pxd2"; // filename where the stream will be written to



debugger::comm::PvdConnection* theConnection = PxVisualDebuggerExt::createConnection(gPhysicsSDK->getPvdConnectionManager(), filename, connectionFlags);


گزينه هاي برقراري ارتباط

، فيلتر كنيم . اين كار با سفارشي كردن PVDطول ارتباط را در PVDمي توانيم داده هاي

PxVisualDebuggerConnectionFlag انجام مي شود . اين كار همچنين به كاهش اندازه فايل با ناديده

گرفتن داده هائي كه الزم نيستند ، كمك مي كند .

PxVisualDebuggerConnectionFlag::eDEBUG اين شيوه ، همه داده هاي :debug اجسام جامد ، شكل

ها ، مفصل ها و ... را انتقال مي دهد . در زمينه پهناي باند ذخيره سازي ، اين سخت ترين شيوه است .

PxVisualDebuggerConnectionFlag::ePROFILE اين شيوه پروفايلي از :PVD جمع آوري مي كند و در

ي مي خواهد . اين گزينه همراه با پارامتر ، پهناي باند ذخيره سازي خيلي كمتر DEBUGمقايسه با

PxCreatePhysics وprofileZoneManager كار مي كند و به شما اجازه مي دهد رويدادهاي پروفايل را به

PVD . بفرستيد

PxVisualDebuggerConnectionFlag::eMEMORY ، داده هاي مورد استفاده حافظه را انتقال مي : اين شيوه

اجازه مي دهد يك ديد دقيق از حافظه مورد استفاده براي شبيه سازي داشته باشد . دهد و به كاربر

: PVDكد پروفايل كردن داده هاي

debugger::comm::PvdConnection * theConnection = PxVisualDebuggerExt::createConnection(mPhysics->getPvdConnectionManager(), pvd_host_ip, port, timeout, PxVisualDebuggerConnectionFlag::ePROFILE);

خالصه

چيست و چطور مي توان از آن براي ديدن تصويري و اشكال يابي يك برنامه PVDدر اين فصل ، توضيح داديم كه

PhysX استفاده كرد . ياد گرفتيم كه چطور با استفاده از شبكهTCP/IP ارتباط ،PVD با برنامهPhysX شما را

و سفارشي كردن گزينه هاي ارتباط با PVD، چگونگي ذخيره يك فايل محتوي داده هاي را كنيم . همچنين برق

PVD . را ياد گرفتيم

download.game-dev.ir].pdf · M 8&+) PPU (Physics Processing Unit) ˜7 g >+ / Ageia W 7 & ? !KG & !...

Documents

Transcript of download.game-dev.ir].pdf · M 8&+) PPU (Physics Processing Unit) ˜7 g >+ / Ageia W 7 & ? !KG & !...