Clearly, there are significant ince

Clearly, there are significant incentives from both the hardware and software perspective for a clean slate, low-level approach to graphics API design, and the current engine ecosystem seems to allow for it. But what exactly does “low-level” entail? DirectX12 brings a plethora of changes to the API landscape, but the primary efficiency gains which can be expected stem from three central topics:
Work creation and submission
Pipeline state management
Asynchronicity in memory and resource management
All these changes are connected to some extent, and work well together to minimize overhead, but for clarity we’ll try to look at each of them in turn isolated from the rest.
Work Creation and Submission
The ultimate goal of a graphics API is for the program using it to assemble a set of instructions that the GPU can follow, usually called a command list. In higher-level APIs, this is a rather abstract process, while it is performed much more directly in DirectX 12. The following figure compares the approaches of a ‘classical’ high-level API (DirectX 9), with the first attempt at making parallelization possible in DirectX 11 and finally the more direct process in DirectX12.

In the good old days of annually increasing processor frequencies, what Direct3D 9 offered was just fine: the application uses a single context to submit draw calls, which the API checks and forwards to the driver, which in turn generates a command list for the GPU to consume. All of this is a sequential process, so in the age of consumer multicore chips a first attempt was made to allow for parallelization.
It manifested in the Direct3D 11 concept of deferred contexts, which allow games to submit draw commands independently in multiple threads. However, all of them still ultimately need to pass through a single immediate context, and the driver can only complete the command list once this final pass has happened. Thus, the D3D11 approach allows for some degree of parallelism, but still causes a heavy load imbalance on the thread executing the tail end of the process.
Direct3D 12 cuts out the metaphorical middle man. Game code can directly generate an arbitrary number of command lists, in parallel. It also controls when these are submitted to the GPU, which can happen with far less overhead than in previous concepts as they are already much closer to a format the hardware can consume directly. This does come with additional responsibilities for the game code, such as ensuring the availability of all resources used in a given command list during the entirety of its execution, but should in turn allow for much better parallel load balancing.
Pipeline State Management
The graphics or rendering pipeline consists of several interconnected steps, such as pixel shading or rasterization, which work together to render a given 3D scene. Managing the state of various components in this pipeline is an important task in any game, as this state will directly influence how each drawing operation is performed and thus the final output image.
Most high-level APIs provide an abstract, logical view of this state, divided into several categories which can be independently set. This provides a convenient mental image of the rendering process, but does not necessarily lend itself to high draw call throughput with low overhead.

The figure above, while greatly simplified, illustrates the basic issue. Many independent high-level state descriptions can exist, and at the start of any draw call any subset of them may be active. As such, the driver has to build the actual hardware representation of this combination of states—and maybe even check its validity—before it can start actually performing the draw call. While caching may alleviate this issue, it means moving complexity to the driver and running the risk of unpredictable and hard to debug behavior from the application perspective, as discussed earlier.
In DX12, state information is instead gathered in pipeline state objects. These are immutable once constructed, and thus allow the driver to check them and build their hardware representation only once when they are created. Using them is then ideally a simple matter of just copying the relevant description directly to the right hardware memory location before starting to draw.
Asynchronicity in Memory and Resource Management
Direct3D 12 will allow—and force—game developers to manually manage all resources used by their games more directly than before. While higher level APIs offer convenient views to resources such as textures, and may hide others like the GPU-native representation of command lists or storage for some types of state from developers completely, in D3D12 all of these can and must be managed by the developers.
This not only means direct control over which resources reside in which memory at all times, but also makes game programmers responsible for ensuring that all data is where the GPU needs it to be when it is accessed. The GPU and CPU have always acted independently from each other in an asynchronous manner, but the potential problems (e.g. so-called pipeline hazards) arising from this asynchronicity were handled by the driver in higher-level APIs.

To give you a better idea why this can be a significant performance and resource drain, the figure above illustrates a simple example of such a hazard occurring. From the CPU side, the situation is clear-cut: a draw call X utilizing two resources A and B is performed, and later on resource B is modified. However, due to the asynchronous nature of CPU and GPU processing, the GPU may only start actually executing the draw call in question significantly after the game code on the CPU initially performed it, and after B has already changed. In these situations, drivers for high-level APIs could in the worst case be forced to create a full shadow copy of the required resources during the initial call. In D3D12, game developers are tasked with ensuring that such situations do not occur.
In Summary
Tying it all together, the changes discussed above should result in a lean API which has the potential to aid in implementing games that perform both better and, perhaps even more importantly, with improved consistency.
Application-level control and assembly of command lists allows for well-balanced parallel work distribution and thus better utilization of multicore CPUs. Managing pipeline state in a way which more closely mirrors actual hardware requirements will reduce overall CPU load and in particular result in higher draw count throughput. And manual resource management, while complex, will allow game developers to fully understand all the data movement in their game. This insight should make it easier for them to craft a consistent experience and perhaps ultimately eliminate loading/streaming-related stutter completely.

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

อย่างชัดเจน มีแรงจูงใจสำคัญจากมุมมองทั้งฮาร์ดแวร์และซอฟต์แวร์สำหรับวิธีชนวนสะอาด ระดับต่ำกับกราฟิกออกแบบ API และระบบนิเวศเครื่องยนต์ปัจจุบันดูเหมือนว่าให้มัน แต่ที่ว่าไม่ "ต่ำ" อัน DirectX12 นำของการเปลี่ยนแปลงภูมิทัศน์ API แต่กำไรประสิทธิภาพหลักซึ่งคาดว่าเกิดจากหัวข้อกลางสาม:สร้างงานและส่งจัดการสถานะของไปป์ไลน์Asynchronicity ในการจัดการหน่วยความจำและทรัพยากรเปลี่ยนแปลงทั้งหมดเหล่านี้มีการเชื่อมต่อบางขอบเขต และทำงานร่วมกันเพื่อลดค่าใช้จ่ายในดี แต่สำหรับเราจะพยายามดูแต่ละของพวกเขาจะแยกต่างหากจากส่วนเหลือสร้างงานและส่งเป้าหมายสูงสุดของ API เป็นโปรแกรมที่ใช้เพื่อรวบรวมชุดคำสั่งที่ GPU สามารถปฏิบัติตาม กราฟิกมักจะเรียกว่ารายการคำสั่ง ใน APIs สูงกว่า นี้เป็นกระบวนการค่อนข้างนามธรรม ขณะทำมากใน DirectX 12 รูปต่อไปนี้เปรียบเทียบวิธีของ API ระดับสูง 'คลาสสิก' (DirectX 9), กับความพยายามครั้งแรกที่ทำได้ parallelization ใน DirectX 11 และสุดท้ายการอ้อมใน DirectX12ในวันเก่าดีของการเพิ่มความถี่ในการประมวลผลเป็นรายปี Direct3D 9 เสนอท่องเที่ยว: โปรแกรมประยุกต์ที่ใช้บริบทเดียวส่งโทรออก API ตรวจสอบ และส่งต่อการควบคุม การสร้างรายการคำสั่งใน GPU เพื่อใช้ใน การ ทั้งหมดนี้เป็นกระบวนการต่อเนื่อง ดังนั้นในยุคของผู้บริโภค multicore ชิ ตัวแรกพยายามให้ parallelizationจะประจักษ์ใน Direct3D 11 แนวคิดของบริบทถูกเลื่อนออกไป ซึ่งทำให้เกมส่งคำสั่งออกอย่างอิสระในหลาย ๆ กระทู้ อย่างไรก็ตาม ทุกสุดยังต้องผ่านตามบริบทเดียว และโปรแกรมควบคุมสามารถเพียงทำรายการคำสั่งเมื่อตอนนี้ขั้นสุดท้ายที่เกิดขึ้น ดังนั้น วิธี D3D11 สำหรับบางส่วนของ parallelism แต่ยัง ทำให้เกิดสมดุลหนักบนหัวข้อการดำเนินการสุดท้ายของกระบวนการDirect3D 12 ตัดออกจากคนกลางพจน์ รหัสเกมโดยตรงสามารถสร้างหมายเลขที่กำหนดคำสั่งรายการ พร้อมกัน นอกจากนี้ยังควบคุมเมื่อเหล่านี้จะถูกส่งไป GPU ซึ่งสามารถเกิดขึ้นกับไกลน้อยค่าใช้จ่ายในกว่าในแนวคิดก่อนหน้าพวกเขาอยู่ใกล้มากรูปแบบฮาร์ดแวร์สามารถใช้โดยตรง นี้มาพร้อมกับความรับผิดชอบเพิ่มเติมสำหรับรหัสเกม เช่นใจความพร้อมของทรัพยากรทั้งหมดใช้ในรายการคำสั่งที่กำหนดในช่วงทั้งหมดของการดำเนินการของ แต่ควรจะให้มากขึ้นพร้อมการปรับสมดุลการโหลดจัดการสถานะของไปป์ไลน์กราฟิกหรือแสดงขั้นตอนประกอบด้วยจุดเชื่อมระหว่างขั้นตอนต่าง ๆ เช่นการแรเงาพิกเซลหรือ rasterization ซึ่งทำงานร่วมกันเพื่อแสดงฉาก 3D ให้ การจัดการสถานะของส่วนประกอบต่าง ๆ ในขั้นตอนนี้เป็นงานสำคัญในเกมใด ๆ สถานะนี้จะตรงมีอิทธิพลต่อวิธีดำเนินการการดำเนินงานแต่ละรูปวาด และรูปภาพผลลัพธ์สุดท้ายสูงสุด APIs ให้ดูเป็นนามธรรม ตรรกะรัฐนี้ แบ่งออกเป็นหลายประเภทซึ่งสามารถตั้งได้อย่างอิสระ นี้มีภาพสะดวกการแสดง แต่ไม่จำเป็นต้องยืมตัวประมวลโทรออกสูงมีค่าโสหุ้ยต่ำรูปด้านบน ในขณะที่ภาษามาก แสดงปัญหาพื้นฐาน สามารถมีคำอธิบายรัฐอิสระในระดับสูงมาก และที่เริ่มโทรออก ชุดย่อยใด ๆ ของพวกเขาอาจใช้งาน ดัง มีการสร้างนำเสนอฮาร์ดแวร์จริงของชุดนี้ของอเมริกา — และอาจตรวจสอบการมีผลบังคับใช้แม้ — ก่อนที่จะเริ่มทำการโทรออกจริง ในขณะที่แคอาจบรรเทาปัญหานี้ หมายถึง ย้ายความซับซ้อนของโปรแกรมควบคุม และใช้ความเสี่ยงของการไม่แน่นอน และยากที่จะตรวจแก้จุดบกพร่องของลักษณะการทำงานจากมุมมองของแอพลิเคชัน ตามที่อธิบายไว้ก่อนหน้านี้แต่รวบรวมข้อมูลสถานะใน DX12 ในวัตถุสถานะของไปป์ไลน์ เหล่านี้ไม่อาจเปลี่ยนแปลงเมื่อสร้าง และจึง อนุญาตให้ควบคุมตรวจสอบได้ และสร้างตัวแทนฮาร์ดแวร์เพียงครั้งเดียวเมื่อมีสร้าง ใช้ได้แล้วเชิญเรื่องง่าย ๆ เพียงแค่คัดลอกคำอธิบายที่เกี่ยวข้องโดยตรงไปยังตำแหน่งหน่วยความจำฮาร์ดแวร์ขวาก่อนเริ่มต้นการวาดAsynchronicity ในหน่วยความจำและจัดการทรัพยากรDirect3D 12 จะอนุญาต — และบังคับให้ — เกมพัฒนาการจัดการทรัพยากรทั้งหมดที่ใช้ โดยเกมของพวกเขาตรงมากกว่า APIs ระดับสูงวิวสะดวกทรัพยากรเช่นพื้นผิว และอาจซ่อนผู้อื่นเช่นการแสดงพื้นเมือง GPU ของรายการคำสั่งที่เก็บสำหรับบางชนิดของรัฐจากนักพัฒนาทั้งหมด ใน D3D12 ทั้งหมดเหล่านี้สามารถ และต้องจัดการ โดยนักพัฒนานี้ไม่เพียงแต่หมายถึง ควบคุมตรงที่ทรัพยากรอยู่ในหน่วยความจำที่ทุกครั้ง แต่ยัง เกมโปรแกรมเมอร์รับผิดชอบในการรับประกันว่า ข้อมูลทั้งหมดอยู่ที่ GPU ที่ต้องการให้เมื่อมีการเข้าถึง GPU และ CPU มีเสมอดำเนินอย่างเป็นอิสระจากกันในลักษณะการแบบอะซิงโครนัส แต่ปัญหาอาจเกิดขึ้น (เช่นขั้นตอนเรียกว่าอันตราย) เกิดจาก asynchronicity นี้ถูกจัดการ โดยโปรแกรมควบคุมใน APIs ที่สูงกว่าเพื่อให้คุณทราบสาเหตุซึ่งอาจมีผลกระทบต่อประสิทธิภาพ และทรัพยากรท่อระบายน้ำ ตัวเลขข้างต้นแสดงให้เห็นดังกล่าวเป็นอันตรายเกิดขึ้นอย่างเรียบง่าย เป็นที่แน่ชัดจากด้าน CPU สถานการณ์: ดำเนินการเรียกออก X การใช้ทรัพยากรทั้งสอง A และ B และในภายหลังมีการปรับเปลี่ยนทรัพยากร B อย่างไรก็ตาม เนื่องจากลักษณะแบบอะซิงโครนัสของ CPU และ GPU ในการประมวลผล GPU อาจเพียงเริ่มจริง ดำเนินการโทรออกในคำถามอย่างมีนัยสำคัญหลัง จากรหัสเกมบน CPU เริ่มทำมัน และ B มีการเปลี่ยนแปลง ในกรณีนี้ โปรแกรมควบคุมสำหรับ APIs ระดับสูงอาจในกรณีเลวร้ายที่สุดถูกบังคับให้สร้างสำเนาเงาทั้งหมดของทรัพยากรที่จำเป็นในระหว่างการเรียกเริ่มต้น ใน D3D12 นักพัฒนาเกมได้รับมอบหมาย ด้วยมั่นใจว่า สถานการณ์ดังกล่าวไม่เกิดขึ้นในสรุปผูกเข้าด้วยกันทั้งหมด การเปลี่ยนแปลงที่กล่าวถึงข้างต้นควรทำใน API แบบ lean ซึ่งมีศักยภาพในการช่วยเหลือในการดำเนินเกมที่ทำทั้งดี และ บางทีแม้แต่ที่ สำคัญ มีความสอดคล้องกันดีขึ้นควบคุมระดับโปรแกรมประยุกต์และส่วนประกอบของรายการคำสั่งช่วยให้การกระจายงานแบบสมดุลและ Cpu multicore ใช้จึงดีกว่า การจัดการรัฐไปป์ในแบบที่มากกว่ากระจกฮาร์ดแวร์จริงความต้องจะลดโหลด CPU โดยรวม และโดยเฉพาะ ส่งผลให้อัตราความเร็วในการนับออกสูงอย่างใกล้ชิด และจัดการทรัพยากรด้วยตนเอง ในขณะที่ซับซ้อน จะช่วยให้นักพัฒนาเกมเข้าใจย้ายข้อมูลทั้งหมดในเกมของพวกเขา ความเข้าใจนี้ควรทำให้ง่ายขึ้นหัตถกรรมประสบการณ์ที่สอดคล้องกัน และทีสุดกำจัดพูดโหลด/สตรีมมิ่งที่เกี่ยวข้องทั้งหมด

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

เห็นได้ชัดว่ามีแรงจูงใจอย่างมีนัยสำคัญจากทั้งฮาร์ดแวร์และซอฟแวร์สำหรับมุมมองกระดานชนวนสะอาดวิธีการในระดับต่ำในการออกแบบกราฟิก API และระบบนิเวศของเครื่องยนต์ในปัจจุบันดูเหมือนว่าจะช่วยให้มัน แต่สิ่งที่แน่นอนไม่ "ระดับต่ำ" ตกทอด? DirectX12 นำมากมายเหลือเฟือของการเปลี่ยนแปลงภูมิทัศน์ API แต่เพิ่มประสิทธิภาพหลักที่สามารถคาดว่าต้นกำเนิดจากกลางสามหัวข้อ:
การสร้างงานและการส่ง
การจัดการสถานะท่อ
Asynchronicity ในความทรงจำและการจัดการทรัพยากร
การเปลี่ยนแปลงทั้งหมดเหล่านี้จะเชื่อมต่อกับบางส่วนและการทำงาน ร่วมกันเพื่อลดค่าใช้จ่าย แต่เพื่อความชัดเจนเราจะพยายามที่จะมองไปที่แต่ละของพวกเขาในทางกลับกันที่แยกจากส่วนที่เหลือ.
การสร้างงานและการส่ง
เป้าหมายสูงสุดของ API กราฟิกสำหรับโปรแกรมที่ใช้มันในการประกอบชุดของคำสั่งที่ GPU สามารถทำตามมักจะเรียกว่ารายการคำสั่ง APIs ในระดับที่สูงขึ้นนี้เป็นกระบวนการที่ค่อนข้างเป็นนามธรรมในขณะที่มันจะดำเนินการมากขึ้นโดยตรงใน DirectX 12 รูปต่อไปนี้เปรียบเทียบวิธีการของ 'คลาสสิก' ระดับสูง API (DirectX 9) กับความพยายามครั้งแรกที่จะทำให้ . parallelization เป็นไปได้ใน DirectX 11 และในที่สุดก็มากขึ้นในกระบวนการโดยตรง DirectX12 ในวันเก่าที่ดีของความถี่ตัวประมวลผลที่เพิ่มขึ้นเป็นประจำทุกปีสิ่งที่ Direct3D 9 นำเสนอเป็นเพียงแค่ปรับ: โปรแกรมประยุกต์ที่ใช้บริบทเดียวที่จะส่งวาดสายซึ่งการตรวจสอบ API และส่งต่อ ให้คนขับรถซึ่งจะสร้างรายการคำสั่งสำหรับ GPU ในการบริโภค ทั้งหมดนี้เป็นกระบวนการที่ต่อเนื่องดังนั้นในยุคของชิปมัลติคอร์ของผู้บริโภคพยายามครั้งแรกที่ถูกสร้างขึ้นมาเพื่อให้ parallelization. มันประจักษ์ใน Direct3D 11 แนวคิดของบริบทรอการตัดบัญชีซึ่งจะช่วยให้เกมที่จะส่งคำสั่งวาดอิสระในหลายหัวข้อ แต่ทั้งหมดของพวกเขายังคงท้ายที่สุดต้องผ่านบริบททันทีเดียวและคนขับสามารถเสร็จสิ้นรายการคำสั่งครั้งสุดท้ายผ่านนี้ได้เกิดขึ้น ดังนั้นวิธีการ D3D11 ช่วยให้ระดับของความเท่าเทียมบางส่วน แต่ยังคงทำให้เกิดความไม่สมดุลภาระหนักในหัวข้อการดำเนินการปลายหางของกระบวนการ. Direct3D 12 ตัดออกชายกลางเชิงเปรียบเทียบ รหัสเกมโดยตรงสามารถสร้างจำนวนข้อของรายการคำสั่งในแบบคู่ขนาน นอกจากนี้ยังควบคุมเมื่อเหล่านี้จะถูกส่งไปยัง GPU ซึ่งสามารถเกิดขึ้นได้ด้วยค่าใช้จ่ายน้อยกว่าในแนวคิดก่อนหน้านี้ขณะที่พวกเขามีอยู่แล้วมากใกล้ชิดกับรูปแบบฮาร์ดแวร์สามารถใช้โดยตรง นี้จะมาพร้อมกับความรับผิดชอบที่เพิ่มรหัสเกมเช่นการสร้างความมั่นใจความพร้อมของทรัพยากรทั้งหมดที่ใช้ในรายการคำสั่งที่กำหนดในช่วงของการดำเนินการทั้งหมดของมัน แต่ในทางกลับกันควรอนุญาตให้มีการปรับสมดุลการโหลดแบบขนานที่ดีมาก. ท่อรัฐจัดการกราฟิกหรือ ท่อการแสดงผลประกอบด้วยขั้นตอนที่เชื่อมต่อกันหลายอย่างเช่นการแรเงาพิกเซลหรือ rasterization ซึ่งทำงานร่วมกันเพื่อแสดงภาพ 3 มิติที่ได้รับ การจัดการสถานะขององค์ประกอบต่างๆในท่อนี้เป็นงานสำคัญในเกมใด ๆ ตามที่รัฐนี้จะมีผลต่อวิธีการดำเนินการแต่ละวาดภาพโดยตรงจะดำเนินการและทำให้ภาพออกสุดท้าย. APIs ระดับสูงส่วนใหญ่ให้นามธรรมมุมมองเชิงตรรกะของรัฐนี้ แบ่งออกเป็นหลายประเภทซึ่งสามารถตั้งค่าได้อย่างอิสระ นี้จะให้ภาพจิตที่สะดวกในการแสดงผล แต่ไม่จำเป็นต้องให้ยืมตัวไปวาดผ่านโทรสูงที่มีค่าใช้จ่ายต่ำ. ตัวเลขดังกล่าวข้างต้นในขณะที่ง่ายมากแสดงให้เห็นถึงปัญหาพื้นฐาน หลายคนที่เป็นอิสระระดับสูงรายละเอียดของรัฐสามารถอยู่และในช่วงเริ่มต้นของการวาดใด ๆ โทรย่อยของพวกเขาอาจจะใช้งาน เช่นคนขับมีการสร้างการแสดงฮาร์ดแวร์ที่แท้จริงของการรวมกันของรัฐนี้และแม้กระทั่งการตรวจสอบความถูกต้องของตนก่อนที่จะสามารถเริ่มต้นการปฏิบัติจริงโทรวาด ในขณะที่แคชอาจบรรเทาปัญหานี้มันหมายถึงการเคลื่อนย้ายความซับซ้อนให้คนขับรถและใช้ความเสี่ยงของการคาดเดาไม่ได้และยากที่จะแก้ปัญหาพฤติกรรมจากมุมมองของแอพลิเคชันตามที่กล่าวไว้ก่อนหน้านี้. ใน DX12, ข้อมูลของรัฐจะถูกรวบรวมในวัตถุแทนรัฐท่อ เหล่านี้จะไม่เปลี่ยนรูปที่ครั้งหนึ่งเคยสร้างและจึงช่วยให้ผู้ขับขี่สามารถตรวจสอบพวกเขาและสร้างตัวแทนฮาร์ดแวร์ของพวกเขาเพียงครั้งเดียวเมื่อพวกเขาถูกสร้างขึ้น ใช้พวกเขาเป็นอย่างยิ่งจากนั้นเป็นเรื่องง่ายเพียงแค่การคัดลอกคำอธิบายที่เกี่ยวข้องโดยตรงกับฮาร์ดแวร์ที่เหมาะสมตำแหน่งหน่วยความจำก่อนที่จะเริ่มวาด. Asynchronicity ในหน่วยความจำและการจัดการทรัพยากรDirect3D 12 จะช่วยให้นักพัฒนาและบังคับเกมในการจัดการทรัพยากรทั้งหมดด้วยตนเองโดยใช้ของพวกเขา เกมมากขึ้นกว่าก่อนโดยตรง ในขณะที่ระดับที่สูงขึ้น APIs มีวิวที่สะดวกในการทรัพยากรเช่นพื้นผิวและอาจซ่อนอื่น ๆ เช่นการเป็นตัวแทน GPU พื้นเมืองของรายการคำสั่งหรือจัดเก็บข้อมูลสำหรับบางชนิดของรัฐจากนักพัฒนาอย่างสมบูรณ์ใน D3D12 ทั้งหมดเหล่านี้สามารถและจะต้องได้รับการจัดการโดยนักพัฒนา . นี้ไม่เพียง แต่หมายถึงการควบคุมโดยตรงซึ่งทรัพยากรที่อยู่ในหน่วยความจำตลอดเวลา แต่ยังทำให้การเขียนโปรแกรมเกมที่รับผิดชอบในการสร้างความมั่นใจว่าข้อมูลทั้งหมดเป็นที่ที่ GPU ต้องการมันจะเป็นเมื่อมีการเข้าถึงได้ GPU และ CPU ได้กระทำเสมอเป็นอิสระจากกันในลักษณะที่ไม่ตรงกัน แต่ปัญหาที่อาจเกิด (เช่นที่เรียกว่าอันตรายท่อ) ที่เกิดขึ้นจาก asynchronicity นี้ถูกจัดการโดยคนขับ APIs ในระดับที่สูงขึ้น. เพื่อให้คุณได้ความคิดที่ดีว่าทำไม นี้จะมีผลการดำเนินงานที่สำคัญและท่อระบายน้ำทรัพยากรตัวเลขข้างต้นแสดงให้เห็นถึงตัวอย่างง่ายๆเช่นอันตรายที่เกิดขึ้น จากด้านข้างของ CPU สถานการณ์ที่ชัดเจน: โทรวาด X ใช้สองแหล่ง A และ B จะดำเนินการและต่อมาในทรัพยากร B มีการแก้ไข แต่เนื่องจากลักษณะที่ไม่ตรงกันของ CPU และ GPU ประมวลผล, GPU อาจจะเป็นเพียงการเริ่มต้นการดำเนินการจริงโทรวาดในคำถามอย่างมีนัยสำคัญหลังจากรหัสเกมบน CPU ขั้นต้นทำมันและหลังจาก B มีการเปลี่ยนแปลงแล้ว ในสถานการณ์เหล่านี้ไดรเวอร์สำหรับ APIs ระดับสูงอาจจะในกรณีที่เลวร้ายที่สุดจะถูกบังคับให้สร้างสำเนาเงาเต็มรูปแบบของทรัพยากรที่จำเป็นในระหว่างการโทรเริ่มต้น ใน D3D12 นักพัฒนาเกมได้รับมอบหมายกับการสร้างความมั่นใจว่าสถานการณ์ดังกล่าวไม่ได้เกิดขึ้น. ในอย่างย่อผูกไว้ด้วยกันการเปลี่ยนแปลงที่กล่าวข้างต้นจะส่งผลให้ลีน API ซึ่งมีศักยภาพที่จะช่วยในการดำเนินการเกมที่ดำเนินการทั้งที่ดีขึ้นและบางทีอาจจะ ที่สำคัญกว่านั้นมีความสอดคล้องที่ดีขึ้น. ควบคุมแอพลิเคชันระดับและการชุมนุมของรายการคำสั่งช่วยให้การกระจายการทำงานแบบคู่ขนานที่มีความสมดุลและการใช้ประโยชน์ที่ดีกว่าจึงซีพียูแบบมัลติคอร์ ผู้จัดการรัฐท่อในทางที่ใกล้ชิดมากขึ้นสะท้อนความต้องการของฮาร์ดแวร์ที่เกิดขึ้นจริงจะช่วยลดภาระของ CPU โดยรวมและผลโดยเฉพาะอย่างยิ่งในการส่งผ่านข้อมูลที่สูงขึ้นนับวาด และการจัดการทรัพยากรด้วยตนเองในขณะที่ซับซ้อนจะช่วยให้นักพัฒนาเกมเพื่อให้เข้าใจทุกการเคลื่อนไหวของข้อมูลในเกมของพวกเขา ความเข้าใจนี้จะทำให้มันง่ายขึ้นสำหรับพวกเขาที่จะฝีมือประสบการณ์ที่สอดคล้องและบางทีอาจจะในที่สุดขจัดโหลด / พูดติดอ่างสตรีมมิ่งที่เกี่ยวข้องอย่างสมบูรณ์

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

อย่างชัดเจน นอกจากนี้ยังพบว่ามีแรงจูงใจจากทั้งฮาร์ดแวร์และซอฟต์แวร์มุมมองสำหรับกระดานชนวนสะอาด แนวทางในการออกแบบกราฟิก API และระบบนิเวศเครื่องยนต์ปัจจุบันดูเหมือนว่าจะอนุญาตให้มัน แต่สิ่งที่ทำให้ " ระดับต่ำ " ครอบคลุม ? directx12 นำมากมายเหลือเฟือของการเปลี่ยนแปลงภูมิทัศน์ API ได้ แต่การเพิ่มประสิทธิภาพซึ่งสามารถคาดว่าเกิดจากสามหัวข้อกลาง :การสร้างและการส่ง

งานท่อรัฐจัดการ
asynchronicity ในหน่วยความจำและทรัพยากรการจัดการ
เหล่านี้แปลงทั้งหมดจะเชื่อมต่อกับ ขอบเขต และทำงานร่วมกันเพื่อลด ค่าใช้จ่าย แต่เพื่อความชัดเจน เราก็พยายามที่จะมองไปที่แต่ละของพวกเขาจะแยกจากส่วนที่เหลือ การสร้างสรรค์งาน และการส่ง

เป้าหมายสูงสุดของกราฟ API สำหรับโปรแกรมที่ใช้มันในการประกอบชุดคําสั่งที่ GPU สามารถติดตาม มักจะเรียกว่า รายการที่สั่ง ในระดับตลาด นี่คือกระบวนการที่เป็นนามธรรมค่อนข้างมาก ในขณะที่มันดำเนินการโดยตรงในเกม 12 รูปต่อไปนี้เปรียบเทียบแนวทาง ' คลาสสิก ' ระดับสูง API ( DirectX 9 )กับครั้งแรกที่ทำ parallelization ไปเป็นไปได้ใน DirectX 11 และสุดท้ายโดยตรงมากขึ้นกระบวนการใน directx12

ในวันเก่าที่ดีของปีเพิ่มโปรเซสเซอร์ความถี่อะไร direct3d 9 เสนอแค่ปรับ : การใช้บริบทเดียวส่งวาดสาย ซึ่งการตรวจสอบ API และข้างคนขับซึ่งจะสร้างรายชื่อสำหรับ GPU ที่จะบริโภค ทั้งหมดนี้เป็นกระบวนการต่อเนื่อง ดังนั้นในยุคของความพยายามครั้งแรกของผู้บริโภค multicore ชิปได้อนุญาตให้ parallelization ไป .
มันประจักษ์ใน direct3d 11 แนวคิดของภาษีเงินได้รอการตัดบัญชี บริบท ซึ่งอนุญาตให้เกมส่งคำสั่งวาดอิสระในหลายกระทู้ อย่างไรก็ตามทั้งหมดของพวกเขายังสุดต้องผ่านเดียวทันที บริบท และคนขับเท่านั้นที่สามารถให้รายการคำสั่งครั้งนี้ผ่านขั้นสุดท้ายได้เกิดขึ้น ดังนั้น d3d11 วิธีการช่วยให้บางส่วนของความเท่าเทียม แต่ยังทำให้เกิดความไม่สมดุลโหลดหนักในด้ายรันปลายหางของกระบวนการ .
direct3d 12 ตัดออกคนกลางคำอุปมารหัสเกมโดยตรงสามารถสร้างหมายเลขโดยพลการของรายการคำสั่งในแบบคู่ขนาน นอกจากนี้ยังมีการควบคุมเมื่อเหล่านี้จะถูกส่งไปยัง GPU , ซึ่งสามารถเกิดขึ้นได้กับไกลน้อยกว่าค่าใช้จ่ายมากกว่าในแนวคิดก่อนหน้านี้พวกเขาได้ใกล้ชิดกับรูปแบบฮาร์ดแวร์สามารถบริโภคได้โดยตรง นี้จะมาพร้อมกับความรับผิดชอบเพิ่มเติมสำหรับเกมรหัสเช่นมั่นใจความพร้อมของทรัพยากรทั้งหมดที่ใช้ในการระบุรายการคำสั่งในช่วงทั้งหมดของการปฏิบัติได้ แต่ควรเปิดให้ขึ้นมากขนานสมดุลภาระการจัดการของรัฐ
.
ท่อกราฟิกหรือการเชื่อมท่อประกอบด้วยหลายขั้นตอน เช่น พิกเซลแรเงาหรือแร ตอไรเซชั่น ซึ่งทำงานร่วมกันเพื่อแสดงให้ฉาก 3Dการจัดการสถานะของคอมโพเนนต์ต่าง ๆในท่อ นี้เป็นงานที่สำคัญในเกมใด ๆตามที่รัฐนี้โดยตรงจะมีผลต่อแต่ละรูปวาดการผ่าตัดดังนั้นภาพผลลัพธ์สุดท้าย .
ระดับสูงที่สุด APIs ให้นามธรรม , มุมมองเชิงตรรกะของรัฐนี้แบ่งออกเป็นหลายประเภท ซึ่งสามารถแยกชุด