المشهد الذي كان فيه عشر نخلات يعمل على جهازك بستين إطاراً في الثانية دون أن تفكر في الأداء، ثم تجعل العشر بستاناً من ألفين وخمسمئة نخلة، وتضيف تموراً تسقط وماءً يرشه رشاش، فيصبح المشهد يتقطع، وعلى جهاز صديقك المحمول يصبح عرض شرائح. وأول ما يفعله أغلب المطورين في هذه اللحظة أن يخمنوا: يصغرون الصور، أو يلومون المحرك، أو يقررون إعادة كتابة كل شيء بلغة أسرع، أو ينقلون نصائح من منتدى عن لعبة أخرى. وقد يتحسن شيء وقد لا يتحسن، والأسوأ أنك لا تعرف لماذا. والقاعدة التي يعمل بها كل من يحسن أداء الألعاب بسيطة: لا تغير شيئاً قبل أن تقيس، ولا تعتبر تغييراً تحسيناً قبل أن تقيس بعده مرة أخرى.
وفي مقال حلقة اللعبة عرفنا أن الإطار له ميزانية من الزمن، 16.7 مللي ثانية عند 60 إطاراً في الثانية، وفي مقال أساسيات 3D في هذه المرحلة قرأنا من المحرك عدد الأجسام وأوامر الرسم في فناء صغير. وفي هذا المقال سوف نبني ذلك البستان في Godot 4.7.2، بطيئاً عن قصد بستة أخطاء شائعة، ثم نقيسه بأدوات المحرك نفسه، ونصلحه خطوة خطوة، ونقيس بعد كل خطوة، حتى نعرف كم وفرت كل خطوة بالضبط، ومن أين.
وسوف نتناول في هذا المقال ما يلي:
- أين يذهب زمن الإطار: السكربتات والفيزياء والمشهد والرسم على المعالج وعلى كرت الشاشة.
- أدوات القياس في Godot: Profiler وVisual Profiler وMonitors، والمفرد Performance في الكود، والمراقب الخاص Custom Monitor، والخيار
--print-fps. - لماذا لا يكفي رقم Monitors وحده، وكيف تقيس زمن الإطار بنفسك.
- بستان بطيء عن قصد، ثم ست خطوات إصلاح مقيسة: الخامات المشتركة، والسكربتات في كل عقدة، والـ MultiMesh، ونوم الأجسام الفيزيائية، وإعادة الاستخدام Object Pooling، ونطاقات الرؤية Visibility Ranges.
- مستويات التفصيل التلقائية Mesh LOD، ومحركا الفيزياء Jolt وGodot Physics.
- ترتيب العمل عندما يبطئ مشهدك، وقائمة فحص.
أين يذهب زمن الإطار؟
كل إطار في Godot يمر بالمراحل نفسها، وكل مرحلة تأخذ من الميزانية نفسها، والشكل التالي يبينها بالترتيب:

- السكربتات: كل دوال
_processو_physics_processوكل إشارة تنفذ في الإطار. وألفا عقدة لكل منها_processصغيرة تكلف أكثر من عقدة واحدة تفعل الشيء نفسه لألفين، لأن لكل استدعاء تكلفة ثابتة. - الفيزياء: خطوة محاكاة واحدة أو أكثر لكل إطار بحسب الوقت الذي مر، كما شرحنا في مقال حلقة اللعبة، ولكل جسم نشط تكلفة كل خطوة.
- المشهد: كل عقدة في شجرة المشهد تأخذ ذاكرة، وكل عقدة يتغير موضعها تحتاج تحديث موضعها وموضع أبنائها في العالم، وإنشاء العقد وحذفها له ثمن أيضاً.
- الرسم على المعالج Render CPU: المحرك يحدد ما يقع داخل نظر الكاميرا، ويرتب الأجسام، ويرسل أوامر الرسم Draw Calls إلى كرت الشاشة، وكل أمر له تكلفة على المعالج.
- الرسم على كرت الشاشة GPU: المثلثات والبكسلات والظلال والمؤثرات. ويعمل كرت الشاشة في الوقت نفسه مع المعالج على إطار سابق، فالإطار يأخذ في النهاية زمن الأبطأ منهما.
والسؤال الأول دائماً: هل اللعبة محدودة بالمعالج CPU-bound أم بكرت الشاشة GPU-bound؟ لأن تقليل المثلثات لا يفيد لعبة يقتلها كود السكربتات، وتسريع الكود لا يفيد لعبة يقتلها رسم الظلال. ويشرح توثيق مبادئ التحسين في Godot هذا المنهج: قس، ثم حدد عنق الزجاجة Bottleneck، ثم أصلحه، ثم قس من جديد، لأن إصلاح شيء ليس هو عنق الزجاجة لا يغير زمن الإطار.
أدوات القياس في Godot
في المحرر لوحة Debugger في أسفل الشاشة، وفيها ثلاث أدوات للأداء تعمل وأنت تشغل اللعبة من المحرر:
- Profiler: يقيس زمن الإطار وزمن الفيزياء وزمن كل دالة في سكربتاتك، ويشرح توثيق Profiler أنه لا يعمل تلقائياً لأن القياس نفسه يبطئ اللعبة، فتضغط Start عندما تريد. وفيه خياران مهمان: Inclusive يحسب زمن الدالة مع كل ما تستدعيه، وSelf يحسب زمن جسمها فقط، والثاني هو الذي يكشف الدالة البطيئة فعلاً بين دوال تنتظرها.
- Visual Profiler: يقسم زمن الرسم إلى مراحله على المعالج وعلى كرت الشاشة: رسم الظلال، والأجسام المعتمة، والسماء، والمؤثرات اللاحقة.
- Monitors: رسوم بيانية لأرقام المفرد Performance: زمن الإطار، والذاكرة، وعدد العقد، وعدد الأجسام وأوامر الرسم، وعدد الأجسام الفيزيائية النشطة.
والأرقام نفسها متاحة من الكود بالمفرد Performance، ويشرح توثيق Performance كل مراقب فيه، مثل TIME_PROCESS الذي يصفه بأنه الزمن الذي استغرقه إطار واحد، وTIME_PHYSICS_PROCESS لخطوة الفيزياء، وOBJECT_NODE_COUNT لعدد العقد. وتستطيع أن تضيف أرقامك الخاصة إلى لوحة Monitors بالدالة add_custom_monitor، كما يشرح توثيق المراقبات الخاصة، والمختبر يضيف مراقبين لزمن الكودين اللذين سنصلحهما:
Performance.add_custom_monitor("orchard/scan_us", func() -> int: return scan_us) # shows up in the editor: Debugger > Monitors
Performance.add_custom_monitor("orchard/spawn_us", func() -> int: return spawn_us)والجزء قبل الشرطة المائلة اسم المجموعة التي يظهر تحتها الرقم في لوحة Monitors. وأما أبسط أداة على الإطلاق فهي خيار سطر الأوامر --print-fps، الذي يطبع عدد الإطارات في الثانية مرة كل ثانية، دون أي سطر كود، وتستطيع أن تمرره للعبة المصدرة أيضاً. وهذا ما طبعه للبستان البطيء دون شاشة ودون --fixed-fps:
step 0 (headless): built in 498 ms
Project FPS: 16 (62.50 mspf)
Project FPS: 12 (83.33 mspf)
Project FPS: 30 (33.33 mspf)
Project FPS: 30 (33.33 mspf)
Project FPS: 34 (29.41 mspf)
Project FPS: 43 (23.25 mspf)
Project FPS: 39 (25.64 mspf)
Project FPS: 41 (24.39 mspf)
Project FPS: 34 (29.41 mspf)
Project FPS: 28 (35.71 mspf)
Project FPS: 22 (45.45 mspf)
Project FPS: 35 (28.57 mspf)
Project FPS: 39 (25.64 mspf)والرقم بين القوسين mspf هو المللي ثانية لكل إطار، وهو الرقم الذي تقارنه بالميزانية، 16.7 لستين إطاراً. ولاحظ كيف يتأرجح بين 23 و83 مللي ثانية في ثلاث عشرة ثانية، والمشهد نفسه لم يتغير، وهذا سبب آخر لأن نقيس على عدد كبير من الإطارات وأكثر من مرة.
وفي هذا المقال نقيس من الكود لا من المحرر، لسببين: أن المختبر يعمل في Docker دون محرر، وأن الرقم المطبوع يمكن مقارنته بين الخطوات وإعادته على جهازك. والأرقام هي نفسها التي ترسمها لوحة Monitors، والفرق الوحيد أننا نجمعها بأنفسنا لكل إطار.
لماذا لا يكفي رقم Monitors وحده؟
في أول نسخة من المختبر قرأنا Performance.TIME_PROCESS في كل إطار وأخذنا متوسطه، فكان أكبر بكثير من الزمن الذي قسناه بأنفسنا بين إطار وآخر بالدالة Time.get_ticks_usec(). فأضفنا إلى المختبر سطراً يعد كم قيمة مختلفة رأيناها من هذا المراقب في 240 إطاراً، وهذا ما طبعه في أول تشغيل للبستان البطيء:
step 0 (headless): built in 673 ms
frame avg 47.4 ms p95 82.2 ms max 132.4 ms ( 21.1 fps) over 240 frames, 11.4 s
monitors TIME_PROCESS avg 82.7 ms (13 different values) TIME_PHYSICS_PROCESS avg 26.39 ms (13 different values)والقراءة كما يلي:
- 13 قيمة في 11.4 ثانية: المراقب لا يتغير مع كل إطار، وإنما مرة كل ثانية تقريباً، وهذا يتفق مع ما يذكره توثيق المراقبات الخاصة من أن المحرر يقرأ المراقبات مرة كل ثانية.
- 82.7 مقابل 47.4: متوسط المراقب قريب من النسبة المئوية 95 لإطاراتنا، 82.2، وأقل من أبطأ إطار، 132.4. وهذا يتفق مع أن قيمته في كل ثانية أقرب إلى أبطأ إطار في تلك الثانية منها إلى متوسطها.
والدرس العملي: الرسم البياني في Monitors ممتاز لترى الاتجاه والقفزات المفاجئة، ولكن إذا أردت أن تقارن قبل الإصلاح وبعده بدقة، فقس زمن الإطار بنفسك على عدد كاف من الإطارات، واحسب المتوسط والنسبة المئوية 95 وأسوأ إطار، لأن اللاعب يشعر بالإطار البطيء أكثر مما يشعر بالمتوسط. وهذه الدالة التي يقيس بها المختبر كل خطوة:
for i in 180: # warm up: 3 s of game time at --fixed-fps 60, shaders compile, dates land
await get_tree().process_frame
var frames := PackedFloat64Array()
...
var last := Time.get_ticks_usec()
var N := 60 if DisplayServer.get_name() != "headless" else 240
for i in N:
await get_tree().process_frame
var now := Time.get_ticks_usec()
frames.append((now - last) / 1000.0)
last = now
...
rcpu += RenderingServer.viewport_get_measured_render_time_cpu(vp) + RenderingServer.get_frame_setup_time_cpu()
rgpu += RenderingServer.viewport_get_measured_render_time_gpu(vp)والسطران الأخيران يقرآن زمن الرسم على المعالج وعلى كرت الشاشة، ويشرح توثيق RenderingServer أنهما يحتاجان تفعيل القياس أولاً بالدالة viewport_set_measure_render_time، وأن زمن المعالج فيهما لا يشمل السكربتات ولا الفيزياء، وإنما عمل الرسم وحده.
المختبر: بستان بطيء عن قصد
البستان شبكة من 50 في 50 نخلة، كل نخلتين بينهما أربعة أمتار، أي مربع ضلعه 200 متر، والكاميرا عند طرفه تنظر إلى داخله. وكل نخلة جذع من أسطوانة بثمانية أضلاع، وتاج من كرة مسطحة بـ 16 في 8 قطعة، كما تعلمنا في مقال الأساسيات أن نختار التفصيل بقدر الحاجة. وفوق ذلك 400 تمرة تسقط من النخل وتستقر على الأرض، كل منها جسم فيزيائي RigidBody3D، ورشاش ماء يرمي 20 قطرة في كل إطار، وكل قطرة تعيش 40 إطاراً ثم تختفي، أي أن في الهواء 800 قطرة في أي لحظة. والقطرة مشهد صغير فيه Area3D وشكل تصادم ومجسم، مثل الرصاصة في أي لعبة تصويب. وكل ذلك يبنيه السكربت lab.gd بالكود، والخيار --step يحدد كم إصلاحاً يطبق، من 0 للبستان البطيء إلى 6 للبستان بعد كل الإصلاحات.
والأخطاء الستة في البستان البطيء ليست مخترعة، فكل واحد منها شائع في المشاريع الأولى، وهي:
- خامة جديدة لكل نخلة: لون عشوائي قليلاً لكل جذع وكل تاج حتى يبدو البستان طبيعياً، أي 5,000 خامة.
- سكربت في كل نخلة: كل نخلة تحرك نفسها مع الريح في
_process، وتسأل عن الكاميرا وتحسب بعدها عنها في كل إطار. - سؤال كل إطار عن كل شيء: كود يريد معرفة أقرب نخلة إلى الكاميرا، فيطلب قائمة كل النخل من المجموعة ويبني قاموساً Dictionary بمسافاتها في كل إطار.
- ثلاث عقد لكل نخلة: عقدة للنخلة وتحتها عقدتا MeshInstance3D، أي 7,500 عقدة للنخل وحده.
- تمور لا تنام: الخاصية
can_sleepمعطلة، فتبقى التمور الأربعمئة نشطة في الفيزياء حتى وهي ساكنة على الأرض. - إنشاء القطرات وحذفها: 20 قطرة جديدة بـ
instantiate()في كل إطار، و20 قطرة تحذف بـqueue_free().
وهذا سكربت النخلة البطيئة كاملاً، وهو الموجود في الخطوتين 0 و1 فقط:
extends Node3D
## The slow palm (step 0 only): every palm sways itself from its own _process, 2500 times per frame.
var phase := 0.0
func _process(_delta: float) -> void:
var t := Time.get_ticks_msec() / 1000.0
rotation.z = sin(t * 1.5 + phase) * 0.03
var cam := get_viewport().get_camera_3d()
visible = global_position.distance_to(cam.global_position) < 1000.0 # a check that is always true, paid 2500 timesوهذا الكود الذي يبحث عن أقرب نخلة في كل إطار، بنسختيه، البطيئة والمصلحة:
var t0 := Time.get_ticks_usec()
var nearest := INF
if step < 2:
var palms := get_tree().get_nodes_in_group("palms") # a new Array of 2500 nodes, every frame
var dist := {}
for p in palms:
dist[p.name] = (p as Node3D).global_position.distance_to(cam.global_position) # and a Dictionary of 2500 entries
nearest = dist.values().min()
else:
for p in palm_positions: # the positions are computed once and kept
nearest = minf(nearest, p.distance_squared_to(cam.global_position))
nearest = sqrt(nearest)
scan_us = Time.get_ticks_usec() - t0في الكود أعلاه لاحظ التالي:
- النسخة البطيئة تنشئ في كل إطار: مصفوفة بألفين وخمسمئة عقدة، وقاموساً بألفين وخمسمئة مدخل مفتاحه اسم العقدة، ثم مصفوفة ثالثة من
values()، وكل ذلك يحذف في نهاية الإطار ليبنى من جديد في الإطار التالي. - النسخة المصلحة تقرأ مصفوفة ثابتة: مواضع النخل لا تتغير، فحسبناها مرة واحدة عند البناء في
PackedVector3Array، وهي مصفوفة متصلة في الذاكرة لا تحتاج أي إنشاء في كل إطار، واستخدمناdistance_squared_toلأن المقارنة لا تحتاج الجذر التربيعي إلا للنتيجة الأخيرة. - القياس حول الكود: المتغير
scan_usهو المراقب الخاص الذي أضفناه، فتراه في لوحة Monitors إذا شغلت المشروع من المحرر.
كيف نقيس؟ ثلاثة قرارات قبل أي رقم
القياس الخاطئ أسوأ من عدم القياس، لأنه يقنعك بتحسين لم يحدث. ولذلك اتخذنا ثلاثة قرارات قبل أن نقيس أي خطوة:
- الزمن الثابت
--fixed-fps 60: يجعل كل إطار يتقدم 1/60 من الثانية في زمن اللعبة مهما أخذ حسابه، كما في وضع Movie Maker في مقال الصوت. ودونه يتقدم الإطار البطيء أكثر في الزمن، فتنفذ الفيزياء خطوات أكثر، فيصبح أبطأ، وتقيس في كل خطوة مشهداً مختلفاً. ومعه كل خطوة تحاكي الشيء نفسه بالضبط: ثلاث ثوان للتسخين، تسقط فيها التمور وتستقر وتترجم برامج الرسم، ثم إطارات القياس. - بشاشة ودون شاشة: نشغل كل خطوة مرة بالخيار
--headless، حيث لا يرسم شيء أصلاً، فيبقى عمل المعالج من السكربتات والفيزياء والمشهد وحده، ومرة بشاشة حقيقية يرسم فيها العارض Forward+، فنعرف الجزء الذي يخص الرسم. - ثلاث مرات: الجهاز الذي شغلنا عليه المختبر مشترك، وكانت تعمل عليه في الوقت نفسه عشرات الـ Containers الأخرى، فيتغير زمن الإطار من تشغيل لآخر. ولذلك نشغل كل خطوة دون شاشة ثلاث مرات، ونقرأ المدى بين أقل وأعلى متوسط، ولا نعتمد على رقم واحد.
وأما الرسم فيحدث في المختبر على المعالج، لأن الـ Container لا يوجد فيه كرت شاشة، والذي ينفذ Vulkan هو lavapipe من مكتبة Mesa، أي أن «كرت الشاشة» في أرقامنا هو أنوية المعالج نفسها. وهذا يجعل زمن الرسم أطول بعشرات المرات مما تراه على أي كرت شاشة حقيقي، ويجعل عدد المثلثات والبكسلات هو ما يحدد أغلبه، لأن المعالج يرسم كل مثلث بنفسه. ولذلك لا تقرأ الأرقام المطلقة لزمن الرسم كأنها أرقام لعبتك، وإنما اقرأ الفرق بين الخطوات، واقرأ عدادات الرسم، فعدد أوامر الرسم والأجسام والمثلثات هو نفسه على أي جهاز.
الخطوة 0: البستان البطيء كما هو
هذا مخرج البستان البطيء دون شاشة في أول تشغيل من الثلاثة، ثم بشاشة يرسم فيها Forward+:
step 0 (headless): built in 673 ms
frame avg 47.4 ms p95 82.2 ms max 132.4 ms ( 21.1 fps) over 240 frames, 11.4 s
time render cpu 0.0 ms gpu 0.0 ms | scan 10099 us spawn 5737 us
nodes 11049 objects 17952 static memory 107.9 MB | physics: active bodies 0, pairs 0
step 0 (X11): built in 2554 ms
frame avg 722.1 ms p95 1004.4 ms max 1065.4 ms ( 1.4 fps) over 60 frames, 43.3 s
time render cpu 8.5 ms gpu 660.6 ms | scan 6459 us spawn 2712 us
render objects 5281 draw calls 4103 primitives 790354 | shadow pass: draw calls 827
nodes 11049 objects 17962 static memory 174.9 MB | physics: active bodies 0, pairs 0والقراءة كما يلي:
- دون أي رسم، الإطار 47 مللي ثانية: أي ثلاثة أضعاف ميزانية 16.7 قبل أن يرسم بكسل واحد، ففي التشغيلات الثلاثة كان المتوسط بين 28.0 و47.4، والنسبة المئوية 95 بين 45.0 و84.5. وهذا وحده يقول إن البستان محدود بالمعالج حتى على أسرع كرت شاشة.
- البحث عن أقرب نخلة يأخذ 10 مللي ثانية: الرقم
scanبالميكروثانية، أي أن سطرين يبنيان مصفوفة وقاموساً يأخذان وحدهما أكثر من نصف ميزانية الإطار. - 11,049 عقدة و17,952 كائناً: العقد هي النخل بثلاث عقد لكل نخلة، والتمور، والقطرات، والكائنات تشمل معها الخامات الخمسة آلاف وغيرها من الموارد.
- بشاشة: 4,103 أوامر رسم و790,354 مثلثاً: وفي رسم الظلال 827 أمراً آخر. وزمن الرسم على المعالج 8.5 مللي ثانية، وعلى «كرت الشاشة» 660 مللي ثانية، وهذا الرقم الكبير هو المعالج نفسه يرسم 790 ألف مثلث بمكتبة lavapipe، كما شرحنا في قسم طريقة القياس.
- الأجسام الفيزيائية النشطة 0: المشروع يستخدم Jolt Physics، وهو الافتراضي للمشاريع الجديدة في Godot كما يذكر توثيق Jolt، ولاحظنا أنه لا يملأ مراقبي
PHYSICS_3D_ACTIVE_OBJECTSوPHYSICS_3D_COLLISION_PAIRS، فهما صفر دائماً معه، فلا تعتمد عليهما لتعرف هل تنام أجسامك.
الخطوة 1: خامة مشتركة بدل خمسة آلاف خامة
الإصلاح الأول سطر واحد: كل الجذوع تأخذ خامة واحدة، وكل التيجان خامة واحدة، بدل لون عشوائي قليلاً لكل نخلة. وفي مقال الأساسيات رأينا أن العارض Forward+ يجمع الأجسام التي تشترك في المجسم والخامة في أمر رسم واحد، وهذا ما حدث هنا على نطاق أكبر:
step 1 (X11): built in 385 ms
frame avg 979.3 ms p95 2249.0 ms max 6865.2 ms ( 1.0 fps) over 60 frames, 58.8 s
time render cpu 4.4 ms gpu 819.2 ms | scan 7920 us spawn 4010 us
render objects 5282 draw calls 23 primitives 790418 | shadow pass: draw calls 37
nodes 11049 objects 12964 static memory 123.1 MB | physics: active bodies 0, pairs 0أوامر الرسم نزلت من 4,103 إلى 23، وفي الظلال من 827 إلى 37، والكائنات من 17,962 إلى 12,964، وزمن الرسم على المعالج من 8.5 إلى 4.4 مللي ثانية، أي النصف تقريباً. وأما زمن الإطار فلم يتحسن بشاشة، بل جاء أعلى، 979 مللي ثانية مع إطار واحد استغرق 6.8 ثوان، وهذا ما يحدث على جهاز مشترك: الرسم على المعالج يتنافس مع كل ما يعمل عليه، والمثلثات نفسها، 790 ألفاً، ما زالت ترسم. ولهذا السبب بالذات نقرأ الأرقام التي لا يغيرها الجهاز، عدد الأوامر وزمن الرسم على المعالج، ونقرأ زمن الإطار دون شاشة ثلاث مرات. ودون شاشة نزل المتوسط من المدى 28.0 إلى 47.4 مللي ثانية إلى المدى 15.7 إلى 24.6، مع أن شيئاً لا يرسم، فخمسة آلاف خامة أقل تعني خمسة آلاف مورد أقل يديره المحرك في كل إطار، و15 ميجابايت أقل من الذاكرة الثابتة.
وعلى كرت شاشة حقيقي، حيث يرسم الجهاز المثلثات بسرعة، يصبح العدد الكبير من أوامر الرسم هو ما يقيد المعالج، ولذلك هذه الخطوة من أرخص الإصلاحات وأكثرها أثراً في الألعاب ثلاثية الأبعاد. وإذا أردت لوناً مختلفاً لكل نخلة مع خامة واحدة، فلا تنشئ خامات جديدة، وإنما استخدم معامل الخامة لكل جسم Instance Uniform في خامة ShaderMaterial، أو لون كل نسخة في MultiMesh كما سيأتي.
الخطوة 2: الريح في معالج الرؤوس، لا في 2,500 سكربت
الإصلاح الثاني يحذف السكربت من كل نخلة، ويحذف البحث الذي يبني المصفوفة والقاموس في كل إطار. والتمايل مع الريح لا يحتاج أي كود في المعالج أصلاً، فكرت الشاشة يستطيع أن يحرك رؤوس الجذع والتاج في معالج الرؤوس Vertex Shader الذي ذكرناه في مقال الأساسيات، وهذه الخامة التي تفعل ذلك:
shader_type spatial;
uniform vec4 albedo : source_color;
void vertex() {
// sway grows with height; each palm gets its own phase from its position (works for MeshInstance3D and MultiMesh)
vec3 base = (MODEL_MATRIX * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
float h = max(VERTEX.y, 0.0);
VERTEX.x += sin(TIME * 1.5 + base.x * 0.3 + base.z * 0.2) * 0.012 * h * h;
}
void fragment() {
ALBEDO = albedo.rgb;
ROUGHNESS = 0.85;
}في الخامة أعلاه لاحظ التالي:
TIME: زمن تعطيه Godot لكل معالج تلقائياً، فلا يحتاج أحد أن يحدث شيئاً في كل إطار.MODEL_MATRIX: يعطي موضع النخلة في العالم، فتأخذ كل نخلة طوراً Phase مختلفاً ولا تتمايل كلها معاً كأنها جيش. وهو يعمل مع MeshInstance3D ومع نسخ MultiMesh، ولذلك نستخدمه في الخطوة التالية أيضاً.h * h: الإزاحة تكبر مع مربع الارتفاع، فأسفل الجذع ثابت والتاج يتحرك أكثر.
والأثر دون شاشة كان كما يلي، والجدول يجمع أقل وأعلى قيمة في التشغيلات الثلاثة لكل خطوة من الملف out-01-headless.txt:
| الخطوة | متوسط الإطار | النسبة المئوية 95 | البحث عن أقرب نخلة |
|---|---|---|---|
| 1: سكربت في كل نخلة وبحث يبني قاموساً | 15.7 إلى 24.6 مللي ثانية | 23.6 إلى 42.4 | 3,300 إلى 5,414 ميكروثانية |
| 2: الريح في الخامة وبحث في مصفوفة محفوظة | 6.3 إلى 7.2 مللي ثانية | 10.2 إلى 15.0 | 352 إلى 414 ميكروثانية |
زمن الإطار نزل إلى أقل من نصف ميزانية 60 إطاراً، والبحث عن أقرب نخلة من 3 إلى 5 مللي ثانية إلى أقل من نصف مللي ثانية، أي عشر مرات أسرع، رغم أنه ما زال يمر على 2,500 موضع في كل إطار. والفرق كله في الإنشاء: لا مصفوفة جديدة، ولا قاموس، ولا مفاتيح نصية. وإذا رأيت في Profiler دالة صغيرة تأخذ وقتاً كبيراً، فابحث فيها أولاً عن شيء ينشأ في كل إطار: get_nodes_in_group أو get_children أو قاموس أو نص تبنيه بالتنسيق، واجعله يبنى مرة واحدة ويحفظ. وأما بشاشة فبقيت أوامر الرسم 23 والمثلثات 790 ألفاً، وجاء متوسط الإطار 737 مللي ثانية، فالرسم ما زال كما هو، والخطوات التالية له.
الخطوة 3: MultiMesh بدل 7,500 عقدة
بعد الخطوة 2 لم يبق في عقد النخل أي كود، فهي 2,500 عقدة Node3D وتحتها 5,000 MeshInstance3D لا تفعل شيئاً إلا أن يكون لها موضع. والـ MultiMesh مورد يرسم مجسماً واحداً آلاف المرات بمواضع مختلفة في أمر رسم واحد، دون أي عقدة لكل نسخة، ويصفه توثيق MultiMesh بأنه مناسب لآلاف الأجسام المتشابهة مثل العشب والأسراب والجسيمات. وهذا الكود الذي يبني عقدتين بدل 7,500 عقدة:
for pair in [[trunk_mesh, trunk_mat], [crown_mesh, crown_mat]]:
var mm := MultiMesh.new()
mm.transform_format = MultiMesh.TRANSFORM_3D
mm.mesh = pair[0]
mm.instance_count = chunk * chunk
var i := 0
for x in range(cx, cx + chunk):
for z in range(cz, cz + chunk):
mm.set_instance_transform(i, Transform3D(Basis(), palm_positions[x * GRID + z]))
i += 1
var mmi := MultiMeshInstance3D.new()
mmi.multimesh = mm
mmi.material_override = pair[1]
add_child(mmi)في الخطوة 3 قيمة chunk هي 50، أي MultiMesh واحد لكل الجذوع وآخر لكل التيجان، وسوف نغيرها في الخطوة 6. والمخرج بشاشة كان كما يلي:
step 3 (X11): built in 1506 ms
frame avg 975.9 ms p95 1948.0 ms max 2165.1 ms ( 1.0 fps) over 60 frames, 58.6 s
time render cpu 1.8 ms gpu 942.5 ms | scan 514 us spawn 4572 us
render objects 1183 draw calls 5 primitives 946962 | shadow pass: draw calls 16
nodes 3551 objects 5471 static memory 93.0 MB | physics: active bodies 0, pairs 0والقراءة كما يلي:
- العقد من 11,049 إلى 3,551: والذاكرة الثابتة دون شاشة من 91.2 إلى 68.3 ميجابايت، وزمن الإطار دون شاشة بين 5.2 و8.0 مللي ثانية، قريب من الخطوة 2، لأن العقد لم تعد تفعل شيئاً في كل إطار بعد الخطوة السابقة.
- أوامر الرسم 5، والرسم على المعالج 1.8 مللي ثانية: نزل من 8.5 في البداية، ومن 4.4 بعد الخامات المشتركة.
- ولكن المثلثات زادت من 790 ألفاً إلى 947 ألفاً: وهذا ما لا يذكره كثيرون عن MultiMesh. فالمحرك يقرر هل يرسم الجسم بالنظر إلى صندوقه المحيط، والـ MultiMesh جسم واحد صندوقه يحيط بالبستان كله، فهو داخل نظر الكاميرا دائماً، فرسمت كل النخلات الألفان والخمسمئة، ومنها ما خلف الكاميرا وعلى جانبيها. أما العقد المنفصلة فكان المحرك يحذف كل نخلة خارج النظر وحدها، ولذلك رسم 790 ألفاً فقط.
- زمن الرسم على «كرت الشاشة»: 942 مللي ثانية، أعلى من الخطوات السابقة، لأن المعالج الذي يرسم في المختبر يرسم مثلثات أكثر. وعلى كرت شاشة حقيقي يكون المكسب في الأوامر أكبر من الخسارة في المثلثات غالباً، ولكن الرقم يقول لك إن MultiMesh ليس مجانياً، وإن حجم القطعة الواحدة منه قرار مهم، كما سنرى في الخطوة 6.
الخطوة 4: الأجسام التي تنام
التمور الأربعمئة تسقط في الثواني الثلاث الأولى ثم تستقر على الأرض، ولكن الخاصية can_sleep في البستان البطيء معطلة، فيبقى محرك الفيزياء يحسب كل تمرة في كل خطوة كأنها تتحرك. والنوم Sleeping أن يتوقف المحرك عن محاكاة الجسم الساكن حتى يلمسه شيء، والخاصية مفعلة افتراضياً في RigidBody3D، ولكن المطورين يعطلونها أحياناً عندما يحرك كودهم الجسم ثم لا يتحرك، بدل أن يوقظوه. وهذا مخرج الخطوة 4 بشاشة:
step 4 (X11): built in 1017 ms
frame avg 900.2 ms p95 1710.1 ms max 2354.3 ms ( 1.1 fps) over 60 frames, 54.0 s
monitors TIME_PROCESS avg 900.7 ms (48 different values) TIME_PHYSICS_PROCESS avg 0.53 ms (35 different values)ومراقب الفيزياء نزل من 3.23 مللي ثانية في الخطوة 3 إلى 0.53 في الخطوة 4، أي ستة أضعاف. وفي هذه التشغيلات بشاشة يأخذ كل إطار قرابة ثانية، فتكون قيمة المراقب في كل ثانية قيمة إطار واحد تقريباً، ولهذا هو هنا أقرب إلى زمن الخطوة الحقيقي منه في التشغيل دون شاشة. ولاحظ أن التمرة أعطيناها شكل تصادم صندوقاً BoxShape3D لا كرة، والسبب درس آخر من المختبر: في نسخة سابقة كانت كرات، فبقيت تتدحرج على الأرض المستوية ولم ينم منها إلا القليل، لأن الكرة على أرض بلا احتكاك دوران لا تستقر تقريباً.
وفي الأرقام دون شاشة لم يظهر فرق واضح بين الخطوتين 3 و4، فالمدى 5.2 إلى 8.0 مقابل 5.0 إلى 12.5، لأن Jolt يحسب أربعمئة تمرة ساكنة بسرعة كافية حتى وهي مستيقظة، وتقلب الجهاز المشترك أكبر من الفرق. ولذلك قسنا الفيزياء وحدها في تجربة منفصلة أثقل: ألف صندوق في كومة عشرة في عشرة في عشرة، لا ينام منها شيء، 240 خطوة، بمحرك Jolt الذي في المشروع، ثم بمحرك Godot Physics القديم بملف override.cfg يغير إعداد المشروع دون أن نلمسه:
3D physics engine: Jolt Physics
ticks 0- 59 wall clock 3.57 ms per tick | TIME_PHYSICS_PROCESS avg 0.00 ms | active bodies 0 pairs 0
ticks 60-119 wall clock 4.38 ms per tick | TIME_PHYSICS_PROCESS avg 0.00 ms | active bodies 0 pairs 0
ticks 120-179 wall clock 6.00 ms per tick | TIME_PHYSICS_PROCESS avg 5.65 ms | active bodies 0 pairs 0
ticks 180-239 wall clock 4.49 ms per tick | TIME_PHYSICS_PROCESS avg 16.96 ms | active bodies 0 pairs 0
3D physics engine: GodotPhysics3D
ticks 0- 59 wall clock 19.51 ms per tick | TIME_PHYSICS_PROCESS avg 14.29 ms | active bodies 1000 pairs 8630
ticks 60-119 wall clock 38.12 ms per tick | TIME_PHYSICS_PROCESS avg 64.79 ms | active bodies 1000 pairs 7337
ticks 120-179 wall clock 35.56 ms per tick | TIME_PHYSICS_PROCESS avg 78.45 ms | active bodies 1000 pairs 7234
ticks 180-239 wall clock 30.40 ms per tick | TIME_PHYSICS_PROCESS avg 66.16 ms | active bodies 1000 pairs 7243والقراءة كما يلي:
- Jolt: بين 3.6 و6.0 مللي ثانية لكل خطوة بساعة الحائط، والكومة كلها نشطة لأن النوم معطل في هذه التجربة.
- Godot Physics: بين 19.5 و38.1 مللي ثانية للخطوة نفسها، أي أكثر من ميزانية إطار كامل عند 60 خطوة في الثانية، ومعه تبدأ دوامة الموت التي شرحناها في مقال حلقة اللعبة. ولاحظ أنه يملأ مراقبي الأجسام النشطة والأزواج: 1,000 جسم وأكثر من 7,000 زوج متلامس.
- المراقب
TIME_PHYSICS_PROCESS: قيمه هنا لا تتفق مع ساعة الحائط، صفر في أول ثانيتين مع Jolt ثم 16.96، و78.45 مع Godot Physics بينما الخطوة 35.6، لأنه يتحدث مرة في الثانية كما رأينا. ولذلك قسنا هذه التجربة بالزمن بين خطوة وأخرى، فلا شيء آخر يعمل في المشهد.

والدرس: إذا كان مشروعك أنشئ قبل أن يصبح Jolt الافتراضي، وما زال يستخدم Godot Physics، فجرب Jolt من إعدادات المشروع Physics ثم 3D ثم Physics Engine، مع قراءة الفروق التي يذكرها التوثيق في المفاصل Joints قبل أن تنقل لعبة فيها مفاصل. وأيا كان المحرك، فالجسم النائم أرخص جسم، فلا تعطل can_sleep لتحل مشكلة جسم لا يستيقظ، وإنما أيقظه بنفسك عندما تحركه من الكود بالخاصية sleeping = false أو بقوة تطبقها عليه.
الخطوة 5: إعادة استخدام القطرات Object Pooling
الرشاش ينشئ 20 قطرة في كل إطار ويحذف 20، أي 1,200 مشهد ينشأ ويحذف في الثانية، وكل قطرة ثلاث عقد ومعها Area3D يسجل في عالم الفيزياء. وإعادة الاستخدام Object Pooling أن تنشئ القطرات كلها مرة واحدة عند البداية، ثم تخفي القطرة التي انتهت وتعيدها إلى قائمة، وتأخذ منها بدل أن تنشئ جديدة:
for i in DROPS_PER_FRAME:
var n: Node3D
if step >= 5:
n = pool.pop_back()
n.visible = true
n.process_mode = Node.PROCESS_MODE_INHERIT
else:
n = drop_scene.instantiate()
add_child(n)
...
elif step >= 5:
d[0].visible = false
d[0].process_mode = Node.PROCESS_MODE_DISABLED
pool.append(d[0])
else:
d[0].queue_free()والخاصية process_mode هنا مهمة، لأن إخفاء Area3D لا يخرجها من عالم الفيزياء، وتعطيل العقدة يخرجها. والنتيجة دون شاشة في التشغيلات الثلاثة:
| الخطوة | متوسط الإطار | زمن كود الرشاش spawn | العقد |
|---|---|---|---|
| 4: إنشاء وحذف | 5.0 إلى 12.5 مللي ثانية | 2,389 إلى 4,902 ميكروثانية | 3,551 |
| 5: إعادة استخدام | 3.9 إلى 6.9 مللي ثانية | 1,921 إلى 3,376 ميكروثانية | 3,611 |
وبصراحة، المديان متداخلان، فلا نستطيع من هذه الأرقام وحدها أن نقول كم وفر التجميع على هذا الجهاز المشترك، وكل ما نستطيع قوله إن القيم العليا والدنيا نزلت. والسبب أن 20 قطرة في الإطار عمل صغير، وأن أغلب زمن spawn في تحريك 800 قطرة في الهواء لا في إنشائها، وأن حذف العقد بـ queue_free يحدث في نهاية الإطار خارج المؤقت. ولاحظ أن العقد زادت 60 لا نقصت، لأن البركة تحفظ 800 قطرة دائماً، بينما كان العدد في البستان البطيء يتغير. ومتى يصبح التجميع ضرورياً؟ عندما يكون الإنشاء نفسه ثقيلاً: مشهد عدو فيه عشرات العقد وأصوات وجسيمات، أو مئات الرصاصات في الإطار، أو لعبة بلغة C# حيث يضيف كل كائن جديد عملاً على جامع القمامة Garbage Collector، فتظهر القفزات في أسوأ إطار لا في المتوسط. والقاعدة: لا تضف التجميع لأنه نصيحة مشهورة، وإنما عندما يظهر الإنشاء في Profiler.
الخطوة 6: نطاقات الرؤية Visibility Ranges ومستويات التفصيل LOD
في الخطوة 3 رسم الـ MultiMesh كل النخيل لأنه جسم واحد، وفي الخطوة 6 نقسمه إلى 25 قطعة، كل قطعة عشر نخلات في عشر، ونعطي كل قطعة نطاق رؤية Visibility Range ينتهي عند 70 متراً، فيخفيها المحرك عندما يبعد مركز صندوقها المحيط عن الكاميرا أكثر من ذلك، كما يشرح توثيق نطاقات الرؤية:
var chunk := 10 if step >= 6 else GRID # step 6: 25 chunks of 10 × 10 palms, each can be hidden on its own
...
if step >= 6:
mmi.visibility_range_end = 70.0 # whole chunk hidden when its box is farther than 70 m
mmi.visibility_range_end_margin = 10.0
mmi.visibility_range_fade_mode = GeometryInstance3D.VISIBILITY_RANGE_FADE_DISABLEDوالهامش end_margin يمنع القطعة من الظهور والاختفاء بسرعة عندما تقف الكاميرا عند حد المسافة بالضبط، ووضع الاختفاء دون تلاش هو الأسرع بحسب التوثيق. والمخرج بشاشة كان كما يلي:
step 6 (X11): built in 1011 ms
frame avg 257.1 ms p95 363.5 ms max 398.9 ms ( 3.9 fps) over 60 frames, 15.4 s
monitors TIME_PROCESS avg 296.7 ms (16 different values) TIME_PHYSICS_PROCESS avg 0.45 ms (15 different values)
time render cpu 1.8 ms gpu 245.6 ms | scan 310 us spawn 2188 us
render objects 1187 draw calls 9 primitives 172562 | shadow pass: draw calls 24
nodes 3659 objects 5627 static memory 93.7 MB | physics: active bodies 0, pairs 0المثلثات نزلت من 946,962 إلى 172,562، أي إلى أقل من خمسها، وأوامر الرسم زادت من 5 إلى 9 فقط، والرسم على «كرت الشاشة» نزل من 562 إلى 245 مللي ثانية، وزمن الإطار بشاشة من 577 إلى 257. وهذه أكبر خطوة في المختبر بشاشة، لأن الرسم هنا على المعالج، والمثلثات هي ما يحدد زمنه، وهذا يخص المختبر. وعلى كرت شاشة حقيقي يبقى المبدأ نفسه: ما لا يراه اللاعب، أو يراه بضعة بكسلات في الأفق، لا يستحق أن يرسم كاملاً. والصورة التالية تبين البستان في الخطوات 0 و3 و6 من الكاميرا نفسها:

ولاحظ في الإطار الأخير أن الأفق أصبح فارغاً خلف الصفوف القريبة، وهذا ثمن نطاق الرؤية القصير. وفي لعبة حقيقية لا تخفي البعيد تماماً، وإنما تضع مكانه شيئاً أرخص: نسخة بسيطة من النخلة بنطاق رؤية يبدأ حيث ينتهي الأول، أو صورة مسطحة Impostor كما يقترح توثيق أداء 3D، أو ضباباً يخفي الحد كما رأينا في مقال الأساسيات.
مستويات التفصيل التلقائية Mesh LOD
نطاق الرؤية يخفي الجسم أو يبدله بجسم آخر تصنعه أنت، أما مستويات التفصيل Level of Detail واختصاراً LOD فيصنعها Godot تلقائياً لكل مجسم يستورده، وهو الإعداد meshes/generate_lods الذي رأيناه في مقال Blender، ثم يختار في كل إطار أبسط مستوى لا يغير شكل الجسم على الشاشة بأكثر من بكسل، كما يشرح توثيق Mesh LOD. وتجربة lod تولد هذه المستويات لكرة من 4,224 مثلثاً بالدالة نفسها التي يستخدمها المستورد، ثم تضع 120 كرة في صف يبتعد عن الكاميرا من 5 أمتار إلى 300، وتقرأ العدادات بثلاث قيم للإعداد mesh_lod_threshold، ثم مع نطاق رؤية 100 متر:
sphere: 4224 triangles, generated LOD levels (triangles): [2112, 1056, 528, 264, 132, 66, 32, 16, 8]
mesh_lod_threshold 1.0 objects 120 primitives 4364 draw calls 11
mesh_lod_threshold 4.0 objects 120 primitives 1392 draw calls 9
mesh_lod_threshold 0.0 objects 120 primitives 506880 draw calls 5
visibility_range_end 100 m objects 38 primitives 3380 draw calls 6والقراءة كما يلي:
- تسعة مستويات: كل مستوى نصف الذي قبله تقريباً، من 2,112 مثلثاً إلى 8.
- بالإعداد الافتراضي 1.0: 4,364 مثلثاً للكرات المئة والعشرين كلها، أي 36 مثلثاً لكل كرة في المتوسط، بدل 4,224.
- دون LOD، بالقيمة 0: 506,880 مثلثاً، أي 120 في 4,224 بالضبط، أكثر بـ 116 مرة.
- بالقيمة 4.0: المحرك يقبل تغييراً حتى أربعة بكسلات، فنزلت المثلثات إلى 1,392، وهذا مفيد للأجهزة الضعيفة.
- نطاق رؤية 100 متر: الأجسام من 120 إلى 38، لأن الكرات بعد 100 متر لم تعد ترسم أصلاً.
- أوامر الرسم: زادت مع LOD من 5 إلى 11، لأن الكرات في مستويات مختلفة لا تجمع في أمر واحد، وهذا ثمن صغير مقابل مئة ضعف من المثلثات.

ولاحظ أن الأجسام المصنوعة في الكود مثل SphereMesh لا تحصل على مستويات تفصيل تلقائياً، فالمستورد هو الذي يولدها، ولذلك احتجنا في التجربة إلى ImporterMesh.generate_lods(). وأما الـ MultiMesh فيختار المستوى بحسب الجسم كله لا كل نسخة، وهذا سبب آخر لتقسيمه إلى قطع.
الخطوات كلها في جدول
| الخطوة | دون شاشة: متوسط الإطار (3 تشغيلات) | العقد | بشاشة: أوامر الرسم | المثلثات | الرسم على المعالج |
|---|---|---|---|---|---|
| 0 البستان البطيء | 28.0 إلى 47.4 مللي ثانية | 11,049 | 4,103 | 790,354 | 8.5 مللي ثانية |
| 1 خامات مشتركة | 15.7 إلى 24.6 | 11,049 | 23 | 790,418 | 4.4 |
| 2 الريح في الخامة وبحث محفوظ | 6.3 إلى 7.2 | 11,049 | 23 | 790,354 | 4.4 |
| 3 MultiMesh | 5.2 إلى 8.0 | 3,551 | 5 | 946,962 | 1.8 |
| 4 التمور تنام | 5.0 إلى 12.5 | 3,551 | 5 | 946,962 | 1.7 |
| 5 إعادة استخدام القطرات | 3.9 إلى 6.9 | 3,611 | 5 | 946,962 | 1.8 |
| 6 قطع بنطاق رؤية | 3.8 إلى 6.9 | 3,659 | 9 | 172,562 | 1.8 |
ومن الجدول ثلاث خلاصات. الأولى أن عمل المعالج دون رسم نزل من 28 إلى 47 مللي ثانية، أي أكثر من ميزانية 30 إطاراً، إلى أقل من 7 في أسوأ تشغيل، وأكبر الخطوات كانت أرخصها: خامة مشتركة، وسكربت أقل، ومصفوفة محفوظة. والثانية أن أوامر الرسم نزلت من 4,103 إلى 5، وزمن الرسم على المعالج إلى أقل من ربعه. والثالثة أن كل إصلاح له ثمن يظهر في رقم آخر: MultiMesh رفع المثلثات، والتجميع رفع العقد، وLOD رفع أوامر الرسم، ولهذا تقرأ كل الأرقام بعد كل خطوة لا الرقم الذي تريد تحسينه فقط. والشكلان التاليان يجمعان الجدول:


ترتيب العمل عندما يبطئ مشهدك
- قس الإطار أولاً: المتوسط والنسبة المئوية 95 وأسوأ إطار، على الجهاز الأضعف الذي تستهدفه، لا على جهازك.
- شغل دون رسم إن استطعت: إذا كان الإطار بطيئاً حتى بالخيار
--headless، فالمشكلة في السكربتات أو الفيزياء أو المشهد، وابدأ بـ Profiler. - اقرأ عدادات الرسم: آلاف أوامر الرسم تعني خامات مختلفة أو عقداً كثيرة متشابهة، ومئات الآلاف من المثلثات البعيدة تعني أنك تحتاج LOD أو نطاق رؤية، وأوامر كثيرة في رسم الظلال تعني ظلالاً على أضواء كثيرة أو مسافة ظل طويلة.
- أصلح الأكبر فقط: الإصلاح الذي لا يمس عنق الزجاجة لا يغير زمن الإطار، كما رأينا في الخطوة 1 بشاشة، حيث نزل زمن الرسم على المعالج إلى النصف ولم يتغير الإطار لأن المثلثات هي التي كانت تحدده.
- قس من جديد، أكثر من مرة: الجهاز نفسه يعطي أرقاماً مختلفة بين تشغيل وآخر، فلا تحكم من تشغيل واحد.
ملفات المختبر وتشغيله
المختبر في مجلد lab: صورة Godot 4.7.2 نفسها التي استخدمناها في مقالي الأساسيات وBlender، والمشروع في game بثلاثة سكربتات: main.gd الذي يضيف عقدة المختبر، وlab.gd الذي يبني البستان ويقيس، وpalm_slow.gd سكربت النخلة البطيئة. وفي project.godot سطر يجعل محرك الفيزياء Jolt Physics كما في أي مشروع جديد. والملف run.sh يعرف دالتين، واحدة دون شاشة وأخرى بشاشة:
# 1. without a screen: the CPU side only (scripts, nodes, physics), nothing is drawn
headless() { MSYS_NO_PATHCONV=1 timeout 900 docker run --init --rm --name $N-$RANDOM -v "$W/game:/game" "$IMG" \
godot --headless --fixed-fps 60 --path /game -- --lab $1 2>&1 | filter; }
# 2. with a screen: Xvfb + Mesa drawing on the CPU (lavapipe = Vulkan, so Forward+ works)
drawn() { MSYS_NO_PATHCONV=1 timeout 900 docker run --init --rm --name $N-$RANDOM -v "$W/game:/game" -v "$W/shots:/shots" "$IMG" bash -c \
"Xvfb :99 -screen 0 960x540x24 > /dev/null 2>&1 & sleep 2; DISPLAY=:99 godot --rendering-driver vulkan --fixed-fps 60 --path /game -- --lab $1 --shot /shots" 2>&1 | filter; }ثم يشغل الخطوات السبع دون شاشة ثلاث مرات لكل منها، ثم بشاشة مرة واحدة، ثم تجربتي LOD والفيزياء، ثم --print-fps، ويحفظ كل مخرج في ملف out-*.txt. وتشغله بالأمر bash run.sh من مجلد lab، وأغلب وقته في الخطوات الأولى بشاشة، لأن كل إطار منها يأخذ قرابة ثانية من الرسم على المعالج. وإذا أردت خطوة واحدة فقط، فشغل مثلاً headless "step --step 3" بعد أن تعرف الدالة.
أخطاء شائعة وكيف تقرأ أعراضها
- آلاف أوامر الرسم لأجسام متشابهة: خامة جديدة لكل جسم، ولو باللون نفسه. اجعلها خامة مشتركة، واستخدم Instance Uniform أو ألوان MultiMesh للتنويع.
- الإطار بطيء حتى دون رسم: سكربتات
_processفي آلاف العقد، أو كود ينشئ مصفوفات وقواميس في كل إطار. اجمعها في عقدة واحدة، أو انقلها إلى الخامة إذا كانت حركة بصرية. - الذاكرة والكائنات تكبر بلا سبب واضح: عقد تنشأ ولا تحذف، أو تحذف من الشجرة دون
queue_freeفتبقى يتيمة. راقبOBJECT_COUNTوOBJECT_ORPHAN_NODE_COUNT. - زمن الفيزياء عال والمشهد ساكن: أجسام لا تنام، بسبب
can_sleepمعطل، أو أشكال كرات تتدحرج إلى الأبد على أرض مستوية. اسمح بالنوم، واستخدم أشكالاً تستقر. - مراقبات الفيزياء صفر دائماً: Jolt لا يملؤها. لا تستنتج من الصفر أن الأجسام نائمة.
- رقم Monitors لا يطابق إحساسك: المراقب يتحدث مرة في الثانية. قس زمن الإطار بنفسك على عدد كاف من الإطارات.
- MultiMesh لا يختفي بعيداً: النسخ كلها جسم واحد بصندوق محيط واحد. قسمها إلى قطع، واجعل لكل قطعة نطاق رؤية.
- تحسين لم يغير شيئاً: أصلحت شيئاً ليس عنق الزجاجة. عد إلى القياس، وحدد هل اللعبة محدودة بالمعالج أم بكرت الشاشة.
قائمة فحص: ماذا تقرأ وماذا تفعل
| ما تراه في الأرقام | السبب المحتمل | الإصلاح |
|---|---|---|
الإطار بطيء حتى بـ --headless | سكربتات، أو فيزياء، أو إنشاء وحذف عقد | Profiler مع Self، ثم انقل الكود من آلاف العقد إلى عقدة واحدة أو إلى الخامة |
| آلاف أوامر الرسم لأجسام متشابهة | خامات مختلفة لكل جسم | خامة مشتركة، فيجمعها Forward+ تلقائياً |
| آلاف العقد بلا كود | عقدة لكل نسخة من الشيء نفسه | MultiMesh مقسم إلى قطع |
| مثلثات كثيرة من أجسام بعيدة | كل شيء يرسم بكامل تفصيله مهما بعد | LOD التلقائي للنماذج المستوردة، ونطاق رؤية للقطع البعيدة |
| أوامر كثيرة في رسم الظلال | ظلال على أضواء كثيرة أو مسافة ظل طويلة | ظل الشمس فقط، ومسافة ظل أقصر |
| زمن الفيزياء عال والمشهد ساكن | أجسام لا تنام، أو أشكال لا تستقر | اسمح بالنوم، وJolt إذا كان المشروع على Godot Physics |
| قفزات في أسوأ إطار مع إنشاء متكرر | إنشاء مشاهد ثقيلة في وقت اللعب | Object Pooling بعد أن يؤكده Profiler |
تطبيق عملي
- غير
GRIDإلى 70 وشغل الخطوتين 0 و2 دون شاشة، وانظر هل يكبر زمن البحث عن أقرب نخلة مع عدد النخل بالنسبة نفسها في النسختين. - في الخطوة 6 غير حجم القطعة من 10 إلى 5 ثم إلى 25، واكتب أوامر الرسم والمثلثات في كل مرة، وابحث عن الحجم الذي يعطي أقل مثلثات دون أوامر كثيرة.
- أضف إلى الخطوة 6 نخلة بسيطة، أسطوانة وكرة بأقل تفصيل، بنطاق رؤية يبدأ عند 70 متراً، حتى لا يبقى الأفق فارغاً، وقس كم تكلف.
- غير الرشاش ليطلق 200 قطرة في الإطار بدل 20، وقارن الخطوتين 4 و5 مرة أخرى، وانظر هل يظهر التجميع الآن بوضوح.
- شغل المشروع من محرر Godot على جهازك، وافتح Debugger ثم Monitors، وابحث عن المجموعة orchard التي أضفناها، وراقب
scan_usوأنت تغير--step.
حذف المختبر Cleanup
docker image rm godot-lab:4.7.2-3d
rm -rf shots game/.godot out-*.txtالخلاصة Summary
- قس قبل أن تغير شيئاً، وقس بعده، وأكثر من مرة: على جهاز مشترك تغير متوسط الإطار للمشهد نفسه بين 28 و47 مللي ثانية.
- مراقبات Performance تتحدث مرة كل ثانية تقريباً، وقيمتها أقرب إلى أبطأ إطار، فقس زمن الإطار بنفسك للمقارنة الدقيقة.
- الخامة المشتركة نزلت بأوامر الرسم من 4,103 إلى 23 في Forward+، وزمن الرسم على المعالج إلى النصف.
- نقل الريح من 2,500 سكربت إلى معالج الرؤوس، وحفظ المواضع بدل بناء قاموس كل إطار، نزل بعمل المعالج إلى 6.3 إلى 7.2 مللي ثانية، والبحث وحده عشر مرات أسرع.
- MultiMesh نزل بالعقد من 11,049 إلى 3,551 وبالأوامر إلى 5، ولكنه رسم كل النخيل لأنه جسم واحد، فزادت المثلثات من 790 ألفاً إلى 947 ألفاً.
- تقسيم MultiMesh إلى 25 قطعة بنطاق رؤية 70 متراً نزل بالمثلثات إلى 172 ألفاً، ومستويات التفصيل التلقائية قسمت مثلثات 120 كرة على 116.
- Jolt حسب ألف صندوق نشط في 3.6 إلى 6.0 مللي ثانية للخطوة، وGodot Physics في 19.5 إلى 38.1، والنوم جعل مراقب الفيزياء في البستان ينزل من 3.23 إلى 0.53.
- كل إصلاح له ثمن في رقم آخر، فاقرأ كل العدادات بعد كل خطوة.
- الرسم في المختبر على المعالج بمكتبة lavapipe، فالمثلثات هي ما يحدد زمنه هناك، وعدادات الرسم هي التي تبقى نفسها على أي جهاز.
وبهذا تنتهي مرحلة الألعاب ثلاثية الأبعاد: فناء تفهم كل رقم فيه، ونماذج من Blender تصل كما صممتها، ومشهد كبير تعرف كيف تقيسه وتصلحه. وفي المرحلة التالية بإذن الله ننتقل إلى اللعب الجماعي والخوادم:
دليلأساسيات 3D في الألعاب: المجسمات Meshes والخامات والإضاءةنبني فناءً صغيراً ثلاثي الأبعاد بالكود في Godot 4 ونرسمه إطاراً حقيقياً، ثم نقرأ من المحرك نفسه ما يكلفه كل مجسم وخامة وضوء وظل، ونصنع أخطاء العموديات وUV والعمق التي يقع فيها كل مبتدئ.
دليلمن Blender إلى Godot: تجهيز النماذج والحركات Animationsنصنع نخلة أصلية بهيكل عظمي وحركتين في Blender دون واجهة، ونصدرها بصيغة glTF 2.0 إلى Godot، ثم نصنع أخطاء المقياس والمحاور والموضع وأسماء الحركات ودورانها عن قصد ونقيس أثر كل منها ونصلحه.
دليلكيف تعمل اللعبة من الداخل؟ حلقة اللعبة Game Loopلماذا تتحرك الشخصية بالسرعة نفسها على شاشة 144 هرتز وحاسوب بطيء: نبني حلقة اللعبة من الصفر حتى الخطوة الثابتة والاستيفاء، ونقيس كل طريقة في مختبر.
دليلتصدير اللعبة من Godot إلى الويب والجوال وسطح المكتبماذا يحدث فعلاً عند تصدير لعبة Godot، ولماذا تحتاج نسخة الويب Headers خاصة أحياناً، وما تطلبه كل منصة ومتجر، مع مختبر يصدر لعبة واحدة إلى خمس منصات.
دليلاللعب الجماعي Multiplayer: السيرفر صاحب القرار والتأخيرنبني في Godot 4 سيرفراً مخصصاً صاحب قرار وكلاينتات آلية، ثم نضيف التأخير والارتعاش والفقدان ونقيس كيف يخفي التنبؤ والمطابقة والاستيفاء أثرها عن اللاعب.سجل التحديثات Changelog
- 18 نوفمبر 2026: كتابة المقال، وبناء البستان وقياس الخطوات السبع على Godot 4.7.2 في Docker دون شاشة وبشاشة (Mesa 22.3.6 lavapipe)، ومقارنة Jolt Physics وGodot Physics، وتجربة Mesh LOD.