DiligentCore
v2.5.6
Diligent Core เป็น API กราฟิกระดับต่ำแบบข้ามแพลตฟอร์มสมัยใหม่ที่สร้างรากฐานของ Diligent Engine โมดูลนี้ใช้แบ็คเอนด์การเรนเดอร์ Direct3D11, Direct3D12, OpenGL, OpenGLES และ Vulkan (การใช้งาน Metal นั้นพร้อมใช้งานสำหรับลูกค้าเชิงพาณิชย์) รวมถึงยูทิลิตี้พื้นฐานเฉพาะแพลตฟอร์ม มันมีอยู่ในตัวเองและสามารถสร้างได้ด้วยตัวเอง โปรดดูที่พื้นที่เก็บข้อมูลหลักสำหรับข้อมูลเกี่ยวกับแพลตฟอร์มและคุณสมบัติที่รองรับ คำแนะนำในการสร้าง ฯลฯ
| แพลตฟอร์ม | สถานะการสร้าง |
|---|---|
 Win32 | |
 หน้าต่างสากล | |
 ลินุกซ์ | |
 หุ่นยนต์ | |
 แมคโอเอส | |
 ไอโอเอส | |
 tvOS | |
 เอ็มสคริปเทน |
การโคลนพื้นที่เก็บข้อมูล
พื้นฐาน API
เค้าโครงทรัพยากรไปป์ไลน์
Win32
แพลตฟอร์ม Windows สากล
ลินุกซ์
แมคโอเอส
หุ่นยนต์
ไอโอเอส
เอ็มสคริปเทน
ทำลายเครื่องยนต์
การเริ่มต้นเครื่องยนต์
การสร้างทรัพยากร
การสร้างเชเดอร์
การเริ่มต้นสถานะไปป์ไลน์
ทรัพยากร Binding Shader
การตั้งค่าสถานะไปป์ไลน์และการเรียกใช้คำสั่ง Draw
การทำงานร่วมกันของ API ระดับต่ำ
คำแนะนำในการสร้างแพ็คเกจ NuGet
ใบอนุญาต
มีส่วนร่วม
ประวัติการเผยแพร่
หากต้องการรับพื้นที่เก็บข้อมูลและโมดูลย่อยทั้งหมด ให้ใช้คำสั่งต่อไปนี้:
git clone --recursive https://github.com/DiligentGraphics/DiligentCore.git
หากต้องการสร้างโมดูล โปรดดูคำแนะนำในการสร้างในพื้นที่เก็บข้อมูลหลัก
ก่อนที่คุณจะสามารถใช้ฟังก์ชันการทำงานใดๆ ที่เอ็นจิ้นมีให้ คุณจะต้องสร้างอุปกรณ์เรนเดอร์ บริบททันที และห่วงโซ่การสลับ
บนแพลตฟอร์ม Win32 คุณสามารถสร้างอุปกรณ์ OpenGL, Direct3D11, Direct3D12 หรือ Vulkan ดังที่แสดงด้านล่าง:
เป็นโมฆะ InitializeDiligentEngine (HWND NativeWindowHandle)
-
SwapChainDesc SCDesc;// RefCntAutoPtr<IRenderDevice> m_pDevice;// RefCntAutoPtr<IDeviceContext> m_pImmediateContext;// RefCntAutoPtr<ISwapChain> m_pSwapChain;สวิตช์ (m_DeviceType)
{กรณี RENDER_DEVICE_TYPE_D3D11:
-
เครื่องยนต์D3D11สร้างข้อมูลเครื่องยนต์CI;
# ถ้า ENGINE_DLL// โหลด dll และนำเข้า GetEngineFactoryD3D11() functionauto* GetEngineFactoryD3D11 = LoadGraphicsEngineD3D11();
# endifauto* pFactoryD3D11 = GetEngineFactoryD3D11();
pFactoryD3D11->สร้างDeviceAndContextsD3D11(EngineCI, &m_pDevice, &m_pImmediateContext);
หน้าต่าง Win32NativeWindow {hWnd};
pFactoryD3D11->สร้างSwapChainD3D11(m_pDevice, m_pImmediateContext, SCDesc,
FullScreenModeDesc{}, หน้าต่าง, &m_pSwapChain);
} แตกหักกรณี RENDER_DEVICE_TYPE_D3D12:
-
# ถ้า ENGINE_DLL// โหลด dll และนำเข้า GetEngineFactoryD3D12() functionauto GetEngineFactoryD3D12 = LoadGraphicsEngineD3D12();
# endifEngineD3D12CreateInfo EngineCI;อัตโนมัติ* pFactoryD3D12 = GetEngineFactoryD3D12();
pFactoryD3D12->สร้างDeviceAndContextsD3D12(EngineCI, &m_pDevice, &m_pImmediateContext);
หน้าต่าง Win32NativeWindow {hWnd};
pFactoryD3D12->สร้างSwapChainD3D12(m_pDevice, m_pImmediateContext, SCDesc,
FullScreenModeDesc{}, หน้าต่าง, &m_pSwapChain);
}ตัวแบ่งกรณี RENDER_DEVICE_TYPE_GL:
-
# ถ้า EXPLICITLY_LOAD_ENGINE_GL_DLL// โหลด dll และนำเข้า GetEngineFactoryOpenGL() functionauto GetEngineFactoryOpenGL = LoadGraphicsEngineOpenGL();
# endifauto* pFactoryOpenGL = GetEngineFactoryOpenGL();
เครื่องยนต์GLCreateInfo EngineCI;
EngineCI.Window.hWnd = hWnd;
pFactoryOpenGL->สร้างDeviceAndSwapChainGL(EngineCI, &m_pDevice, &m_pImmediateContext,
SCDesc, &m_pSwapChain);
} แบ่งกรณี RENDER_DEVICE_TYPE_VULKAN:
-
# ถ้า EXPLICITLY_LOAD_ENGINE_VK_DLL// โหลด dll และนำเข้า GetEngineFactoryVk() functionauto GetEngineFactoryVk = LoadGraphicsEngineVk();
# endifEngineVkCreateInfo EngineCI;อัตโนมัติ* pFactoryVk = GetEngineFactoryVk();
pFactoryVk->สร้างDeviceAndContextsVk (EngineCI, &m_pDevice, &m_pImmediateContext);
หน้าต่าง Win32NativeWindow {hWnd};
pFactoryVk->CreateSwapChainVk(m_pDevice, m_pImmediateContext, SCDesc, หน้าต่าง, &m_pSwapChain);
} ทำลาย; ค่าเริ่มต้น:
std::cerr << "ประเภทอุปกรณ์ที่ไม่รู้จัก";
-
- บน Windows กลไกสามารถเชื่อมโยงกับแอปพลิเคชันแบบคงที่หรือสร้างเป็น DLL แยกต่างหากได้ ในกรณีแรก สามารถเรียกใช้ฟังก์ชันโรงงาน GetEngineFactoryOpenGL() , GetEngineFactoryD3D11() , GetEngineFactoryD3D12() และ GetEngineFactoryVk() ได้โดยตรง ในกรณีที่สอง คุณต้องโหลด DLL ลงในพื้นที่ที่อยู่ของกระบวนการโดยใช้ฟังก์ชัน LoadGraphicsEngineOpenGL() , LoadGraphicsEngineD3D11() , LoadGraphicsEngineD3D12() หรือ LoadGraphicsEngineVk() แต่ละฟังก์ชันจะโหลดไลบรารีไดนามิกที่เหมาะสมและนำเข้าฟังก์ชันที่จำเป็นในการเริ่มต้นกลไก คุณต้องรวมส่วนหัวต่อไปนี้:
#รวม "EngineFactoryD3D11.h"#รวม "EngineFactoryD3D12.h"#รวม "EngineFactoryOpenGL.h"#รวม "EngineFactoryVk.h"
คุณต้องเพิ่มไดเร็กทอรีต่อไปนี้ในพาธการค้นหารวม:
DiligentCore/Graphics/GraphicsEngineD3D11/interface
DiligentCore/Graphics/GraphicsEngineD3D12/interface
DiligentCore/Graphics/GraphicsEngineOpenGL/interface
DiligentCore/Graphics/GraphicsEngineVulkan/interface
อีกทางเลือกหนึ่ง คุณสามารถเพิ่มเส้นทางไปยังโฟลเดอร์รูทเท่านั้น จากนั้นใช้เส้นทางรวมที่สัมพันธ์กับโฟลเดอร์นั้น
เปิดใช้งานเนมสเปซ Diligent :
ใช้เนมสเปซขยัน;
ฟังก์ชัน IEngineFactoryD3D11::CreateDeviceAndContextsD3D11() , IEngineFactoryD3D12::CreateDeviceAndContextsD3D12() และ IEngineFactoryVk::CreateDeviceAndContextsVk() ยังสามารถสร้างจำนวนที่ระบุของบริบททันทีและบริบทที่เลื่อนออกไป ซึ่งสามารถใช้สำหรับการแสดงผลแบบอะซิงโครนัสและ การบันทึกคำสั่งแบบมัลติเธรด บริบทอาจถูกสร้างขึ้นระหว่างการเริ่มต้นกลไกเท่านั้น ฟังก์ชันนี้เติมอาร์เรย์ของพอยน์เตอร์ไปยังบริบท โดยที่บริบททันทีไปก่อน ตามด้วยบริบทที่เลื่อนออกไปทั้งหมด
สำหรับรายละเอียดเพิ่มเติม โปรดดูที่ไฟล์ Tutorial00_HelloWin32.cpp
บน Universal Windows Platform คุณสามารถสร้างอุปกรณ์ Direct3D11 หรือ Direct3D12 ได้ การเริ่มต้นจะดำเนินการในลักษณะเดียวกับบนแพลตฟอร์ม Win32 ข้อแตกต่างคือคุณต้องสร้างอุปกรณ์เรนเดอร์และบริบทอุปกรณ์ก่อนโดยการเรียก IEngineFactoryD3D11::CreateDeviceAndContextsD3D11() หรือ IEngineFactoryD3D12::CreateDeviceAndContextsD3D12() Swap Chain จะถูกสร้างขึ้นในภายหลังโดยการเรียก IEngineFactoryD3D11::CreateSwapChainD3D11() หรือ IEngineFactoryD3D12::CreateSwapChainD3D12() โปรดดูที่ไฟล์ SampleAppUWP.cpp สำหรับรายละเอียดเพิ่มเติม
บนแพลตฟอร์ม Linux เอ็นจิ้นรองรับแบ็กเอนด์ OpenGL และ Vulkan การเริ่มต้นบริบท GL บน Linux ควบคู่ไปกับการสร้างหน้าต่างอย่างแน่นหนา ด้วยเหตุนี้ Diligent Engine จะไม่เริ่มต้นบริบท แต่เชื่อมโยงกับบริบทที่แอปเริ่มต้น ตัวอย่างของการเริ่มต้นกลไกบน Linux สามารถพบได้ใน Tutorial00_HelloLinux.cpp
บน MacOS Diligent Engine รองรับแบ็กเอนด์ OpenGL, Vulkan และ Metal แอปพลิเคชันจะเริ่มต้นบริบท GL บน MacOS และกลไกจะเชื่อมต่อกับบริบทที่สร้างโดยแอป ดู GLView.mm สำหรับรายละเอียด แบ็กเอนด์ Vulkan ได้รับการเริ่มต้นคล้ายกับแพลตฟอร์มอื่นๆ ดู MetalView.mm.
บน Android คุณสามารถสร้างอุปกรณ์ OpenGLES หรือ Vulkan ได้ ข้อมูลโค้ดต่อไปนี้แสดงตัวอย่าง:
อัตโนมัติ* pFactoryOpenGL = GetEngineFactoryOpenGL();
เครื่องยนต์GLCreateInfo EngineCI;
EngineCI.Window.pAWindow = NativeWindowHandle;
pFactoryOpenGL->สร้างDeviceAndSwapChainGL(
EngineCI, &m_pDevice, &m_pContext, SCDesc, &m_pSwapChain);หากกลไกถูกสร้างเป็นไลบรารีแบบไดนามิก ไลบรารีจะต้องถูกโหลดโดยกิจกรรมดั้งเดิม รหัสต่อไปนี้แสดงวิธีหนึ่งที่เป็นไปได้:
คงที่ {ลอง {System.loadLibrary ("GraphicsEngineOpenGL");
} catch (UnsatisfiedLinkError e) {Log.e("native-activity", "ไม่สามารถโหลด GraphicsEngineOpenGL Library.n" + e);
-
-การใช้งาน iOS รองรับแบ็กเอนด์ OpenGLES, Vulkan และ Metal การเตรียมใช้งานบริบท GL บน iOS ดำเนินการโดยแอปพลิเคชัน และกลไกจะแนบกับบริบทที่เริ่มต้นโดยแอป ดู EAGLView.mm สำหรับรายละเอียด
บน Emscripten คุณสามารถสร้างอุปกรณ์ OpenGLES ได้ ข้อมูลโค้ดต่อไปนี้แสดงตัวอย่าง:
//คุณต้องส่ง ID ของ Canvas ไปที่ NativeWindowauto* pFactoryOpenGL = GetEngineFactoryOpenGL();
EngineGLCreateInfo EngineCI = {};
EngineCI.Window = NativeWindow{"#canvas"};
pFactoryOpenGL->สร้างDeviceAndSwapChainGL(EngineCI, &m_pDevice, &m_pContext, SCDesc, &m_pSwapChain); หากคุณใช้ SDL หรือ GLFW กับบริบทที่มีอยู่ คุณสามารถระบุค่าว่างเป็นตัวจัดการหน้าต่างดั้งเดิมได้: EngineCI.Window = NativeWindow{nullptr}
เครื่องยนต์ทำการนับการอ้างอิงอัตโนมัติและปิดลงเมื่อมีการปล่อยการอ้างอิงล่าสุดไปยังวัตถุของเครื่องยนต์
ทรัพยากรอุปกรณ์ถูกสร้างขึ้นโดยอุปกรณ์แสดงผล ทรัพยากรหลักสองประเภทคือบัฟเฟอร์ซึ่งแสดงถึงหน่วยความจำเชิงเส้น และพื้นผิวซึ่งใช้เค้าโครงหน่วยความจำที่ปรับให้เหมาะสมเพื่อการกรองที่รวดเร็ว ในการสร้างบัฟเฟอร์ คุณต้องเติมโครงสร้าง BufferDesc และเรียก IRenderDevice::CreateBuffer() รหัสต่อไปนี้สร้างบัฟเฟอร์สม่ำเสมอ (คงที่):
บัฟเฟอร์Desc บัฟเฟอร์Desc; BuffDesc.Name = "บัฟเฟอร์สม่ำเสมอ"; BuffDesc.BindFlags = BIND_UNIFORM_BUFFER; BuffDesc.Usage = USAGE_DYNAMIC; BuffDesc.uiSizeInBytes = ขนาดของ (ShaderConstants); BuffDesc.CPUAccessFlags = CPU_ACCESS_WRITE; m_pDevice->CreateBuffer(BuffDesc, nullptr, &m_pConstantBuffer);
ในทำนองเดียวกัน หากต้องการสร้างพื้นผิว ให้เติมโครงสร้าง TextureDesc และเรียก IRenderDevice::CreateTexture() ดังตัวอย่างต่อไปนี้:
พื้นผิวDesc TexDesc; TexDesc.Name = "พื้นผิวของฉัน 2D"; TexDesc.Type = TEXTURE_TYPE_2D; TexDesc.ความกว้าง = 1024; TexDesc.ความสูง = 1024; TexDesc.Format = TEX_FORMAT_RGBA8_UNORM; TexDesc.Usage = USAGE_DEFAULT; TexDesc.BindFlags = BIND_SHADER_RESOURCE | BIND_RENDER_TARGET | BIND_UNORDERED_ACCESS; TexDesc.Name = "ตัวอย่างพื้นผิว 2D"; m_pRenderDevice->สร้างพื้นผิว(TexDesc, nullptr, &m_pTestTex);
มีเพียงฟังก์ชันเดียวคือ CreateTexture() ที่สามารถสร้างพื้นผิวได้ทุกประเภท ประเภท รูปแบบ ขนาดอาร์เรย์ และพารามิเตอร์อื่นๆ ทั้งหมดจะถูกระบุโดยสมาชิกของโครงสร้าง TextureDesc
สำหรับทุก ๆ แฟล็กผูกที่ระบุระหว่างเวลาสร้างพื้นผิว ออบเจ็กต์พื้นผิวจะสร้างมุมมองเริ่มต้น มุมมองทรัพยากรเชเดอร์เริ่มต้นระบุพื้นผิวทั้งหมด เป้าหมายการเรนเดอร์เริ่มต้นและมุมมองสเตนซิลเชิงลึกอ้างอิงชิ้นส่วนอาเรย์ทั้งหมดในระดับ mip ที่มีรายละเอียดมากที่สุด และมุมมองการเข้าถึงแบบไม่เรียงลำดับอ้างอิงพื้นผิวทั้งหมด หากต้องการรับมุมมองเริ่มต้นจากพื้นผิว ให้ใช้ฟังก์ชัน ITexture::GetDefaultView() โปรดทราบว่าฟังก์ชันนี้จะไม่เพิ่มตัวนับอ้างอิงของอินเทอร์เฟซที่ส่งคืน คุณสามารถสร้างมุมมองพื้นผิวเพิ่มเติมได้โดยใช้ ITexture::CreateView() ใช้ IBuffer::CreateView() เพื่อสร้างมุมมองเพิ่มเติมของบัฟเฟอร์
หากต้องการสร้างเชเดอร์ ให้เติมโครงสร้าง ShaderCreateInfo :
ShaderCreateInfo ShaderCI;
มีสามวิธีในการสร้างเชดเดอร์ วิธีแรกคือการให้ตัวชี้ไปยังซอร์สโค้ดเชเดอร์ผ่านสมาชิก ShaderCreateInfo::Source วิธีที่สองคือการระบุชื่อไฟล์ วิธีที่สามคือการให้ตัวชี้ไปยังรหัสไบต์ที่คอมไพล์ผ่านสมาชิก ShaderCreateInfo::ByteCode Graphics Engine แยกออกจากแพลตฟอร์มโดยสิ้นเชิง เนื่องจากระบบไฟล์โฮสต์ขึ้นอยู่กับแพลตฟอร์ม โครงสร้างจึงเปิดเผยสมาชิก ShaderCreateInfo::pShaderSourceStreamFactory ที่มีจุดประสงค์เพื่อให้กลไกการเข้าถึงระบบไฟล์ หากคุณระบุชื่อไฟล์ต้นฉบับ คุณต้องระบุตัวชี้ที่ไม่ใช่ค่าว่างไปยังแฟกทอรีสตรีมแหล่งที่มาของเชเดอร์ด้วย หากแหล่งที่มาของเชเดอร์มีคำสั่ง #include ใดๆ แฟกทอรีสตรีมแหล่งที่มาก็จะใช้ในการโหลดไฟล์เหล่านี้ด้วย กลไกจัดการให้การใช้งานเริ่มต้นสำหรับทุกแพลตฟอร์มที่รองรับซึ่งควรจะเพียงพอในกรณีส่วนใหญ่ อย่างไรก็ตาม คุณสามารถกำหนดการใช้งานของคุณเองได้
สมาชิกที่สำคัญคือ ShaderCreateInfo::SourceLanguage ต่อไปนี้เป็นค่าที่ถูกต้องสำหรับสมาชิกรายนี้:
SHADER_SOURCE_LANGUAGE_DEFAULT - รูปแบบแหล่งที่มาของเชเดอร์ตรงกับ API กราฟิกที่เกี่ยวข้อง: HLSL สำหรับโหมด D3D11 หรือ D3D12 และ GLSL สำหรับโหมด OpenGL, OpenGLES และ Vulkan
SHADER_SOURCE_LANGUAGE_HLSL - แหล่งที่มาของเชเดอร์อยู่ใน HLSL สำหรับโหมด OpenGL และ OpenGLES ซอร์สโค้ดจะถูกแปลงเป็น GLSL ในระบบแบ็คเอนด์ของ Vulkan โค้ดจะถูกคอมไพล์ไปยัง SPIRV โดยตรง
SHADER_SOURCE_LANGUAGE_GLSL - แหล่งที่มาของเชเดอร์อยู่ใน GLSL
SHADER_SOURCE_LANGUAGE_GLSL_VERBATIM - ภาษาต้นฉบับของเชเดอร์คือ GLSL และควรได้รับการรวบรวมแบบคำต่อคำ
SHADER_SOURCE_LANGUAGE_MSL - ภาษาต้นฉบับคือภาษา Metal Shading
สมาชิกคนอื่นๆ ของโครงสร้าง ShaderCreateInfo กำหนดเชเดอร์รวมถึงไดเร็กทอรีการค้นหา คำจำกัดความของแมโครเชเดอร์ จุดเข้าเชเดอร์ และพารามิเตอร์อื่นๆ
มาโคร ShaderMacroHelper;
Macros.AddShaderMacro("USE_SHADOWS", 1);
Macros.AddShaderMacro("NUM_SHADOW_SAMPLES", 4);
Macros.สรุป();
ShaderCI.Macros = มาโคร; เมื่อทุกอย่างพร้อมแล้ว ให้เรียก IRenderDevice::CreateShader() เพื่อสร้างวัตถุเชเดอร์:
ShaderCreateInfo ShaderCI; ShaderCI.Desc.Name = "MyPixelShader"; ShaderCI.FilePath = "MyShaderFile.fx"; ShaderCI.EntryPoint = "MyPixelShader"; ShaderCI.Desc.ShaderType = SHADER_TYPE_PIXEL; ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_HLSL;const auto* SearchDirectories = "shaders;shadersinc;"; RefCntAutoPtr <IShaderSourceInputStreamFactory> pShaderSourceFactory; m_pEngineFactory->สร้างDefaultShaderSourceStreamFactory(SearchDirectories, &pShaderSourceFactory); ShaderCI.pShaderSourceStreamFactory = pShaderSourceFactory; RefCntAutoPtr<IShader> pShader; m_pDevice->CreateShader(ShaderCI, &pShader);
Diligent Engine เป็นไปตามสไตล์ Direct3D12/Vulkan เพื่อกำหนดค่าไปป์ไลน์กราฟิก/คำนวณ Monolithic Pipelines State Object (PSO) หนึ่งรายการครอบคลุมสถานะที่จำเป็นทั้งหมด (ขั้นตอนเชเดอร์ทั้งหมด คำอธิบายเค้าโครงอินพุต สเตนซิลเชิงลึก คำอธิบายแรสเตอร์และการผสมผสานสถานะ ฯลฯ) หากต้องการสร้างออบเจ็กต์สถานะไปป์ไลน์กราฟิก ให้กำหนดอินสแตนซ์ของโครงสร้าง GraphicsPipelineStateCreateInfo :
กราฟิกPipelineStateCreateInfo PSOCreateInfo; PipelineStateDesc& PSODesc = PSOCreateInfo.PSODesc; PSODesc.Name = "สถานะไปป์ไลน์ของฉัน";
อธิบายลักษณะเฉพาะของไปป์ไลน์ เช่น จำนวนและรูปแบบของเป้าหมายการเรนเดอร์ รวมถึงรูปแบบลายฉลุเชิงลึก:
// นี่คือกราฟิกไปป์ไลน์PSODesc.PipelineType = PIPELINE_TYPE_GRAPHICS; PSOCreateInfo.GraphicsPipeline.NumRenderTargets = 1; PSOCreateInfo.GraphicsPipeline.RTVFormats[0] = TEX_FORMAT_RGBA8_UNORM_SRGB; PSOCreateInfo.GraphicsPipeline.DSVFormat = TEX_FORMAT_D32_FLOAT;
เริ่มต้นคำอธิบายสถานะลายฉลุเชิงลึก DepthStencilStateDesc โปรดทราบว่า Constructor จะเริ่มต้นสมาชิกด้วยค่าเริ่มต้น และคุณสามารถตั้งค่าได้เฉพาะสมาชิกที่แตกต่างจากค่าเริ่มต้นเท่านั้น
// เริ่มต้นสถานะลายฉลุความลึกDepthStencilStateDesc& DepthStencilDesc = PSOCreateInfo.GraphicsPipeline.DepthStencilDesc; DepthStencilDesc.DepthEnable = จริง; DepthStencilDesc.DepthWriteEnable = จริง;
เริ่มต้นคำอธิบายสถานะการผสมผสาน BlendStateDesc :
// เริ่มต้นการผสมผสาน stateBlendStateDesc& BSDesc = PSOCreateInfo.GraphicsPipeline.BlendDesc; BSDesc.IndependentBlendEnable = False;อัตโนมัติ &RT0 = BSDesc.RenderTargets[0]; RT0.BlendEnable = จริง; RT0.RenderTargetWriteMask = COLOR_MASK_ALL; RT0.SrcBlend = BLEND_FACTOR_SRC_ALPHA; RT0.DestBlend = BLEND_FACTOR_INV_SRC_ALPHA; RT0.BlendOp = BLEND_OPERATION_ADD; RT0.SrcBlendAlpha = BLEND_FACTOR_SRC_ALPHA; RT0.DestBlendAlpha = BLEND_FACTOR_INV_SRC_ALPHA; RT0.BlendOpAlpha = BLEND_OPERATION_ADD;
เริ่มต้นคำอธิบายสถานะแรสเตอร์ไรเซอร์ RasterizerStateDesc :
// เริ่มต้น rasterizer stateRasterizerStateDesc& RasterizerDesc = PSOCreateInfo.GraphicsPipeline.RasterizerDesc; RasterizerDesc.FillMode = FILL_MODE_SOLID; RasterizerDesc.CullMode = CULL_MODE_NONE; RasterizerDesc.FrontCounterClockwise = จริง; RasterizerDesc.ScissorEnable = จริง; RasterizerDesc.AntialiasedLineEnable = เท็จ;
เริ่มต้นคำอธิบายเค้าโครงอินพุต InputLayoutDesc :
// กำหนดเค้าโครงอินพุตInputLayoutDesc& เค้าโครง = PSOCreateInfo.GraphicsPipeline.InputLayout;
องค์ประกอบโครงร่าง องค์ประกอบโครงร่าง[] =
{LayoutElement( 0, 0, 3, VT_FLOAT32, False ),LayoutElement( 1, 0, 4, VT_UINT8, True ),LayoutElement( 2, 0, 2, VT_FLOAT32, False ),
-
Layout.LayoutElements = LayoutElems;
Layout.NumElements = _countof(LayoutElems);กำหนดโทโพโลยีดั้งเดิมและตั้งค่าตัวชี้เชเดอร์:
// กำหนดเชเดอร์และโทโพโลยีดั้งเดิมPSOCreateInfo.GraphicsPipeline.PrimitiveTopology = PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; PSOCreateInfo.pVS = m_pVS; PSOCreateInfo.pPS = m_pPS;
เค้าโครงทรัพยากรไปป์ไลน์แจ้งให้กลไกทราบว่าแอปพลิเคชันจะใช้ตัวแปรทรัพยากรเชเดอร์ที่แตกต่างกันอย่างไร เพื่อให้จัดกลุ่มทรัพยากรตามความถี่ที่คาดไว้ของการเปลี่ยนแปลงการเชื่อมโยงทรัพยากร Diligent Engine ขอแนะนำการจำแนกประเภทของตัวแปรเชเดอร์:
ตัวแปรคงที่ ( SHADER_RESOURCE_VARIABLE_TYPE_STATIC ) คือตัวแปรที่คาดว่าจะตั้งค่าเพียงครั้งเดียว ไม่สามารถเปลี่ยนแปลงได้เมื่อทรัพยากรเชื่อมโยงกับตัวแปร ตัวแปรดังกล่าวมีจุดประสงค์เพื่อเก็บค่าคงที่โกลบอล เช่น คุณลักษณะของกล้องหรือบัฟเฟอร์คงที่ของคุณลักษณะแสงโกลบอล โปรดทราบว่าเป็นการ ผูกทรัพยากร ที่อาจไม่มีการเปลี่ยนแปลง ในขณะที่เนื้อหาของทรัพยากรได้รับอนุญาตให้เปลี่ยนแปลงตามการใช้งาน
ตัวแปรที่ไม่แน่นอน ( SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE ) กำหนดทรัพยากรที่คาดว่าจะเปลี่ยนแปลงตามความถี่ต่อวัสดุ ตัวอย่างอาจรวมถึงพื้นผิวแบบกระจาย แผนที่ปกติ ฯลฯ การอัปเดตเนื้อหาของทรัพยากรอีกครั้งจะเป็นมุมฉากกับการเปลี่ยนแปลงที่มีผลผูกพัน
ตัวแปรไดนามิก ( SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC ) คาดว่าจะเปลี่ยนแปลงบ่อยครั้งและสุ่ม
ในการกำหนดประเภทตัวแปร ให้เตรียมอาร์เรย์ของโครงสร้าง ShaderResourceVariableDesc และเตรียมใช้งานสมาชิก PSODesc.ResourceLayout.Variables และ PSODesc.ResourceLayout.NumVariables นอกจากนี้ PSODesc.ResourceLayout.DefaultVariableType ยังสามารถใช้เพื่อตั้งค่าประเภทที่จะใช้หากไม่มีการระบุชื่อตัวแปร
ShaderResourceVariableDesc ShaderVars[] =
-
{SHADER_TYPE_PIXEL, "g_StaticTexture", SHADER_RESOURCE_VARIABLE_TYPE_STATIC},
{SHADER_TYPE_PIXEL, "g_MutableTexture", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},
{SHADER_TYPE_PIXEL, "g_DynamicTexture", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC}
-
PSODesc.ResourceLayout.Variables = ShaderVars;
PSODesc.ResourceLayout.NumVariables = _countof(ShaderVars);
PSODesc.ResourceLayout.DefaultVariableType = SHADER_RESOURCE_VARIABLE_TYPE_STATIC; เมื่อสร้างสถานะไปป์ไลน์ คุณสามารถกำหนดพื้นผิวให้กับตัวอย่างที่ไม่เปลี่ยนรูปแบบได้อย่างถาวร หากมีการกำหนดตัวอย่างที่ไม่เปลี่ยนรูปให้กับพื้นผิว ตัวอย่างนั้นจะถูกนำมาใช้แทนตัวอย่างที่เตรียมใช้งานในมุมมองทรัพยากรเชเดอร์พื้นผิวเสมอ เมื่อต้องการกำหนดตัวอย่างที่ไม่เปลี่ยนรูป ให้เตรียมอาร์เรย์ของโครงสร้าง ImmutableSamplerDesc และเตรียมใช้งานสมาชิก PSODesc.ResourceLayout.ImmutableSamplers และ PSODesc.ResourceLayout.NumImmutableSamplers โปรดสังเกตว่าตัวเก็บตัวอย่างที่ไม่เปลี่ยนรูปสามารถกำหนดให้กับตัวแปรพื้นผิวประเภทใดก็ได้ ไม่จำเป็นต้องคงที่ เพื่อให้การเชื่อมโยงพื้นผิวสามารถเปลี่ยนแปลงได้ในขณะรันไทม์ ในขณะที่ตัวเก็บตัวอย่างจะยังคงไม่เปลี่ยนรูป ขอแนะนำให้ใช้เครื่องเก็บตัวอย่างที่ไม่เปลี่ยนรูปแบบทุกครั้งที่เป็นไปได้
ImmutableSamplerDesc ImtblSampler; ImtblSampler.ShaderStages = SHADER_TYPE_PIXEL; ImtblSampler.Desc.MinFilter = FILTER_TYPE_LINEAR; ImtblSampler.Desc.MagFilter = FILTER_TYPE_LINEAR; ImtblSampler.Desc.MipFilter = FILTER_TYPE_LINEAR; ImtblSampler.TextureName = "g_MutableTexture"; PSODesc.ResourceLayout.NumImmutableSamplers = 1; PSODesc.ResourceLayout.ImmutableSamplers = &ImtblSampler;
เอกสารนี้ให้ข้อมูลโดยละเอียดเกี่ยวกับการทำงานกับตัวอย่างพื้นผิว
เมื่อตั้งค่าฟิลด์ที่จำเป็นทั้งหมดของโครงสร้างคำอธิบาย PSO แล้ว ให้เรียก IRenderDevice::CreateGraphicsPipelineState() เพื่อสร้างอ็อบเจ็กต์ PSO:
m_pDevice->สร้างGraphicsPipelineState (PSOCreateInfo, & m_pPSO);
ตามที่กล่าวไว้ข้างต้น การเชื่อมโยงทรัพยากรเชเดอร์ใน Diligent Engine ขึ้นอยู่กับการจัดกลุ่มตัวแปรใน 3 กลุ่มที่แตกต่างกัน (คงที่ ไม่แน่นอน และไดนามิก) ตัวแปรคงที่คือตัวแปรที่คาดว่าจะตั้งค่าเพียงครั้งเดียว ไม่สามารถเปลี่ยนแปลงได้เมื่อทรัพยากรเชื่อมโยงกับตัวแปร ตัวแปรดังกล่าวมีจุดประสงค์เพื่อเก็บค่าคงที่โกลบอล เช่น คุณลักษณะของกล้องหรือบัฟเฟอร์คงที่ของคุณลักษณะแสงโกลบอล พวกมันถูกผูกไว้โดยตรงกับ Pipeline State Object:
m_pPSO->GetStaticShaderVariable(SHADER_TYPE_PIXEL, "g_tex2DShadowMap")->ชุด(pShadowMapSRV);
ตัวแปรที่เปลี่ยนแปลงได้และไดนามิกจะถูกผูกไว้ผ่านออบเจ็กต์ใหม่ที่เรียกว่า Shader Resource Binding (SRB) ซึ่งสร้างขึ้นโดยสถานะของไปป์ไลน์ ( IPipelineState::CreateShaderResourceBinding() ) หรือลายเซ็นทรัพยากรไปป์ไลน์ในกรณีการใช้งานขั้นสูง:
m_pPSO->CreateShaderResourceBinding(&m_pSRB, จริง);
พารามิเตอร์ที่สองบอกให้ระบบเตรียมใช้งานโครงสร้างภายในในอ็อบเจ็กต์ SRB ที่อ้างอิงตัวแปรคงที่ใน PSO
ทรัพยากรแบบไดนามิกและไม่แน่นอนจะถูกผูกไว้ผ่านวัตถุ SRB:
m_pSRB->GetVariable(SHADER_TYPE_PIXEL, "tex2DDiffuse")->ชุด(pDiffuseTexSRV); m_pSRB->GetVariable(SHADER_TYPE_VERTEX, "cbRandomAttribs")->ชุด(pRandomAttrsCB);
ความแตกต่างระหว่างทรัพยากรที่ไม่แน่นอนและทรัพยากรแบบไดนามิกคือ ทรัพยากรที่ไม่แน่นอนสามารถตั้งค่าได้เพียงครั้งเดียวต่ออินสแตนซ์ของการเชื่อมโยงทรัพยากรเชเดอร์ ทรัพยากรแบบไดนามิกสามารถตั้งค่าได้หลายครั้ง สิ่งสำคัญคือต้องตั้งค่าประเภทตัวแปรให้เหมาะสมเนื่องจากจะส่งผลต่อประสิทธิภาพ ตัวแปรแบบคงที่และไม่แน่นอนมีประสิทธิภาพมากกว่า ตัวแปรไดนามิกมีราคาแพงกว่าและทำให้เกิดค่าใช้จ่ายรันไทม์บางส่วน
อีกวิธีหนึ่งในการผูกทรัพยากรเชเดอร์คือการสร้างอินเทอร์เฟซ IResourceMapping ที่แมปชื่อตามตัวอักษรของทรัพยากรกับทรัพยากรจริง:
รายการ ResourceMappingEntry[] =
-
{"g_Texture", pTexture->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE)}
-
ResourceMappingCreateInfo ResMappingCI;
ResMappingCI.pEntries = รายการ;
ResMappingCI.NumEntries = _countof(รายการ);
RefCntAutoPtr <IResourceMapping> pResMapping;
pRenderDevice->CreateResourceMapping(ResMappingCI, &pResMapping); การแมปทรัพยากรสามารถใช้เพื่อผูกทรัพยากรคงที่ทั้งหมดในสถานะไปป์ไลน์ ( IPipelineState::BindStaticResources() ):
m_pPSO->BindStaticResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, การแมป pRes,
BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED); หรือทรัพยากรที่ไม่แน่นอนและไดนามิกทั้งหมดในการเชื่อมโยงทรัพยากรเชเดอร์ ( IShaderResourceBinding::BindResources() ):
m_pSRB->BindResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, pResMapping,
BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED); พารามิเตอร์สุดท้ายสำหรับฟังก์ชัน BindResources() ทั้งหมดจะกำหนดวิธีการแก้ไขทรัพยากร:
BIND_SHADER_RESOURCES_UPDATE_STATIC - บ่งชี้ว่าการเชื่อมโยงตัวแปรแบบคงที่จะต้องได้รับการอัปเดต
BIND_SHADER_RESOURCES_UPDATE_MUTABLE - บ่งชี้ว่าการเชื่อมโยงตัวแปรที่ไม่แน่นอนจะได้รับการอัปเดต
BIND_SHADER_RESOURCES_UPDATE_DYNAMIC - ระบุว่าจะต้องอัปเดตการเชื่อมโยงตัวแปรแบบไดนามิก
BIND_SHADER_RESOURCES_UPDATE_ALL - ระบุว่าตัวแปรทุกประเภท (คงที่ ไม่แน่นอน และไดนามิก) จะต้องได้รับการอัปเดต โปรดทราบว่าหากไม่มีการตั้งค่าแฟล็ก BIND_SHADER_RESOURCES_UPDATE_STATIC , BIND_SHADER_RESOURCES_UPDATE_MUTABLE และ BIND_SHADER_RESOURCES_UPDATE_DYNAMIC ไว้ ประเภทของตัวแปรทั้งหมดจะได้รับการอัปเดตเหมือนกับว่ามีการระบุ BIND_SHADER_RESOURCES_UPDATE_ALL
BIND_SHADER_RESOURCES_KEEP_EXISTING - หากมีการระบุแฟล็กนี้ เฉพาะการเชื่อมโยงที่ยังไม่ได้แก้ไขเท่านั้นที่จะได้รับการอัปเดต การเชื่อมโยงที่มีอยู่ทั้งหมดจะคงค่าดั้งเดิมไว้ หากไม่ได้ระบุแฟล็กนี้ ตัวแปรเชเดอร์ทุกตัวจะได้รับการอัปเดตหากการแมปมีทรัพยากรที่เกี่ยวข้อง
BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED - หากมีการระบุแฟล็กนี้ การผูกเชเดอร์ทั้งหมดจะได้รับการแก้ไขหลังจากการเรียก หากไม่เป็นเช่นนั้นจะมีการรายงานข้อผิดพลาด
BindResources() อาจถูกเรียกหลายครั้งโดยมีการแมปทรัพยากรที่แตกต่างกันเพื่อผูกทรัพยากร อย่างไรก็ตาม ขอแนะนำให้ใช้การแมปทรัพยากรขนาดใหญ่รายการเดียว เนื่องจากขนาดของการแมปไม่ส่งผลต่อเวลาในการค้นหาองค์ประกอบ
เอ็นจิ้นทำการตรวจสอบรันไทม์เพื่อตรวจสอบว่ามีการผูกทรัพยากรที่ถูกต้อง ตัวอย่างเช่น หากคุณพยายามผูกบัฟเฟอร์คงที่กับตัวแปรมุมมองทรัพยากรเชเดอร์ ข้อผิดพลาดจะถูกส่งไปยังคอนโซลดีบัก
ก่อนที่จะเรียกใช้คำสั่ง Draw ใด ๆ จุดยอดและบัฟเฟอร์ดัชนีที่จำเป็นทั้งหมด รวมถึงสถานะไปป์ไลน์ควรเชื่อมโยงกับบริบทของอุปกรณ์:
// ตั้งเป้าหมายการเรนเดอร์ก่อนที่จะออกคำสั่งวาดใด ๆ auto* pRTV = m_pSwapChain->GetCurrentBackBufferRTV();auto* pDSV = m_pSwapChain->GetDepthBufferDSV();
m_pContext->SetRenderTargets(1, &pRTV, pDSV, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);// ล้างเป้าหมายการเรนเดอร์และความลึก-stencilconst float ศูนย์ [4] = {0, 0, 0, 0};
m_pContext->ClearRenderTarget(pRTV, ClearColor, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
m_pContext->ClearDepthStencil(pDSV, CLEAR_DEPTH_FLAG, 1.f, 0, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);// ตั้งค่าจุดยอดและดัชนีบัฟเฟอร์ IBuffer* buffer[] = {m_pVertexBuffer};
Uint32 ออฟเซ็ต[] = {0};
m_pContext->SetVertexBuffers (0, 1, บัฟเฟอร์, ออฟเซ็ต, SET_VERTEX_BUFFERS_FLAG_RESET,
ทรัพยากร_STATE_TRANSITION_MODE_TRANSITION);
m_pContext->SetIndexBuffer(m_pIndexBuffer, 0, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
m_pContext->SetPipelineState(m_pPSO); วิธีการทั้งหมดที่อาจจำเป็นต้องดำเนินการเปลี่ยนสถานะทรัพยากรใช้แจงนับ RESOURCE_STATE_TRANSITION_MODE เป็นพารามิเตอร์ enum กำหนดโหมดต่อไปนี้:
RESOURCE_STATE_TRANSITION_MODE_NONE - ไม่มีการเปลี่ยนแปลงสถานะทรัพยากร
RESOURCE_STATE_TRANSITION_MODE_TRANSITION - การเปลี่ยนทรัพยากรเป็นสถานะที่คำสั่งต้องการ
RESOURCE_STATE_TRANSITION_MODE_VERIFY - ห้ามเปลี่ยน แต่ตรวจสอบว่าสถานะถูกต้อง
ขั้นตอนสุดท้ายคือการมอบทรัพยากรเชเดอร์ให้กับบริบทของอุปกรณ์ ซึ่งสามารถทำได้โดยวิธี IDeviceContext::CommitShaderResources() :
m_pContext->CommitShaderResources(m_pSRB, COMMIT_SHADER_RESOURCES_FLAG_TRANSITION_RESOURCES);
ถ้าไม่ได้เรียกเมธอด เอ็นจิ้นจะตรวจพบว่าทรัพยากรไม่ได้ถูกคอมมิตและแสดงข้อความดีบัก โปรดทราบว่าพารามิเตอร์สุดท้ายจะบอกระบบให้เปลี่ยนทรัพยากรเพื่อแก้ไขสถานะ หากไม่ได้ระบุแฟล็กนี้ ทรัพยากรจะต้องได้รับการเปลี่ยนอย่างชัดเจนไปยังสถานะที่ต้องการโดยการเรียกไปยัง IDeviceContext::TransitionShaderResources() :
m_pContext->TransitionShaderResources (m_pPSO, m_pSRB);
โปรดทราบว่าวิธีการนี้ต้องใช้ตัวชี้ไปยังสถานะไปป์ไลน์ที่สร้างการเชื่อมโยงทรัพยากรเชเดอร์
เมื่อสถานะและทรัพยากรที่จำเป็นทั้งหมดถูกผูกไว้แล้ว IDeviceContext::DrawIndexed() สามารถใช้เพื่อดำเนินการคำสั่ง Draw หรือ IDeviceContext::DispatchCompute() สามารถใช้เพื่อดำเนินการคำสั่งคำนวณได้ โปรดทราบว่าสำหรับคำสั่ง Draw จะต้องผูกไปป์ไลน์กราฟิก และสำหรับคำสั่งจัดส่ง จะต้องผูกไปป์ไลน์การคำนวณ DrawIndexed() รับโครงสร้าง DrawIndexedAttribs เป็นอาร์กิวเมนต์ ตัวอย่างเช่น:
DrawIndexedAttribs attrs; attrs.IndexType = VT_UINT16; attrs.NumIndices = 36; attrs.Flags = DRAW_FLAG_VERIFY_STATES; pContext->DrawIndexed(attrs);
การตั้งค่าสถานะ DRAW_FLAG_VERIFY_STATES สั่งให้กลไกตรวจสอบว่าจุดยอดและบัฟเฟอร์ดัชนีที่ใช้โดยคำสั่ง Draw ได้รับการเปลี่ยนไปสู่สถานะที่เหมาะสม
DispatchCompute() รับโครงสร้าง DispatchComputeAttribs ที่กำหนดขนาดตารางคำนวณ:
m_pContext->SetPipelineState(m_pComputePSO);
m_pContext->CommitShaderResources (m_pComputeSRB, COMMIT_SHADER_RESOURCES_FLAG_TRANSITION_RESOURCES);
DispatchComputeAttribs DispatchAttrs{64, 64, 8};
m_pContext->DispatchCompute (DispatchAttrs);คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับ Engine API ได้โดยศึกษาตัวอย่างและบทช่วยสอน
Diligent Engine รองรับการทำงานร่วมกันอย่างกว้างขวางกับ API ระดับต่ำพื้นฐาน กลไกสามารถเริ่มต้นได้โดยการเชื่อมต่อกับอุปกรณ์ D3D11/D3D12 ที่มีอยู่หรือบริบท OpenGL/GLES และให้การเข้าถึงออบเจ็กต์ API ดั้งเดิมที่ซ่อนอยู่ อ้างอิงถึงหน้าต่อไปนี้สำหรับข้อมูลเพิ่มเติม:
การทำงานร่วมกันของ Direct3D11
การทำงานร่วมกันของ Direct3D12
การทำงานร่วมกันของ OpenGL/GLES
การทำงานร่วมกันของวัลแคน
ทำตามขั้นตอนต่อไปนี้เพื่อสร้างแพ็คเกจ NuGet:
ติดตั้งแพ็คเกจ Python ที่จำเป็น
python -m pip install -r ./BuildTools/.NET/requirements.txt
รันสคริปต์สร้างแพ็คเกจ NuGet เช่น:
python ./BuildTools/.NET/dotnet-build-package.py -c Debug -d ./
| การโต้แย้ง | คำอธิบาย | ที่จำเป็น |
|---|---|---|
-c ( configuration ) | การกำหนดค่าการสร้างไลบรารีไดนามิกดั้งเดิม (เช่น Debug, Release ฯลฯ ) | ใช่ |
-d ( root-dir ) | เส้นทางไปยังไดเรกทอรีรากของ DiligentCore | ใช่ |
-s ( settings ) | เส้นทางไปยังไฟล์การตั้งค่า | เลขที่ |
dotnet-tests | แฟล็กที่ระบุว่าจะรันการทดสอบ .NET หรือไม่ | เลขที่ |
dotnet-publish | แฟล็กที่ระบุว่าจะเผยแพร่แพ็คเกจไปยัง NuGet Gallery หรือไม่ | เลขที่ |
free-memory | ใช้อาร์กิวเมนต์นี้หากคุณพบหน่วยความจำไม่เพียงพอในระหว่างกระบวนการสร้าง | เลขที่ |
คุณสามารถแทนที่การตั้งค่าเริ่มต้นได้โดยใช้ไฟล์การตั้งค่า (ตรวจสอบพจนานุกรม default_settings ใน dotnet-build-package.py )
ดูใบอนุญาต Apache 2.0
โปรเจ็กต์นี้มีการอ้างอิงของบุคคลที่สาม ซึ่งแต่ละรายการอาจมีใบอนุญาตอิสระ:
Vulkan-Headers: ไฟล์ Vulkan Header และการลงทะเบียน API (Apache License 2.0)
SPIRV-Cross: เครื่องมือแยกวิเคราะห์และรวบรวมข้าม SPIRV (Apache License 2.0)
SPIRV-Headers: ไฟล์ส่วนหัว SPIRV (ลิขสิทธิ์เหมือน Khronos MIT)
เครื่องมือ SPIRV: เครื่องมือเพิ่มประสิทธิภาพและการตรวจสอบ SPIRV (Apache License 2.0)
glslang: คอมไพเลอร์อ้างอิง Khronos และเครื่องมือตรวจสอบความถูกต้องสำหรับ GLSL, ESSL และ HLSL (ใบอนุญาต BSD แบบ 3 ข้อ, ใบอนุญาต BSD แบบ 2 ข้อ, MIT, Apache License 2.0)
glew: OpenGL Extension Wrangler Library (ไลบรารีกราฟิก Mesa 3-D, ลิขสิทธิ์เหมือน Khronos MIT)
volk: Meta loader สำหรับ Vulkan API (ใบอนุญาตเหมือน Arseny Kapoulkine MIT)
stb: ไลบรารีโดเมนสาธารณะไฟล์เดียว stb สำหรับ C/C++ (ใบอนุญาต MIT หรือโดเมนสาธารณะ)
googletest: กรอบการทดสอบและการเยาะเย้ยของ Google (ใบอนุญาต BSD 3-Clause "ใหม่" หรือ "แก้ไข")
DirectXShaderCompiler: DirectX Shader Compiler ที่ใช้ LLVM/Clang (ใบอนุญาตเผยแพร่ LLVM)
DXBCChecksum: อัลกอริธึมการคำนวณ DXBC Checksum โดย AMD Developer Tools Team (MIT lincesne)
xxHash: อัลกอริธึมแฮชแบบไม่เข้ารหัสที่รวดเร็วเป็นพิเศษ (ใบอนุญาต BSD แบบ 2 ข้อ)
หากต้องการสนับสนุนโค้ดของคุณ ให้ส่งคำขอดึงไปยังพื้นที่เก็บข้อมูลนี้ Diligent Engine ได้รับการเผยแพร่ภายใต้ลิขสิทธิ์ Apache 2.0 ซึ่งรับประกันว่าเนื้อหาในพื้นที่เก็บข้อมูล DiligentCore ปราศจากภาระผูกพันด้านทรัพย์สินทางปัญญา ในการส่งเนื้อหาใดๆ ไปยังพื้นที่เก็บข้อมูลนี้ คุณอนุญาตเนื้อหานั้นภายใต้ข้อกำหนดเดียวกัน และคุณยอมรับว่าเนื้อหานั้นไม่มีการอ้างสิทธิ์ในทรัพย์สินทางปัญญาใดๆ และคุณมีสิทธิ์ในการอนุญาตภายใต้ข้อกำหนดเหล่านั้น
Diligent Engine ใช้รูปแบบเสียงดังกราวเพื่อให้แน่ใจว่าสไตล์ของซอร์สโค้ดสอดคล้องกันทั่วทั้งฐานโค้ด รูปแบบได้รับการตรวจสอบโดย CI สำหรับคำขอคอมมิตและพูลแต่ละรายการ และบิลด์จะล้มเหลวหากพบปัญหาการจัดรูปแบบโค้ด โปรดดูหน้านี้สำหรับคำแนะนำเกี่ยวกับวิธีตั้งค่ารูปแบบเสียงดังกราวและการจัดรูปแบบโค้ดอัตโนมัติ
ดูประวัติการเผยแพร่
ขยันกราฟิกดอทคอม
