All GPUs used in iOS devices use ti

All GPUs used in iOS devices use tile-based deferred rendering (TBDR). When you call OpenGL ES functions to submit rendering commands to the hardware, the commands are buffered until a large list of commands is accumulated. The hardware renders these commands as a single operation by dividing the framebuffer into tiles and then drawing the commands once for each tile, with each tile rendering only the primitives that are visible within it. The key advantage to a deferred renderer is that it accesses memory very efficiently. Partitioning rendering into tiles allows the GPU to more effectively cache the pixel values from the framebuffer, making depth testing and blending more efficient.

Deferred rendering also allows the GPU to perform hidden surface removal before fragments are processed. Pixels that are not visible are discarded without sampling textures or performing fragment processing, significantly reducing the calculations that the GPU must perform to render the tile. To gain the most benefit from this feature, draw as much of the frame with opaque content as possible and minimize use of blending, alpha testing, and the discard instruction in GLSL shaders. Because the hardware performs hidden surface removal, it is not necessary for your app to sort primitives from front to back.

Some operations under a deferred renderer are more expensive than they would be under a traditional stream renderer. For example, the memory bandwidth and computational savings described above perform best when processing large scenes. But when the hardware receives OpenGL ES commands that require it to render smaller scenes, the renderer loses much of its efficiency. For example, if your app renders batches of triangles using a texture and then modifies the texture, the OpenGL ES implementation must either flush out those commands immediately or duplicate the texture—neither option uses the hardware efficiently. Similarly, any attempt to read pixel data from the framebuffer requires that preceding commands be processed if they would alter that framebuffer.

Apple A7 GPU Hardware

The Apple A7 GPU is a new generation of graphics hardware with support for OpenGL ES 3.0. OpenGL ES 3.0 incorporates many features previously available in OpenGL ES 2.0 in iOS. But it also incorporates many new features, such as multiple render targets and transform feedback, that have not been available on mobile processors before. This means that advanced rendering techniques that have previously been available only on desktop machines, such as deferred rendering, can now be used in iOS apps.

To take advantage of the power of the A7 GPU, your app must support OpenGL ES 3.0. Using OpenGL ES 3.0 gives you access to the new features and also to a larger pool of rendering resources. For example, on the A7 GPU, an app that uses OpenGL ES 3.0 can access twice as many textures in a shader than an app that uses OpenGL ES 2.0.

ผลลัพธ์ (ไทย) 1:

GPUs ทั้งหมดที่ใช้ในอุปกรณ์ iOS ใช้ยึดกระเบื้องเลื่อนเวลาจำลอง (TBDR) เมื่อคุณเรียกใช้ฟังก์ชัน OpenGL ES ต้องแสดงคำสั่งการฮาร์ดแวร์ คำสั่งเป็น buffered จนสะสมรายการคำสั่งขนาดใหญ่ ฮาร์ดแวร์ทำให้คำสั่งเหล่านี้เป็นการดำเนินการเดียว โดยแบ่ง framebuffer กระเบื้องแล้ว วาดคำสั่งหนึ่งครั้งสำหรับแต่ละแผ่น กับกระเบื้องแต่ละแสดงนำที่มองเห็นภายใน ประโยชน์สำคัญที่ตัวเลื่อนเวลาได้ว่า จะเข้าถึงหน่วยความจำอย่างมีประสิทธิภาพ สีแบ่งพาร์ติชันเป็นกระเบื้องทำให้ GPU เพื่อค่าพิกเซลจาก framebuffer ทำให้ความลึกของการทดสอบ และการผสมผสานประสิทธิภาพของแคชได้อย่างมีประสิทธิภาพ

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

บางการดำเนินงานภายใต้การสร้างภาพเลื่อนเวลามีราคาแพงมากขึ้นกว่าที่พวกเขาจะอยู่ภายใต้กระแสข้อมูลแบบจำลอง ตัวอย่าง แบนด์วิดธ์หน่วยความจำและคำนวณประหยัดข้างทำส่วนฉากขนาดใหญ่การประมวลผล แต่เมื่อฮาร์ดแวร์ได้รับคำสั่ง OpenGL ES ที่ต้องแสดงฉากเล็ก การสร้างภาพการสูญเสียมากประสิทธิภาพของ ตัวอย่างเช่น ถ้า app ของคุณทำให้ชุดของสามเหลี่ยมที่ใช้เป็นพื้นผิว และจากนั้น ปรับเปลี่ยนพื้นผิว ใช้งาน OpenGL ES ต้องล้างออกคำสั่งดังกล่าวทันที หรือซ้ำพื้นผิว — เลือกไม่ใช้ฮาร์ดแวร์ได้อย่างมีประสิทธิภาพ ในทำนองเดียวกัน การอ่านข้อมูลพิกเซลจาก framebuffer ต้องที่อยู่ก่อนหน้าคำสั่งประมวลผลถ้าพวกเขาจะเปลี่ยน framebuffer ที่

ฮาร์ดแวร์ GPU A7 แอปเปิ้ล

GPU A7 แอปเปิ้ลเป็นรุ่นใหม่ของฮาร์ดแวร์กราฟิกด้วยการสนับสนุนสำหรับ OpenGL ES 3.0 OpenGL ES 3.0 ประกอบด้วยคุณลักษณะหลายอย่างที่เคยมีใน OpenGL ES 2.0 ใน iOS แต่มันยังประกอบด้วยหลายคุณลักษณะใหม่ หลายเป้าหมายให้ผลลัพธ์และผลป้อนกลับแปลง ที่ไม่มีพร้อมใช้งานบนโปรเซสเซอร์ก่อน นี้หมายความว่าขั้นสูงเทคนิคการเรนเดอร์ที่ก่อนหน้านี้มีอยู่ในเครื่องเดสก์ท็อป เช่นเลื่อนเวลาแสดง ตอนนี้ใช้ใน iOS ปพลิเคชันได้

การใช้ประโยชน์จากพลังของ A7 GPU, app ของคุณต้องสนับสนุน OpenGL ES 3.0 ได้ ใช้ OpenGL ES 3.0 ช่วยให้คุณเข้า ถึงคุณลักษณะใหม่ และสระว่ายน้ำขนาดใหญ่ของทรัพยากรการแสดงผล ตัวอย่าง บน A7 GPU app ที่ใช้ OpenGL ES 3.0 สามารถเข้าถึงพื้นผิวที่สองเป็นจำนวนมากใน shader กว่า app ที่ใช้ OpenGL ES 2.0 ได้

ผลลัพธ์ (ไทย) 2:

GPUs ทั้งหมดที่ใช้ในอุปกรณ์ iOS ที่ใช้กระเบื้องที่ใช้การแสดงผลรอการตัดบัญชี (TBDR) เมื่อคุณเรียกใช้ฟังก์ชัน OpenGL ES ที่จะส่งคำสั่งไปยังการแสดงผลฮาร์ดแวร์คำสั่งจะถูกบัฟเฟอร์จนกว่ารายการใหญ่ของคำสั่งที่จะถูกสะสม ฮาร์ดแวร์ทำให้คำสั่งเหล่านี้เป็นงานเดียวโดยการหาร framebuffer เป็นกระเบื้องแล้ววาดภาพคำสั่งครั้งเดียวสำหรับแต่ละกระเบื้องกับการแสดงผลกระเบื้องแต่ละเพียงพื้นฐานที่มองเห็นได้ภายใน ข้อได้เปรียบที่สำคัญในการ renderer รอการตัดบัญชีที่จะเข้าถึงหน่วยความจำได้อย่างมีประสิทธิภาพ แบ่งการแสดงผลเป็นกระเบื้อง GPU ช่วยให้มีประสิทธิภาพมากขึ้นเก็บค่าพิกเซลจากเฟรมบัฟเฟอร์ที่ทำให้การทดสอบเชิงลึกและการผสมมีประสิทธิภาพมากขึ้นการแสดงผลรอการตัดบัญชียังช่วยให้ GPU ในการดำเนินการกำจัดพื้นผิวที่ซ่อนชิ้นส่วนก่อนที่จะมีการประมวลผล พิกเซลที่มองไม่เห็นจะถูกยกเลิกโดยไม่ต้องสุ่มตัวอย่างพื้นผิวหรือดำเนินการประมวลผลส่วนช่วยลดการคำนวณที่ GPU ต้องดำเนินการที่จะทำให้กระเบื้อง เพื่อให้ได้รับประโยชน์สูงสุดจากคุณสมบัตินี้วาดเท่าของกรอบที่มีเนื้อหาที่ทึบแสงที่เป็นไปได้และลดการใช้การผสม, การทดสอบอัลฟาและการเรียนการสอนทิ้งใน shaders GLSL เพราะฮาร์ดแวร์จะดำเนินการกำจัดพื้นผิวที่ซ่อนอยู่ก็ไม่ได้เป็นสิ่งที่จำเป็นสำหรับการตรวจสอบของคุณในการจัดเรียงวิทยาการจากด้านหน้าไปด้านหลังการดำเนินงานภายใต้บาง renderer รอการตัดบัญชีที่มีราคาแพงมากขึ้นกว่าที่พวกเขาจะอยู่ภายใต้กระแส renderer แบบดั้งเดิม ตัวอย่างเช่นแบนด์วิดธ์หน่วยความจำและการคำนวณเงินฝากออมทรัพย์ที่อธิบายข้างต้นทำงานได้ดีที่สุดเมื่อการประมวลผลขนาดใหญ่ฉาก แต่เมื่อฮาร์ดแวร์ได้รับคำสั่ง OpenGL ES ที่จำเป็นต้องใช้ในการแสดงฉากที่มีขนาดเล็ก renderer สูญเสียมากในประสิทธิภาพของ ตัวอย่างเช่นถ้า app ของคุณทำให้กระบวนการของรูปสามเหลี่ยมโดยใช้พื้นผิวและจากนั้นปรับเปลี่ยนพื้นผิวการดำเนินงาน OpenGL ES ทั้งต้องล้างออกคำสั่งดังกล่าวได้ทันทีหรือซ้ำเนื้อไม่เลือกใช้ฮาร์ดแวร์ได้อย่างมีประสิทธิภาพ ในทำนองเดียวกันความพยายามที่จะอ่านข้อมูลพิกเซลจากเฟรมบัฟเฟอร์ใดกำหนดว่าคำสั่งก่อนหน้านี้มีการประมวลผลว่าพวกเขาจะเปลี่ยนเฟรมบัฟเฟอร์ที่แอปเปิ้ล A7 ฮาร์ดแวร์ GPU แอปเปิ้ล A7 GPU เป็นรุ่นใหม่ของฮาร์ดแวร์กราฟิกที่มีการสนับสนุน OpenGL ES 3.0 OpenGL ES 3.0 ประกอบด้วยคุณสมบัติหลายก่อนหน้านี้ที่มีอยู่ใน OpenGL ES 2.0 ใน iOS แต่มันยังรวมเอาคุณสมบัติใหม่ ๆ เช่นการทำให้เป้าหมายและเปลี่ยนหลายความคิดเห็นที่ยังไม่ได้รับการบริการบนมือถือก่อนที่จะประมวลผล ซึ่งหมายความว่าเทคนิคการแสดงผลขั้นสูงที่ได้รับก่อนหน้านี้ใช้ได้เฉพาะในเครื่องคอมพิวเตอร์เช่นการแสดงผลเลื่อนขณะนี้คุณสามารถใช้ในแอพพลิเค iOS เพื่อใช้ประโยชน์จากพลังของ GPU A7, app ของคุณจะต้องสนับสนุน OpenGL ES 3.0 ใช้ OpenGL ES 3.0 จะช่วยให้คุณเข้าถึงคุณลักษณะใหม่และยังสระว่ายน้ำขนาดใหญ่ของการแสดงผลทรัพยากร ตัวอย่างเช่นใน A7 GPU, app ที่ใช้ OpenGL ES 3.0 สามารถเข้าถึงพื้นผิวสองครั้งเป็นจำนวนมากใน shader กว่า app ที่ใช้ OpenGL ES 2.0

ผลลัพธ์ (ไทย) 3:

ทั้งหมดที่ใช้ในอุปกรณ์ที่ใช้ iOS GPUs กระเบื้องตามรอเรนเดอร์ ( tbdr ) เมื่อคุณเรียก OpenGL ES ฟังก์ชันส่งการสั่งงานฮาร์ดแวร์ , คําสั่งนี้ จนกว่ารายการขนาดใหญ่ของคำสั่งคือการสะสม ฮาร์ดแวร์แสดงคำสั่งเหล่านี้เป็นงานเดียวโดยแบ่งเฟรมบัฟเฟอร์เป็นกระเบื้องแล้วเขียนคำสั่งเมื่อกระเบื้องแต่ละกับกระเบื้องแต่ละการแสดงผลเฉพาะ primitives ที่มองเห็นภายใน ประโยชน์หลักเพื่อรอการแสดงที่เข้าถึงหน่วยความจำได้อย่างมีประสิทธิภาพมากขึ้น การแบ่งการแสดงผลเป็นกระเบื้องให้ GPU ให้มีประสิทธิภาพมากขึ้นค่าจากเฟรมบัฟเฟอร์แคชพิกเซล ทำให้การทดสอบความลึกและการผสมที่มีประสิทธิภาพมากขึ้น

เลื่อนการแสดงผลยังช่วยให้ GPU แสดงซ่อนเอาเศษผิวก่อนแปรรูป พิกเซลที่ไม่สามารถมองเห็นได้ ถูกยกเลิกโดยไม่มีการสุ่มตัวอย่างหรือแสดงการประมวลผลพื้นผิวชิ้นส่วนลดการคํานวณที่ GPU ต้องปฏิบัติเพื่อให้กระเบื้อง ที่จะได้รับประโยชน์สูงสุดจากคุณสมบัตินี้วาดมากของเฟรมกับเนื้อหาทึบแสงที่สุด และลดการใช้การทดสอบอัลฟ่า และละทิ้งการสอน Language shaders . เนื่องจากฮาร์ดแวร์ประสิทธิภาพการกำจัดพื้นผิวซ่อน มันไม่จำเป็นสำหรับ app ของคุณเพื่อจัดเรียง primitives จากด้านหน้าไปด้านหลัง

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



A7 GPU ฮาร์ดแวร์แอปเปิ้ลแอปเปิ้ล A7 GPU เป็นรุ่นใหม่ของกราฟิกฮาร์ดแวร์สนับสนุน OpenGL ES 3.0 OpenGL ES 3.0 ประกอบด้วยคุณสมบัติ OpenGL ES 2.0 ก่อนหน้านี้ใช้ได้ใน iOS มากมาย แต่มันยังรวมคุณสมบัติใหม่ ๆเช่นหลายแสดงเป้าหมายและเปลี่ยนความคิดเห็น ที่ไม่สามารถใช้ได้บนมือถือ ประมวลผลก่อนซึ่งหมายความว่าการแสดงผลขั้นสูงเทคนิคที่ได้รับก่อนหน้านี้ใช้ได้เฉพาะบนเครื่องเดสก์ทอป เช่นรอเรนเดอร์ ขณะนี้คุณสามารถใช้ใน iOS ปพลิเคชัน

เพื่อใช้ประโยชน์จากพลังของ A7 GPU , app ของคุณต้องสนับสนุน OpenGL ES 3.0 การใช้ OpenGL ES 3.0 ช่วยให้คุณสามารถเข้าถึงคุณลักษณะใหม่และยังมีสระว่ายน้ำขนาดใหญ่ของการแสดงผลข้อมูล ตัวอย่างเช่นใน A7 GPU ,เป็น app ที่ใช้ OpenGL ES 3.0 สามารถเข้าถึงสองครั้งเป็นลวดลายมากมายใน Shader กว่า app ที่ใช้ OpenGL ES 2.0 .