การเรนเดอร์ / การแรเงาเป็นไปได้ด้วย OpenGL ES 2.0 หรือไม่

ฉันถามสิ่งนี้ในStackOverflowแต่อาจเหมาะสมกว่าที่นี่:

มีใครใช้การเรนเดอร์ / การแรเงาภายใต้ OpenGL ES 2.0 หรือไม่ ไม่รองรับ MRTs ด้วยบัฟเฟอร์สีเดียวมันไม่ใช่สิ่งที่สามารถนำมาใช้ในลักษณะ "ปกติ"

โดยเฉพาะฉันกำลังสำรวจบน iPad, iPhone4 (maaaybe iPhone 3gs) และ Android ในแอป GLESView บน iPad / iPhone4 / iPhone3gs มีส่วนขยาย GL_OES_RGB8_RGBA8 อยู่และฉันยังไม่ได้ดูลึกเกินไป แต่ด้วย 8 บิต / ช่องแนวคิดนี้น่าสนใจ: http://www.gamedev.net/topic/ 562138-OpenGL ES--20-และรอการตัดบัญชี-แรเงา /

ความคิดอื่น ๆ ? มันคุ้มค่าที่จะทำประสิทธิภาพที่ชาญฉลาด?

ใช่มันเป็นไปได้ อย่างไรก็ตามมันไม่คุ้มค่าอย่างยิ่ง

ประการแรกถ้าคุณมีการเข้าถึงการขยาย NV_draw_buffers (เป็นชื่อที่มีความหมายก็คือ NVIDIA เท่านั้น. ดังนั้นถ้าคุณกำลังทำงานอยู่บน Tegra, คุณไม่ได้มีมัน) framebuffer วัตถุภายใต้ ES 2.0 เท่านั้นที่สามารถแสดงผลการหนึ่งภาพ ขณะนั้น. ดังนั้นในการสร้าง G-buffers ของคุณคุณจะต้องแสดงฉากของคุณหลาย ๆ ครั้งดังนั้นจึงลดข้อดีข้อเสียของการเรนเดอร์

ประการที่สองแบนด์วิดท์บนแพลตฟอร์มมือถือนั้นไม่เหมือนกับที่คุณเคยได้รับใน GPU ระดับกลาง และแบนด์วิดธ์มีความสำคัญต่อการเรนเดอร์เรนเดอร์ หากไม่มีแบนด์วิดท์นั้นแสงก็จะผ่านไปเจ็บจริงประสิทธิภาพ

ประการที่สามฮาร์ดแวร์ PowerVR ไม่ได้ออกแบบมาสำหรับสิ่งนี้ มันปรับการเรนเดอร์ด้วยฮาร์ดแวร์การเรนเดอร์แบบไทล์ ดังนั้นการเรนเดอร์ที่เลื่อนออกไปจะเป็นประโยชน์น้อยกว่าในสถาปัตยกรรมการแปลงสแกนแบบดั้งเดิม

ปัญหาหลักคือการกรอก สำหรับ GPU มือถืออัตราการส่งข้อมูลของคุณอยู่ในระดับต่ำซึ่งคุณไม่สามารถใช้การแรเงาแบบ Deferred ได้แบบเรียลไทม์ที่ความละเอียดมาตรฐาน

สำหรับ iPhone 4 และ iPad 1 การเติมเต็มนั้นไร้สาระ IOS อุปกรณ์เดียวที่มีการกรอกข้อมูลที่ดีคือ iPad 2 แต่ฉันสงสัยว่ามีเพียงพอ ... สำหรับ Android อุปกรณ์ Tegra เท่านั้นที่มี GL_NV_draw_buffers เพื่อใช้ MRT แต่การเติมนั้นก็ต่ำมากเช่นกัน ดูเหมือนว่ามาลี 400 จะมีสิ่งที่ดีที่สุด หากคุณต้องการร้องไห้เพียงลองเติมสี่เหลี่ยมสีที่ความละเอียดเต็มหน้าจอ 4 ครั้ง ... อุปกรณ์จำนวนมากไม่สามารถทำได้ 60 fps

บน GPU เดสก์ท็อปคุณมี 10 ครั้ง (หรือมากกว่า) ในการเติมเป็น gpus สำหรับมือถือ อย่าลืมว่า GPU บนมือถือใช้หน่วยความจำเดียวกับ CPU และคุณไม่มีหน่วยความจำเฉพาะ

มีบางตัวอย่างใน WebGL (API เดียวกัน) ดังนั้นจึงไม่มีข้อ จำกัด ของ API

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

ฉันจะใช้รูปแบบ GBuffer ต่อไปนี้:

• นำบัฟเฟอร์ความลึกกลับมาใช้ใหม่สำหรับการให้แสงผ่านไม่แน่ใจว่าอุปกรณ์มือถือนี้รองรับการใช้งานได้อย่างกว้างขวางเพียงใด
• เนื้อ GBuffer เดียวข้างในนั้นฉันจะเก็บไว้: Normal U, Normal V, Param 0, Param 1 การเข้ารหัส Lambert-Azimuthal นั้นดูดีมากสำหรับบรรทัดฐานและบีบอัดให้เป็นสององค์ประกอบซึ่งค่อนข้างถูกในการเข้ารหัสและถอดรหัสเช่นกัน
• ตัวแปรสองตัวสำหรับตัวแปรไฟส่องสว่างเป็นจำนวนมากสามารถใช้หนึ่งค่าเป็นตัวนับสำหรับฟังก์ชั่นแสงหลายตัวหากฮาร์ดแวร์ทำงานได้ดีกับการแยกสาขาแบบไดนามิก

แสงที่เลื่อนออกไปนั้นคล้ายกับการเรนเดอร์ยกเว้นคุณแสดงฉากสองครั้ง:

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

เกี่ยวกับการจัดเก็บผลแสง ฉันชอบเก็บสีแบบกระจายและความส่องแสงแบบพิเศษเพื่อให้บัฟเฟอร์การสะสมต้องเป็นพื้นผิวสีแบบ 32 บิตมาตรฐานเท่านั้น คุณสามารถประมาณสี specular ได้โดยการคำนวณ chroma ของ diffuse color และรวมเข้ากับ specular luminance

แต่ส่วนที่สำคัญที่สุดคือการใช้บัฟเฟอร์ความลึกลายฉลุเพื่อให้เต็มตรวจสอบให้แน่ใจว่าคุณไม่ได้แสดงรหัสแสงใด ๆ ที่ไม่จำเป็น ฉันยังต้องเพิ่มงบทิ้งลงในส่วนที่แตกออกซึ่งจะลดการมองเห็นแสงด้านล่างช่วงที่แสดงของอุปกรณ์ (1e-3 มักจะเป็นทางลัดที่ปลอดภัย)

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

เทคนิคนี้ใช้เพื่อลดขนาดของ G-Buffer เนื่องจากต้องการคุณลักษณะน้อยลง นอกจากนี้ยังซื้อข้อดีให้คุณซึ่ง G-Buffer และ lightmap ของพื้นที่หน้าจออาจมีความละเอียดต่ำกว่าหน้าจอ

ฉันใช้ตัวแสดงผลที่อิงตาม GLES 2.0 อย่างเข้มงวด (แม้ว่าจะเป็นรุ่นทดลอง) และฉันจัดการต้ม G-Buffer ลงไปที่พื้นผิว RGBA หนึ่งอัน (ใช่ฉันใช้ texture2D แทนที่จะเป็น renderbuffer) มันบรรจุแผนที่ปกติของพื้นที่หน้าจอ + บัฟเฟอร์ความลึกในช่องอัลฟา (ซึ่งถูกบีบอัดโดยใช้ลอการิทึมเท่าที่ฉันจำได้)

คุณลักษณะตำแหน่ง (เรียกว่าโลกที่นี่) สามารถคำนวณได้ในระหว่างการส่องผ่านแสงโดยใช้ความจริงซึ่งในมุมมองของปริพันธ์นั้น. xiถูกเบี่ยงเบนโดย. zดังนั้น:

ฉันประมาณค่าตำแหน่งของxyโดยทำ:

หมายเหตุ: ฉันต้องทำการปรับเปลี่ยนเพิ่มเติมตามการตั้งค่าเมทริกซ์การฉาย

นอกจากนี้ยังมีข้อสังเกตว่าฉันสามารถตัดส่วนประกอบ. zของเวกเตอร์ปกติได้เนื่องจากฉันสามารถสร้าง. zจาก . xy ได้อีกครั้งเนื่องจากเวกเตอร์ปกติถูกทำให้เป็นมาตรฐานเพื่อให้:

การใช้เทคนิคนี้ฉันสามารถเพิ่มช่องสัญญาณอื่นใน RGBA G-Buffer ของฉันและใช้วิธีนี้เพื่อจัดเก็บพื้นที่หน้าจอ specular-map (หรือความมันวาวถ้าคุณต้องการ)

ใช่มันเป็นไปได้อย่างแน่นอน อัตราการส่งสัญญาณไม่ใช่ปัญหาดังกล่าวเนื่องจากชิปกราฟิกมือถือออกแบบมาเพื่อจัดการกับหน้าจอความละเอียดสูงมาก อันที่จริงแล้วการเรนเดอร์ช่วยด้วยสิ่งนี้เพราะการคำนวณแสงของคุณไม่ขึ้นกับความซับซ้อนของฉากดังนั้นการถอนออกมากเกินไปจะไม่ทำให้เกิดความล่าช้า นี่คือการดำเนินการของฉันใน iPad รุ่นที่สี่: http://www.youtube.com/watch?v=K4X1oF6b4V8

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

ชิปกราฟิกมือถือทำได้ดีในการเรนเดอร์เนื่องจากวิธีการจัดการเรนเดอร์ to-texture ซึ่งแตกต่างจากการ์ดกราฟิก PC ซึ่งโดยทั่วไปจะได้รับผลกระทบอย่างมากเมื่อคุณเริ่มแสดงผลเป็นพื้นผิวแทนบริบทหน้าต่างกราฟิกมือถือได้รับการออกแบบมาเพื่อทำสิ่งนี้โดยไม่กระทบประสิทธิภาพ ดังนั้นคุณจะได้รับความสามารถในการปรับขยายของตัวแสดงผลที่เลื่อนออกไปโดยไม่มีการลงโทษขั้นต้นที่คุณจะได้รับจากการ์ดกราฟิกเดสก์ท็อป

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