microsoft
/
DirectXShaderCompiler
зеркало из https://github.com/microsoft/DirectXShaderCompiler.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
DirectXShaderCompiler/include/dxc/dxcapi.internal.h

255 строки
13 KiB
C
Исходник Обычный вид История

first commit
2016-12-28 22:52:27 +03:00
///////////////////////////////////////////////////////////////////////////////
// //
// dxcapi.internal.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
fixes #37 - License cleanup.
2017-01-28 03:48:08 +03:00
// This file is distributed under the University of Illinois Open Source //
// License. See LICENSE.TXT for details. //
first commit
2016-12-28 22:52:27 +03:00
// //
// Provides non-public declarations for the DirectX Compiler component. //
// //
///////////////////////////////////////////////////////////////////////////////
#ifndef __DXC_API_INTERNAL__
#define __DXC_API_INTERNAL__
#include "dxcapi.h"
///////////////////////////////////////////////////////////////////////////////
// Forward declarations.
[linux-port] Minor changes towards cross-platform compilation. (#1352)
2018-06-19 17:36:53 +03:00
typedef struct ITextFont ITextFont;
typedef struct IEnumSTATSTG IEnumSTATSTG;
typedef struct ID3D10Blob ID3D10Blob;
first commit
2016-12-28 22:52:27 +03:00
///////////////////////////////////////////////////////////////////////////////
// Intrinsic definitions.
[linux-port] Use standard int literal suffixes (#1276) Replaces -i64 suffixes with -LL which are said to be equivalent by MSDN. Both should result in 64 bit behavior. Additionally, I dropped a superfluous repetition of the class name on the CheckVectorConditional method of HLSLExternalSource. By all rights, it should be its own change, but it gets lonely so it came along for the ride. The repeated class name made some compilers unhappy and losing it doesn't bother anyone.
2018-05-11 08:39:11 +03:00
#define AR_QUAL_IN 0x0000000000000010ULL
#define AR_QUAL_OUT 0x0000000000000020ULL
#define AR_QUAL_CONST 0x0000000000000200ULL
#define AR_QUAL_ROWMAJOR 0x0000000000000400ULL
#define AR_QUAL_COLMAJOR 0x0000000000000800ULL
first commit
2016-12-28 22:52:27 +03:00
#define AR_QUAL_IN_OUT (AR_QUAL_IN | AR_QUAL_OUT)
static const BYTE INTRIN_TEMPLATE_FROM_TYPE = 0xff;
static const BYTE INTRIN_TEMPLATE_VARARGS = 0xfe;
Add support for RWRawByteBuffer.Store<T> (#2176) Adds support for templatized RWRawByteBuffer.Store<T>. To avoid SROA making us lose the original layout of any struct arguments, a new pass runs before SROA and breaks down such cases into per-element stores. So better be careful with the likes of buf.Store(0, (int[65536])0);...
2019-05-09 21:51:38 +03:00
static const BYTE INTRIN_TEMPLATE_FROM_FUNCTION = 0xfd;
first commit
2016-12-28 22:52:27 +03:00
// Use this enumeration to describe allowed templates (layouts) in intrinsics.
enum LEGAL_INTRINSIC_TEMPLATES {
LITEMPLATE_VOID = 0, // No return type.
LITEMPLATE_SCALAR = 1, // Scalar types.
LITEMPLATE_VECTOR = 2, // Vector types (eg. float3).
LITEMPLATE_MATRIX = 3, // Matrix types (eg. float3x3).
LITEMPLATE_ANY = 4, // Any one of scalar, vector or matrix types (but not object).
LITEMPLATE_OBJECT = 5, // Object types.
LITEMPLATE_COUNT = 6
};
// INTRIN_COMPTYPE_FROM_TYPE_ELT0 is for object method intrinsics to indicate
// that the component type of the type is taken from the first subelement of the
// object's template type; see for example Texture2D.Gather
static const BYTE INTRIN_COMPTYPE_FROM_TYPE_ELT0 = 0xff;
enum LEGAL_INTRINSIC_COMPTYPES {
LICOMPTYPE_VOID = 0, // void, used for function returns
LICOMPTYPE_BOOL = 1, // bool
LICOMPTYPE_INT = 2, // i32, int-literal
LICOMPTYPE_UINT = 3, // u32, int-literal
LICOMPTYPE_ANY_INT = 4, // i32, u32, i64, u64, int-literal
LICOMPTYPE_ANY_INT32 = 5, // i32, u32, int-literal
LICOMPTYPE_UINT_ONLY = 6, // u32, u64, int-literal; no casts allowed
LICOMPTYPE_FLOAT = 7, // f32, partial-precision-f32, float-literal
RawBufferLoad and new methods for ByteAddressBuffer (#762) This change is an extension of float16 support. We are adding LoadHalf, LoadFloat, and LoadDouble method to byte address buffer so that users can access data from byte address buffer by these types. Also starting shader model 6.2, we are mapping byte address buffer and structure buffer load/store operations to RawBufferLoad/Store to differentiate raw buffer load from typed buffer load. Unlike BufferLoad for typed buffers, RawBufferLoad for min precision types will not have its min precision values as its return types, but their actual scalar size in buffer (i.e rawBufferLoad.i32 for min16int and rawBufferLoad.f32 for min16float). RawBufferLoad/Store contains additional parameters, where mask was required for correct status behavior for CheckAccessFullyMapped, and alignment is for relative alignment for future potential benefit for backend.
2017-11-08 05:15:19 +03:00
LICOMPTYPE_ANY_FLOAT = 8, // f32, partial-precision-f32, f64, float-literal, min10-float, min16-float, half
LICOMPTYPE_FLOAT_LIKE = 9, // f32, partial-precision-f32, float-literal, min10-float, min16-float, half
first commit
2016-12-28 22:52:27 +03:00
LICOMPTYPE_FLOAT_DOUBLE = 10, // f32, partial-precision-f32, f64, float-literal
LICOMPTYPE_DOUBLE = 11, // f64, float-literal
LICOMPTYPE_DOUBLE_ONLY = 12, // f64; no casts allowed
LICOMPTYPE_NUMERIC = 13, // float-literal, f32, partial-precision-f32, f64, min10-float, min16-float, int-literal, i32, u32, min12-int, min16-int, min16-uint, i64, u64
LICOMPTYPE_NUMERIC32 = 14, // float-literal, f32, partial-precision-f32, int-literal, i32, u32
LICOMPTYPE_NUMERIC32_ONLY = 15, // float-literal, f32, partial-precision-f32, int-literal, i32, u32; no casts allowed
LICOMPTYPE_ANY = 16, // float-literal, f32, partial-precision-f32, f64, min10-float, min16-float, int-literal, i32, u32, min12-int, min16-int, min16-uint, bool, i64, u64
LICOMPTYPE_SAMPLER1D = 17,
LICOMPTYPE_SAMPLER2D = 18,
LICOMPTYPE_SAMPLER3D = 19,
LICOMPTYPE_SAMPLERCUBE = 20,
LICOMPTYPE_SAMPLERCMP = 21,
LICOMPTYPE_SAMPLER = 22,
LICOMPTYPE_STRING = 23,
LICOMPTYPE_WAVE = 24,
LICOMPTYPE_UINT64 = 25, // u64, int-literal
Fix countbits, reversebits, firstbitlow intrinsics for int16 types (#1037) Fix countbits, reversebits, firstbitlow intrinsics for int16 types
2018-01-31 01:29:10 +03:00
LICOMPTYPE_FLOAT16 = 26,
LICOMPTYPE_INT16 = 27,
LICOMPTYPE_UINT16 = 28,
LICOMPTYPE_NUMERIC16_ONLY = 29,
first commit
2016-12-28 22:52:27 +03:00
Support TraceRay and ReportIntersection which has user-define param at front-end.
2018-01-31 22:26:58 +03:00
LICOMPTYPE_RAYDESC = 30,
LICOMPTYPE_ACCELERATION_STRUCT = 31,
change *_USER_DEFINE_TYPE to *_USER_DEFINED_TYPE
2018-02-14 02:31:02 +03:00
LICOMPTYPE_USER_DEFINED_TYPE = 32,
Support TraceRay and ReportIntersection which has user-define param at front-end.
2018-01-31 22:26:58 +03:00
This change implements the `FeedbackTexture2D[Array](MinLOD|Tiled)` types in HLSL and the backing `WriteSamplerFeedback[Bias|Level|Grad]` DXIL intrinsics.
2019-07-12 02:10:52 +03:00
LICOMPTYPE_TEXTURE2D = 33,
LICOMPTYPE_TEXTURE2DARRAY = 34,
Add GetResourceFromHeap. (#2691) Add GetResourceFromHeap for hlsl. For Dxil, add CreateHandleFromHeap and AnnotateHandle. All handles ( createHandle, createHandleForLib, createHandleFromHeap ) must be annotated with AnnotateHandle before use. TODO: add AnnotateHandle for pix passes. cleanup code about resource.
2020-02-13 08:50:02 +03:00
LICOMPTYPE_RESOURCE = 35,
Restrict parameters to Interlocked* Intrinsics (#3057) Because the defined types of Interlocked* Parameters do not restrict type casting, they can result in late errors that cause crashes due to reference params with casts that aren't actually respected by dxil generation. By constraining the parameters as they should be, instead of crashes, we get errors. Fixes #2077 Fixes #2483
2020-07-28 22:56:50 +03:00
LICOMPTYPE_INT32_ONLY = 36,
LICOMPTYPE_COUNT = 37
first commit
2016-12-28 22:52:27 +03:00
};
static const BYTE IA_SPECIAL_BASE = 0xf0;
static const BYTE IA_R = 0xf0;
static const BYTE IA_C = 0xf1;
static const BYTE IA_R2 = 0xf2;
static const BYTE IA_C2 = 0xf3;
static const BYTE IA_SPECIAL_SLOTS = 4;
struct HLSL_INTRINSIC_ARGUMENT {
LPCSTR pName; // Name of the argument; the first argument has the function name.
UINT64 qwUsage; // A combination of AR_QUAL_IN|AR_QUAL_OUT|AR_QUAL_COLMAJOR|AR_QUAL_ROWMAJOR in parameter tables; other values possible elsewhere.
BYTE uTemplateId; // One of INTRIN_TEMPLATE_FROM_TYPE, INTRIN_TEMPLATE_VARARGS or the argument # the template (layout) must match (trivially itself).
BYTE uLegalTemplates; // A LEGAL_INTRINSIC_TEMPLATES value for allowed templates.
BYTE uComponentTypeId; // INTRIN_COMPTYPE_FROM_TYPE_ELT0, or the argument # the component (element type) must match (trivially itself).
BYTE uLegalComponentTypes; // A LEGAL_INTRINSIC_COMPTYPES value for allowed components.
BYTE uRows; // Required number of rows, or one of IA_R/IA_C/IA_R2/IA_C2 for matching input constraints.
BYTE uCols; // Required number of cols, or one of IA_R/IA_C/IA_R2/IA_C2 for matching input constraints.
};
struct HLSL_INTRINSIC {
UINT Op; // Intrinsic Op ID
BOOL bReadOnly; // Only read memory
BOOL bReadNone; // Not read memory
Use Attribute to designate wave-sensitive intrinsics (#2853) * Use Attribute to designate wave-sensitive intrinsics This adds an intrinsic attribute to indicate wave-sensitivity that can be indicated in gen_intrin_main.txt. This and other attributes are passed along through function representations and lowerings. The wave-sensitivity needs to be maintained specifically through SROA passes since it is used by the CleanupDxbreak pass that comes after them. Specifically this is done to allow extension intrinsics to indicate wave-sensitivity, but the same mechanism is now used for builtin intrinsics. Most intrinsics get a mostly nameless function to represent them between Codegen and dxilgen. This allows any that have the same prototype to share the same function. For wave-sensitive intrinsics, they need a different function or else the attrubute would be similarly shared with intrinsics matching the prototype. So a minor change is made to their function names to prevent this. Adds testing for all these ops and a dummy extension one.
2020-04-29 04:19:51 +03:00
BOOL bIsWave; // Is a wave-sensitive op
first commit
2016-12-28 22:52:27 +03:00
INT iOverloadParamIndex; // Parameter decide the overload type, -1 means ret type
UINT uNumArgs; // Count of arguments in pArgs.
const HLSL_INTRINSIC_ARGUMENT* pArgs; // Pointer to first argument.
};
///////////////////////////////////////////////////////////////////////////////
// Interfaces.
struct __declspec(uuid("f0d4da3f-f863-4660-b8b4-dfd94ded6215"))
IDxcIntrinsicTable : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetTableName(_Outptr_ LPCSTR *pTableName) = 0;
virtual HRESULT STDMETHODCALLTYPE LookupIntrinsic(
LPCWSTR typeName, LPCWSTR functionName,
const HLSL_INTRINSIC** pIntrinsic,
_Inout_ UINT64* pLookupCookie) = 0;
Add initial support for extension intrinsics and defines (#5) This commit adds initial support for extension intrinsics and defines, including: -Support for recognizing hlsl extensions as new intrinsic functions. -Support for requesting lowering of extensions. -Support for preserving semantic defines. -Support for validating semantic defines. This commit adds support for hlsl extensions in the form of additional intrisic functions and semantic defines. We now allow a dxcompiler instance to register that it can handle additional intrinsic functions beyond the standard hlsl intrinsics. These new intrinsics are called extensions. For each extension, the compiler supplies a lowering strategy that is used by the dxcompiler to translate from the source level intrinsic to a high-level dxil intrinsic. We initially support the two lowering strategies: replicate and pack. The replicate strategy will scalarize the vector elements in the call and replicate the function call once for each element in the vector. The pack strategy changes the vector arguments into literal struct arguments. We also now include support for "semantic defines". A semantic define is a source level define whose value is preserved in the final dxil as metatdata. The source level define can come as either a #define in the hlsl source or a /D define from the command line. We provide a hook to validate that a semantic define has a legal value (for example to ensure that the value is an integer). Validation failures can produce warnings and errors that will be emitted through the standard clang diagnostic mechanism. This code was originally written by marcelolr and modified by dmpots to support packed lowering of intriniscs and validation of semantic defines.
2017-01-18 04:51:13 +03:00
// Get the lowering strategy for an hlsl extension intrinsic.
virtual HRESULT STDMETHODCALLTYPE GetLoweringStrategy(UINT opcode, LPCSTR *pStrategy) = 0;
Remove unnecessary whitespace in files touched by #3062 (#3272)
2020-11-20 01:22:42 +03:00
Add initial support for extension intrinsics and defines (#5) This commit adds initial support for extension intrinsics and defines, including: -Support for recognizing hlsl extensions as new intrinsic functions. -Support for requesting lowering of extensions. -Support for preserving semantic defines. -Support for validating semantic defines. This commit adds support for hlsl extensions in the form of additional intrisic functions and semantic defines. We now allow a dxcompiler instance to register that it can handle additional intrinsic functions beyond the standard hlsl intrinsics. These new intrinsics are called extensions. For each extension, the compiler supplies a lowering strategy that is used by the dxcompiler to translate from the source level intrinsic to a high-level dxil intrinsic. We initially support the two lowering strategies: replicate and pack. The replicate strategy will scalarize the vector elements in the call and replicate the function call once for each element in the vector. The pack strategy changes the vector arguments into literal struct arguments. We also now include support for "semantic defines". A semantic define is a source level define whose value is preserved in the final dxil as metatdata. The source level define can come as either a #define in the hlsl source or a /D define from the command line. We provide a hook to validate that a semantic define has a legal value (for example to ensure that the value is an integer). Validation failures can produce warnings and errors that will be emitted through the standard clang diagnostic mechanism. This code was originally written by marcelolr and modified by dmpots to support packed lowering of intriniscs and validation of semantic defines.
2017-01-18 04:51:13 +03:00
// Callback to support custom naming of hlsl extension intrinsic functions in dxil.
// Return the empty string to get the default intrinsic name, which is the mangled
// name of the high level intrinsic function.
//
// Overloaded intrinsics are supported by use of an overload place holder in the
// name. The string "$o" in the name will be replaced by the return type of the
// intrinsic.
virtual HRESULT STDMETHODCALLTYPE GetIntrinsicName(UINT opcode, LPCSTR *pName) = 0;
Support lowering extensions directly to dxil (#217) This commit adds the 'dxil' strategy for lowering extensions. This strategy will change the extension call into a call to a dxil intrinsic. This is useful for targeting dxil intrinsics that are not exposed in hlsl.
2017-04-13 20:19:00 +03:00
// Callback to support the 'dxil' lowering strategy.
// Returns the dxil opcode that the intrinsic should use for lowering.
virtual HRESULT STDMETHODCALLTYPE GetDxilOpCode(UINT opcode, UINT *pDxilOpcode) = 0;
Add initial support for extension intrinsics and defines (#5) This commit adds initial support for extension intrinsics and defines, including: -Support for recognizing hlsl extensions as new intrinsic functions. -Support for requesting lowering of extensions. -Support for preserving semantic defines. -Support for validating semantic defines. This commit adds support for hlsl extensions in the form of additional intrisic functions and semantic defines. We now allow a dxcompiler instance to register that it can handle additional intrinsic functions beyond the standard hlsl intrinsics. These new intrinsics are called extensions. For each extension, the compiler supplies a lowering strategy that is used by the dxcompiler to translate from the source level intrinsic to a high-level dxil intrinsic. We initially support the two lowering strategies: replicate and pack. The replicate strategy will scalarize the vector elements in the call and replicate the function call once for each element in the vector. The pack strategy changes the vector arguments into literal struct arguments. We also now include support for "semantic defines". A semantic define is a source level define whose value is preserved in the final dxil as metatdata. The source level define can come as either a #define in the hlsl source or a /D define from the command line. We provide a hook to validate that a semantic define has a legal value (for example to ensure that the value is an integer). Validation failures can produce warnings and errors that will be emitted through the standard clang diagnostic mechanism. This code was originally written by marcelolr and modified by dmpots to support packed lowering of intriniscs and validation of semantic defines.
2017-01-18 04:51:13 +03:00
};
struct __declspec(uuid("1d063e4f-515a-4d57-a12a-431f6a44cfb9"))
IDxcSemanticDefineValidator : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetSemanticDefineWarningsAndErrors(LPCSTR pName, LPCSTR pValue, IDxcBlobEncoding **ppWarningBlob, IDxcBlobEncoding **ppErrorBlob) = 0;
first commit
2016-12-28 22:52:27 +03:00
};
struct __declspec(uuid("282a56b4-3f56-4360-98c7-9ea04a752272"))
IDxcLangExtensions : public IUnknown
{
public:
/// <summary>
/// Registers the name of a preprocessor define that has semantic meaning
/// and should be preserved for downstream consumers.
/// </summary>
virtual HRESULT STDMETHODCALLTYPE RegisterSemanticDefine(LPCWSTR name) = 0;
/// <summary>Registers a name to exclude from semantic defines.</summary>
virtual HRESULT STDMETHODCALLTYPE RegisterSemanticDefineExclusion(LPCWSTR name) = 0;
/// <summary>Registers a definition for compilation.</summary>
virtual HRESULT STDMETHODCALLTYPE RegisterDefine(LPCWSTR name) = 0;
/// <summary>Registers a table of built-in intrinsics.</summary>
virtual HRESULT STDMETHODCALLTYPE RegisterIntrinsicTable(_In_ IDxcIntrinsicTable* pTable) = 0;
Add initial support for extension intrinsics and defines (#5) This commit adds initial support for extension intrinsics and defines, including: -Support for recognizing hlsl extensions as new intrinsic functions. -Support for requesting lowering of extensions. -Support for preserving semantic defines. -Support for validating semantic defines. This commit adds support for hlsl extensions in the form of additional intrisic functions and semantic defines. We now allow a dxcompiler instance to register that it can handle additional intrinsic functions beyond the standard hlsl intrinsics. These new intrinsics are called extensions. For each extension, the compiler supplies a lowering strategy that is used by the dxcompiler to translate from the source level intrinsic to a high-level dxil intrinsic. We initially support the two lowering strategies: replicate and pack. The replicate strategy will scalarize the vector elements in the call and replicate the function call once for each element in the vector. The pack strategy changes the vector arguments into literal struct arguments. We also now include support for "semantic defines". A semantic define is a source level define whose value is preserved in the final dxil as metatdata. The source level define can come as either a #define in the hlsl source or a /D define from the command line. We provide a hook to validate that a semantic define has a legal value (for example to ensure that the value is an integer). Validation failures can produce warnings and errors that will be emitted through the standard clang diagnostic mechanism. This code was originally written by marcelolr and modified by dmpots to support packed lowering of intriniscs and validation of semantic defines.
2017-01-18 04:51:13 +03:00
/// <summary>Sets an (optional) validator for parsed semantic defines.<summary>
/// This provides a hook to check that the semantic defines present in the source
/// contain valid data. One validator is used to validate all parsed semantic defines.
virtual HRESULT STDMETHODCALLTYPE SetSemanticDefineValidator(_In_ IDxcSemanticDefineValidator* pValidator) = 0;
/// <summary>Sets the name for the root metadata node used in DXIL to hold the semantic defines.</summary>
virtual HRESULT STDMETHODCALLTYPE SetSemanticDefineMetaDataName(LPCSTR name) = 0;
[linux-port] Enable extensiontest for Unix (#1478) Enable the UUID for IDxcLangExtensions so its interface can be properly queried. Sundry const, semicolon, and override warning eliminating changes that might have been included in the larger corresponding changes had this test not been an afterthought.
2018-08-01 14:50:11 +03:00
DECLARE_CROSS_PLATFORM_UUIDOF(IDxcLangExtensions)
first commit
2016-12-28 22:52:27 +03:00
};
Add IDxcLangExtensions2 to set target triple. (#2981) * Add IDxcLangExtensions2 to set target triple.
2020-06-18 19:42:49 +03:00
struct __declspec(uuid("2490C368-89EE-4491-A4B2-C6547B6C9381"))
IDxcLangExtensions2 : public IDxcLangExtensions {
public:
virtual HRESULT STDMETHODCALLTYPE SetTargetTriple(LPCSTR name) = 0;
DECLARE_CROSS_PLATFORM_UUIDOF(IDxcLangExtensions2)
};
first commit
2016-12-28 22:52:27 +03:00
struct __declspec(uuid("454b764f-3549-475b-958c-a7a6fcd05fbc"))
IDxcSystemAccess : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE EnumFiles(LPCWSTR fileName, IEnumSTATSTG** pResult) = 0;
virtual HRESULT STDMETHODCALLTYPE OpenStorage(
_In_ LPCWSTR lpFileName,
_In_ DWORD dwDesiredAccess,
_In_ DWORD dwShareMode,
_In_ DWORD dwCreationDisposition,
_In_ DWORD dwFlagsAndAttributes, IUnknown** pResult) = 0;
virtual HRESULT STDMETHODCALLTYPE SetStorageTime(_In_ IUnknown* storage,
_In_opt_ const FILETIME *lpCreationTime,
_In_opt_ const FILETIME *lpLastAccessTime,
_In_opt_ const FILETIME *lpLastWriteTime) = 0;
virtual HRESULT STDMETHODCALLTYPE GetFileInformationForStorage(_In_ IUnknown* storage, _Out_ LPBY_HANDLE_FILE_INFORMATION lpFileInformation) = 0;
virtual HRESULT STDMETHODCALLTYPE GetFileTypeForStorage(_In_ IUnknown* storage, _Out_ DWORD* fileType) = 0;
virtual HRESULT STDMETHODCALLTYPE CreateHardLinkInStorage(_In_ LPCWSTR lpFileName, _In_ LPCWSTR lpExistingFileName) = 0;
virtual HRESULT STDMETHODCALLTYPE MoveStorage(_In_ LPCWSTR lpExistingFileName, _In_opt_ LPCWSTR lpNewFileName, _In_ DWORD dwFlags) = 0;
virtual HRESULT STDMETHODCALLTYPE GetFileAttributesForStorage(_In_ LPCWSTR lpFileName, _Out_ DWORD* pResult) = 0;
virtual HRESULT STDMETHODCALLTYPE DeleteStorage(_In_ LPCWSTR lpFileName) = 0;
virtual HRESULT STDMETHODCALLTYPE RemoveDirectoryStorage(LPCWSTR lpFileName) = 0;
virtual HRESULT STDMETHODCALLTYPE CreateDirectoryStorage(_In_ LPCWSTR lpPathName) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCurrentDirectoryForStorage(DWORD nBufferLength, _Out_writes_(nBufferLength) LPWSTR lpBuffer, _Out_ DWORD* written) = 0;
virtual HRESULT STDMETHODCALLTYPE GetMainModuleFileNameW(DWORD nBufferLength, _Out_writes_(nBufferLength) LPWSTR lpBuffer, _Out_ DWORD* written) = 0;
virtual HRESULT STDMETHODCALLTYPE GetTempStoragePath(DWORD nBufferLength, _Out_writes_(nBufferLength) LPWSTR lpBuffer, _Out_ DWORD* written) = 0;
virtual HRESULT STDMETHODCALLTYPE SupportsCreateSymbolicLink(_Out_ BOOL* pResult) = 0;
virtual HRESULT STDMETHODCALLTYPE CreateSymbolicLinkInStorage(_In_ LPCWSTR lpSymlinkFileName, _In_ LPCWSTR lpTargetFileName, DWORD dwFlags) = 0;
virtual HRESULT STDMETHODCALLTYPE CreateStorageMapping(
_In_ IUnknown* hFile,
_In_ DWORD flProtect,
_In_ DWORD dwMaximumSizeHigh,
_In_ DWORD dwMaximumSizeLow,
_Outptr_ IUnknown** pResult) = 0;
virtual HRESULT MapViewOfFile(
_In_ IUnknown* hFileMappingObject,
_In_ DWORD dwDesiredAccess,
_In_ DWORD dwFileOffsetHigh,
_In_ DWORD dwFileOffsetLow,
_In_ SIZE_T dwNumberOfBytesToMap,
_Outptr_ ID3D10Blob** pResult) = 0;
virtual HRESULT STDMETHODCALLTYPE OpenStdStorage(int standardFD, _Outptr_ IUnknown** pResult) = 0;
virtual HRESULT STDMETHODCALLTYPE GetStreamDisplay(_COM_Outptr_result_maybenull_ ITextFont** textFont, _Out_ unsigned* columnCount) = 0;
};
struct __declspec(uuid("e991ca8d-2045-413c-a8b8-788b2c06e14d"))
IDxcContainerEventsHandler : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE OnDxilContainerBuilt(_In_ IDxcBlob *pSource, _Out_ IDxcBlob **ppTarget) = 0;
};
struct __declspec(uuid("0cfc5058-342b-4ff2-83f7-04c12aad3d01"))
IDxcContainerEvent : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE RegisterDxilContainerEventHandler(IDxcContainerEventsHandler *pHandler, UINT64 *pCookie) = 0;
virtual HRESULT STDMETHODCALLTYPE UnRegisterDxilContainerEventHandler(UINT64 cookie) = 0;
};
#endif