คำถามติดแท็ก interpolation

ในเกมของฉันมีภูมิประเทศที่เหมือน Minecraft ทำจากก้อน ฉันสร้างบัฟเฟอร์จุดสุดยอดจากข้อมูล voxel และใช้แผนที่พื้นผิวสำหรับลักษณะของบล็อกที่แตกต่างกัน: ปัญหาคือพื้นผิวของลูกบาศก์ที่อยู่ห่างไกลสอดแทรกด้วยกระเบื้องที่อยู่ติดกันในแผนที่พื้นผิว ผลลัพธ์ในบรรทัดของสีที่ไม่ถูกต้องระหว่างคิวบ์ (คุณอาจต้องดูภาพหน้าจอด้านล่างในขนาดเต็มเพื่อดูข้อบกพร่องกราฟิก): ตอนนี้ฉันใช้การตั้งค่าการแก้ไขเหล่านี้ แต่ฉันลองทุกชุดรวมกันและแม้GL_NEARESTไม่มีการแมปแมปก็ไม่ได้ผลลัพธ์ที่ดี glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); ฉันได้ลองเพิ่มออฟเซ็ตในพิกัดพื้นผิวเพื่อเลือกพื้นที่เล็ก ๆ ของกระเบื้อง แต่เนื่องจากเอฟเฟกต์ที่ไม่ต้องการขึ้นอยู่กับระยะห่างจากกล้องจึงไม่สามารถแก้ปัญหาได้อย่างสมบูรณ์ ในระยะทางไกล ฉันจะแก้ไขการตกเลือดนี้ได้อย่างไร เนื่องจากการใช้แผนที่พื้นผิวเป็นเทคนิคที่นิยมอาจมีวิธีการทั่วไป น่าเศร้าด้วยเหตุผลบางอย่างที่อธิบายในความคิดเห็นฉันไม่สามารถเปลี่ยนเป็นพื้นผิวหรืออาร์เรย์พื้นผิวที่แตกต่างกันได้

46 opengl  textures  interpolation  texture-atlas  mipmaps 

รูปแบบที่ดีที่สุดในการสร้างระบบคือตำแหน่งของวัตถุทั้งหมดที่จะถูกแก้ไขระหว่างสถานะการอัพเดทสองสถานะ การอัปเดตจะทำงานที่ความถี่เดิมเสมอ แต่ฉันต้องการให้สามารถแสดงผลที่ FPS ใด ๆ ดังนั้นการเรนเดอร์จะราบรื่นเท่าที่จะเป็นไปได้ไม่ว่าเฟรมต่อวินาทีไม่ว่าจะต่ำกว่าหรือสูงกว่าความถี่การอัปเดตก็ตาม ฉันต้องการอัปเดต 1 เฟรมเป็นการประมาณค่าในอนาคตจากเฟรมปัจจุบันเป็นเฟรมในอนาคต คำตอบนี้มีลิงก์ที่พูดถึงการทำสิ่งนี้: การกำหนดเวลาแบบกึ่งถาวรหรือแบบคงที่ครบหรือไม่ แก้ไข: ฉันจะใช้ความเร็วล่าสุดและความเร็วในการแก้ไขได้อย่างไร ตัวอย่างเช่นการแก้ไขเชิงเส้นเพียงอย่างเดียวมันจะเคลื่อนที่ด้วยความเร็วเท่ากันระหว่างตำแหน่ง ฉันต้องการวิธีที่จะให้มันสอดแทรกตำแหน่งระหว่างสองจุด แต่คำนึงถึงความเร็วในแต่ละจุดสำหรับการแก้ไข มันจะมีประโยชน์สำหรับการจำลองอัตราต่ำเช่นผลกระทบของอนุภาค

24 design-patterns  interpolation  fixed-timestep 

นี่เป็นคำถามเปิดเล็กน้อย แต่ฉันต้องการเห็นใครบางคนให้เหตุผลที่ดีสำหรับทั้งคู่ สำหรับตัวอย่างรวดเร็วของทั้งสอง: แบบจำลองการแก้ไข คิดว่ารูปแบบ Valve ที่ลูกค้าได้รับการอัปเดตตำแหน่งบ่อยครั้งและรีโมตอัพเดตตำแหน่งโดยใช้การแก้ไขข้อมูลนี้ เส้นทางการค้นพบ ในรูปแบบนี้คิดว่าผู้ใช้ส่งปลายทางและทุกคนหาเส้นทางไป เกมประเภทใดที่เหมาะสมกับแต่ละเกมและเมื่อใดควรใช้เกมแต่ละเกม

21 networking  path-finding  interpolation 

ฉันกำลังแสดงสไปรต์ที่พิกัดพิกเซลที่แน่นอนเพื่อหลีกเลี่ยงผลเบลอที่เกิดจากการลดรอยหยัก (สไปรต์เป็นพิกเซลศิลปะและจะดูแย่หากกรอง) อย่างไรก็ตามเนื่องจากการเคลื่อนที่ของวัตถุนั้นเกี่ยวข้องกับความเร็วตัวแปรแรงโน้มถ่วงและปฏิกิริยาทางกายภาพวิถีจึงถูกคำนวณด้วยความแม่นยำระดับพิกเซลย่อย ที่ความเร็วหน้าจอขนาดใหญ่พอ (vΔtมากกว่า 2 หรือ 3 พิกเซล) นี้ทำงานได้ดีมาก อย่างไรก็ตามเมื่อความเร็วมีขนาดเล็กเอฟเฟกต์บันไดที่เห็นได้ชัดเจนสามารถปรากฏขึ้นได้โดยเฉพาะอย่างยิ่งในแนวเส้นทแยงมุม นี่ไม่ใช่ปัญหาที่ความเร็วหน้าจอช้ามาก (v << 1 พิกเซลต่อวินาที) ดังนั้นฉันจึงมองหาวิธีแก้ปัญหาสำหรับค่าความเร็วกลางเท่านั้น ทางด้านซ้ายเป็นเส้นทางที่พล็อตสำหรับความเร็วขนาดใหญ่ที่ได้จากการปัดเศษของพิกัดวัตถุ ตรงกลางคุณจะเห็นว่าเกิดอะไรขึ้นเมื่อความเร็วมีขนาดเล็กลงและเอฟเฟกต์บันไดที่ฉันกำลังพูดถึง ทางด้านขวาสถานทีของเส้นทางการเคลื่อนที่ที่ฉันต้องการ ฉันสนใจแนวคิดของอัลกอริทึมในการกรองวิถีเพื่อลดนามแฝงในขณะที่ยังคงพฤติกรรมเดิมที่ความเร็วสูงและขนาดเล็ก ฉันสามารถเข้าถึงΔtตำแหน่งทันทีและความเร็วเช่นเดียวกับจำนวนโดยพลการของค่าก่อนหน้า แต่เนื่องจากเป็นการจำลองแบบเรียลไทม์ฉันจึงไม่ทราบเกี่ยวกับค่าในอนาคต . โปรดทราบว่าเนื่องจากการจำลองทางฟิสิกส์การเปลี่ยนแปลงทิศทางอย่างฉับพลันอาจเกิดขึ้นได้เช่นกัน

21 physics  interpolation  trajectory  pixel 

ฉันได้รับการจัดการกับปัญหาการกระเพื่อมอัตราเฟรมกับเกมของฉันเมื่อเร็ว ๆ นี้และดูเหมือนว่าทางออกที่ดีที่สุดจะเป็นที่แนะนำโดย Glenn Fiedler (Gaffer ในเกม) ในคลาสสิกFix Your Timestep! บทความ. ตอนนี้ - ฉันใช้ขั้นตอนเวลาที่แน่นอนสำหรับการอัปเดตของฉันแล้ว ปัญหาคือฉันไม่ได้ทำการแก้ไขที่แนะนำสำหรับการเรนเดอร์ ผลที่สุดคือฉันได้รับสองเท่าหรือข้ามเฟรมหากอัตราการแสดงผลของฉันไม่ตรงกับอัตราการอัปเดตของฉัน สิ่งเหล่านี้สามารถสังเกตเห็นได้ชัดเจน ดังนั้นฉันจึงต้องการเพิ่มการแก้ไขในเกมของฉัน - และฉันสนใจที่จะรู้ว่าคนอื่นมีโครงสร้างข้อมูลและรหัสของพวกเขาเพื่อสนับสนุนสิ่งนี้อย่างไร เห็นได้ชัดว่าฉันจะต้องจัดเก็บ (ที่ไหน / อย่างไร?) ข้อมูลสถานะเกมสองชุดที่เกี่ยวข้องกับโหมดแสดงภาพของฉันเพื่อให้สามารถแก้ไขระหว่างพวกเขาได้ นอกจากนี้ - นี่เป็นสถานที่ที่เหมาะสำหรับเพิ่มเธรด ฉันคิดว่าเธรดการอัปเดตสามารถทำงานในสถานะเกมที่สามได้โดยปล่อยให้อีกสองสำเนาเป็นแบบอ่านอย่างเดียวสำหรับเธรดการแสดงผล (นี่เป็นความคิดที่ดีใช่ไหม) มันดูเหมือนว่าจะมีสองหรือสามรุ่นของรัฐของเกมสามารถนำประสิทธิภาพการทำงานและ - ไกลที่สำคัญกว่า - ความน่าเชื่อถือและผลิตพัฒนาปัญหาเมื่อเทียบกับมีเพียงรุ่นเดียว ดังนั้นฉันจึงสนใจเป็นพิเศษในวิธีการลดปัญหาเหล่านั้น โดยเฉพาะอย่างยิ่งผมคิดว่าเป็นปัญหาของวิธีจัดการกับการเพิ่มและลบวัตถุออกจากสถานะเกม ในที่สุดดูเหมือนว่าบางรัฐอาจไม่จำเป็นต้องทำการเรนเดอร์โดยตรงหรืออาจจะยากเกินกว่าที่จะติดตามเวอร์ชั่นต่าง ๆ ของ (เช่น: เอ็นจิ้นฟิสิกส์ของบุคคลที่สามที่เก็บสถานะเดี่ยว) - ดังนั้นฉันสนใจที่จะทราบ ผู้คนจัดการข้อมูลประเภทนั้นภายในระบบดังกล่าว

20 physics  multithreading  fixed-timestep  interpolation 

ฉันมีปัญหาในการทำความเข้าใจเมื่อใดที่จะคาดการณ์และเมื่อใดที่จะแก้ไข ในเกมคนขายเหล้าเขาพูดเพื่อสอดแทรก แต่ในบทความอื่นแนะนำให้ผู้เล่นคาดการณ์ ดังนั้นคำถามของฉันคือเมื่อใดจะดีกว่าที่จะคาดการณ์และเมื่อใดจะดีกว่าที่จะสอดแทรก?

16 interpolation  extrapolation 

ฉันมีเวกเตอร์ความเร็วสูงที่ลูกค้าของฉันอยู่และกำลังจะไปและฉันมีเวกเตอร์เดียวกันที่มาจากเซิร์ฟเวอร์บอกว่าลูกค้าควรจะอยู่ที่ไหน บางครั้งมันก็แตกต่างกันเล็กน้อยดังนั้นฉันต้องการแก้ไขระหว่างตำแหน่งปัจจุบันของฉันกับตำแหน่งที่ถูกต้องของเซิร์ฟเวอร์ ลูกศรสีดำเป็นเวกเตอร์ความเร็วของลูกค้าลูกศรสีแดงเป็นเวกเตอร์ความเร็วของลูกค้าบนเซิร์ฟเวอร์และลูกศรสีน้ำเงินเป็นอันที่ฉันต้องการคำนวณและสอดแทรก ฉันจะคำนวณเวกเตอร์สีน้ำเงินได้อย่างไร จากนั้นฉันจะแก้ไขเชิงเส้นตรงระหว่างพวกเขาได้อย่างไร

16 mathematics  vector  interpolation 

เพื่อประหยัดแบนด์วิดธ์ในเกมที่มีผู้เล่นหลายคนของฉันฉันจะไม่อัปเดตทุกออบเจ็กต์ทุก ๆ เห็บเซิร์ฟเวอร์แทนแต่ละอ๊อพเจ็กมีอัปเดตให้คะแนนซึ่งบอกเกมว่าวัตถุนี้คาดว่าจะได้รับการอัพเดท เมื่อฉันได้รับข้อความอัปเดตสำหรับวัตถุฉันคำนวณเวลาที่ฉันคาดว่าจะมีการอัพเดทครั้งต่อไป: origin = serverCurrentPosition diff = serverNextPosition - origin arriveTime = now + timeBetweenTicks * updateRate เมื่อฉันวาดวัตถุฉันจะคำนวณเวลาที่เหลือจนถึงการอัปเดตครั้งถัดไปและแก้ไขตำแหน่งตามนั้น: step = 100 / timeBetweenTicks * updateRate delta = 1 - step * ((arriveTime - now) / 100) position = origin + diff * delta มันใช้งานได้ ... แต่ยังมีความกระวนกระวายใจเล็กน้อยในการวาดแม้ว่าในทฤษฎีของฉันทุกสิ่งควรจะทำงานได้ดีเพราะมาตราส่วนควรดูแลความล่าช้าบางอย่างใช่ไหม? ดังนั้นคำถามนี่คือนี่เป็นวิธีที่ดีที่สุดหรือไม่? ฉันควรใส่ความล่าช้าที่เกิดขึ้นจริงในการคำนวณหรือไม่? …

14 multiplayer  client-server  interpolation 

ฉันพยายามรวมสองสิ่งเข้าด้วยกัน ฉันกำลังเขียนเกมและฉันจำเป็นต้องกำหนดสี่เหลี่ยมกริดที่วางอยู่บนเส้นตรงกับจุดสิ้นสุดของจุดลอยตัว ยิ่งกว่านั้นฉันต้องการมันเพื่อรวมสี่เหลี่ยมกริดทั้งหมดที่มันแตะ (เช่นไม่ใช่แค่เส้นของ Bresenhamแต่เป็นสีน้ำเงิน): มีใครให้ข้อมูลเชิงลึกเกี่ยวกับวิธีการใช้หรือไม่ วิธีแก้ปัญหาที่ชัดเจนคือการใช้อัลกอริธึมแบบไร้เดียงสา แต่มีบางสิ่งที่ได้รับการปรับให้เหมาะสมที่สุด (เร็วกว่า)?

12 c#  algorithm  grid  interpolation  floating-point 

เพื่อความเข้าใจของฉัน, ฟังก์ชั่น Lerp สอดแทรกระหว่างสองค่า ( aและb) โดยใช้ค่าที่สาม ( t) ระหว่างและ0 1ที่t = 0ค่า a ถูกส่งคืน at ที่t = 1ค่าbจะถูกส่งคืน ที่ 0.5 ค่าครึ่งทางระหว่างaและbจะถูกส่งกลับ (ภาพต่อไปนี้เป็นแบบสเต็ปสเตปซึ่งมักจะเป็นการแก้ไขแบบลูกบาศก์) ฉันได้ดูฟอรัมและคำตอบนี้ฉันพบบรรทัดของรหัสต่อไปนี้:transform.rotation = Quaternion.Slerp(transform.rotation, _lookRotation, Time.deltaTime); ฉันคิดกับตัวเองว่า "เป็นคนโง่เขาไม่มีความคิดอะไรเลย" แต่เนื่องจากมีผู้โหวตมากกว่า 40+ ครั้งฉันจึงได้ลองและแน่นอนว่ามันใช้ได้ดี! float t = Time.deltaTime; transform.rotation = Quaternion.Slerp(transform.rotation, toRotation, t); Debug.Log(t); ผมได้รับค่าสุ่มระหว่าง0.01และสำหรับ0.02 tฟังก์ชั่นไม่ควรแก้ไขตามหรือไม่ ทำไมค่าเหล่านี้สแต็ก มันเกี่ยวกับ lerp อะไรที่ฉันไม่เข้าใจ?

12 unity  mathematics  interpolation  lerp 

ฉันต้องการสร้างแอนิเมชั่นแฟนซีที่จุดหนึ่งเดินทางไปรอบ ๆ สี่เหลี่ยมผืนผ้า tฉันต้องการที่จะหาตำแหน่งของจุดในเวลา สี่เหลี่ยมผืนผ้าจะได้รับจากX, Y, และWidthHeight มีอัลกอริทึมสำหรับสิ่งนี้หรือไม่? ฉันใช้sin/ cosสำหรับแวดวง อะไรคือวิธีที่เทียบเท่าสำหรับสี่เหลี่ยม?

11 animation  geometry  interpolation 

โครงการ SmoothVideo ใช้การสอดแทรกเฟรมภาพต่อวินาทีเพื่อเพิ่มวิดีโอจาก 24 ถึง 60 ผลเป็นที่น่าประทับใจสวย ฉันสงสัยว่าสามารถใช้กับสิ่งนี้ได้หรือไม่และจะดูดีในวิดีโอเกมหรือไม่ มันใช้ทรัพยากรน้อยกว่าการเรนเดอร์เฟรมทั้งหมดดังนั้นจะช่วยให้แท่นวางที่ต่ำกว่าแสดงผลได้ที่คุณภาพของแท่นวางที่ดีกว่ามากในบางระดับของการประนีประนอม ฉันรู้ว่ามันจะไม่ถูกต้องและจะเพิ่มความล่าช้าในการป้อนข้อมูลเล็กน้อยตามที่จำเป็นต้องยึดไว้กับเฟรมใหม่ล่าสุดเพื่อให้สามารถสร้างและแทรกการแก้ไขที่หนึ่ง มันไม่ได้แย่เหมือนฟูลเฟรม แต่โดยเหตุผลของฉันมีเพียงความล่าช้าเท่านั้นคือเวลาการแก้ไขบวกครึ่งเวลาในการรีเฟรชเฟรมต่อวินาทีดั้งเดิม ดังนั้นสำหรับ 30 fps มันจะเป็นเวลาประมาณ 33ms / 2 + บางทีความล่าช้านี้อาจทำให้มันไม่เหมาะกับเกมบุคคลที่ผ่านมาเร็ว แต่ฉันสงสัยว่ามันจะเป็นอุปสรรคในเกมที่เล่นช้ากว่า ความล่าช้าจะลดลงที่อัตราเริ่มต้นที่สูงขึ้นดังนั้นฉันคิดว่ามันจะคุ้มค่าอย่างแน่นอนเมื่อไปจาก 60fps ถึง 100 + fps ซึ่งปรับปรุงประสบการณ์แม้ว่าจะเพิ่มขึ้นเล็กน้อยในขณะที่การเก็บภาษีบนระบบมาก

11 rendering  frame-rate  interpolation 

ฉันมีเอนทิตีจำนวนมากในฝั่งไคลเอ็นต์ที่ถูกจำลอง (ความเร็วของพวกเขาถูกเพิ่มลงในตำแหน่งของพวกเขาตามเฟรมต่อเฟรม) และฉันปล่อยให้พวกเขาตายนับเอง พวกเขาส่งการอัปเดตเกี่ยวกับที่ที่พวกเขาเห็นครั้งสุดท้ายและการเปลี่ยนแปลงความเร็วของพวกเขา มันใช้งานได้ดีและผู้เล่นคนอื่นเห็นงานนี้พบ อย่างไรก็ตามหลังจากที่ในขณะที่ผู้เล่นเหล่านี้เริ่ม desync หลังจากเวลา นี่เป็นเพราะเวลาแฝง ฉันต้องการทราบวิธีแก้ไขปัญหาระหว่างรัฐดังนั้นพวกเขาจึงอยู่ในตำแหน่งที่ถูกต้อง ฉันรู้ว่าผู้เล่นคนใดถูกมองเห็นเมื่อเร็ว ๆ นี้และความเร็วปัจจุบันของพวกเขา แต่การสอดแทรกไปยังสถานะที่เห็นล่าสุดทำให้ผู้เล่นเลื่อนไปข้างหลัง - ฉันไม่สามารถใช้ความเร็วเลยสำหรับลูกค้าคนอื่น ๆ และเพียง 'lerp' พวกเขาไปในทิศทางที่เหมาะสม แต่ฉันรู้สึกว่าสิ่งนี้จะทำให้เกิดการเคลื่อนไหวที่ขรุขระ ทางเลือกคืออะไร?

11 c#  movement  interpolation 

ฉันกำลังสร้างเกมมัลติเพลเยอร์แบบเรียลไทม์ที่รันลูป 'ฟิสิกส์' แบบเดียวกันบนไคลเอนต์และเซิร์ฟเวอร์ ฉันกำลังใช้พฤติกรรมการบังคับเลี้ยว 'เดิน' ที่เป็นการเคลื่อนไหวแบบสุ่มที่สำคัญ ไคลเอนต์และเซิร์ฟเวอร์สร้างหมายเลขสุ่มที่แตกต่างกันเมื่อเรียกใช้อัลกอริทึมหลงทาง ฉันสงสัยว่าฉันสามารถเคลื่อนไหวแบบสุ่มตามธรรมชาติได้อย่างไร แต่ใช้ค่าคงที่ที่จะประกันลูกค้าและเซิร์ฟเวอร์ให้ได้ข้อสรุปเดียวกัน

10 multiplayer  client-server  interpolation  movement-prediction 

ฉันถามคำถามที่คล้ายกันสองสามครั้งในช่วง 8 เดือนที่ผ่านมาโดยไม่มีความสุขจริง ๆ ดังนั้นฉันจะทำให้คำถามทั่วไปยิ่งขึ้น ฉันมีเกม Android ซึ่งเป็น OpenGL ES 2.0 ภายในนั้นฉันมี Game Loop ดังต่อไปนี้: ลูปของฉันทำงานบนหลักการขั้นตอนเวลาที่แน่นอน (dt = 1 / ticksPerSecond ) loops=0; while(System.currentTimeMillis() > nextGameTick && loops < maxFrameskip){ updateLogic(dt); nextGameTick+=skipTicks; timeCorrection += (1000d/ticksPerSecond) % 1; nextGameTick+=timeCorrection; timeCorrection %=1; loops++; } render(); การรวมของฉันทำงานเช่นนี้: sprite.posX+=sprite.xVel*dt; sprite.posXDrawAt=sprite.posX*width; ตอนนี้ทุกอย่างทำงานได้สวยตามที่ฉันต้องการ ฉันสามารถระบุได้ว่าฉันต้องการให้วัตถุเคลื่อนที่ในระยะหนึ่ง (ความกว้างของหน้าจอพูด) ภายใน …

10 android  interpolation  lerp  extrapolation