تطوير الألعاب الأدلة التقنية

أداء اللعبة: قياس الإطارات Profiling وتحسينها

نبني في Godot 4 بستاناً من 2,500 نخلة بطيئاً عن قصد، ثم نقيسه بأدوات المحرك ونصلحه في ست خطوات، ونعرف بالأرقام كم وفرت كل خطوة ومن أين، وما الثمن الذي دفعناه في رقم آخر.

أداء اللعبة: قياس الإطارات Profiling وتحسينها

المشهد الذي كان فيه عشر نخلات يعمل على جهازك بستين إطاراً في الثانية دون أن تفكر في الأداء، ثم تجعل العشر بستاناً من ألفين وخمسمئة نخلة، وتضيف تموراً تسقط وماءً يرشه رشاش، فيصبح المشهد يتقطع، وعلى جهاز صديقك المحمول يصبح عرض شرائح. وأول ما يفعله أغلب المطورين في هذه اللحظة أن يخمنوا: يصغرون الصور، أو يلومون المحرك، أو يقررون إعادة كتابة كل شيء بلغة أسرع، أو ينقلون نصائح من منتدى عن لعبة أخرى. وقد يتحسن شيء وقد لا يتحسن، والأسوأ أنك لا تعرف لماذا. والقاعدة التي يعمل بها كل من يحسن أداء الألعاب بسيطة: لا تغير شيئاً قبل أن تقيس، ولا تعتبر تغييراً تحسيناً قبل أن تقيس بعده مرة أخرى.

وفي مقال حلقة اللعبة عرفنا أن الإطار له ميزانية من الزمن، 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 يمر بالمراحل نفسها، وكل مرحلة تأخذ من الميزانية نفسها، والشكل التالي يبينها بالترتيب:

شريط أفقي يمثل ميزانية إطار واحد 16.7 مللي ثانية عند 60 إطاراً في الثانية، مقسم إلى خمسة أجزاء ملونة من اليمين: السكربتات _process و_physics_process، والفيزياء Physics Step، وتحديث المشهد Scene Tree، والرسم على المعالج Render CPU من فرز الأجسام وإرسال أوامر الرسم، والرسم على كرت الشاشة GPU. وتحت كل جزء الأدوات التي تقيسه: Profiler للسكربتات، وTIME_PHYSICS_PROCESS للفيزياء، وOBJECT_NODE_COUNT للمشهد، وVisual Profiler وعدد أوامر الرسم للرسم على المعالج، وزمن GPU لكرت الشاشة. وملاحظة أن المعالج وكرت الشاشة يعملان في الوقت نفسه، فالإطار يأخذ زمن الأبطأ بينهما
زمن الإطار موزع على خمسة أماكن، ولكل مكان أداة تقيسه
  • السكربتات: كل دوال _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 للبستان بعد كل الإصلاحات.

والأخطاء الستة في البستان البطيء ليست مخترعة، فكل واحد منها شائع في المشاريع الأولى، وهي:

  1. خامة جديدة لكل نخلة: لون عشوائي قليلاً لكل جذع وكل تاج حتى يبدو البستان طبيعياً، أي 5,000 خامة.
  2. سكربت في كل نخلة: كل نخلة تحرك نفسها مع الريح في _process، وتسأل عن الكاميرا وتحسب بعدها عنها في كل إطار.
  3. سؤال كل إطار عن كل شيء: كود يريد معرفة أقرب نخلة إلى الكاميرا، فيطلب قائمة كل النخل من المجموعة ويبني قاموساً Dictionary بمسافاتها في كل إطار.
  4. ثلاث عقد لكل نخلة: عقدة للنخلة وتحتها عقدتا MeshInstance3D، أي 7,500 عقدة للنخل وحده.
  5. تمور لا تنام: الخاصية can_sleep معطلة، فتبقى التمور الأربعمئة نشطة في الفيزياء حتى وهي ساكنة على الأرض.
  6. إنشاء القطرات وحذفها: 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 إذا شغلت المشروع من المحرر.

كيف نقيس؟ ثلاثة قرارات قبل أي رقم

القياس الخاطئ أسوأ من عدم القياس، لأنه يقنعك بتحسين لم يحدث. ولذلك اتخذنا ثلاثة قرارات قبل أن نقيس أي خطوة:

  1. الزمن الثابت --fixed-fps 60: يجعل كل إطار يتقدم 1/60 من الثانية في زمن اللعبة مهما أخذ حسابه، كما في وضع Movie Maker في مقال الصوت. ودونه يتقدم الإطار البطيء أكثر في الزمن، فتنفذ الفيزياء خطوات أكثر، فيصبح أبطأ، وتقيس في كل خطوة مشهداً مختلفاً. ومعه كل خطوة تحاكي الشيء نفسه بالضبط: ثلاث ثوان للتسخين، تسقط فيها التمور وتستقر وتترجم برامج الرسم، ثم إطارات القياس.
  2. بشاشة ودون شاشة: نشغل كل خطوة مرة بالخيار --headless، حيث لا يرسم شيء أصلاً، فيبقى عمل المعالج من السكربتات والفيزياء والمشهد وحده، ومرة بشاشة حقيقية يرسم فيها العارض ⁦Forward+⁩، فنعرف الجزء الذي يخص الرسم.
  3. ثلاث مرات: الجهاز الذي شغلنا عليه المختبر مشترك، وكانت تعمل عليه في الوقت نفسه عشرات الـ 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.43,300 إلى 5,414 ميكروثانية
2: الريح في الخامة وبحث في مصفوفة محفوظة6.3 إلى 7.2 مللي ثانية10.2 إلى 15.0352 إلى 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 Physics باللون الأخضر: 3.57 ثم 4.38 ثم 6.00 ثم 4.49 مللي ثانية. Godot Physics باللون البرتقالي: 19.51 ثم 38.12 ثم 35.56 ثم 30.40 مللي ثانية. وخط أفقي عند 16.7 مللي ثانية ميزانية الإطار
ألف صندوق لا تنام: Jolt تحت 6 مللي ثانية للخطوة، وGodot Physics فوق ميزانية الإطار كله

والدرس: إذا كان مشروعك أنشئ قبل أن يصبح 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 من الكاميرا نفسها:

ثلاثة إطارات حقيقية من Godot للبستان من الكاميرا نفسها: صفوف من النخيل بجذوع بنية وتيجان خضراء مسطحة، وتمور حمراء صغيرة على الأرض في المقدمة، ورذاذ أبيض من الرشاش في الوسط. الخطوة 0: 4103 أوامر رسم و790354 مثلثاً. الخطوة 3 بـ MultiMesh واحد: 5 أوامر و946962 مثلثاً، والصورة نفسها تقريباً. الخطوة 6 بخمس وعشرين قطعة ونطاق رؤية 70 متراً: 9 أوامر و172562 مثلثاً، والأفق خلف الصفوف القريبة فارغ من النخيل
البستان نفسه في ثلاث خطوات: الصورة تكاد لا تتغير، والأرقام تتغير كثيراً

ولاحظ في الإطار الأخير أن الأفق أصبح فارغاً خلف الصفوف القريبة، وهذا ثمن نطاق الرؤية القصير. وفي لعبة حقيقية لا تخفي البعيد تماماً، وإنما تضع مكانه شيئاً أرخص: نسخة بسيطة من النخلة بنطاق رؤية يبدأ حيث ينتهي الأول، أو صورة مسطحة 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، لأن الكرات في مستويات مختلفة لا تجمع في أمر واحد، وهذا ثمن صغير مقابل مئة ضعف من المثلثات.
رسم بأعمدة أفقية بمقياس لوغاريتمي لعدد المثلثات المرسومة لـ 120 كرة في صف. دون LOD بالقيمة 0: 506880. بالإعداد الافتراضي 1.0: 4364. بالقيمة 4.0: 1392. مع نطاق رؤية 100 متر: 3380 و38 جسماً بدل 120. وفوقها مستويات الكرة التسعة من 2112 إلى 8 مثلثات
120 كرة تفصيلية في صف: مستويات التفصيل التلقائية تقسم المثلثات على 116

ولاحظ أن الأجسام المصنوعة في الكود مثل SphereMesh لا تحصل على مستويات تفصيل تلقائياً، فالمستورد هو الذي يولدها، ولذلك احتجنا في التجربة إلى ImporterMesh.generate_lods(). وأما الـ MultiMesh فيختار المستوى بحسب الجسم كله لا كل نسخة، وهذا سبب آخر لتقسيمه إلى قطع.

الخطوات كلها في جدول

الخطوةدون شاشة: متوسط الإطار (3 تشغيلات)العقدبشاشة: أوامر الرسمالمثلثاتالرسم على المعالج
0 البستان البطيء28.0 إلى 47.4 مللي ثانية11,0494,103790,3548.5 مللي ثانية
1 خامات مشتركة15.7 إلى 24.611,04923790,4184.4
2 الريح في الخامة وبحث محفوظ6.3 إلى 7.211,04923790,3544.4
3 MultiMesh5.2 إلى 8.03,5515946,9621.8
4 التمور تنام5.0 إلى 12.53,5515946,9621.7
5 إعادة استخدام القطرات3.9 إلى 6.93,6115946,9621.8
6 قطع بنطاق رؤية3.8 إلى 6.93,6599172,5621.8

ومن الجدول ثلاث خلاصات. الأولى أن عمل المعالج دون رسم نزل من 28 إلى 47 مللي ثانية، أي أكثر من ميزانية 30 إطاراً، إلى أقل من 7 في أسوأ تشغيل، وأكبر الخطوات كانت أرخصها: خامة مشتركة، وسكربت أقل، ومصفوفة محفوظة. والثانية أن أوامر الرسم نزلت من 4,103 إلى 5، وزمن الرسم على المعالج إلى أقل من ربعه. والثالثة أن كل إصلاح له ثمن يظهر في رقم آخر: MultiMesh رفع المثلثات، والتجميع رفع العقد، وLOD رفع أوامر الرسم، ولهذا تقرأ كل الأرقام بعد كل خطوة لا الرقم الذي تريد تحسينه فقط. والشكلان التاليان يجمعان الجدول:

رسم بأعمدة أفقية لمتوسط زمن الإطار دون شاشة في الخطوات السبع، كل عمود يمتد من أقل متوسط إلى أعلى متوسط في ثلاثة تشغيلات، مع خط عمودي عند 16.7 مللي ثانية. الخطوة 0 من 28.0 إلى 47.4، والخطوة 1 من 15.7 إلى 24.6، والخطوة 2 من 6.3 إلى 7.2، والخطوة 3 من 5.2 إلى 8.0، والخطوة 4 من 5.0 إلى 12.5، والخطوة 5 من 3.9 إلى 6.9، والخطوة 6 من 3.8 إلى 6.9
عمل المعالج دون رسم: كل عمود هو المدى بين ثلاثة تشغيلات على جهاز مشترك
ثلاثة رسوم بأعمدة للخطوات السبع بشاشة. الأول أوامر الرسم بمقياس لوغاريتمي: 4103 ثم 23 و23 ثم 5 و5 و5 ثم 9. الثاني المثلثات بالآلاف: 790 و790 و790 ثم 947 و947 و947 ثم 173. الثالث زمن الرسم على المعالج بالمللي ثانية: 8.5 ثم 4.4 و4.4 ثم 1.8 و1.7 و1.8 و1.8
الرسم في الخطوات السبع: أوامر الرسم والمثلثات وزمن الرسم على المعالج

ترتيب العمل عندما يبطئ مشهدك

  1. قس الإطار أولاً: المتوسط والنسبة المئوية 95 وأسوأ إطار، على الجهاز الأضعف الذي تستهدفه، لا على جهازك.
  2. شغل دون رسم إن استطعت: إذا كان الإطار بطيئاً حتى بالخيار --headless، فالمشكلة في السكربتات أو الفيزياء أو المشهد، وابدأ بـ Profiler.
  3. اقرأ عدادات الرسم: آلاف أوامر الرسم تعني خامات مختلفة أو عقداً كثيرة متشابهة، ومئات الآلاف من المثلثات البعيدة تعني أنك تحتاج LOD أو نطاق رؤية، وأوامر كثيرة في رسم الظلال تعني ظلالاً على أضواء كثيرة أو مسافة ظل طويلة.
  4. أصلح الأكبر فقط: الإصلاح الذي لا يمس عنق الزجاجة لا يغير زمن الإطار، كما رأينا في الخطوة 1 بشاشة، حيث نزل زمن الرسم على المعالج إلى النصف ولم يتغير الإطار لأن المثلثات هي التي كانت تحدده.
  5. قس من جديد، أكثر من مرة: الجهاز نفسه يعطي أرقاماً مختلفة بين تشغيل وآخر، فلا تحكم من تشغيل واحد.

ملفات المختبر وتشغيله

المختبر في مجلد 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

تطبيق عملي

  1. غير GRID إلى 70 وشغل الخطوتين 0 و2 دون شاشة، وانظر هل يكبر زمن البحث عن أقرب نخلة مع عدد النخل بالنسبة نفسها في النسختين.
  2. في الخطوة 6 غير حجم القطعة من 10 إلى 5 ثم إلى 25، واكتب أوامر الرسم والمثلثات في كل مرة، وابحث عن الحجم الذي يعطي أقل مثلثات دون أوامر كثيرة.
  3. أضف إلى الخطوة 6 نخلة بسيطة، أسطوانة وكرة بأقل تفصيل، بنطاق رؤية يبدأ عند 70 متراً، حتى لا يبقى الأفق فارغاً، وقس كم تكلف.
  4. غير الرشاش ليطلق 200 قطرة في الإطار بدل 20، وقارن الخطوتين 4 و5 مرة أخرى، وانظر هل يظهر التجميع الآن بوضوح.
  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.
نشرة عرب رووت | ArabRoot

معرفة تستحق مكاناً في بريدك.

مقالات مختارة وأدوات مفيدة وأفكار لمشروعك القادم، في رسالة واحدة كل أسبوع.

يمكنك إلغاء الاشتراك متى شئت. الخصوصية

تم استلام طلبك. افتح بريدك واضغط رابط التأكيد لإتمام الاشتراك.