ฉันจะปรับปรุงความเร็วการเรนเดอร์ของเกมประเภท Voxel / Minecraft ได้อย่างไร?

ฉันกำลังเขียนโคลนของ Minecraft เอง (เขียนด้วยภาษาจาวา) มันใช้งานได้ดีในขณะนี้ ด้วยระยะการดู 40 เมตรฉันสามารถกด 60 FPS บน MacBook Pro 8,1 ได้อย่างง่ายดาย (Intel i5 + Intel HD Graphics 3000) แต่ถ้าฉันวางระยะทางในการมองที่ 70 เมตรฉันจะไปถึง 15-25 FPS ใน Minecraft ตัวจริงฉันสามารถใส่ความไม่ลงรอยกันในการมองไกล (= 256m) ได้โดยไม่มีปัญหา ดังนั้นคำถามของฉันคือฉันควรทำอย่างไรเพื่อทำให้เกมของฉันดีขึ้น?

การเพิ่มประสิทธิภาพที่ฉันใช้:

• เก็บเฉพาะชิ้นส่วนในหน่วยความจำเท่านั้น (ขึ้นอยู่กับระยะการมองของผู้เล่น)
• Frustum culling (ครั้งแรกบนชิ้นแล้วบนบล็อก)
• วาดเฉพาะใบหน้าที่มองเห็นได้จริงๆของบล็อกเท่านั้น
• ใช้รายการต่ออันที่มีบล็อกที่มองเห็นได้ ส่วนที่มองเห็นได้จะเพิ่มเข้าไปในรายการนี้ หากพวกเขากลายเป็นล่องหนพวกเขาจะถูกลบออกจากรายการนี้โดยอัตโนมัติ บล็อกกลายเป็น (ใน) มองเห็นได้โดยการสร้างหรือทำลายบล็อกเพื่อนบ้าน
• การใช้รายการต่ออันประกอบด้วยบล็อกการปรับปรุง กลไกเดียวกับรายการบล็อกที่มองเห็นได้
• ใช้newคำสั่งแทบไม่มีในลูปเกม (เกมของฉันทำงานประมาณ 20 วินาทีจนกระทั่งตัวรวบรวมข้อมูลขยะถูกเรียกใช้)
• ฉันใช้รายการโทร OpenGL ในขณะนี้ ( glNewList(), glEndList(), glCallList()) สำหรับแต่ละด้านของชนิดของบล็อก

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

มีเทคนิคอื่น ๆ เพื่อปรับปรุงประสิทธิภาพหรือไม่?

การทำโปรไฟล์ VisualVM แสดงให้ฉันเห็น (การทำโปรไฟล์สำหรับ 33 เฟรมเท่านั้นด้วยระยะการดู 70 เมตร):

การทำโปรไฟล์ 40 เมตร (246 เฟรม):

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

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

ฉันคิดว่ามันค่อนข้างชัดเจนว่าselectVisibleBlocksเป็นปัญหาที่นี่

ขอบคุณล่วงหน้า!
Martijn

อัปเดต : หลังจากการปรับปรุงพิเศษบางอย่าง (เช่นการใช้ลูปแทนแต่ละตัวการกำหนดบัฟเฟอร์ตัวแปรภายนอกลูป ฯลฯ ... ) ตอนนี้ฉันสามารถเรียกใช้ระยะการดู 60 ได้ค่อนข้างดี

ฉันคิดว่าฉันจะใช้ VBO โดยเร็วที่สุด

PS: ซอร์สโค้ดทั้งหมดมีอยู่ใน GitHub:
https://github.com/mcourteaux/CraftMania

คุณพูดถึงการทำ frustum คัดสรรในแต่ละบล็อก - ลองโยนที่ ชิ้นเรนเดอร์ส่วนใหญ่ควรมองเห็นได้อย่างสมบูรณ์หรือมองไม่เห็น

Minecraft สร้างใหม่เฉพาะรายการที่แสดง / บัฟเฟอร์จุดสุดยอด (ฉันไม่รู้ว่ามันใช้อะไร) เมื่อบล็อกถูกแก้ไขในกลุ่มที่กำหนดและฉันก็เช่นกัน หากคุณกำลังแก้ไขรายการแสดงผลทุกครั้งที่มีการเปลี่ยนแปลงมุมมองคุณจะไม่ได้รับประโยชน์จากรายการแสดงผล

นอกจากนี้คุณดูเหมือนจะใช้ชิ้นส่วนที่มีความสูงระดับโลก โปรดทราบว่า Minecraft ใช้ลูกบาศก์ขนาด 16 × 16 × 16 สำหรับรายการแสดงผลซึ่งแตกต่างจากโหลดและบันทึก หากคุณทำเช่นนั้นมีเหตุผลที่น้อยกว่าที่จะคัดชิ้นส่วนบุคคล

(หมายเหตุ: ฉันยังไม่ได้ตรวจสอบรหัสของ Minecraft ข้อมูลทั้งหมดนี้เป็นข่าวลือหรือข้อสรุปของฉันเองจากการสังเกตการแสดงผลของ Minecraft ขณะที่ฉันเล่น)

คำแนะนำทั่วไปเพิ่มเติม:

โปรดจำไว้ว่าการเรนเดอร์ของคุณดำเนินการกับโปรเซสเซอร์สองตัว: CPU และ GPU เมื่ออัตราเฟรมของคุณไม่เพียงพอหนึ่งในนั้นคือทรัพยากรที่ จำกัด - โปรแกรมของคุณเป็นCPU-boundหรือGPU-bound (สมมติว่ามันไม่ได้แลกเปลี่ยนหรือมีปัญหาเกี่ยวกับการตั้งเวลา)

หากโปรแกรมของคุณทำงานที่ CPU 100% (และไม่มีงานอื่นที่ไม่เสร็จสมบูรณ์) แสดงว่า CPU ของคุณทำงานหนักเกินไป คุณควรพยายามทำให้ภารกิจง่ายขึ้น (เช่นลดการคัดทิ้งน้อยลง) เพื่อแลกกับการทำให้ GPU ทำงานได้มากขึ้น ฉันสงสัยอย่างยิ่งว่านี่เป็นปัญหาของคุณเนื่องจากคำอธิบายของคุณ

ในทางกลับกันหาก GPU มีขีด จำกัด (น่าเศร้ามักจะไม่สะดวกในการตรวจสอบโหลด 0% -100%) คุณควรคิดถึงวิธีการส่งข้อมูลให้น้อยลงหรือต้องการเติมพิกเซลให้น้อยลง

Vec3f.set เรียกอะไรมาก หากคุณกำลังสร้างสิ่งที่คุณต้องการให้แสดงตั้งแต่เริ่มต้นแต่ละเฟรมนั่นคือจุดที่คุณต้องการเริ่มต้นให้เร็วขึ้น ฉันไม่ได้เป็นผู้ใช้ OpenGL มากนักและฉันไม่ค่อยรู้ว่า Minecraft วาทกรรมอย่างไร แต่ดูเหมือนว่าฟังก์ชันทางคณิตศาสตร์ที่คุณใช้กำลังฆ่าคุณในตอนนี้ (แค่ดูว่าคุณใช้เวลากับพวกเขามากแค่ไหนและจำนวนครั้ง) พวกเขาถูกเรียก - ความตายด้วยการบาดพันครั้งเรียกพวกเขา)

เป็นการดีที่โลกของคุณจะถูกแบ่งกลุ่มเพื่อให้คุณสามารถจัดกลุ่มสิ่งของเพื่อแสดงผลร่วมกันสร้าง Vertex Buffer Objects และนำกลับมาใช้ใหม่ในหลาย ๆ เฟรม คุณจะต้องแก้ไข VBO หากโลกนั้นแสดงถึงการเปลี่ยนแปลงอย่างใด (เช่นผู้ใช้แก้ไข) จากนั้นคุณสามารถสร้าง / ทำลาย VBO สำหรับสิ่งที่คุณเป็นตัวแทนในขณะที่มองเห็นได้เพื่อลดการใช้หน่วยความจำคุณจะได้รับความนิยมเมื่อ VBO ถูกสร้างขึ้นมากกว่าทุกเฟรม

หากการนับ "เรียกใช้" นั้นถูกต้องในโปรไฟล์ของคุณคุณกำลังโทรหาหลายสิ่งหลายอย่างที่แย่มาก ๆ (10 ล้านสายไปที่ Vec3f.set ... อุ๊ย!)

คำอธิบายของฉัน (จากการทดลองของฉันเอง) ที่นี่ใช้ได้:

สำหรับการเรนเดอร์ voxel จะมีประสิทธิภาพมากขึ้น: VBO ที่สร้างไว้ล่วงหน้าหรือ shader เรขาคณิต

Minecraft และรหัสของคุณน่าจะใช้ฟังก์ชั่นคงที่ ความพยายามของฉันเองได้อยู่กับ GLSL แต่โดยทั่วไปแล้วฉันรู้สึกว่า:

(จากหน่วยความจำ) ฉันสร้าง frustum ที่มีขนาดครึ่งบล็อกใหญ่กว่า frustum ของหน้าจอ จากนั้นฉันทดสอบจุดศูนย์กลางของแต่ละก้อน ( minecraft มีบล็อก 16 * 16 * 128 )

ใบหน้าในแต่ละหน้ามีช่วง VBO แบบองค์ประกอบ (ใบหน้าจำนวนมากจากชิ้นส่วนแบ่งปัน VBO เดียวกันจนกว่าจะเป็น 'เต็ม'; คิดเช่นmallocนั้นกับพื้นผิวเดียวกันใน VBO เดียวกันที่เป็นไปได้) และดัชนีจุดสุดยอดสำหรับทางทิศเหนือ ใบหน้า, ใบหน้าใต้และอื่น ๆ อยู่ติดกันมากกว่าแบบผสม เมื่อฉันวาดฉันทำglDrawRangeElementsเพื่อใบหน้าเหนือโดยปกติฉายแล้วและปกติในเครื่องแบบ จากนั้นฉันก็หันไปทางทิศใต้และอื่น ๆ ดังนั้นบรรทัดฐานไม่ได้อยู่ใน VBO ใด ๆ สำหรับแต่ละก้อนฉันต้องปล่อยใบหน้าที่จะมองเห็นได้ - เฉพาะใบหน้าที่อยู่ตรงกลางของหน้าจอเท่านั้นที่จะต้องวาดด้านซ้ายและขวาเช่น ง่ายGL_CULL_FACEในระดับแอปพลิเคชัน

การเร่งความเร็วที่ใหญ่ที่สุดคือ iirc ถูกกำจัดใบหน้าด้านในเมื่อทำการเรียงหลาย ๆ อัน

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

เห็นได้ชัดว่าคุณมีรูปหลายเหลี่ยมชิ้นเท่านั้นที่เคยเห็นคุณอาจทิ้งชิ้นที่ไม่ได้ปรากฏมาเป็นเวลานานและคุณรูปหลายเหลี่ยมชิ้นที่แก้ไข (เช่นนี้เป็นเหตุการณ์ที่เกิดขึ้นน้อยเมื่อเทียบกับการแสดงผล)

การเปรียบเทียบทั้งหมดของคุณBlockDistanceComparatorมาจากไหน ถ้ามันมาจากฟังก์ชั่นการจัดเรียงนั้นจะถูกแทนที่ด้วยการเรียงลำดับแบบ Radix (ซึ่ง asymptotically เร็วกว่าและไม่ใช่การเปรียบเทียบตาม)

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

struct DistanceIndexPair
{
    float m_distanceSquaredFromOrigin;
    int m_index;
};

แล้วใน pseudoCode

// for i = 0..numBlocks
//     distanceIndexPairs[i].m_distanceSquaredFromOrigin = ...;
///    distanceIndexPairs[i].m_index = i;
// sort distanceIndexPairs
// for i = 0..numBlocks
//    sortedBlock[i] = unsortedBlocks[ distanceIndexPairs.m_index ]

ขออภัยหากนั่นไม่ใช่โครงสร้าง Java ที่ถูกต้อง (ฉันไม่ได้แตะ Java ตั้งแต่ระดับปริญญาตรี) แต่หวังว่าคุณจะเข้าใจ

ใช่ใช้ VBOs และ CULL หันหน้าเข้าหา แต่นั่นก็ทำให้เกมทุกเกม สิ่งที่คุณต้องการจะทำคือการแสดงผลลูกบาศก์หากผู้เล่นมองเห็นได้และหากบล็อกสัมผัสในวิธีเฉพาะ (สมมติว่าก้อนที่คุณมองไม่เห็นเพราะมันอยู่ใต้ดิน) คุณเพิ่มจุดยอดของบล็อกและสร้าง มันเกือบจะเหมือน "บล็อกที่ใหญ่กว่า" หรือในกรณีของคุณ - อัน สิ่งนี้เรียกว่าการโลภแบบตาข่ายและเพิ่มประสิทธิภาพอย่างมาก ฉันกำลังพัฒนาเกม (ใช้ voxel) และใช้อัลกอริธึมแบบโลภ

แทนที่จะแสดงทุกอย่างเช่นนี้

มันแสดงผลแบบนี้:

ข้อเสียของสิ่งนี้คือคุณต้องทำการคำนวณเพิ่มเติมต่อชิ้นในการสร้างโลกครั้งแรกหรือหากผู้เล่นลบ / เพิ่มบล็อก

เครื่องยนต์ voxel ประเภทใดต้องการสิ่งนี้เพื่อประสิทธิภาพที่ดี

สิ่งที่ต้องทำคือตรวจสอบเพื่อดูว่าใบหน้าบล็อกกำลังสัมผัสใบหน้าบล็อกอื่นหรือไม่และหากเป็นเช่นนั้นให้แสดงผลเป็นหน้าบล็อกเดียวเท่านั้น (หรือศูนย์) มันเป็นสัมผัสที่มีราคาแพงเมื่อคุณแสดงผลชิ้นเร็วจริงๆ

public void greedyMesh(int p, BlockData[][][] blockData){
        boolean[][][][] mask = new boolean[blockData.length][blockData[0].length][blockData[0][0].length][6];

    for(int side=0; side<6; side++){
        for(int x=0; x<blockData.length; x++){
            for(int y=0; y<blockData[0].length; y++){
                for(int z=0; z<blockData[0][0].length; z++){
                    if(data[x][y][z] > Material.AIR && !mask[x][y][z][side] && blockData[x][y][z].faces[side]){
                        if(side == 0 || side == 1){
                            int width = 0;
                            int height = 0;
                            loop:
                            for(int i=y; i<blockData[0].length; i++){
                                if(i == y){
                                    for(int j=z; j<blockData[0][0].length; j++){
                                        if(!mask[x][i][j][side] && blockData[x][i][j].id == blockData[x][y][z].id && blockData[x][i][j].faces[side]){
                                            width++;
                                        }else{
                                            break;
                                        }
                                    }
                                }else{
                                    for(int j=0; j<width; j++){
                                        if(mask[x][i][z+j][side] || blockData[x][i][z+j].id != blockData[x][y][z].id || !blockData[x][i][z+j].faces[side]){
                                            break loop;
                                        }
                                    }
                                }
                                height++;
                            }
                            for(int i=0; i<height; i++){
                                for(int j=0; j<width; j++){
                                    mask[x][y+i][z+j][side] = true;
                                }
                            }

                            if(side == 0)
                                meshes.get(p).add(new Mesh(new VoxelVector3i(x+1, y, z), new VoxelVector3i(x+1, y+height, z+width), new VoxelVector3i(1, 0, 0), Material.getColor(data[x][y][z])));
                            else
                                meshes.get(p).add(new Mesh(new VoxelVector3i(x, y, z+width), new VoxelVector3i(x, y+height, z), new VoxelVector3i(-1, 0, 0), Material.getColor(data[x][y][z])));
                        }else if(side == 2 || side == 3){
                            int width = 0;
                            int height = 0;
                            loop:
                            for(int i=x; i<blockData.length; i++){
                                if(i == x){
                                    for(int j=z; j<blockData[0][0].length; j++){
                                        if(!mask[i][y][j][side] && blockData[i][y][j].id == blockData[x][y][z].id && blockData[i][y][j].faces[side]){
                                            width++;
                                        }else{
                                            break;
                                        }
                                    }
                                }else{
                                    for(int j=0; j<width; j++){
                                        if(mask[i][y][z+j][side] || blockData[i][y][z+j].id != blockData[x][y][z].id || !blockData[i][y][z+j].faces[side]){
                                            break loop;
                                        }
                                    }
                                }
                                height++;
                            }
                            for(int i=0; i<height; i++){
                                for(int j=0; j<width; j++){
                                    mask[x+i][y][z+j][side] = true;
                                }
                            }

                            if(side == 2)
                                meshes.get(p).add(new Mesh(new VoxelVector3i(x, y+1, z+width), new VoxelVector3i(x+height, y+1, z), new VoxelVector3i(0, 1, 0), Material.getColor(data[x][y][z])));
                            else
                                meshes.get(p).add(new Mesh(new VoxelVector3i(x+height, y, z+width), new VoxelVector3i(x, y, z), new VoxelVector3i(0, -1, 0), Material.getColor(data[x][y][z])));
                        }else if(side == 4 || side == 5){
                            int width = 0;
                            int height = 0;
                            loop:
                            for(int i=x; i<blockData.length; i++){
                                if(i == x){
                                    for(int j=y; j<blockData[0].length; j++){
                                        if(!mask[i][j][z][side] && blockData[i][j][z].id == blockData[x][y][z].id && blockData[i][j][z].faces[side]){
                                            width++;
                                        }else{
                                            break;
                                        }
                                    }
                                }else{
                                    for(int j=0; j<width; j++){
                                        if(mask[i][y+j][z][side] || blockData[i][y+j][z].id != blockData[x][y][z].id || !blockData[i][y+j][z].faces[side]){
                                            break loop;
                                        }
                                    }
                                }
                                height++;
                            }
                            for(int i=0; i<height; i++){
                                for(int j=0; j<width; j++){
                                    mask[x+i][y+j][z][side] = true;
                                }
                            }

                            if(side == 4)
                                meshes.get(p).add(new Mesh(new VoxelVector3i(x+height, y, z+1), new VoxelVector3i(x, y+width, z+1), new VoxelVector3i(0, 0, 1), Material.getColor(data[x][y][z])));
                            else
                                meshes.get(p).add(new Mesh(new VoxelVector3i(x, y, z), new VoxelVector3i(x+height, y+width, z), new VoxelVector3i(0, 0, -1), Material.getColor(data[x][y][z])));
                        }
                    }
                }
            }
        }
    }
}

ดูเหมือนว่ารหัสของคุณจะจมอยู่ในวัตถุและการเรียกใช้ฟังก์ชัน การหาตัวเลขดูเหมือนจะไม่เกิดอะไรขึ้น

คุณสามารถลองหาสภาพแวดล้อม Java ที่แตกต่างกันหรือเพียงแค่ยุ่งกับการตั้งค่าที่คุณมี แต่วิธีที่เรียบง่ายและเรียบง่ายในการสร้างโค้ดของคุณไม่ใช่เร็ว แต่การจัดการที่ช้าน้อยลงอย่างน้อยภายใน Vec3f หยุดอย่างน้อย การเข้ารหัส OOO * ทำให้ทุกวิธีประกอบด้วยตัวเองอย่าเรียกวิธีอื่นใด ๆ เพียงเพื่อทำงานที่ไม่ได้ใช้งาน

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

* วางวัตถุมากเกินไป

คุณสามารถลองแบ่งการดำเนินการทางคณิตศาสตร์ให้เหลือผู้ประกอบการระดับบิตได้ หากคุณมีความพยายามที่จะทำให้ผู้ประกอบการค่าที่เหมาะสม:128 / 16 128 << 4สิ่งนี้จะช่วยได้มากกับปัญหาของคุณ อย่าพยายามทำให้ทุกอย่างทำงานได้อย่างเต็มประสิทธิภาพ ทำการอัปเดตเกมของคุณในอัตรา 60 หรืออะไรสักอย่างและแม้แต่ทำลายมันลงเพื่อสิ่งอื่น ๆ แต่คุณต้องทำลายและวาง voxels มิฉะนั้นคุณจะต้องทำรายการสิ่งที่ต้องทำซึ่งจะทำให้ fps ของคุณต่ำลง คุณสามารถอัปเดตอัตราประมาณ 20 รายการสำหรับเอนทิตี และบางอย่างเช่น 10 สำหรับการอัปเดตและหรือรุ่นของโลก