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

นี้จะเป็นเรื่องง่ายสำหรับเกมที่มีขอบเขตกำหนดไว้อย่างดี แต่คำถามคือเกี่ยวกับเกม sandbox ที่ที่ผู้เล่นจะได้รับอนุญาตให้สร้างและสร้างอะไร เทคนิคที่เป็นไปได้: ใช้พูลหน่วยความจำที่มีขีด จำกัด สูงสุด ลบวัตถุที่ไม่ต้องการเป็นระยะ ๆ จัดสรรจำนวนหน่วยความจำเพิ่มเติมที่จุดเริ่มต้นเพื่อให้สามารถเป็นอิสระในภายหลังเป็นกลไกการกู้คืน ฉันจะบอกว่าประมาณ 2-4 MBs สิ่งนี้มีแนวโน้มที่จะเกิดขึ้นในแพลตฟอร์มมือถือ / คอนโซลซึ่งหน่วยความจำมักจะถูก จำกัด ไม่เหมือนกับพีซีขนาด 16 GB ของคุณ ฉันสมมติว่าคุณสามารถควบคุมการจัดสรร / การจัดสรรคืนหน่วยความจำได้อย่างสมบูรณ์และไม่มีการรวบรวมขยะ นั่นเป็นเหตุผลที่ฉันกำลังติดแท็กสิ่งนี้เป็น C ++ โปรดทราบว่าฉันไม่ได้พูดถึงรายการ C ++ ที่มีประสิทธิภาพ 7 "เตรียมพร้อมสำหรับเงื่อนไขหน่วยความจำไม่เพียงพอ"แม้ว่าจะเกี่ยวข้องกัน แต่ฉันต้องการดูคำตอบเพิ่มเติมเกี่ยวกับการพัฒนาเกมซึ่งคุณมักจะควบคุมสิ่งที่มากกว่า สิ่งที่เกิดขึ้น เพื่อสรุปคำถามคุณจะเตรียมตัวอย่างไรสำหรับเงื่อนไขหน่วยความจำไม่เพียงพอสำหรับเกมแซนด์บ็อกซ์เมื่อคุณกำหนดเป้าหมายแพลตฟอร์มด้วยคอนโซลหน่วยความจำ / อุปกรณ์เคลื่อนที่ จำกัด

18 c++  optimization  memory-efficiency  memory 

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

18 optimization  console  file 

ฉันสร้างเกม HTML5 Canvas และ JS ที่ทำงานได้ดีบนเดสก์ท็อปหรือแล็ปท็อปใน Chrome (30fps) แต่สำหรับ Safari บนอุปกรณ์เคลื่อนที่ฉันจะได้รับเพียง 8 เฟรมต่อวินาที มีเคล็ดลับหรือเทคนิคง่ายๆในการเพิ่มอัตราเฟรมหรือไม่?

17 optimization  javascript  html5  mobile 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันพัฒนาเครื่องมือเกมโดยใช้ OpenGL 3 และ C ++ (และ glfw สำหรับการจัดการหน้าต่าง) ฉันได้ก้าวหน้าไปแล้วทำสิ่งต่าง ๆ ให้เสร็จยกเว้นเสียงและการปรับให้เหมาะสมที่สุด เอ็นจิ้นใช้การแรเงาที่เลื่อนออกไปดังนั้นเนื่องจากการแรเงาที่เลื่อนออกไปนั้นเป็นกระบวนการที่น่าเบื่อสำหรับ GPU โดยเฉลี่ยฉันต้องการเพิ่มประสิทธิภาพของกระบวนการเรนเดอร์ให้มากที่สุด ระบบปัจจุบันประกอบด้วยฉากที่มี Renderer std::vectorsและโลกปัจจุบันและโลกถือหน่วยงานและหน่วยงานที่แยกออกจากแสง ดังนั้นโดยทั่วไปทุกครั้งที่ซีนถูกเรียกโดย->render()และมันเรียกว่า Renderer ผ่านโลกเป็นพารามิเตอร์และรับเอนทิตีซ้ำจากทั่วโลกดึงพวกมันไปยัง FBO จากนั้นผ่านหน่วยแสงสำหรับการผ่านครั้งที่สอง และฉันคิดว่ามันไม่เพียงพอ อัลกอริทึมปัจจุบันของฉันวนซ้ำทุกอย่างแม้ว่าเอนทิตีไม่ได้อยู่ในพื้นที่หน้าจอ ฉันกำลังคิดหาวิธีเพิ่มประสิทธิภาพอัลกอริธึมการแสดงผลปัจจุบันดังนั้นจึงเรียกเฉพาะฟังก์ชัน API เฉพาะสำหรับวัตถุที่มองเห็นดังนั้นเทคนิคทั่วไปในการปรับการแสดงผลให้เหมาะสมคืออะไร

16 opengl  c++  optimization  deferred-rendering 

ฉันกำลังออกแบบเกมที่ประกอบด้วยการสำรวจดาวเคราะห์บางส่วน ฉันต้องการใช้การสร้างแบบสุ่มหลอกสำหรับพวกเขาสร้างใหม่จากเมล็ดที่กำหนดไว้เมื่อฉันต้องโหลดพวกเขาแทนที่จะเก็บทุกรายละเอียดซึ่งจะหนักเกินไป ดังนั้นฉันจะเก็บไฟล์แบบสุ่มและการดัดแปลงที่ทำโดยผู้เล่นในไฟล์ถ้ามี ผู้เล่นจะต้องสามารถมองเห็นดาวเคราะห์จากวงโคจร (ด้วยรายละเอียดที่ต่ำมากจากนั้นก็ลงไปที่พื้นเพิ่มระดับของรายละเอียดของภูมิภาคที่เขา / เธอลงจอดอย่างช้า ๆ และขนลงด้านอื่น ๆ ของดาวเคราะห์ซึ่งอยู่นอกมุมมองของผู้เล่น ถ้าฉันต้องทำบนพื้นราบฉันจะทำอย่างง่ายดายด้วยระบบอันทรงสี่เหลี่ยม แต่ปัญหาตรงนี้ก็คือดาวเคราะห์เกือบจะเป็นทรงกลม ดังนั้นวิธีที่ดีที่สุดในการโหลดรายละเอียดภาคพื้นดิน (วัตถุการผ่อนปรนและวัตถุที่มีการลงดิน) รอบจุดที่แม่นยำคืออะไร ฉันว่าแล้วในสองวิธี แต่ทั้งสองมีจุดอ่อน: 1. การตัดทรงกลมเป็นชิ้นสี่เหลี่ยม เมื่อผู้เล่นอยู่ใกล้พื้นดินมากพอฉันต้องปรับปรุงรายละเอียดของสี่เหลี่ยมที่ใกล้เคียงที่สุดจากตำแหน่งของเขา / เธอ หากยังไม่พอฉันยังสามารถตัดสี่เหลี่ยมแต่ละช่องเป็นสี่เหลี่ยมย่อยเพื่อโหลดเมื่อผู้เล่นอยู่บนหรือใกล้พื้นดินจริงๆ แต่อย่างที่คุณเห็นในภาพมีปัญหาถ้าผู้เล่นพยายามที่จะลงจอดบนเสา: สแควร์สกลายเป็นรูปสี่เหลี่ยมผืนผ้าที่บางมากหรือแม้กระทั่งรูปสามเหลี่ยมสำหรับบรรทัดสุดท้ายและนอกจากนี้ความจริงที่ว่าพวกเขาจะโหลดจำนวนมาก รุ่นจะปรากฏบิดเบี้ยว 2. เริ่มต้นจาก icosahedron ที่นี่ฉันสามารถเพิ่มรูปสามเหลี่ยม tessellation รอบตำแหน่งของผู้เล่นเมื่อเขา / เธอเข้าใกล้ แต่ฉันไม่รู้วิธีหาสามเหลี่ยมใกล้ตำแหน่งของผู้เล่น ฉันได้ยินว่าพิกัดคาร์ทีเซียนอาจเป็นประโยชน์อย่างเต็มที่ในกรณีนั้น แต่ฉันไม่รู้วิธีใช้งาน ฉันใช้ C ++ / OpenGL สำหรับมันดังนั้นสิ่งสำคัญในการสร้างและโหลดที่นี่คือจุดยอดที่แสดงถึงการลดพื้นผิวและสี / พื้นผิว

15 opengl  c++  procedural-generation  optimization  sphere 

เครื่องยนต์ฟิสิกส์สามารถลดความซับซ้อนนั้นได้หรือไม่โดยการจัดกลุ่มวัตถุที่อยู่ใกล้กันและตรวจสอบการชนภายในกลุ่มนี้แทนที่จะเทียบกับวัตถุทั้งหมดหรือไม่ (ตัวอย่างเช่นวัตถุที่อยู่ไกลสามารถลบออกจากกลุ่มโดยดูที่ความเร็วและระยะทางจากวัตถุอื่น) ถ้าไม่นั่นทำให้เกิดการปะทะกันเล็กน้อยสำหรับทรงกลม (ใน 3d) หรือดิสก์ (เป็น 2d) หรือไม่ ฉันควรสร้างวงคู่หรือสร้างอาร์เรย์ของคู่แทน? แก้ไข: สำหรับเครื่องยนต์ฟิสิกส์เช่นกระสุนและ box2d การตรวจจับการชนยังคงเป็น O (N ^ 2) หรือไม่

14 collision-detection  physics  optimization  physics-engine 

หากนี่เป็นครั้งแรกของคุณสำหรับคำถามนี้ฉันขอแนะนำให้อ่านส่วนอัปเดตด้านล่างก่อนจากนั้นส่วนนี้ นี่คือการสังเคราะห์ปัญหาแม้ว่า: โดยพื้นฐานแล้วฉันมีระบบตรวจจับการชนและการแก้ปัญหาด้วยระบบแบ่งพาร์ติชันแบบกริดซึ่งการเรียงลำดับการชนและการชนมีความสำคัญ ร่างกายหนึ่งคนในแต่ละครั้งจะต้องเคลื่อนที่จากนั้นตรวจจับการชนแล้วแก้ไขการชน ถ้าฉันย้ายร่างกายทั้งหมดในครั้งเดียวจากนั้นสร้างคู่การชนกันที่เป็นไปได้มันจะเร็วขึ้นอย่างเห็นได้ชัด แต่ตัวแบ่งความละเอียดเนื่องจากการเรียงลำดับของการชนกันไม่ได้รับการเคารพ ถ้าฉันขยับร่างกายหนึ่งครั้งฉันก็ต้องบังคับให้ร่างกายตรวจสอบการชนและมันจะกลายเป็นปัญหา ^ 2 ใส่กลุ่มในการผสมและคุณสามารถจินตนาการได้ว่าทำไมมันถึงช้ามากอย่างรวดเร็วด้วยร่างกายจำนวนมาก อัปเดต:ฉันทำงานอย่างหนักกับสิ่งนี้ แต่ไม่สามารถจัดการเพื่อเพิ่มประสิทธิภาพอะไรได้เลย ฉันประสบความสำเร็จในการนำ "ภาพวาด" ที่อธิบายโดย Will และเปลี่ยนกลุ่มเป็นบิตเซ็ต แต่มันเป็นการเร่งความเร็วที่น้อยมาก ฉันค้นพบปัญหาใหญ่เช่นกัน: เครื่องยนต์ของฉันขึ้นอยู่กับการชนกันของข้อมูล ฉันพยายามที่มีการใช้งานของคนรุ่นชนคู่ที่ไม่ซ้ำกันซึ่งแน่นอนเพิ่มความเร็วในการทุกอย่างด้วยเป็นจำนวนมาก แต่ยากจนชนการสั่งซื้อของ ให้ฉันอธิบาย: ในการออกแบบดั้งเดิมของฉัน (ไม่สร้างคู่) สิ่งนี้เกิดขึ้น: เคลื่อนไหวร่างกายเดียว หลังจากที่มันเคลื่อนไหวแล้วมันจะรีเฟรชเซลล์และทำให้ร่างกายได้รับการชนกัน หากมันทับร่างกายที่ต้องแก้ไขให้แก้ไขการชนกัน นี่หมายความว่าหากร่างกายเคลื่อนไหวและชนกับกำแพง (หรือร่างกายอื่น ๆ ) เฉพาะร่างกายที่เคลื่อนไหวเท่านั้นที่จะแก้ไขการชนและร่างกายอื่น ๆ จะไม่ได้รับผลกระทบ นี่คือความปรารถนาที่พฤติกรรมของฉัน ผมเข้าใจว่ามันไม่ธรรมดาสำหรับเครื่องยนต์ฟิสิกส์ แต่มันก็มีประโยชน์มากสำหรับสไตล์ย้อนยุคเกม ในการออกแบบกริดปกติ (สร้างคู่ที่ไม่ซ้ำกัน) สิ่งนี้เกิดขึ้น: ทุกสิ่งเคลื่อนไหว หลังจากย้ายวัตถุทั้งหมดแล้วให้รีเฟรชเซลล์ทั้งหมด สร้างคู่การชนกันที่ไม่ซ้ำกัน สำหรับแต่ละคู่จัดการการตรวจจับการชนและความละเอียด ในกรณีนี้การเคลื่อนที่พร้อมกันอาจส่งผลให้มีสองวัตถุซ้อนทับกันและพวกมันจะแก้ไขในเวลาเดียวกัน - สิ่งนี้ทำให้ร่างกาย "ผลักกันอีกรอบ" …

14 c++  collision-detection  performance  optimization  grid 

เป็นไปได้หรือไม่ที่จะอธิบายโครงร่าง "ดีที่สุด" (ในแง่ของประสิทธิภาพ) สำหรับลูปเกมของผู้เลื่อนด้าน 2D ในบริบทนี้ "game loop" ใช้การป้อนข้อมูลของผู้ใช้อัปเดตสถานะของวัตถุเกมและดึงวัตถุเกม ตัวอย่างเช่นการมีคลาสฐาน GameObject ที่มีลำดับชั้นการสืบทอดลึกอาจดีสำหรับการบำรุงรักษา ... คุณสามารถทำสิ่งต่อไปนี้: foreach(GameObject g in gameObjects) g.update(); อย่างไรก็ตามฉันคิดว่าวิธีนี้สามารถสร้างปัญหาด้านประสิทธิภาพได้ ในทางกลับกันข้อมูลและฟังก์ชันของวัตถุในเกมทั้งหมดอาจเป็นข้อมูลทั่วโลก ซึ่งจะเป็นการบำรุงรักษาอาการปวดหัว แต่อาจเข้าใกล้กับลูปเกมที่มีประสิทธิภาพสูงสุด ความคิดใด ๆ ฉันสนใจในการใช้งานจริงของโครงสร้างลูปเกมที่ดีที่สุด ... แม้ว่าฉันจะปวดหัวในการบำรุงรักษาเพื่อแลกกับประสิทธิภาพที่ยอดเยี่ยม

14 optimization  performance  game-loop 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน2 ปีที่ผ่านมา มีเกมพีซีจำนวนมากออกมาที่มี (เหมือน) กราฟิกโดยประมาณ (กับ bump-maps, shaders, ฯลฯ ) ความซับซ้อนของเสียงและเวลาในการเล่น แต่หนึ่งในนั้นต้องการพื้นที่ 4GB ในขณะที่อีก 13GB ทำไมถึงเป็นอย่างนั้น? ทำไมถึงมีขนาดแตกต่างกันมาก?

13 optimization  pc 

ในขั้นตอนการเพิ่มประสิทธิภาพการเขียนโปรแกรมธุรกิจ 'ปกติ' มักจะถูกทิ้งไว้จนจำเป็นจริงๆ หมายความว่าคุณไม่ควรยกเลิกการเลือกจนกว่าจะจำเป็นจริงๆ จำสิ่งที่Donald Knuthพูดว่า "เราควรลืมประสิทธิภาพเล็ก ๆ น้อย ๆ พูดถึง 97% ของเวลา: การเพิ่มประสิทธิภาพก่อนวัยอันควรเป็นรากฐานของความชั่วร้ายทั้งหมด" เวลาที่จะเพิ่มประสิทธิภาพเพื่อให้แน่ใจว่าฉันไม่ได้พยายาม ฉันควรทำระดับวิธีการหรือไม่? ระดับชั้น? ระดับโมดูล? นอกจากนี้สิ่งที่ฉันควรวัดการเพิ่มประสิทธิภาพ? เห็บ? อัตราเฟรม? เวลารวม?

13 optimization 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน2 ปีที่ผ่านมา ฉันกำลังมองหาแหล่งการเรียนรู้ที่ดีสำหรับฮาร์ดแวร์กราฟิก (และซอฟต์แวร์ระดับต่ำที่เกี่ยวข้อง) โดยทั่วไปฉันต้องการเรียนรู้เพิ่มเติมเกี่ยวกับสิ่งที่เกิดขึ้นภายใต้เลเยอร์ opengl / direcx API ในแง่ของวิธีการใช้งาน ฉันคุ้นเคยกับสิ่งที่เกิดขึ้นในหลักการระหว่างขั้นตอนต่าง ๆ ของไปป์ไลน์เรนเดอร์ (การดูการฉายภาพการตัดการแรสเตอร์ ฯลฯ ) เป้าหมายของฉันคือเพื่อให้สามารถตัดสินใจได้ดีขึ้นและมีข้อมูลมากขึ้นเกี่ยวกับการแลกเปลี่ยนและการเพิ่มประสิทธิภาพที่เป็นไปได้เมื่อโปรแกรมกราฟิก / shader ที่เกี่ยวข้องกับประเด็นต่อไปนี้; เครื่องผสม ดูการเลือกสรร occlusions วาดคำสั่ง หลีกเลี่ยงการเปลี่ยนแปลงสถานะ สามเหลี่ยม vs พอยท์ การสุ่มตัวอย่างพื้นผิว ฯลฯ โดยพื้นฐานแล้วสิ่งที่โปรแกรมเมอร์กราฟิกจำเป็นต้องรู้เกี่ยวกับฮาร์ดแวร์กราฟิกสมัยใหม่เพื่อให้มีประสิทธิภาพมากขึ้น ฉันไม่ได้มองหาเทคนิคการเพิ่มประสิทธิภาพที่เฉพาะเจาะจง แต่ฉันต้องการความรู้ทั่วไปเพิ่มเติมเพื่อที่ฉันจะเขียนโค้ดที่มีประสิทธิภาพมากขึ้น

12 graphics-programming  optimization  hardware 

บริบท Old Lucas Arts (ScummVM era) ชี้และคลิกเกมผจญภัยกราฟิกที่ใช้การคำนวณเส้นทางก่อน นี่คือคร่าวๆของเทคนิค ขั้นตอนที่ 1 พื้นในแต่ละห้องถูกแบ่งออกเป็นสิ่งที่พวกเขาเรียกว่า "กล่องเดิน" ซึ่งค่อนข้างคล้ายกับโหนดในตาข่ายนำทาง แต่ จำกัด รูปร่างรูปสี่เหลี่ยมคางหมู เช่น: ______ _____ _________ _____ \ A | B | C | D \ \_____| | |_______\ |_____| | |_________| ขั้นตอนที่ 2 อัลกอริทึมออฟไลน์ (เช่น Dijkstra หรือ A *) จะคำนวณเส้นทางที่สั้นที่สุดระหว่างแต่ละโหนดและทุกคู่ของโหนดและเก็บขั้นตอนแรกของเส้นทางในเมทริกซ์ 2D โดยสร้างดัชนีในแต่ละมิติโดยใช้โหนดเริ่มต้นและสิ้นสุด เช่นใช้กล่องเดินด้านบน: ___ ___ …

12 ai  path-finding  performance  optimization 

เล่นกับการสร้าง minecraftish / lego world landscapes ใน Unity 3D (สร้าง voxel landscapes with cubes) ฉันพบว่า mesh ที่สร้างขึ้นสำหรับทิวทัศน์เหล่านี้ใช้หน่วยความจำจำนวนมาก ในปัจจุบันตาข่ายประกอบด้วยเพียงจุดยอดสำหรับด้านที่มองเห็นของก้อน การใช้หน่วยความจำสำหรับภูมิประเทศที่ซับซ้อนอาจใช้เวลา 6 หรือ 7 ร้อย megs ตาข่ายเหล่านี้อาจปรับให้เหมาะสม แต่ฉันพยายามหาอัลกอริธึมที่เหมาะสมในการทำเช่นนี้ อัลกอริทึมต้องคำนึงถึงว่าคุณไม่ต้องการบล็อก "ผสาน" ที่มีประเภทภูมิประเทศที่แตกต่างกัน ฉันเดาว่าการเริ่มต้นที่ง่ายจริงๆอาจจะแค่ประมวลผลบล็อคทั้งหมดตามแกนหนึ่งและทำเรตติ้งพิเศษสำหรับอีกสองแกน ฉันต้องการรักษารูปร่างของตาข่ายนั่นคือไม่มีการรวมจุดยอดไปยังจุดที่มีการเปลี่ยนแปลงพื้นที่ว่างเปล่าหรือของแข็ง เหตุผลก็คืออาจมีสิ่งมีชีวิต / ฯลฯ ที่ยังคงต้องไปรอบ ๆ ตาข่าย ดังนั้นฉันไม่สามารถสร้างรายละเอียดที่ต่ำมากบิดเบือนตาข่าย ความคิด / คำแนะนำ / เคล็ดลับเกี่ยวกับเรื่องนี้?

12 3d-meshes  optimization  voxels 

ฉันอ่านเกี่ยวกับการสร้างการแสดงผลแฟลชดั้งเดิมBitmapDataกับการสร้างเฟรมบัฟเฟอร์แบบกำหนดเองและคำตอบบางข้อนั้นขัดแย้งกันเล็กน้อยดังนั้นฉันจึงสงสัยว่า: โดยทั่วไปแล้ววิธีที่ดีที่สุดที่จะใช้เส้นทางบัฟเฟอร์บิตแมปที่กำหนดเองหรือเป็นการดีที่สุดที่จะปล่อยให้การแสดงผลไปยังเอ็นจิ้นแฟลช หากคุณใช้ภาพเคลื่อนไหวเวกเตอร์MovieClipซึ่งต่างจากสไปรต์นั่นจะเปลี่ยนคำตอบข้างต้นหรือไม่? ถ้าเป็นเช่นนั้นเป็นวิธีปฏิบัติที่ดีที่สุดในการใช้ภาพเคลื่อนไหวแบบผี (ฉันกำหนดเป้าหมายเป็น Flash 10 หากสร้างความแตกต่าง)

11 flash  optimization  sprites  performance 

ส่วนหนึ่งเพื่อประโยชน์ในการเพิ่มประสิทธิภาพส่วนหนึ่งเพื่อจุดประสงค์ในการเรียนรู้ฉันจะกล้าถาม: ฉันจะตรวจสอบได้อย่างมีประสิทธิภาพมากที่สุดว่าจุด 2D นั้นPอยู่ในสี่เหลี่ยมหมุนรอบสองมิติXYZWโดยใช้ C # หรือ C ++ อย่างไร ขณะนี้สิ่งที่ฉันกำลังทำคือการใช้อัลกอริทึม "จุดเป็นรูปสามเหลี่ยม" ที่พบในหนังสือการตรวจหาการชนกันแบบเรียลไทม์และเรียกใช้สองครั้ง (สำหรับสามเหลี่ยมสองรูปที่ประกอบเป็นสี่เหลี่ยมพูด XYZ และ XZW): bool PointInTriangle(Vector2 A, Vector2 B, Vector2 C, Vector2 P) { // Compute vectors Vector2 v0 = C - A; Vector2 v1 = B - A; Vector2 v2 = P - A; // Compute …

11 c#  collision-detection  geometry  optimization